टेबल के साथ काम करना

Google Docs API की मदद से, टेबल के कॉन्टेंट में बदलाव किया जा सकता है. इन कार्रवाइयों को पूरा किया जा सकता है:

• पंक्तियां, कॉलम या पूरी टेबल जोड़ें और मिटाएं.
• टेबल की सेल में कॉन्टेंट डालें.
• टेबल सेल से कॉन्टेंट पढ़ता है.
• कॉलम की प्रॉपर्टी और लाइनों की स्टाइल में बदलाव करें.

Google Docs में मौजूद टेबल को दस्तावेज़ में StructuralElement के तौर पर दिखाया जाता है. हर टेबल में टेबल की पंक्तियों की सूची होती है. हर पंक्ति में टेबल के सेल की सूची होती है. सभी स्ट्रक्चरल एलिमेंट की तरह, टेबल में भी स्टार्ट और एंड इंडेक्स होते हैं. इनसे दस्तावेज़ में टेबल की पोज़िशन का पता चलता है. इंडेक्सिंग के बारे में ज़्यादा जानने के लिए, स्ट्रक्चर देखें. टेबल की प्रॉपर्टी में कई स्टाइल एलिमेंट शामिल होते हैं. जैसे, कॉलम की चौड़ाई और पैडिंग.

JSON के इस फ़्रैगमेंट में, 2x2 वाली एक सामान्य टेबल दिखाई गई है. इसमें ज़्यादातर जानकारी हटा दी गई है:

"table": {
    "columns": 2,
    "rows": 2,
    "tableRows": [
        { "tableCells": [
                {
                    "content": [ { "paragraph": { ...  }, } ],
                },
                {
                    "content": [ { "paragraph": { ... }, } ],
                }
            ],
        },
        {
            "tableCells": [
                {
                    "content": [ { "paragraph": { ... }, } ],
                },
                {
                    "content": [ { "paragraph": { ... }, } ],
                }
            ],
        }
    ]
}

टेबल डालना और मिटाना

किसी दस्तावेज़ में नई टेबल जोड़ने के लिए, InsertTableRequest का इस्तेमाल करें. टेबल डालते समय, आपको यह जानकारी देनी होगी:

• टेबल डाइमेंशन, पंक्तियों और कॉलम में होते हैं.
• नई टेबल को जोड़ने की जगह: यह सेगमेंट में कोई इंडेक्स हो सकता है या यह किसी सेगमेंट के आखिर में हो सकता है. इनमें से किसी एक में, तय किए गए टैब का आईडी शामिल होना चाहिए.

बॉडी के आखिर में कोई टेबल डालने के लिए, endOfSegmentLocation ऑब्जेक्ट तय करें और segmentId को खाली छोड़ दें.

टेबल मिटाने का कोई तरीका नहीं है. किसी दस्तावेज़ से टेबल मिटाने के लिए, उसे किसी अन्य कॉन्टेंट की तरह ही ट्रीट करें: DeleteContentRangeRequest का इस्तेमाल करें. साथ ही, ऐसी रेंज तय करें जिसमें पूरी टेबल शामिल हो.

यहां दिए गए उदाहरण में, खाली दस्तावेज़ के आखिर में 3x3 टेबल डाली गई है:

Java

// Insert a table at the end of the body.
// (An empty or unspecified segmentId field indicates the document's body.)

List<Request> requests = new ArrayList<>();
requests.add(
    new Request()
        .setInsertTable(
            new InsertTableRequest()
                .setEndOfSegmentLocation(
                    new EndOfSegmentLocation().setTabId(TAB_ID))
                .setRows(3)
                .setColumns(3)));

BatchUpdateDocumentRequest body =
    new BatchUpdateDocumentRequest().setRequests(requests);
BatchUpdateDocumentResponse response =
    docsService.documents().batchUpdate(DOCUMENT_ID, body).execute();

Python

# Insert a table at the end of the body.
# (An empty or unspecified segmentId field indicates the document's body.)

requests = [{
    'insertTable': {
        'rows': 3,
        'columns': 3,
        'endOfSegmentLocation': {
          'segmentId': '',
          'tabId': TAB_ID
        }
    },
}
]

result = service.documents().batchUpdate(documentId=DOCUMENT_ID, body={'requests': requests}).execute()

यहां दिए गए उदाहरण में, पहले से जोड़ी गई टेबल को मिटाने का तरीका बताया गया है:

Java

// Delete a table that was inserted at the start of the body of the first tab.
// (The table is the second element in the body:
//  documentTab.getBody().getContent().get(2).)

Document document = docsService.documents().get(DOCUMENT_ID).setIncludeTabsContent(true).execute();
String tabId = document.getTabs()[0].getTabProperties().getTabId();
DocumentTab documentTab = document.getTabs()[0].getDocumentTab();
StructuralElement table = documentTab.getBody().getContent().get(2);

List<Request> requests = new ArrayList<>();
requests.add(
    new Request()
        .setDeleteContentRange(
            new DeleteContentRangeRequest()
                .setRange(
                    new Range()
                        .setStartIndex(table.getStartIndex())
                        .setEndIndex(table.getEndIndex())
                        .setTabId(tabId))));

BatchUpdateDocumentRequest body =
    new BatchUpdateDocumentRequest().setRequests(requests);
BatchUpdateDocumentResponse response =
    docsService.documents().batchUpdate(DOCUMENT_ID, body).execute();

Python

# Delete a table that was inserted at the start of the body of the first tab.
# (The table is the second element in the body: ['body']['content'][2].)

document = service.documents().get(documentId=DOCUMENT_ID, includeTabsContent=True).execute()
tab_id = document['tabs'][0]['tabProperties']['tabId']
document_tab = document['tabs'][0]['documentTab']
table = document_tab['body']['content'][2]

requests = [{
    'deleteContentRange': {
      'range': {
        'segmentId': '',
        'startIndex': table['startIndex'],
        'endIndex':   table['endIndex'],
        'tabId': tab_id
      }
    },
}
]

result = service.documents().batchUpdate(documentId=DOCUMENT_ID, body={'requests': requests}).execute()

आपने टेबल को सामान्य कॉन्टेंट के तौर पर मिटाया है. इसके लिए, आपने शुरुआती और आखिरी इंडेक्स तय किए हैं. इसलिए, आपको ये इंडेक्स कहीं से पाने होंगे. इस उदाहरण में, दस्तावेज़ के कॉन्टेंट से इन इंडेक्स को निकालने का एक तरीका दिखाया गया है.

पिछले उदाहरण में, टेबल को बॉडी की शुरुआत में डाला गया था. इसलिए, इस उदाहरण में इसे तीसरा एलिमेंट (शून्य से इंडेक्स किया गया) माना जाता है. पहले दो एलिमेंट, पहला सेक्शन ब्रेक और पैराग्राफ़ हैं. ये हमेशा मौजूद रहते हैं और इन्हें हटाया नहीं जा सकता.

लाइनें जोड़ना और मिटाना

अगर आपके दस्तावेज़ में पहले से ही कोई टेबल मौजूद है, तो Google Docs API की मदद से टेबल की पंक्तियां जोड़ी और मिटाई जा सकती हैं. किसी टेबल सेल के ऊपर या नीचे लाइनें जोड़ने के लिए, InsertTableRowRequest का इस्तेमाल करें. साथ ही, किसी लाइन को हटाने के लिए, DeleteTableRowRequest का इस्तेमाल करें. यह लाइन, सेल की तय की गई जगह पर फैली होती है.

यहां दिए गए उदाहरण में, किसी टेबल की पहली सेल में टेक्स्ट डाला गया है और टेबल की एक लाइन जोड़ी गई है.

Java

List<Request> requests = new ArrayList<>();
requests.add(new Request().setInsertText(new InsertTextRequest()
        .setText("Hello")
        .setLocation(new Location().setIndex(5).setTabId(TAB_ID))));
requests.add(new Request().setInsertTableRow(new InsertTableRowRequest()
        .setTableCellLocation(new TableCellLocation()
                .setTableStartLocation(new Location()
                        .setIndex(2).setTabId(TAB_ID))
                .setRowIndex(1)
                .setColumnIndex(1))
        .setInsertBelow(true)));

BatchUpdateDocumentRequest body =
    new BatchUpdateDocumentRequest().setRequests(requests);
BatchUpdateDocumentResponse response = docsService.documents()
        .batchUpdate(DOCUMENT_ID, body).execute();

Python

requests = [{
      'insertText': {
        'location': {
          'index': 5,
          'tabId': TAB_ID
        },
        'text': 'Hello'
    }
  },
  {
    'insertTableRow': {
        'tableCellLocation': {
            'tableStartLocation': {
                'index': 2,
                'tabId': TAB_ID
            },
            'rowIndex': 1,
            'columnIndex': 1
        },
        'insertBelow': 'true'
    }
  }
]

result = service.documents().batchUpdate(documentId=DOCUMENT_ID, body={'requests': requests}).execute()

कॉलम जोड़ना और मिटाना

किसी मौजूदा टेबल में कॉलम जोड़ने के लिए, InsertTableColumnRequest का इस्तेमाल करें. आपको यह जानकारी देनी होगी:

• वह सेल जिसके बगल में आपको नया कॉलम डालना है.
• नया कॉलम किस तरफ़ (बाईं या दाईं ओर) जोड़ना है.

यहां दिए गए उदाहरण में, पहले दिखाई गई 2x2 टेबल में कॉलम जोड़ने का तरीका बताया गया है:

Java

List<Request> requests = new ArrayList<>();
requests.add(
    new Request()
        .setInsertTableColumn(
            new InsertTableColumnRequest()
                .setTableCellLocation(
                    new TableCellLocation()
                        .setTableStartLocation(
                            new Location().setIndex(2).setTabId(TAB_ID))
                        .setRowIndex(0)
                        .setColumnIndex(0))
                .setInsertRight(true)));

BatchUpdateDocumentRequest body =
    new BatchUpdateDocumentRequest().setRequests(requests);
BatchUpdateDocumentResponse response =
    docsService.documents().batchUpdate(DOCUMENT_ID, body).execute();

Python

requests = [{
    'insertTableColumn': {
      'tableCellLocation': {
        'tableStartLocation': {
          'segmentId': '',
          'index': 2,
          'tabId': TAB_ID
        },
        'rowIndex': 0,
        'columnIndex': 0
      },
      'insertRight': True
    },
}
]

result = service.documents().batchUpdate(documentId=DOCUMENT_ID, body={'requests': requests}).execute()

किसी कॉलम को मिटाने के लिए, DeleteTableColumnRequest का इस्तेमाल करें. टारगेट कॉलम में सेल की जगह की जानकारी उसी तरह से दी जाती है जिस तरह से कॉलम डालने के लिए दी गई थी.

टेबल सेल में मौजूद कॉन्टेंट को पढ़ना

टेबल सेल में स्ट्रक्चरल एलिमेंट की सूची होती है. इनमें से हर स्ट्रक्चरल एलिमेंट, टेक्स्ट वाला पैराग्राफ़ या किसी दूसरे तरह का स्ट्रक्चर हो सकता है. यहां तक कि कोई दूसरी टेबल भी हो सकती है. टेबल का कॉन्टेंट पढ़ने के लिए, हर एलिमेंट की बार-बार जांच की जा सकती है. जैसा कि टेक्स्ट एक्सट्रैक्ट करें में दिखाया गया है.

टेबल की सेल में कॉन्टेंट डालना

किसी टेबल सेल में लिखने के लिए, उस सेल के इंडेक्स में InsertTextRequest का इस्तेमाल करें जिसे आपको अपडेट करना है. अपडेट किए गए टेक्स्ट के हिसाब से, टेबल इंडेक्स में बदलाव किया जाता है. DeleteContentRangeRequest का इस्तेमाल करके सेल का टेक्स्ट मिटाने पर भी यही तरीका लागू होता है.

कॉलम की प्रॉपर्टी में बदलाव करना

UpdateTableColumnPropertiesRequest की मदद से, टेबल में मौजूद एक या उससे ज़्यादा कॉलम की प्रॉपर्टी में बदलाव किया जा सकता है.

आपको TableColumnProperties ऑब्जेक्ट के साथ-साथ टेबल का शुरुआती इंडेक्स भी देना होगा. अगर आपको सिर्फ़ चुने गए कॉलम में बदलाव करना है, तो अनुरोध में कॉलम नंबर की सूची शामिल करें. अगर आपको टेबल के सभी कॉलम में बदलाव करना है, तो एक खाली सूची दें.

यहां दिए गए उदाहरण में, टेबल के कॉलम की चौड़ाई को अपडेट किया गया है. इसमें सभी कॉलम की चौड़ाई 100pt पर सेट की गई है. इसके बाद, पहले कॉलम की चौड़ाई 200pt पर सेट की गई है:

Java

List<Request> requests = new ArrayList<>();
requests.add(
    new Request()
        .setUpdateTableColumnProperties(
            new UpdateTableColumnPropertiesRequest()
                .setTableStartLocation(
                    new Location()
                        .setIndex(2)
                        .setTabId(TAB_ID))
                .setColumnIndices(null)
                .setTableColumnProperties(
                    new TableColumnProperties()
                        .setWidthType("FIXED_WIDTH")
                        .setWidth(
                            new Dimension().setMagnitude(100d).setUnit("PT")))
                .setFields("*")));

List<Integer> columnIndices = new ArrayList<>();
columnIndices.add(0);
requests.add(
    new Request()
        .setUpdateTableColumnProperties(
            new UpdateTableColumnPropertiesRequest()
                .setTableStartLocation(
                    new Location()
                        .setIndex(2)
                        .setTabId(TAB_ID))
                .setColumnIndices(columnIndices)
                .setTableColumnProperties(
                    new TableColumnProperties()
                        .setWidthType("FIXED_WIDTH")
                        .setWidth(
                            new Dimension().setMagnitude(200d).setUnit("PT")))
                .setFields("*")));

BatchUpdateDocumentRequest body =
    new BatchUpdateDocumentRequest().setRequests(requests);
BatchUpdateDocumentResponse response =
    docsService.documents().batchUpdate(DOCUMENT_ID, body).execute();

Python

requests = [{
  'updateTableColumnProperties': {
    'tableStartLocation': {'index': 2, 'tabId': TAB_ID},
    'columnIndices': [],
    'tableColumnProperties': {
      'widthType': 'FIXED_WIDTH',
      'width': {
        'magnitude': 100,
        'unit': 'PT'
      }
    },
    'fields': '*'
  },
  'updateTableColumnProperties': {
    'tableStartLocation': {'index': 2, 'tabId': TAB_ID},
    'columnIndices': [0],
    'tableColumnProperties': {
      'widthType': 'FIXED_WIDTH',
      'width': {
        'magnitude': 200,
        'unit': 'PT'
      }
    },
    'fields': '*'
  },
}
]

result = service.documents().batchUpdate(documentId=DOCUMENT_ID, body={'requests': requests}).execute()

लाइन की स्टाइल में बदलाव करना

UpdateTableRowsStyleRequest की मदद से, टेबल की एक या उससे ज़्यादा लाइनों के स्टाइल में बदलाव किया जा सकता है.

आपको टेबल का शुरुआती इंडेक्स और TableRowStyle ऑब्जेक्ट देना होगा. अगर आपको सिर्फ़ चुनी गई लाइनों में बदलाव करना है, तो अनुरोध में लाइन नंबर की सूची शामिल करें. अगर आपको टेबल की सभी लाइनों में बदलाव करना है, तो खाली सूची दें.

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

Java

List<Integer> rowIndices = new ArrayList<>();
rowIndices.add(3);

List<Request> requests = new ArrayList<>();
requests.add(
    new Request()
        .setUpdateTableRowStyle(
            new UpdateTableRowStyleRequest()
                .setTableStartLocation(
                    new Location()
                        .setIndex(2)
                        .setTabId(TAB_ID))
                .setRowIndices(rowIndices)
                .setTableRowStyle(
                    new TableRowStyle()
                        .setMinRowHeight(
                            new Dimension().setMagnitude(18d).setUnit("PT")))
                .setFields("*")));

BatchUpdateDocumentRequest body =
    new BatchUpdateDocumentRequest().setRequests(requests);
BatchUpdateDocumentResponse response =
    docsService.documents().batchUpdate(DOCUMENT_ID, body).execute();

Python

requests = [{
    'updateTableRowStyle': {
        'tableStartLocation': {'index': 2, 'tabId': TAB_ID},
        'rowIndices': [3],
        'tableRowStyle': {
            'minRowHeight': {
              'magnitude': 18,
              'unit': 'PT'
            }
        },
        'fields': '*'
    },
}
]

result = service.documents().batchUpdate(documentId=DOCUMENT_ID, body={'requests': requests}).execute()