इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

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

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

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

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

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