Работа с колони и редове

За повече контрол върху начина на работа на таблиците научете как да манипулирате колони и редове.

Намерете индекса на елементите на таблицата

Колоните, редовете и клетките се управляват чрез достъп до избрания възел на документа по неговия индекс. Намирането на индекса на всеки възел включва събиране на всички дъщерни възли от типа на елемента от родителския възел и след това използване на метода IndexOf за намиране на индекса на желания възел в колекцията.

Намиране на индекса на таблица в документ

Понякога може да се наложи да направите промени в определена таблица в документ. За да направите това, можете да се обърнете към таблица по нейния индекс.

Следващият пример за код показва как да извлечете индекса на таблица в документ:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto table = System::ExplicitCast<Table>(doc->GetChild(NodeType::Table, 0, true));

SharedPtr<NodeCollection> allTables = doc->GetChildNodes(NodeType::Table, true);
int tableIndex = allTables->IndexOf(table);

Намерете индекса на ред в Таблица

По същия начин може да се наложи да направите промени в определен ред в избрана таблица. За да направите това, можете също да препращате към ред по неговия индекс.

Следващият пример за код показва как да извлечете индекса на ред в таблица:

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

Намерете индекса на клетка в ред

И накрая, може да се наложи да направите промени в определена клетка и можете да направите това и по Индекс на клетките.

Следващият пример за код показва как да извлечете индекса на клетка в ред:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
int cellIndex = row->IndexOf(row->get_Cells()->idx_get(4));

Работа с колони

В Aspose.Words обектен модел на документ (DOM), Table възел се състои от Row възли и след това Cell възли. Така, в Document обектен модел на Aspose.Words, както и в Word документи, няма концепция за колона.

По дизайн редовете на таблицата в Microsoft Word и Aspose.Words са напълно независими, а основните свойства и операции се съдържат само в редовете и клетките на таблицата. Това дава възможност на таблиците да имат някои интересни атрибути:

• Всеки ред на таблица може да има напълно различен брой клетки
• Вертикално, клетките на всеки ред могат да имат различни ширини
• Възможно е да се присъедините към таблици с различни формати на редове и брой клетки

Всички операции, извършвани върху колони, всъщност са" преки пътища", които извършват операцията, като колективно променят клетките на редовете по такъв начин, че да изглежда, че те се прилагат към колони. Това означава, че можете да извършвате операции върху колони, като просто итерирате върху същия индекс на клетки от редове на таблица.

Следващият пример за код опростява такива операции, като доказва клас фасада, който събира клетките, които съставляват" колона " на таблица:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
/// <summary>
/// Represents a facade object for a column of a table in a Microsoft Word document.
/// </summary>
class Column : public System::Object
{
public:
    /// <summary>
    /// Returns the cells which make up the column.
    /// </summary>
    ArrayPtr<SharedPtr<Cell>> get_Cells()
    {
        return GetColumnCells()->ToArray();
    }

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

    /// <summary>
    /// Returns the index of the given cell in the column.
    /// </summary>
    int IndexOf(SharedPtr<Cell> cell)
    {
        return GetColumnCells()->IndexOf(cell);
    }

    /// <summary>
    /// Inserts a brand new column before this column into the table.
    /// </summary>
    SharedPtr<WorkingWithTables::Column> InsertColumnBefore()
    {
        ArrayPtr<SharedPtr<Cell>> columnCells = get_Cells();

        if (columnCells->get_Length() == 0)
        {
            throw System::ArgumentException(u"Column must not be empty");
        }

        // Create a clone of this column.
        for (SharedPtr<Cell> cell : columnCells)
        {
            cell->get_ParentRow()->InsertBefore(cell->Clone(false), cell);
        }

        // This is the new column.
        auto column = WorkingWithTables::Column::MakeObject(columnCells[0]->get_ParentRow()->get_ParentTable(), mColumnIndex);

        // We want to make sure that the cells are all valid to work with (have at least one paragraph).
        for (SharedPtr<Cell> cell : column->get_Cells())
        {
            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>
    void Remove()
    {
        for (SharedPtr<Cell> cell : get_Cells())
        {
            cell->Remove();
        }
    }

    /// <summary>
    /// Returns the text of the column.
    /// </summary>
    String ToTxt()
    {
        auto builder = System::MakeObject<System::Text::StringBuilder>();

        for (SharedPtr<Cell> cell : get_Cells())
        {
            builder->Append(cell->ToString(SaveFormat::Text));
        }

        return builder->ToString();
    }

private:
    int mColumnIndex;
    SharedPtr<Table> mTable;

    Column(SharedPtr<Table> table, int columnIndex) : mColumnIndex(0)
    {
        if (table == nullptr)
        {
            throw System::ArgumentException(u"table");
        }

        mTable = table;
        mColumnIndex = columnIndex;
    }

    MEMBER_FUNCTION_MAKE_OBJECT(Column, CODEPORTING_ARGS(SharedPtr<Table> table, int columnIndex), CODEPORTING_ARGS(table, columnIndex));
    /// <summary>
    /// Provides an up-to-date collection of cells which make up the column represented by this facade.
    /// </summary>
    SharedPtr<System::Collections::Generic::List<SharedPtr<Cell>>> GetColumnCells()
    {
        SharedPtr<System::Collections::Generic::List<SharedPtr<Cell>>> columnCells =
            System::MakeObject<System::Collections::Generic::List<SharedPtr<Cell>>>();

        for (const auto& row : System::IterateOver<Row>(mTable->get_Rows()))
        {
            SharedPtr<Cell> cell = row->get_Cells()->idx_get(mColumnIndex);
            if (cell != nullptr)
            {
                columnCells->Add(cell);
            }
        }

        return columnCells;
    }
};

Следващият пример за код показва как да вмъкнете празна колона в таблица:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Tables.docx");

auto table = System::ExplicitCast<Table>(doc->GetChild(NodeType::Table, 0, true));

SharedPtr<WorkingWithTables::Column> column = WorkingWithTables::Column::FromIndex(table, 0);
// Print the plain text of the column to the screen.
std::cout << column->ToTxt() << std::endl;

// Create a new column to the left of this column.
// This is the same as using the "Insert Column Before" command in Microsoft Word.
SharedPtr<WorkingWithTables::Column> newColumn = column->InsertColumnBefore();

for (SharedPtr<Cell> cell : newColumn->get_Cells())
{
    cell->get_FirstParagraph()->AppendChild(MakeObject<Run>(doc, String(u"Column Text ") + newColumn->IndexOf(cell)));
}

Следващият пример за код показва как да премахнете колона от таблица в документ:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Tables.docx");

auto table = System::ExplicitCast<Table>(doc->GetChild(NodeType::Table, 1, true));

SharedPtr<WorkingWithTables::Column> column = WorkingWithTables::Column::FromIndex(table, 2);
column->Remove();

Задаване на редове като заглавни редове

Можете да изберете да повторите първия ред в таблицата като заглавен ред само на първата страница или на всяка страница, ако таблицата е разделена на няколко. В Aspose.Words можете да повтаряте заглавния ред на всяка страница, като използвате свойството HeadingFormat.

Можете също да маркирате няколко заглавни реда, ако тези редове са разположени един след друг в началото на таблицата. За да направите това, трябва да приложите свойствата HeadingFormat към тези редове.

Обърнете внимание, че заглавните редове не работят в вложени таблици. Това означава, че ако имате маса в друга маса, тази настройка няма да има ефект. Това е ограничение на Microsoft Word, което не позволява това, а не Aspose.Words.

Следващият пример за код показва как да създадете таблица, която включва заглавни редове, които се повтарят на следващите страници:

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

builder->StartTable();
builder->get_RowFormat()->set_HeadingFormat(true);
builder->get_ParagraphFormat()->set_Alignment(ParagraphAlignment::Center);
builder->get_CellFormat()->set_Width(100);
builder->InsertCell();
builder->Writeln(u"Heading row 1");
builder->EndRow();
builder->InsertCell();
builder->Writeln(u"Heading row 2");
builder->EndRow();

builder->get_CellFormat()->set_Width(50);
builder->get_ParagraphFormat()->ClearFormatting();

for (int i = 0; i < 50; i++)
{
    builder->InsertCell();
    builder->get_RowFormat()->set_HeadingFormat(false);
    builder->Write(u"Column 1 Text");
    builder->InsertCell();
    builder->Write(u"Column 2 Text");
    builder->EndRow();
}

doc->Save(ArtifactsDir + u"WorkingWithTables.RepeatRowsOnSubsequentPages.docx");

Пазете таблиците и редовете от счупване на страници

Има моменти, когато съдържанието на една таблица не трябва да се разделя на страници. Например, ако заглавието е над таблица, заглавието и таблицата трябва винаги да се съхраняват заедно на една и съща страница, за да се запази правилният външен вид.

Има две отделни техники, които са полезни за постигането на тази функционалност.:

• Allow row break across pages, който се прилага към редовете на таблицата
• Keep with next, която се прилага към абзаците в клетките на таблицата

По подразбиране горните свойства са забранени.

Пазете ред от счупване на страници

Това включва ограничаване на съдържанието в клетките на ред от разделяне на страница. В Microsoft Word това може да се намери под свойства на таблицата като опцията “Разрешаване на ред да се прекъсне през страници”. В Aspose.Words това се намира под RowFormat обект на а Row като собственост RowFormat.AllowBreakAcrossPages.

Следващият пример за код показва как да забраните прекъсването на редове в страници за всеки ред в таблица:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Table spanning two pages.docx");

auto table = System::ExplicitCast<Table>(doc->GetChild(NodeType::Table, 0, true));

// Disable breaking across pages for all rows in the table.
for (const auto& row : System::IterateOver<Row>(table->get_Rows()))
{
    row->get_RowFormat()->set_AllowBreakAcrossPages(false);
}

doc->Save(ArtifactsDir + u"WorkingWithTables.RowFormatDisableBreakAcrossPages.docx");

Пазете таблицата да не се счупи на страници

За да спрем разделянето на таблицата на страници, трябва да уточним, че искаме съдържанието, съдържащо се в таблицата, да остане заедно.

За да направите това, Aspose.Words използва метод, който позволява на потребителите да изберат таблица и да разрешат параметъра KeepWithNext да е верен за всеки абзац в клетките на таблицата. Изключение е последният параграф в таблицата, който трябва да бъде зададен като неверен.

Следващият пример за код показва как да зададете таблица, за да останат заедно на една и съща страница:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Table spanning two pages.docx");

auto table = System::ExplicitCast<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 (const auto& cell : System::IterateOver<Cell>(table->GetChildNodes(NodeType::Cell, true)))
{
    cell->EnsureMinimum();

    for (const auto& para : System::IterateOver<Paragraph>(cell->get_Paragraphs()))
    {
        if (!(cell->get_ParentRow()->get_IsLastRow() && para->get_IsEndOfCell()))
        {
            para->get_ParagraphFormat()->set_KeepWithNext(true);
        }
    }
}

doc->Save(ArtifactsDir + u"WorkingWithTables.KeepTableTogether.docx");