Aplicar Formatação

Cada elemento de uma tabela pode ser aplicado com formatação diferente. Por exemplo, a formatação da tabela será aplicada a toda a tabela, a formatação de linhas apenas a linhas específicas, a formatação de células apenas a determinadas células.

Aspose.Words fornece um rich API para recuperar e aplicar formatação a uma tabela. Você pode usar os nós Table, RowFormat e CellFormat para definir a formatação.

Neste artigo, falaremos sobre como aplicar formatação a diferentes nós de tabela e quais configurações de formatação de tabela Aspose.Words suportam.

Aplicar formatação a diferentes nós

Nesta seção, veremos a aplicação de formatação a vários nós de tabela.

Formatação Ao Nível Da Tabela

Para aplicar a formatação a uma tabela, você pode usar as propriedades disponíveis no nó Table correspondente usando as classes Table, PreferredWidth e TableCollection.

As imagens abaixo mostram uma representação das características de formatação Table em Microsoft Word e suas propriedades correspondentes em Aspose.Words.

formattin-features-table-level-aspose-words-cpp

formatting-table-options-aspose-words-cpp

O exemplo de código a seguir mostra como aplicar uma borda de contorno a uma tabela:

// 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));
// Align the table to the center of the page.
table->set_Alignment(TableAlignment::Center);
// Clear any existing borders from the table.
table->ClearBorders();
// Set a green border around the table but not inside.
table->SetBorder(BorderType::Left, LineStyle::Single, 1.5, System::Drawing::Color::get_Green(), true);
table->SetBorder(BorderType::Right, LineStyle::Single, 1.5, System::Drawing::Color::get_Green(), true);
table->SetBorder(BorderType::Top, LineStyle::Single, 1.5, System::Drawing::Color::get_Green(), true);
table->SetBorder(BorderType::Bottom, LineStyle::Single, 1.5, System::Drawing::Color::get_Green(), true);
// Fill the cells with a light green solid color.
table->SetShading(TextureIndex::TextureSolid, System::Drawing::Color::get_LightGreen(), System::Drawing::Color::Empty);
doc->Save(ArtifactsDir + u"WorkingWithTableStylesAndFormatting.ApplyOutlineBorder.docx");

O exemplo de código a seguir mostra como construir uma tabela com todas as bordas habilitadas (grade):

// 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));
// Clear any existing borders from the table.
table->ClearBorders();
// Set a green border around and inside the table.
table->SetBorders(LineStyle::Single, 1.5, System::Drawing::Color::get_Green());
doc->Save(ArtifactsDir + u"WorkingWithTableStylesAndFormatting.BuildTableWithBorders.docx");

Formatação De Nível De Linha

Nível da linha

As imagens abaixo mostram uma representação das características de formatação Row em Microsoft Word e suas propriedades correspondentes em Aspose.Words.

formatting-row-level-aspose-words-cpp

O exemplo de código a seguir mostra como modificar a formatação da linha da tabela:

// 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));
// Retrieve the first row in the table.
SharedPtr<Row> firstRow = table->get_FirstRow();
firstRow->get_RowFormat()->get_Borders()->set_LineStyle(LineStyle::None);
firstRow->get_RowFormat()->set_HeightRule(HeightRule::Auto);
firstRow->get_RowFormat()->set_AllowBreakAcrossPages(true);

Formatação De Nível De Célula

A formatação no nível da célula é controlada pelas classes Cell, CellFormat e CellCollection.

As imagens abaixo mostram uma representação das características de formatação Cell em Microsoft Word e suas propriedades correspondentes em Aspose.Words.

formatting-cell-level-aspose-words-cpp

auto-formatting-cell-level-aspose-words-cpp

O exemplo de código a seguir mostra como modificar a formatação de uma célula da tabela:

// 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<Cell> firstCell = table->get_FirstRow()->get_FirstCell();
firstCell->get_CellFormat()->set_Width(30);
firstCell->get_CellFormat()->set_Orientation(TextOrientation::Downward);
firstCell->get_CellFormat()->get_Shading()->set_ForegroundPatternColor(System::Drawing::Color::get_LightGreen());

O exemplo de código a seguir mostra como definir a quantidade de espaço (em pontos) a ser adicionada à esquerda / superior / direita / inferior do conteúdo da célula:

// 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->InsertCell();
// Sets the amount of space (in points) to add to the left/top/right/bottom of the cell's contents.
builder->get_CellFormat()->SetPaddings(30, 50, 30, 50);
builder->Writeln(u"I'm a wonderful formatted cell.");
builder->EndRow();
builder->EndTable();
doc->Save(ArtifactsDir + u"WorkingWithTableStylesAndFormatting.CellPadding.docx");
view raw cell-padding.h hosted with ❤ by GitHub

Especificar As Alturas Das Linhas

A maneira mais simples de definir a altura da linha é usar o DocumentBuilder. Usando as propriedades RowFormat apropriadas, você pode definir a configuração de altura padrão ou aplicar uma altura diferente para cada linha da tabela.

Em Aspose.Words, a altura da linha da tabela é controlada por:

  • a propriedade altura da linha - Height
  • a propriedade da regra de altura para a linha fornecida - HeightRule

Ao mesmo tempo, uma altura diferente pode ser definida para cada linha – Isso permite que você controle amplamente as configurações da tabela.

O exemplo de código a seguir mostra como criar uma tabela que contém uma única célula e aplicar a formatação de linha:

// 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);
SharedPtr<Table> table = builder->StartTable();
builder->InsertCell();
SharedPtr<RowFormat> rowFormat = builder->get_RowFormat();
rowFormat->set_Height(100);
rowFormat->set_HeightRule(HeightRule::Exactly);
// These formatting properties are set on the table and are applied to all rows in the table.
table->set_LeftPadding(30);
table->set_RightPadding(30);
table->set_TopPadding(30);
table->set_BottomPadding(30);
builder->Writeln(u"I'm a wonderful formatted row.");
builder->EndRow();
builder->EndTable();
doc->Save(ArtifactsDir + u"WorkingWithTableStylesAndFormatting.ApplyRowFormatting.docx");

Especificação das larguras das tabelas e das células

Uma tabela em um documento Microsoft Word fornece várias maneiras diferentes de redimensionar a tabela e as células individuais. Essas propriedades permitem um controle considerável sobre a aparência e o comportamento da tabela, de modo que Aspose.Words suporta o comportamento das tabelas, como em Microsoft Word.

É importante saber que os elementos da tabela apresentam várias propriedades diferentes que podem afetar a forma como as larguras da tabela geral, bem como as células individuais, são calculadas:

  • Largura preferida sobre a mesa
  • Largura preferida em células individuais
  • Permitindo a adaptação automática na mesa

Este artigo detalha como as várias propriedades de cálculo da largura da tabela funcionam e como obter controle total sobre o cálculo da largura da tabela. Isto é especialmente útil saber em casos em que o layout da tabela não aparece como esperado.

Como utilizar a largura preferida

A largura desejada de uma tabela ou células individuais é definida através da propriedade largura preferida, que é o tamanho que um elemento se esforça para ajustar. Ou seja, a largura preferida pode ser especificada para toda a tabela ou para células individuais. Em algumas situações, pode não ser possível ajustar exactamente esta largura, mas a largura real será próxima deste valor na maioria dos casos.

O tipo e o valor de largura preferidos apropriados são definidos usando os métodos da classe PreferredWidth:

  • o método Auto para especificar auto ou “sem largura preferencial”
  • o método FromPercent para especificar uma largura percentual
  • o método FromPoints para especificar a largura em pontos

As imagens abaixo mostram uma representação do preferred width setting features em Microsoft Word e suas propriedades correspondentes em Aspose.Words.

formatting-table-properties-aspose-words-cpp

Um exemplo de como essas opções são aplicadas a uma tabela real em um documento pode ser visto na figura abaixo.

todo:image_alt_text

Especifique a largura da tabela ou da célula preferida

Em Aspose.Words, as larguras da tabela e da célula são definidas usando a propriedade Table.PreferredWidth e a propriedade CellFormat.PreferredWidth, com opções disponíveis na enumeração PreferredWidthType:

  • Auto, que é equivalente a nenhum conjunto de largura preferencial
  • Percent, que ajusta o elemento em relação ao espaço disponível na janela ou no tamanho do recipiente e recalcula o valor quando a largura disponível muda
  • Points, que corresponde a um elemento da largura especificada em pontos

O uso da propriedade Table.PreferredWidth ajustará sua largura preferida em relação ao contêiner: página, coluna de texto ou célula externa da tabela, se for uma tabela aninhada.

O exemplo de código a seguir mostra como definir a tabela para ajuste automático em 50% da largura da página:

// 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);
// Insert a table with a width that takes up half the page width.
SharedPtr<Table> table = builder->StartTable();
builder->InsertCell();
table->set_PreferredWidth(PreferredWidth::FromPercent(50));
builder->Writeln(u"Cell #1");
builder->InsertCell();
builder->Writeln(u"Cell #2");
builder->InsertCell();
builder->Writeln(u"Cell #3");
doc->Save(ArtifactsDir + u"WorkingWithTables.AutoFitToPageWidth.docx");

Usar a propriedade CellFormat.PreferredWidth em uma determinada célula ajustará sua largura preferida.

O exemplo de código a seguir mostra como definir as diferentes configurações de largura preferidas:

// 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);
// Insert a table row made up of three cells which have different preferred widths.
builder->StartTable();
// Insert an absolute sized cell.
builder->InsertCell();
builder->get_CellFormat()->set_PreferredWidth(PreferredWidth::FromPoints(40));
builder->get_CellFormat()->get_Shading()->set_BackgroundPatternColor(System::Drawing::Color::get_LightYellow());
builder->Writeln(u"Cell at 40 points width");
// Insert a relative (percent) sized cell.
builder->InsertCell();
builder->get_CellFormat()->set_PreferredWidth(PreferredWidth::FromPercent(20));
builder->get_CellFormat()->get_Shading()->set_BackgroundPatternColor(System::Drawing::Color::get_LightBlue());
builder->Writeln(u"Cell at 20% width");
// Insert a auto sized cell.
builder->InsertCell();
builder->get_CellFormat()->set_PreferredWidth(PreferredWidth::Auto());
builder->get_CellFormat()->get_Shading()->set_BackgroundPatternColor(System::Drawing::Color::get_LightGreen());
builder->Writeln(u"Cell automatically sized. The size of this cell is calculated from the table preferred width.");
builder->Writeln(u"In this case the cell will fill up the rest of the available space.");
doc->Save(ArtifactsDir + u"WorkingWithTables.PreferredWidthSettings.docx");

Encontre o tipo e o valor de largura preferidos

Você pode usar as propriedades Type e Value para encontrar os detalhes de largura preferidos da tabela ou célula desejada.

O exemplo de código a seguir mostra como recuperar o tipo de largura preferido de uma célula de tabela:

// 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));
table->set_AllowAutoFit(true);
SharedPtr<Cell> firstCell = table->get_FirstRow()->get_FirstCell();
PreferredWidthType type = firstCell->get_CellFormat()->get_PreferredWidth()->get_Type();
double value = firstCell->get_CellFormat()->get_PreferredWidth()->get_Value();

Como definir o ajuste automático

A propriedade AllowAutoFit permite que as células de uma tabela cresçam e encolham de acordo com um critério selecionado. Por exemplo, você pode usar a opção AutoFit to Window para ajustar a tabela à largura da página e a opção AutoFit to Content para permitir que cada célula cresça ou diminua de acordo com seu conteúdo.

Por padrão, Aspose.Words insere uma nova tabela usando AutoFit to Window. A tabela será dimensionada de acordo com a largura da página disponível. Para redimensionar uma tabela, você pode chamar o método AutoFit. Este método aceita uma enumeração AutoFitBehavior que especifica que tipo de ajuste automático é aplicado à tabela.

É importante saber que o método autofit é, na verdade, um atalho que aplica propriedades diferentes à tabela ao mesmo tempo. Estas são propriedades que realmente dão à tabela o comportamento observado. Discutiremos essas propriedades para cada opção de ajuste automático.

O exemplo de código a seguir mostra como definir uma tabela para reduzir ou aumentar cada célula de acordo com seu conteúdo:

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

AutoFit Tabela Para Janela

Quando o ajuste automático a uma janela é aplicado a uma tabela, as seguintes operações são realmente realizadas nos bastidores:

  1. A propriedade Table.AllowAutoFit está habilitada para redimensionar automaticamente as colunas para se ajustarem ao conteúdo disponível, usando um valor Table.PreferredWidth de 100%
  2. CellFormat.PreferredWidth é removido de todas as células da tabela
  3. As larguras das colunas são recalculadas para o conteúdo atual da tabela – o resultado final é uma tabela que ocupa toda a largura disponível
  4. A largura das colunas na tabela muda automaticamente à medida que o utilizador edita o texto

O exemplo de código a seguir mostra como ajustar automaticamente uma tabela à largura da página:

// 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));
// Autofit the first table to the page width.
table->AutoFit(AutoFitBehavior::AutoFitToWindow);
doc->Save(ArtifactsDir + u"WorkingWithTables.AutoFitTableToWindow.docx");

AutoFit tabela para conteúdo

Quando a tabela é ajustada automaticamente ao conteúdo, as etapas a seguir são realmente executadas nos bastidores:

  1. A propriedade Table.AllowAutoFit está habilitada para redimensionar automaticamente cada célula de acordo com seu conteúdo

  2. A largura da tabela preferida é removida de Table.PreferredWidth, CellFormat.PreferredWidth é removida para cada célula da tabela

  3. As larguras das colunas são recalculadas para o conteúdo atual da tabela – o resultado final é uma tabela em que as larguras das colunas e a largura de toda a tabela são redimensionadas automaticamente para melhor se ajustarem ao conteúdo à medida que o usuário edita o texto

O exemplo de código a seguir mostra como ajustar automaticamente uma tabela ao seu conteúdo:

// 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));
table->AutoFit(AutoFitBehavior::AutoFitToContents);
doc->Save(ArtifactsDir + u"WorkingWithTables.AutoFitTableToContents.docx");

Desactivar AutoFit na tabela e utilizar larguras de coluna fixas

Se uma tabela tiver o ajuste automático desativado e forem utilizadas larguras de coluna fixas, são executadas as seguintes etapas:

  1. Table.AllowAutoFit a propriedade está desativada para que as colunas não aumentem ou diminuam para o seu conteúdo
  2. A largura preferida de toda a tabela é removida de Table.PreferredWidth, CellFormat.PreferredWidth é removida de todas as células da tabela
  3. O resultado final é uma tabela cujas larguras de coluna são determinadas pela propriedade CellFormat.Width e cujas colunas não são redimensionadas automaticamente quando o usuário insere texto ou quando a página é redimensionada

O exemplo de código a seguir mostra como desativar o ajuste automático e ativar a largura fixa para a tabela especificada:

// 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));
// Disable autofitting on this table.
table->AutoFit(AutoFitBehavior::FixedColumnWidths);
doc->Save(ArtifactsDir + u"WorkingWithTables.AutoFitTableToFixedColumnWidths.docx");

Ordem de precedência no cálculo da largura da célula

Aspose.Words permite que os usuários definam a largura de uma tabela ou célula por meio de vários objetos, incluindo CellFormat – sua propriedade Width é principalmente remanescente de versões anteriores, no entanto, ainda é útil para simplificar a configuração da largura da célula.

É importante saber que a propriedade CellFormat.Width funciona de forma diferente dependendo de qual das outras propriedades width já existem na tabela.

Aspose.Words usa a seguinte ordem para calcular as larguras das células:

Ordem Propriedade Descrição
AllowAutoFit é determinado Se AutoFit estiver activado:
- a tabela pode crescer além da largura preferida para acomodar o conteúdo-geralmente não encolhe abaixo da largura preferida
- qualquer alteração no valor CellFormat.Width é ignorada e a célula se ajustará ao seu conteúdo
PreferredWidthType com um valor de Points ou Percent CellFormat.Width é ignorado
PreferredWidthType com um valor de Auto O valor de CellFormat.Width é copiado e torna-se a largura preferida da célula (em pontos)

Permitir Espaçamento Entre Células

Você pode obter ou definir qualquer espaço adicional entre as células da tabela semelhante à opção" espaçamento entre células " em Microsoft Word. Isso pode ser feito usando a propriedade AllowCellSpacing.

Um exemplo de como essas opções são aplicadas a uma tabela real em um documento pode ser visto na figura abaixo.

formatting-spacing-between-cells-aspose-words-cpp

O exemplo de código a seguir mostra como definir o espaçamento entre as células:

// 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));
table->set_AllowCellSpacing(true);
table->set_CellSpacing(2);
doc->Save(ArtifactsDir + u"WorkingWithTableStylesAndFormatting.AllowCellSpacing.docx");

Aplicar bordas e sombreamento

Bordas e sombreamento podem ser aplicados a toda a tabela usando Table.SetBorder, Table.SetBorders e Table.SetShading, ou apenas a células específicas usando CellFormat.Borders e CellFormat.Shading. Além disso, as bordas das linhas podem ser definidas usando RowFormat.Borders, no entanto, o sombreamento não pode ser aplicado dessa maneira.

As imagens abaixo mostram as configurações de borda e sombra em Microsoft Word e suas propriedades correspondentes em Aspose.Words.

formatting-border-line-aspose-words-cpp

formatting-cell-color-aspose-words-cpp

O exemplo de código a seguir mostra como formatar uma tabela e uma célula com bordas e sombreamentos diferentes:

// 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);
SharedPtr<Table> table = builder->StartTable();
builder->InsertCell();
// Set the borders for the entire table.
table->SetBorders(LineStyle::Single, 2.0, System::Drawing::Color::get_Black());
// Set the cell shading for this cell.
builder->get_CellFormat()->get_Shading()->set_BackgroundPatternColor(System::Drawing::Color::get_Red());
builder->Writeln(u"Cell #1");
builder->InsertCell();
// Specify a different cell shading for the second cell.
builder->get_CellFormat()->get_Shading()->set_BackgroundPatternColor(System::Drawing::Color::get_Green());
builder->Writeln(u"Cell #2");
builder->EndRow();
// Clear the cell formatting from previous operations.
builder->get_CellFormat()->ClearFormatting();
builder->InsertCell();
// Create larger borders for the first cell of this row. This will be different
// compared to the borders set for the table.
builder->get_CellFormat()->get_Borders()->get_Left()->set_LineWidth(4.0);
builder->get_CellFormat()->get_Borders()->get_Right()->set_LineWidth(4.0);
builder->get_CellFormat()->get_Borders()->get_Top()->set_LineWidth(4.0);
builder->get_CellFormat()->get_Borders()->get_Bottom()->set_LineWidth(4.0);
builder->Writeln(u"Cell #3");
builder->InsertCell();
builder->get_CellFormat()->ClearFormatting();
builder->Writeln(u"Cell #4");
doc->Save(ArtifactsDir + u"WorkingWithTableStylesAndFormatting.FormatTableAndCellWithDifferentBorders.docx");