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

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

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

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

दोनों अनुरोधों पर कार्रवाई करने के बाद, तीर का ऊपरी बायां कोना (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 कोड सैंपल में, 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"
        }
      }
    }
  ]
}