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, 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.

Observe que a tabela deve ter pelo menos uma linha antes que as propriedades da tabela possam ser aplicadas. Isso significa que, ao construir uma tabela com o DocumentBuilder, essa formatação deve ser feita após a primeira chamada para InsertCell, ou depois que a primeira linha é adicionada à tabela, ou quando os nós são inseridos diretamente no DOM.

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

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-Java.git.
Document doc = new Document(getMyDir() + "Tables.docx");

Table table = (Table) doc.getChild(NodeType.TABLE, 0, true);
// Align the table to the center of the page.
table.setAlignment(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.TEXTURE_SOLID, Color.lightGray, new Color(0, true));

doc.save(getArtifactsDir() + "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-Java.git.
Document doc = new Document(getMyDir() + "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(getArtifactsDir() + "WorkingWithTableStylesAndFormatting.BuildTableWithBorders.docx");

Formatação De Nível De Linha

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

Observe que a Row só pode ser um nó filho de a Table. Ao mesmo tempo, deve haver pelo menos um Cell no Row para que a formatação possa ser aplicada a ele.

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

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-Java.git.
Document doc = new Document(getMyDir() + "Tables.docx");

Table table = (Table) doc.getChild(NodeType.TABLE, 0, true);
        
// Retrieve the first row in the table.
Row firstRow = table.getFirstRow();
firstRow.getRowFormat().getBorders().setLineStyle(LineStyle.NONE);
firstRow.getRowFormat().setHeightRule(HeightRule.AUTO);
firstRow.getRowFormat().setAllowBreakAcrossPages(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.

Observe que a Cell só pode ser um nó filho de a Row. Ao mesmo tempo, deve haver pelo menos um Paragraph no Cell para que a formatação possa ser aplicada a ele.

Além do Paragraph, Você também pode inserir um Table em um Cell.

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

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-Java.git.
Document doc = new Document(getMyDir() + "Tables.docx");
Table table = (Table) doc.getChild(NodeType.TABLE, 0, true);

Cell firstCell = table.getFirstRow().getFirstCell();
firstCell.getCellFormat().setWidth(30.0);
firstCell.getCellFormat().setOrientation(TextOrientation.DOWNWARD);
firstCell.getCellFormat().getShading().setForegroundPatternColor(Color.GREEN);

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-Java.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.getCellFormat().setPaddings(30.0, 50.0, 30.0, 50.0);
builder.writeln("I'm a wonderful formatted cell.");

builder.endRow();
builder.endTable();

doc.save(getArtifactsDir() + "WorkingWithTableStylesAndFormatting.CellPadding.docx");

Especificação Das 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.

As opções de regra para especificar a altura de um objecto podem ser definidas utilizando os campos HeightRule.

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-Java.git.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

Table table = builder.startTable();
builder.insertCell();

RowFormat rowFormat = builder.getRowFormat();
rowFormat.setHeight(100.0);
rowFormat.setHeightRule(HeightRule.EXACTLY);
        
// These formatting properties are set on the table and are applied to all rows in the table.
table.setLeftPadding(30.0);
table.setRightPadding(30.0);
table.setTopPadding(30.0);
table.setBottomPadding(30.0);

builder.writeln("I'm a wonderful formatted row.");

builder.endRow();
builder.endTable();

doc.save(getArtifactsDir() + "WorkingWithTableStylesAndFormatting.ApplyRowFormatting.docx");

Especificar as larguras da tabela e da célula

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.

Na maioria dos casos, a célula preferida é recomendada do que a largura da tabela. A largura da célula preferida está mais de acordo com a especificação do formato DOCX, bem como com o modelo Aspose.Words.

A largura da célula é, na verdade, um valor calculado para o formato DOCX. A largura real da célula pode depender de muitas coisas. Por exemplo, alterar as margens da página ou a largura da tabela preferida pode afetar a largura real da célula.

A largura da célula preferida é uma propriedade da célula armazenada no documento. Não depende de nada e não muda quando você altera a tabela ou outras propriedades da célula.

Todas as propriedades e métodos descritos neste artigo estão relacionados à forma como as tabelas funcionam em Microsoft Word. Portanto, na maioria dos casos, se você está construindo sua tabela programaticamente, mas está achando difícil criar a tabela desejada, você pode tentar criá-la visualmente em Microsoft Word primeiro e depois simplesmente copiar os valores de formatação em seu aplicativo.

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 campo 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.

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

Antes de poder utilizar a largura preferida numa tabela, deve assegurar-se de que a tabela contém pelo menos uma linha. Isso ocorre porque essa formatação de tabela em um documento Microsoft Word ou em um documento criado em Aspose.Words é armazenada nas linhas da tabela.

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

Por predefinição, uma tabela pode ser descrita como sendo ajustada a 100% do espaço disponível na página. Nesse caso, isso significa que a tabela tentará ocupar o espaço entre as margens da Página esquerda e direita.

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-Java.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.setPreferredWidth(PreferredWidth.fromPercent(50.0));
builder.writeln("Cell #1");

builder.insertCell();
builder.writeln("Cell #2");

builder.insertCell();
builder.writeln("Cell #3");

doc.save(getArtifactsDir() + "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-Java.git.
Document doc = new Document();
DocumentBuilder builder = new 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.getCellFormat().setPreferredWidth(PreferredWidth.fromPoints(40.0));
builder.getCellFormat().getShading().setBackgroundPatternColor(Color.YELLOW);
builder.writeln("Cell at 40 points width");

// Insert a relative (percent) sized cell.
builder.insertCell();
builder.getCellFormat().setPreferredWidth(PreferredWidth.fromPercent(20.0));
builder.getCellFormat().getShading().setBackgroundPatternColor(Color.BLUE);
builder.writeln("Cell at 20% width");

// Insert a auto sized cell.
builder.insertCell();
builder.getCellFormat().setPreferredWidth(PreferredWidth.AUTO);
builder.getCellFormat().getShading().setBackgroundPatternColor(Color.GREEN);
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(getArtifactsDir() + "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-Java.git.
Document doc = new Document(getMyDir() + "Tables.docx");

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

Cell firstCell = table.getFirstRow().getFirstCell();
/*PreferredWidthType*/int type = firstCell.getCellFormat().getPreferredWidth().getType();
double value = firstCell.getCellFormat().getPreferredWidth().getValue();

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.

Além disso, a propriedade AllowAutoFit pode ser usada em conjunto com uma largura de célula preferida para formatar uma célula que se ajusta automaticamente ao seu conteúdo, mas também tem uma largura inicial. Se necessário, a largura da célula pode então crescer além dessa largura.

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-Java.git.
table.setAllowAutoFit(true);

Usaremos a tabela a seguir para aplicar as várias configurações de ajuste automático como demonstração.

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
   Observe que isso é ligeiramente diferente do comportamento Microsoft Word, em que a largura preferida de cada célula é definida como valores apropriados com base em seu tamanho e conteúdo atuais. Aspose.Words não atualiza a largura preferida, então eles são limpos.
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-Java.git.
Document doc = new Document(getMyDir() + "Tables.docx");

Table table = (Table) doc.getChild(NodeType.TABLE, 0, true);
// Autofit the first table to the page width.
table.autoFit(AutoFitBehavior.AUTO_FIT_TO_WINDOW);

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

Um exemplo de como estas opções são aplicadas ao quadro acima pode ser visto na figura abaixo.

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

   Observe que esta opção de ajuste automático remove a largura preferida das células, assim como em Microsoft Word. Se você quiser manter os tamanhos das colunas e aumentar ou diminuir as colunas para se ajustarem ao conteúdo, defina a propriedade Table.AllowAutoFit como True por conta própria, em vez de usar o atalho de ajuste automático.

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-Java.git.
Document doc = new Document(getMyDir() + "Tables.docx");

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

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

Um exemplo de como estas opções são aplicadas ao quadro acima pode ser visto na figura abaixo.

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

Observe que, se nenhuma largura for especificada para CellFormat.Width, o valor padrão de uma polegada (72 pontos) será usado.

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-Java.git.
Document doc = new Document(getMyDir() + "Tables.docx");

Table table = (Table) doc.getChild(NodeType.TABLE, 0, true);
// Disable autofitting on this table.
table.autoFit(AutoFitBehavior.FIXED_COLUMN_WIDTHS);

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

Um exemplo de como estas opções são aplicadas ao quadro acima pode ser visto na figura abaixo.

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)

Quaisquer alterações na propriedade width não são atualizadas na largura preferida e devem ser aplicadas à largura preferida.

Ao criar um layout de tabela fixo, especifique a largura da célula. Uma célula sem largura não pode ser salva no formato DOC. Formatos de documentos diferentes de DOC, como DOCX, permitem, em princípio, guardar células sem largura num esquema de tabela fixo.

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.

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-Java.git.
Document doc = new Document(getMyDir() + "Tables.docx");

Table table = (Table) doc.getChild(NodeType.TABLE, 0, true);
table.setAllowCellSpacing(true);
table.setCellSpacing(2.0);
        
doc.save(getArtifactsDir() + "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.

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-Java.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.getCellFormat().getShading().setBackgroundPatternColor(Color.RED);
builder.writeln("Cell #1");

builder.insertCell();
        
// Specify a different cell shading for the second cell.
builder.getCellFormat().getShading().setBackgroundPatternColor(Color.GREEN);
builder.writeln("Cell #2");

builder.endRow();

// Clear the cell formatting from previous operations.
builder.getCellFormat().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.getCellFormat().getBorders().getLeft().setLineWidth(4.0);
builder.getCellFormat().getBorders().getRight().setLineWidth(4.0);
builder.getCellFormat().getBorders().getTop().setLineWidth(4.0);
builder.getCellFormat().getBorders().getBottom().setLineWidth(4.0);
builder.writeln("Cell #3");

builder.insertCell();
builder.getCellFormat().clearFormatting();
builder.writeln("Cell #4");
        
doc.save(getArtifactsDir() + "WorkingWithTableStylesAndFormatting.FormatTableAndCellWithDifferentBorders.docx");