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

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) = (20,00,000, 15,000) ईएमयू कोऑर्डिनेट पर ले जाता है. इसके लिए, ऐब्सलूट ट्रांसलेशन 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 तरीके का इस्तेमाल करके, तीर के आकार के उदाहरण वाले पेज एलिमेंट को उसके बीच से हॉरिज़ॉन्टल तौर पर पलटने का तरीका दिखाया गया है. ऐसा करते समय, पेज पर उसकी जगह या स्केल में कोई बदलाव नहीं किया जाता.

इसके लिए, एलिमेंट के 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% कैसे बनाया जाए. साथ ही, तीर के बीच के हिस्से को उसी जगह पर रखा जाए और उसके ओरिएंटेशन को बनाए रखा जाए.

इसके लिए, एलिमेंट के reference frame में basic scaling 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.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 डिग्री तक घड़ी की सुई की उलटी दिशा में कैसे घुमाया जा सकता है. इस दौरान, तीर के बीच वाले हिस्से की जगह में कोई बदलाव नहीं होता और उसके साइज़ में भी कोई बदलाव नहीं होता.

इसके लिए, एलिमेंट के reference frame में basic rotation 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":  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"
        }
      }
    }
  ]
}