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

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 ईएमयू) नीचे होता है. नए आयत का X कोऑर्डिनेट, ऐरो के X कोऑर्डिनेट के बराबर होना चाहिए, ताकि उसका बायां बॉर्डर अलाइन रहे. Y कॉर्डिनेट, ऐरो के Y कॉर्डिनेट के साथ-साथ 50 pt के बराबर होता है, क्योंकि दूरी को ऐरो के सबसे ऊपरी हिस्से से मापा जाता है. इसलिए, आयत के कोऑर्डिनेट ये हैं:

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

दूसरे अनुरोध से 40 पीटी चौड़ा सर्कल बनता है. इसकी हॉरिज़ॉन्टल सेंटर लाइन, उदाहरण के ऐरो की तरह ही होती है. हालांकि, इसे ऐरो के दाईं ओर के किनारे से 100 पीटी (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 मैट्रिक्स को इस तरह से बनाया गया है कि एलिमेंट के साइज़ और ओरिएंटेशन में बदलाव न हो.

दोनों अनुरोधों को पूरा करने के बाद, ऐरो का ऊपर-बायां कोना (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 तरीके का इस्तेमाल करके, ऐरो के उदाहरण वाली शेप पेज तत्व को पेज पर उसकी जगह या स्केल में बदलाव किए बिना, उसके बीच में हॉरिज़ॉन्टल तरीके से दिखाने का तरीका बताया गया है.

इसके लिए, एलिमेंट के रेफ़रंस फ़्रेम में बेसिक रिफ़्लेक्शन ट्रांसफ़ॉर्म का इस्तेमाल किया जाता है. आसानी से समझने के लिए, रेफ़रंस फ़्रेम में बदलाव और रिफ़्लेक्शन को 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 कोड के सैंपल में दिखाया गया है कि तीर के उदाहरण के आकार वाले पेज एलिमेंट को 50% ज़्यादा चौड़ा करने और उसकी मौजूदा ऊंचाई को सिर्फ़ 80% रखने के लिए, UpdatePageElementTransformRequest तरीके का इस्तेमाल कैसे किया जाता है. साथ ही, इसमें यह भी दिखाया गया है कि तीर के सेंटर को उसी जगह पर कैसे रखा जाता है और उसके ओरिएंटेशन को कैसे बनाए रखा जाता है.

इसके लिए, एलिमेंट के रेफ़रंस फ़्रेम में बेसिक स्केलिंग ट्रांसफ़ॉर्म का इस्तेमाल किया जाता है. साफ़ तौर पर कहा जाए, तो रेफ़रंस फ़्रेम में बदलाव और स्केलिंग को 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"
        }
      }
    }
  ]
}