Sütunlarla ve Satırlarla Çalışın

Tablo üzerinde daha fazla kontrol için, nasıl sütunları ve satırları manipüle edileceğini öğrenin.

Tablo Öğesi Dizini Bulun

Sütunlar, satırlar ve hücreler seçilen belge düğümüne erişerek yönetilir. Herhangi bir düğümün dizinini bulmak, alt düğümlerin tümünü ebeveyn düğümden toplayıp ardından IndexOf yöntemini kullanarak arzu edilen düğümün koleksiyon içindeki dizinini bulmayı içerir.

Bir Belge İçinde Bir Tablonun Dizinini Bulun

Bazen bir belgedeki belirli bir tabloya değişiklik yapmanız gerekebilir. Bunu yapmak için, bir tablonun dizinine başvurabilirsiniz.

Aşağıdaki kod örneği bir belgedeki tablonun dizinini nasıl alacağını göstermektedir:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Table table = (Table) doc.getChild(NodeType.TABLE, 0, true);

NodeCollection allTables = doc.getChildNodes(NodeType.TABLE, true);
int tableIndex = allTables.indexOf(table);

Bir Tablodaki Bir Satırın Endeksini Bulma

Benzer şekilde, belirli bir satıra seçilmiş bir tabloda değişiklik yapmanız gerekebilir. Bunu yapmak için, dizinine göre bir satıra da başvurabilirsiniz.

Aşağıdaki kod örneği bir tablodaki bir satırın dizinini nasıl alacağını göstermektedir:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
int rowIndex = table.indexOf(table.getLastRow());

Bir Sırada Hücre Endeksini Bulma

Son olarak, özel bir hücreye değişiklik yapmanız gerekebilir ve bunu hücre dizinine göre de yapabilirsiniz.

Aşağıdaki kod örneği bir satırdaki bir hücrenin dizinini nasıl alacağınızı gösterir:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
int cellIndex = row.indexOf(row.getCells().get(4));

Sütunlarla Çalış

Aspose.Words Document Object Model (DOM), Table düğümü Row düğüm ve sonra Cell düğüm içerir. Böylece, Document Nesne Modeli Aspose.Words içerisinde, kelime belgelerinde olduğu gibi, bir sütunun kavramı yoktur.

Tasarım gereği tablo satırları Microsoft Word ve Aspose.Words tamamen bağımsızdır, temel özellikler ve işlemler yalnızca tablodaki satırlar ve hücrelerde bulunur. Bu tabloların bazı ilginç özniteliklere sahip olma yeteneğini verir:

• Her tablo satırı tamamen farklı bir hücre sayısı olabilir
• Dikey olarak her satırdaki hücreler farklı genişlikler alabilir
• Farklı satır formatı ve hücre sayısına sahip tablolarla birleştirme mümkündür

Sütunlara uygulanan herhangi bir işlem aslında “hızlı yollar”‘dır ve bu şekilde satır hücrelerini toplu olarak değiştirerek sütunlara uygulanmış gibi göründüğü şekilde işlemi gerçekleştirir. Bu, yani; aynı tablo satırı hücre dizinini yineleyerek sütunlarda işlemler gerçekleştirebilirsiniz.

Aşağıdaki kod örneği, bir tablodaki “sütun"u oluşturan hücreleri toplayan bir “facade” sınıfı sağlayarak bu tür işlemleri basitleştirir:”

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
/// <summary>
/// Represents a facade object for a column of a table in a Microsoft Word document.
/// </summary>
static class Column
{
    private Column(Table table, int columnIndex) {
        if (table != null) {
            mTable = table;
        } else {
            throw new IllegalArgumentException("table");
        }

        mColumnIndex = columnIndex;
    }

    /// <summary>
    /// Returns a new column facade from the table and supplied zero-based index.
    /// </summary>
    public static Column fromIndex(Table table, int columnIndex)
    {
        return new Column(table, columnIndex);
    }

    private ArrayList<Cell> getCells() {
        return getColumnCells();
    }

    /// <summary>
    /// Returns the index of the given cell in the column.
    /// </summary>
    public int indexOf(Cell cell)
    {
        return getColumnCells().indexOf(cell);
    }

    /// <summary>
    /// Inserts a brand new column before this column into the table.
    /// </summary>
    public Column insertColumnBefore()
    {
        ArrayList<Cell> columnCells = getCells();

        if (columnCells.size() == 0)
            throw new IllegalArgumentException("Column must not be empty");

        // Create a clone of this column.
        for (Cell cell : columnCells)
            cell.getParentRow().insertBefore(cell.deepClone(false), cell);

        // This is the new column.
        Column column = new Column(columnCells.get(0).getParentRow().getParentTable(), mColumnIndex);

        // We want to make sure that the cells are all valid to work with (have at least one paragraph).
        for (Cell cell : column.getCells())
            cell.ensureMinimum();

        // Increase the index which this column represents since there is now one extra column in front.
        mColumnIndex++;

        return column;
    }

    /// <summary>
    /// Removes the column from the table.
    /// </summary>
    public void remove()
    {
        for (Cell cell : getCells())
            cell.remove();
    }

    /// <summary>
    /// Returns the text of the column. 
    /// </summary>
    public String toTxt() throws Exception
    {
        StringBuilder builder = new StringBuilder();

        for (Cell cell : getCells())
            builder.append(cell.toString(SaveFormat.TEXT));

        return builder.toString();
    }

    /// <summary>
    /// Provides an up-to-date collection of cells which make up the column represented by this facade.
    /// </summary>
    private ArrayList<Cell> getColumnCells()
    {
        ArrayList<Cell> columnCells = new ArrayList<Cell>();

        for (Row row : mTable.getRows())
        {
            Cell cell = row.getCells().get(mColumnIndex);
            if (cell != null)
                columnCells.add(cell);
        }

        return columnCells;
    }

    private int mColumnIndex;
    private Table mTable;
}

Aşağıdaki kod örneği bir tabloya boş sütun eklemenin nasıl yapılacağını göstermektedir:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Tables.docx");

Table table = (Table) doc.getChild(NodeType.TABLE, 0, true);

Column column = Column.fromIndex(table, 0);
// Print the plain text of the column to the screen.
System.out.println(column.toTxt());
        
// Create a new column to the left of this column.
// This is the same as using the "Insert Column Before" command in Microsoft Word.
Column newColumn = column.insertColumnBefore();

for (Cell cell : newColumn.getColumnCells())
    cell.getFirstParagraph().appendChild(new Run(doc, "Column Text " + newColumn.indexOf(cell)));

Aşağıdaki kod örneği bir belgedeki bir tablodan bir sütun nasıl kaldırılacağını göstermektedir:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Tables.docx");

Table table = (Table) doc.getChild(NodeType.TABLE, 1, true);

Column column = Column.fromIndex(table, 2);
column.remove();

Sütunları Başlık Sütunları Olarak Belirt

Tabloya ilk sayfa için sadece başlık satırı olarak veya birden fazla ise tablo bölündüğünde her sayfada tekrar tekrarlanabilir bir ilk satır seçebilirsiniz. In Aspose.Words birinde, başlık satırını her sayfada tekrarlayabilirsiniz ve bunu yapmak için HeadingFormat özelliğini kullanabilirsiniz.

Bir sonraki satırda bulunan bu satırlar birbiri ardına yer alıyorsa birden fazla başlık satırı işaretleyebilirsiniz. Bunu yapmak için bu satırlara HeadingFormat özelliklerini uygulamanız gerekir.

Not that başlık satırları iç içe geçmiş tablolarda çalışmaz. Bu demek oluyor ki, eğer bir tablo içinde başka bir tablo varsa, bu ayar etkili olmayacak. Bu bunu yapmaz bir sınırlamadır Microsoft Word, değilse Aspose.Words.

Aşağıdaki kod örneği bir sonraki sayfada tekrarlanan başlık satırları içeren bir tablo oluşturmayı gösterir:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

builder.startTable();
builder.getRowFormat().setHeadingFormat(true);
builder.getParagraphFormat().setAlignment(ParagraphAlignment.CENTER);
builder.getCellFormat().setWidth(100.0);
builder.insertCell();
builder.writeln("Heading row 1");
builder.endRow();
builder.insertCell();
builder.writeln("Heading row 2");
builder.endRow();

builder.getCellFormat().setWidth(50.0);
builder.getParagraphFormat().clearFormatting();

for (int i = 0; i < 50; i++)
{
    builder.insertCell();
    builder.getRowFormat().setHeadingFormat(false);
    builder.write("Column 1 Text");
    builder.insertCell();
    builder.write("Column 2 Text");
    builder.endRow();
}

doc.save(getArtifactsDir() + "WorkingWithTables.RepeatRowsOnSubsequentPages.docx");

Sayfa Aralarında Kırılmadan Tablolar ve Satırlar Tut"

Bir tablodaki içeriğin sayfalar arasında bölünmemesi gereken zamanlar var. Örneğin, eğer bir başlık bir tablonun üstündese, başlık ve tablo her zaman düzgün görünümlerini korumak için aynı sayfada birlikte tutulmalıdır.

Bu işlevselliği elde etmek için yararlı olan iki ayrı teknik vardır:’'

• Allow row break across pages, tablo satırlarına uygulanan
• Keep with next, tablo hücrelerindeki paragraflara uygulanan

Varsayılan olarak, yukarıdaki özellikler devre dışı bırakılır.

Sayfalara yayılmaktan bir satırı sakla

Bu, bir satırın hücrelerindeki içeriğin bir sayfaya yayılmasını sınırlandırmayı içerir. Bu, Microsoft Word ‘da Tablonun Özellikleri altında “Satırın Sayfa Arasında Kırılmasına İzin Ver” seçeneğinde bulunur. Bu, bir Row nesnesindeki RowFormat altında, RowFormat.AllowBreakAcrossPages özelliğinin Aspose.Words olarak bulunur.

Aşağıdaki kod örneği, bir tablodaki her satır için sayfaları kesmeyi nasıl devre dışı bırakacağını göstermektedir:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Table spanning two pages.docx");

Table table = (Table) doc.getChild(NodeType.TABLE, 0, true);

// Disable breaking across pages for all rows in the table.
for (Row row : (Iterable<Row>) table.getRows())
    row.getRowFormat().setAllowBreakAcrossPages(false);

doc.save(getArtifactsDir() + "WorkingWithTables.RowFormatDisableBreakAcrossPages.docx");

Bir Tablonun Sayfa Üstünden Kırılmasını Önle."

Tablonun sayfaların arasında bölünmesini durdurmak için, tablodaki içeriğin birlikte kalmasını istediğimizi belirtmemiz gerekiyor.

Bunu yapmak için, Aspose.Words bir yöntem kullanır, kullanıcıların bir tablo seçmesine ve KeepWithNext parametresini her tablo hücresi içindeki paragraf için true etmesine izin verir. Bu, tablodaki son paragraftır ve false’ye ayarlanmalıdır.

Aşağıdaki kod örneği bir tablonun aynı sayfada kalmasını nasıl ayarlayacağını gösterir:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Table spanning two pages.docx");
        
Table table = (Table) doc.getChild(NodeType.TABLE, 0, true);

// We need to enable KeepWithNext for every paragraph in the table to keep it from breaking across a page,
// except for the last paragraphs in the last row of the table.
for (Cell cell : (Iterable<Cell>) table.getChildNodes(NodeType.CELL, true))
{
    cell.ensureMinimum();

    for (Paragraph para : (Iterable<Paragraph>) cell.getParagraphs())
        if (!(cell.getParentRow().isLastRow() && para.isEndOfCell()))
            para.getParagraphFormat().setKeepWithNext(true);
}

doc.save(getArtifactsDir() + "WorkingWithTables.KeepTableTogether.docx");