Aplicar formatação de tabela

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 e a formatação de células apenas a determinadas células.

Aspose.Words fornece um API rico 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 o Aspose.Words suporta.

Aplicar formatação a diferentes nós

Nesta seção, veremos como aplicar a formatação a vários nós da tabela.

Formatação em nível de tabela

Para aplicar 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 dos recursos de formatação Table em Microsoft Word e suas propriedades correspondentes em Aspose.Words.

formattin-features-table-level-aspose-words-net

formatting-table-options-aspose-words-net

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-.NET.git.
Document doc = new Document(MyDir + "Tables.docx");
Table table = (Table) doc.GetChild(NodeType.Table, 0, true);
// Align the table to the center of the page.
table.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, Color.Green, true);
table.SetBorder(BorderType.Right, LineStyle.Single, 1.5, Color.Green, true);
table.SetBorder(BorderType.Top, LineStyle.Single, 1.5, Color.Green, true);
table.SetBorder(BorderType.Bottom, LineStyle.Single, 1.5, Color.Green, true);
// Fill the cells with a light green solid color.
table.SetShading(TextureIndex.TextureSolid, Color.LightGreen, Color.Empty);
doc.Save(ArtifactsDir + "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-.NET.git.
Document doc = new Document(MyDir + "Tables.docx");
Table table = (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, Color.Green);
doc.Save(ArtifactsDir + "WorkingWithTableStylesAndFormatting.BuildTableWithBorders.docx");

Formatação em nível de linha

A formatação Nível de linha pode ser controlada usando as classes Row, RowFormat e RowCollection.

As imagens abaixo mostram uma representação dos recursos de formatação Row em Microsoft Word e suas propriedades correspondentes em Aspose.Words.

formatting-row-level-aspose-words-net

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-.NET.git.
Document doc = new Document(MyDir + "Tables.docx");
Table table = (Table) doc.GetChild(NodeType.Table, 0, true);
// Retrieve the first row in the table.
Row firstRow = table.FirstRow;
firstRow.RowFormat.Borders.LineStyle = LineStyle.None;
firstRow.RowFormat.HeightRule = HeightRule.Auto;
firstRow.RowFormat.AllowBreakAcrossPages = true;

Formatação em nível de célula

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

As imagens abaixo mostram uma representação dos recursos de formatação Cell em Microsoft Word e suas propriedades correspondentes em Aspose.Words.

formatting-cell-level-aspose-words-net

auto-formatting-cell-level-aspose-words-net

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-.NET.git.
Document doc = new Document(MyDir + "Tables.docx");
Table table = (Table) doc.GetChild(NodeType.Table, 0, true);
Cell firstCell = table.FirstRow.FirstCell;
firstCell.CellFormat.Width = 30;
firstCell.CellFormat.Orientation = TextOrientation.Downward;
firstCell.CellFormat.Shading.ForegroundPatternColor = Color.LightGreen;

O exemplo de código a seguir mostra como definir a quantidade de espaço (em pontos) a ser adicionado à 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-.NET.git.
Document doc = new Document();
DocumentBuilder builder = new 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.CellFormat.SetPaddings(30, 50, 30, 50);
builder.Writeln("I'm a wonderful formatted cell.");
builder.EndRow();
builder.EndTable();
doc.Save(ArtifactsDir + "WorkingWithTableStylesAndFormatting.CellPadding.docx");
view raw cell-padding.cs hosted with ❤ by GitHub

Especifique as alturas das linhas

A maneira mais simples de definir a altura da linha é usar 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.

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

  • a propriedade de 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 controlar amplamente as configurações da mesa.

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

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
Table table = builder.StartTable();
builder.InsertCell();
RowFormat rowFormat = builder.RowFormat;
rowFormat.Height = 100;
rowFormat.HeightRule = HeightRule.Exactly;
// These formatting properties are set on the table and are applied to all rows in the table.
table.LeftPadding = 30;
table.RightPadding = 30;
table.TopPadding = 30;
table.BottomPadding = 30;
builder.Writeln("I'm a wonderful formatted row.");
builder.EndRow();
builder.EndTable();
doc.Save(ArtifactsDir + "WorkingWithTableStylesAndFormatting.ApplyRowFormatting.docx");

Especifique larguras de tabelas e células

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

É importante saber que os elementos da tabela apresentam diversas propriedades diferentes que podem afetar o cálculo da largura da tabela geral, bem como das células individuais:

  • Largura preferida na mesa
  • Largura preferida em células individuais
  • Permitindo ajuste automático na mesa

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

Como usar a largura preferida

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

O tipo e valor de largura preferencial apropriado 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 dos recursos de configuração de largura preferidos em Microsoft Word e suas propriedades correspondentes em Aspose.Words.

formatting-table-properties-aspose-words-net

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

todo:image_alt_text

Especifique a tabela preferida ou a largura da célula

No Aspose.Words, as larguras das tabelas e das células são definidas usando a propriedade Table.PreferredWidth e a propriedade CellFormat.PreferredWidth, com opções disponíveis na enumeração PreferredWidthType:

  • Auto, que equivale a nenhum conjunto de largura preferencial
  • Percent, que ajusta o elemento em relação ao espaço disponível no tamanho da janela ou contêiner e recalcula o valor quando a largura disponível muda
  • Points, que corresponde a um elemento com a 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-.NET.git.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
// Insert a table with a width that takes up half the page width.
Table table = builder.StartTable();
builder.InsertCell();
table.PreferredWidth = PreferredWidth.FromPercent(50);
builder.Writeln("Cell #1");
builder.InsertCell();
builder.Writeln("Cell #2");
builder.InsertCell();
builder.Writeln("Cell #3");
doc.Save(ArtifactsDir + "WorkingWithTables.AutoFitPageWidth.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-.NET.git.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
// Insert a table row made up of three cells which have different preferred widths.
// Insert an absolute sized cell.
builder.InsertCell();
builder.CellFormat.PreferredWidth = PreferredWidth.FromPoints(40);
builder.CellFormat.Shading.BackgroundPatternColor = Color.LightYellow;
builder.Writeln("Cell at 40 points width");
// Insert a relative (percent) sized cell.
builder.InsertCell();
builder.CellFormat.PreferredWidth = PreferredWidth.FromPercent(20);
builder.CellFormat.Shading.BackgroundPatternColor = Color.LightBlue;
builder.Writeln("Cell at 20% width");
// Insert a auto sized cell.
builder.InsertCell();
builder.CellFormat.PreferredWidth = PreferredWidth.Auto;
builder.CellFormat.Shading.BackgroundPatternColor = Color.LightGreen;
builder.Writeln(
"Cell automatically sized. The size of this cell is calculated from the table preferred width.");
builder.Writeln("In this case the cell will fill up the rest of the available space.");
doc.Save(ArtifactsDir + "WorkingWithTables.PreferredWidthSettings.docx");

Encontre o tipo e valor de largura preferido

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 preferencial de uma célula da tabela:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document(MyDir + "Tables.docx");
Table table = (Table) doc.GetChild(NodeType.Table, 0, true);
table.AllowAutoFit = true;
Cell firstCell = table.FirstRow.FirstCell;
PreferredWidthType type = firstCell.CellFormat.PreferredWidth.Type;
double value = firstCell.CellFormat.PreferredWidth.Value;

Como definir o ajuste automático

A propriedade AllowAutoFit permite que as células de uma tabela aumentem e diminuam de acordo com um critério selecionado. Por exemplo, você pode usar a opção Ajustar automaticamente à janela para ajustar a tabela à largura da página e a opção Ajuste automático ao conteúdo para permitir que cada célula aumente ou diminua de acordo com seu conteúdo.

Por padrão, Aspose.Words insere uma nova tabela usando Ajustar automaticamente à janela. A tabela será dimensionada de acordo com a largura de 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 diferentes propriedades à tabela ao mesmo tempo. Estas são propriedades que realmente conferem à tabela o comportamento observado. Discutiremos essas propriedades para cada opção de ajuste automático.

O exemplo de código a seguir mostra como configurar 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-.NET.git.
table.AllowAutoFit = true;

Ajustar automaticamente a tabela à janela

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

  1. A propriedade Table.AllowAutoFit está habilitada para redimensionar colunas automaticamente para caber no 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 da tabela muda automaticamente conforme o usuário 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-.NET.git.
Document doc = new Document(MyDir + "Tables.docx");
Table table = (Table) doc.GetChild(NodeType.Table, 0, true);
// Autofit the first table to the page width.
table.AutoFit(AutoFitBehavior.AutoFitToWindow);
doc.Save(ArtifactsDir + "WorkingWithTables.AutoFitTableToWindow.docx");

Ajustar automaticamente a tabela ao conteúdo

Quando a tabela é ajustada automaticamente ao conteúdo, as etapas a seguir são 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 preferencial da tabela é removida do Table.PreferredWidth, o CellFormat.PreferredWidth é removido 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 onde as larguras das colunas e a largura de toda a tabela são redimensionadas automaticamente para melhor ajustar o conteúdo conforme 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-.NET.git.
Document doc = new Document(MyDir + "Tables.docx");
Table table = (Table) doc.GetChild(NodeType.Table, 0, true);
table.AutoFit(AutoFitBehavior.AutoFitToContents);
doc.Save(ArtifactsDir + "WorkingWithTables.AutoFitTableToContents.docx");

Desative o ajuste automático na tabela e use larguras de coluna fixas

Se uma tabela tiver o ajuste automático desabilitado e forem usadas larguras de coluna fixas, as seguintes etapas serão executadas:

  1. A propriedade Table.AllowAutoFit está desativada para que as colunas não aumentem ou diminuam de acordo com seu conteúdo

  2. A largura preferencial de toda a tabela é removida de Table.PreferredWidth, CellFormat.PreferredWidth é removido 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 desabilitar o ajuste automático e habilitar largura fixa para a tabela especificada:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document(MyDir + "Tables.docx");
Table table = (Table) doc.GetChild(NodeType.Table, 0, true);
// Disable autofitting on this table.
table.AutoFit(AutoFitBehavior.FixedColumnWidths);
doc.Save(ArtifactsDir + "WorkingWithTables.AutoFitTableToFixedColumnWidths.docx");

Ordem de precedência ao calcular a largura da célula

Aspose.Words permite aos usuários definir a largura de uma tabela ou célula por meio de vários objetos, incluindo CellFormat – sua propriedade Width é em grande parte 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 quais das outras propriedades de largura já existem na tabela.

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

Ordem Propriedade Descrição
1 AllowAutoFit é determinado Se AutoFit estiver ativado:
- a tabela pode ultrapassar a largura preferida para acomodar o conteúdo – geralmente não diminui abaixo da largura preferida
- qualquer alteração no valor CellFormat.Width será ignorada e a célula caberá em seu conteúdo
2 PreferredWidthType com valor Points ou Percent CellFormat.Width é ignorado
3 PreferredWidthType com valor Auto O valor do CellFormat.Width é copiado e se torna 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” no Microsoft Word. Isso pode ser feito usando a propriedade AllowCellSpacing.

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

formatação-espaçamento-entre-células-aspose-words-net

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

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document(MyDir + "Tables.docx");
Table table = (Table) doc.GetChild(NodeType.Table, 0, true);
table.AllowCellSpacing = true;
table.CellSpacing = 2;
doc.Save(ArtifactsDir + "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, porém o sombreamento não pode ser aplicado desta forma.

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-net

formatting-cell-color-aspose-words-net

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-.NET.git.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
Table table = builder.StartTable();
builder.InsertCell();
// Set the borders for the entire table.
table.SetBorders(LineStyle.Single, 2.0, Color.Black);
// Set the cell shading for this cell.
builder.CellFormat.Shading.BackgroundPatternColor = Color.Red;
builder.Writeln("Cell #1");
builder.InsertCell();
// Specify a different cell shading for the second cell.
builder.CellFormat.Shading.BackgroundPatternColor = Color.Green;
builder.Writeln("Cell #2");
builder.EndRow();
// Clear the cell formatting from previous operations.
builder.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.CellFormat.Borders.Left.LineWidth = 4.0;
builder.CellFormat.Borders.Right.LineWidth = 4.0;
builder.CellFormat.Borders.Top.LineWidth = 4.0;
builder.CellFormat.Borders.Bottom.LineWidth = 4.0;
builder.Writeln("Cell #3");
builder.InsertCell();
builder.CellFormat.ClearFormatting();
builder.Writeln("Cell #4");
doc.Save(ArtifactsDir + "WorkingWithTableStylesAndFormatting.FormatTableAndCellWithDifferentBorders.docx");