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

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

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

• 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 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) ईएमयू कोऑर्डिनेट पर होता है.

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

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"
        }
      }
    }
  ]
}