बदलाव से जुड़ी कार्रवाइयां

Google Slides API की मदद से, पेज पर मौजूद PageElement (टेक्स्ट बॉक्स, इमेज, टेबल, और बेसिक शेप) की जगह, साइज़, और ओरिएंटेशन में बदलाव किया जा सकता है. साथ ही, लाइनों को सीधा रखा जा सकता है और पॉइंट और पैरलल लाइनों को सुरक्षित रखा जा सकता है. इन्हें अफ़ाइन ट्रांसफ़ॉर्मेशन कहा जाता है. यहां दिए गए उदाहरणों में, presentations.batchUpdate तरीके का इस्तेमाल करके, पेज के एलिमेंट में बदलाव करने की कुछ सामान्य कार्रवाइयां दिखाई गई हैं.

इन उदाहरणों में, इन वैरिएबल का इस्तेमाल किया गया है:

• PRESENTATION_ID—इससे पता चलता है कि आपको presentation ID कहां देना है. इस आईडी की वैल्यू, प्रज़ेंटेशन यूआरएल से पता लगाई जा सकती है.
• PAGE_ID—इससे पता चलता है कि पेज ऑब्जेक्ट आईडी कहां दिया जाता है. इसकी वैल्यू को यूआरएल से या एपीआई के रीड अनुरोध का इस्तेमाल करके वापस पाया जा सकता है.
• PAGE_ELEMENT_ID—इससे पता चलता है कि पेज एलिमेंट ऑब्जेक्ट आईडी कहां दिया जाता है. आपके पास इस आईडी को उन एलिमेंट के लिए तय करने का विकल्प होता है जिन्हें आपने बनाया है. हालांकि, ऐसा कुछ पाबंदियों के साथ किया जा सकता है. इसके अलावा, Slides API को अपने-आप आईडी बनाने की अनुमति भी दी जा सकती है. एपीआई के रीड अनुरोध के ज़रिए, एलिमेंट आईडी वापस पाए जा सकते हैं.

इन उदाहरणों को एचटीटीपी अनुरोधों के तौर पर दिखाया गया है, ताकि ये किसी भी भाषा में उपलब्ध हों. Google API क्लाइंट लाइब्रेरी का इस्तेमाल करके, अलग-अलग भाषाओं में बैच अपडेट लागू करने का तरीका जानने के लिए, शेप और टेक्स्ट जोड़ना लेख पढ़ें.

ऐरो के आकार का उदाहरण

नीचे दिए गए उदाहरणों के लिए, मान लें कि ऐरो के आकार वाले पेज का कोई उदाहरण मौजूद है. इसमें साइज़ और ट्रांसफ़ॉर्म डेटा शामिल है. यह डेटा, presentations.pages.get तरीके के अनुरोध से मिल सकता है. इस उदाहरण में दी गई शेप के लिए, unit ईएमयू (इंग्लिश मेट्रिक यूनिट) और pt (पॉइंट) मेज़रमेंट का इस्तेमाल किया गया है.

{
  "objectId": PAGE_ELEMENT_ID,
  "size": {
    "width": {
      "magnitude": 3000000,
      "unit": "EMU"
    },
    "height": {
      "magnitude": 3000000,
      "unit": "EMU"
    }
  },
  "transform": {
    "scaleX": 0.3,
    "scaleY": 0.12,
    "shearX": 0,
    "shearY": 0,
    "translateX": 2000000,
    "translateY":  550000,
    "unit": "EMU"
  },
  "shape": {
    "shapeType": "RIGHT_ARROW"
  }
}

किसी एलिमेंट को दूसरे एलिमेंट के साथ अलाइन करना

यहां दिए गए presentations.batchUpdate कोड के सैंपल में बताया गया है कि पेज पर मौजूद उदाहरण के तौर पर दिए गए ऐरो के आकार के साथ अलाइन किए गए नए शेप को सही पोज़िशन में बनाने के लिए, CreateShapeRequest तरीके का इस्तेमाल कैसे किया जाता है. दोनों ही मामलों में, नए शेप के सबसे ऊपर बाएं कोने के X और Y कोऑर्डिनेट का हिसाब लगाया जाना चाहिए.

पहले अनुरोध से, 100 x 50 pt का एक आयत बनता है. यह आयत, ऐरो शेप की बाईं ओर की सीमा के साथ अलाइन होता है. हालांकि, यह ऐरो के ऊपरी किनारे से 50 pt (50 * 12,700 = 635,000 EMU) नीचे होता है. नए रेक्टैंगल का X कोऑर्डिनेट, ऐरो के X कोऑर्डिनेट के बराबर होना चाहिए, ताकि उसका बायां बॉर्डर अलाइन रहे. Y कॉर्डिनेट, ऐरो के Y कॉर्डिनेट के साथ-साथ 50 pt के बराबर होता है, क्योंकि दूरी को ऐरो के सबसे ऊपर वाले हिस्से से मापा जाता है. इसलिए, आयत के निर्देशांक ये हैं:

x" = 2000000 EMU
y" = 550000 + (50 * 12700) = 1185000 EMU

दूसरे अनुरोध से 40 pt चौड़ा सर्कल बनता है. इसकी हॉरिज़ॉन्टल सेंटर लाइन, उदाहरण के ऐरो की तरह ही होती है. हालांकि, इसे ऐरो के दाईं ओर वाले किनारे से 100 pt (12,70,000 ईएमयू) की दूरी पर रखा जाता है. सर्कल का X कोऑर्डिनेट, ऐरो के X कोऑर्डिनेट, ऐरो की चौड़ाई, और 100 pt के योग के बराबर होता है. नए सर्कल के लिए सेंटर-लाइन अलाइनमेंट लागू करने के लिए, तीर और सर्कल, दोनों की ऊंचाई को ध्यान में रखना ज़रूरी है. सर्कल का Y कॉर्डिनेट, ऐरो का Y कॉर्डिनेट प्लस ऐरो की आधी ऊंचाई माइनस सर्कल की आधी ऊंचाई होता है. दोनों ही मामलों में, ऐरो से जुड़े स्केलिंग फ़ैक्टर को भी ध्यान में रखना होगा, क्योंकि इनसे ऐरो की रेंडर की गई चौड़ाई और लंबाई पर असर पड़ता है. इसलिए, सर्कल के कोऑर्डिनेट ये हैं:

x = 2000000 + (0.3 * 3000000) + (100 * 12700) = 4170000 EMU
y = 550000 + (0.5 * 0.12 * 3000000) - (0.5 * 40 * 12700) = 476000 EMU

किसी एलिमेंट को दूसरे एलिमेंट के साथ अलाइन करने के लिए, अनुरोध प्रोटोकॉल यहां दिया गया है:

POST https://slides.googleapis.com/v1/presentations/PRESENTATION_ID:batchUpdate

{
  "requests": [
    {
      "createShape": {
        "shapeType": "RECTANGLE",
        "elementProperties": {
          "pageObjectId": PAGE_ID,
          "size": {
            "width": {
              "magnitude": 100,
              "unit": "PT"
            },
            "height": {
              "magnitude": 50,
              "unit": "PT"
            }
          },
          "transform": {
            "scaleX": 1,
            "scaleY": 1,
            "translateX": 2000000,
            "translateY": 1185000,
            "unit": "EMU"
          }
        }
      }
    },
    {
      "createShape": {
        "shapeType": "ELLIPSE",
        "elementProperties": {
          "pageObjectId": PAGE_ID,
          "size": {
            "width": {
              "magnitude": 40,
              "unit": "PT"
            },
            "height": {
              "magnitude": 40,
              "unit": "PT"
            }
          },
          "transform": {
            "scaleX": 1,
            "scaleY": 1,
            "translateX": 4170000,
            "translateY":  476000,
            "unit": "EMU"
          }
        }
      }
    }
  ]
}

किसी एलिमेंट की जगह बदलना

यहां दिए गए presentations.batchUpdate कोड के सैंपल में, UpdatePageElementTransformRequest तरीके का इस्तेमाल करके, तीर के उदाहरण वाले शेप पेज एलिमेंट को दो अलग-अलग तरीकों से अनुवाद करने का तरीका दिखाया गया है.

बैच में मौजूद पहले अनुरोध से, ऐरो को (X,Y) = (2000000, 150000) ईएमयू कोऑर्डिनेट पर ले जाया जाता है. इसके लिए, ऐब्सलूट ट्रांसलेशन applyMode का इस्तेमाल किया जाता है. बैच में मौजूद दूसरे अनुरोध से, ऐरो को वहां से दाईं ओर 40,000 ईएमयू और ऊपर की ओर 35,000 ईएमयू ले जाया जाता है. इसके लिए, रिलेटिव ट्रांसलेशन applyMode का इस्तेमाल किया जाता है. इस्तेमाल की गई transformation1 matrices को इस तरह से बनाया गया है कि एलिमेंट के साइज़ और ओरिएंटेशन में बदलाव न हो.

दोनों अनुरोधों को पूरा करने के बाद, ऐरो का ऊपर-बायां कोना (X,Y) = (2040000, 115000) EMU कोऑर्डिनेट पर होता है.

किसी एलिमेंट को दूसरी जगह ले जाने के लिए, अनुरोध करने का प्रोटोकॉल यहां दिया गया है:

POST https://slides.googleapis.com/v1/presentations/PRESENTATION_ID:batchUpdate

{
  "requests": [
    {
      "updatePageElementTransform": {
        "objectId": PAGE_ELEMENT_ID,
        "applyMode": "ABSOLUTE",
        "transform": {
            "scaleX": 0.3,
            "scaleY": 0.12,
            "translateX": 2000000,
            "translateY":  150000,
            "unit": "EMU"
        }
      }
    },
    {
      "updatePageElementTransform": {
        "objectId": PAGE_ELEMENT_ID,
        "applyMode": "RELATIVE",
        "transform": {
            "scaleX": 1,
            "scaleY": 1,
            "translateX":  40000,
            "translateY": -35000,
            "unit": "EMU"
        }
      }
    }
  ]
}

किसी एलिमेंट को रिफ़्लेक्ट करना

यहां दिए गए presentations.batchUpdate कोड के सैंपल में, UpdatePageElementTransformRequest तरीके का इस्तेमाल करके, ऐरो के उदाहरण वाली शेप पेज एलिमेंट को उसके बीच में हॉरिज़ॉन्टल तरीके से दिखाने का तरीका बताया गया है. ऐसा करते समय, पेज पर उसकी पोज़िशन या स्केल में कोई बदलाव नहीं किया जाता.

इसके लिए, एलिमेंट के reference frame में basic reflection transform का इस्तेमाल किया जाता है. साफ़ तौर पर कहा जाए, तो रेफ़रंस फ़्रेम में बदलाव और रिफ़्लेक्शन को UpdatePageElementTransformRequest तरीके के तीन अलग-अलग कॉल के साथ दिखाया गया है. हालांकि, इन ट्रांसफ़ॉर्मेशन मैट्रिक्स के प्रॉडक्ट को पहले से कैलकुलेट करना ज़्यादा असरदार होता है. इसके बाद, उस प्रॉडक्ट को एक ही अनुरोध के तौर पर लागू किया जाता है.

अनुवाद ट्रांसफ़ॉर्म के लिए, ऐरो के आकार का सेंटर, ऑरिजिन से और ऑरिजिन तक ले जाया जाता है. पैरामीटर वैल्यू को समझने में आसानी हो, इसलिए उन्हें कैलकुलेशन के तौर पर दिखाया गया है.

किसी एलिमेंट को दिखाने के लिए, अनुरोध का प्रोटोकॉल यहां दिया गया है:

POST https://slides.googleapis.com/v1/presentations/PRESENTATION_ID:batchUpdate

{
  "requests": [
    {
      "updatePageElementTransform": {
        "objectId": PAGE_ELEMENT_ID,
        "applyMode": "RELATIVE",
        "transform": {
            "scaleX":  1,
            "scaleY":  1,
            "translateX": -2000000 - 0.5 * 0.3  * 3000000,
            "translateY":  -550000 - 0.5 * 0.12 * 3000000,
            "unit": "EMU"
        }
      }
    },
    {
      "updatePageElementTransform": {
        "objectId": PAGE_ELEMENT_ID,
        "applyMode": "RELATIVE",
        "transform": {
            "scaleX": -1,
            "scaleY":  1,
            "unit": "EMU"
        }
      }
    },
    {
      "updatePageElementTransform": {
        "objectId": PAGE_ELEMENT_ID,
        "applyMode": "RELATIVE",
        "transform": {
            "scaleX":  1,
            "scaleY":  1,
            "translateX":  2000000 + 0.5 * 0.3  * 3000000,
            "translateY":   550000 + 0.5 * 0.12 * 3000000,
            "unit": "EMU"
        }
      }
    }
  ]
}

किसी एलिमेंट का साइज़ बदलना

नीचे दिए गए presentations.batchUpdate कोड के उदाहरण में दिखाया गया है कि UpdatePageElementTransformRequest तरीके का इस्तेमाल करके, तीर के उदाहरण वाले पेज एलिमेंट को 50% ज़्यादा चौड़ा और उसकी मौजूदा ऊंचाई का सिर्फ़ 80% कैसे बनाया जाए. साथ ही, तीर के बीच के हिस्से को उसी जगह पर रखा जाए और उसके ओरिएंटेशन को बनाए रखा जाए.

इसके लिए, एलिमेंट के रेफ़रंस फ़्रेम में बेसिक स्केलिंग ट्रांसफ़ॉर्म का इस्तेमाल किया जाता है. साफ़ तौर पर कहा जाए, तो रेफ़रंस फ़्रेम में बदलाव और स्केलिंग को UpdatePageElementTransformRequest तरीके के तीन अलग-अलग कॉल के साथ दिखाया गया है. हालांकि, इन ट्रांसफ़ॉर्मेशन मैट्रिक्स के प्रॉडक्ट को पहले से ही कैलकुलेट करना ज़्यादा असरदार होता है. इसके बाद, उस प्रॉडक्ट को एक ही अनुरोध के तौर पर लागू किया जाता है.

अनुवाद ट्रांसफ़ॉर्म के लिए, ऐरो के आकार का सेंटर, ऑरिजिन से और ऑरिजिन तक ले जाया जाता है. पैरामीटर वैल्यू को समझने में आसानी हो, इसलिए उन्हें कैलकुलेशन के तौर पर दिखाया गया है.

किसी एलिमेंट का साइज़ बदलने के लिए, अनुरोध प्रोटोकॉल यहां दिया गया है:

POST https://slides.googleapis.com/v1/presentations/PRESENTATION_ID:batchUpdate

{
  "requests": [
    {
      "updatePageElementTransform": {
          "objectId": PAGE_ELEMENT_ID,
          "applyMode": "RELATIVE",
          "transform": {
              "scaleX":  1,
              "scaleY":  1,
              "translateX": -2000000 - 0.5 * 0.3  * 3000000,
              "translateY":  -550000 - 0.5 * 0.12 * 3000000,
              "unit": "EMU"
          }
      }
    },
    {
      "updatePageElementTransform": {
        "objectId": PAGE_ELEMENT_ID,
        "applyMode": "RELATIVE",
        "transform": {
            "scaleX": 1.5,
            "scaleY": 0.8,
            "unit": "EMU"
        }
      }
    },
    {
      "updatePageElementTransform": {
        "objectId": PAGE_ELEMENT_ID,
        "applyMode": "RELATIVE",
        "transform": {
            "scaleX":  1,
            "scaleY":  1,
            "translateX":  2000000 + 0.5 * 0.3  * 3000000,
            "translateY":   550000 + 0.5 * 0.12 * 3000000,
            "unit": "EMU"
        }
      }
    }
  ]
}

किसी एलिमेंट को उसके बीच वाले हिस्से के चारों ओर घुमाना

यहां दिए गए presentations.batchUpdate कोड के उदाहरण में बताया गया है कि UpdatePageElementTransformRequest तरीके का इस्तेमाल करके, तीर के उदाहरण वाले पेज एलिमेंट को 35 डिग्री तक घड़ी की उलटी दिशा में कैसे घुमाया जा सकता है. साथ ही, तीर के बीच के हिस्से को उसी जगह पर रखकर और उसके साइज़ को बनाए रखकर ऐसा कैसे किया जा सकता है.

इसके लिए, एलिमेंट के रेफ़रंस फ़्रेम में बेसिक रोटेशन ट्रांसफ़ॉर्म का इस्तेमाल किया जाता है. साफ़ तौर पर समझने के लिए, रेफ़रंस फ़्रेम में बदलाव और रोटेशन को UpdatePageElementTransformRequest तरीके के तीन अलग-अलग कॉल के साथ दिखाया गया है. हालांकि, इन ट्रांसफ़ॉर्मेशन मैट्रिक्स के प्रॉडक्ट को पहले से कैलकुलेट करना ज़्यादा असरदार होता है. इसके बाद, उस प्रॉडक्ट को एक ही अनुरोध के तौर पर लागू किया जाता है

अनुवाद ट्रांसफ़ॉर्म के लिए, ऐरो के आकार का सेंटर, ऑरिजिन से और ऑरिजिन तक ले जाया जाता है. पैरामीटर वैल्यू को समझने में आसानी हो, इसलिए उन्हें कैलकुलेशन के तौर पर दिखाया गया है.

किसी एलिमेंट को उसके सेंटर के चारों ओर घुमाने के लिए, अनुरोध प्रोटोकॉल यहां दिया गया है:

POST https://slides.googleapis.com/v1/presentations/PRESENTATION_ID:batchUpdate

{
  "requests": [
    {
      "updatePageElementTransform": {
          "objectId": PAGE_ELEMENT_ID,
          "applyMode": "RELATIVE",
          "transform": {
              "scaleX":  1,
              "scaleY":  1,
              "translateX": -2000000 - 0.5 * 0.3  * 3000000,
              "translateY":  -550000 - 0.5 * 0.12 * 3000000,
              "unit": "EMU"
          }
      }
    },
    {
      "updatePageElementTransform": {
        "objectId": PAGE_ELEMENT_ID,
        "applyMode": "RELATIVE",
        "transform": {
            "scaleX":  cos(35 * (pi/180)),
            "scaleY":  cos(35 * (pi/180)),
            "shearX":  sin(35 * (pi/180)),
            "shearY": -sin(35 * (pi/180)),
            "unit": "EMU"
        }
      }
    },
    {
      "updatePageElementTransform": {
        "objectId": PAGE_ELEMENT_ID,
        "applyMode": "RELATIVE",
        "transform": {
            "scaleX":  1,
            "scaleY":  1,
            "translateX":  2000000 + 0.5 * 0.3  * 3000000,
            "translateY":   550000 + 0.5 * 0.12 * 3000000,
            "unit": "EMU"
        }
      }
    }
  ]
}