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

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

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

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

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

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

नीचे दिए गए उदाहरणों के लिए, मान लें कि नीचे दिए गए साइज़ और ट्रांसफ़ॉर्म डेटा वाला एक उदाहरण ऐरो के आकार वाला पेज एलिमेंट मौजूद है (यह डेटा presentations.pages.get तरीका अनुरोध से मिल सकता है). आकार के उदाहरण में, मेज़रमेंट unit EMU (अंग्रेज़ी मेट्रिक यूनिट) और 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 पॉइंट का एक रेक्टैंगल होता है. यह ऐरो के आकार की बाईं ओर अलाइन होता है, लेकिन ऐरो के ऊपरी किनारे के नीचे 50 pt (50 * 12,700 = 6,35,000 EMU) मौजूद होता है. नए आयत का X निर्देशांक, तीर के X निर्देशांक के समान होना चाहिए, ताकि उसकी बाईं बॉर्डर को अलाइन किया जा सके. Y ऑर्डिनेट, ऐरो के Y कॉर्डिनेट और 50 पॉइंट के बराबर होता है, क्योंकि दूरी को ऐरो के ऊपरी हिस्से से मापा जाता है. इसलिए, आयत के निर्देशांक दिखते हैं:

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

दूसरा अनुरोध 40 पॉइंट चौड़ा गोल घेरा बनाता है, जिसमें हॉरिज़ॉन्टल ऐरो वाली हॉरिज़ॉन्टल लाइन होती है. हालांकि, ऐरो के दाएं किनारे पर 100 pt (1,2,70,000 EMU) दिखते हैं. सर्कल का X निर्देशांक, ऐरो के X निर्देशांक, ऐरो की चौड़ाई, और 100 पॉइंट का योग करता है. नए सर्कल के लिए सेंटर-लाइन अलाइनमेंट लागू करने के लिए, ऐरो और सर्कल, दोनों की ऊंचाई का ध्यान रखना ज़रूरी है. सर्कल का 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) में ले जाता है EMU निर्देशांक (निरपेक्ष अनुवाद का इस्तेमाल करके applyMode). बैच का दूसरा अनुरोध ऐरो को वहां से ले जाता है, इस बार 40,000 EMU दाएं और 35,000 EMU एलिमेंट को ऊपर की ओर applyModeऔर 35,000 EMU एलिमेंट का इस्तेमाल करके अनुवाद से बचने के लिए किया जाता है.

दोनों अनुरोधों को पूरा करने के बाद, ऐरो का ऊपरी बायां कोना (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 तरीके का इस्तेमाल कैसे करें.

ऐसा करने के लिए, एलिमेंट के रेफ़रंस फ़्रेम में बेसिक रिफ़्लेक्शन ट्रांसफ़ॉर्म का इस्तेमाल किया जाता है. साफ़ तौर पर कहा जाए, तो रेफ़रंस फ़्रेम में बदलाव और रिफ़्लेक्शन को, 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 तरीके का इस्तेमाल कैसे करें. इसमें ऐरो के बीच वाले हिस्से को उसी पोज़िशन पर रखें और उसका साइज़ बनाए रखें.

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