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

formatting-table-options-aspose-words-python

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-Python-via-.NET.git.
doc = aw.Document(MY_DIR + "Tables.docx")
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table()
# Align the table to the center of the page.
table.alignment = aw.tables.TableAlignment.CENTER
# Clear any existing borders from the table.
table.clear_borders()
# Set a green border around the table but not inside.
table.set_border(aw.BorderType.LEFT, aw.LineStyle.SINGLE, 1.5, drawing.Color.green, True)
table.set_border(aw.BorderType.RIGHT, aw.LineStyle.SINGLE, 1.5, drawing.Color.green, True)
table.set_border(aw.BorderType.TOP, aw.LineStyle.SINGLE, 1.5, drawing.Color.green, True)
table.set_border(aw.BorderType.BOTTOM, aw.LineStyle.SINGLE, 1.5, drawing.Color.green, True)
# Fill the cells with a light green solid color.
table.set_shading(aw.TextureIndex.TEXTURE_SOLID, drawing.Color.light_green, drawing.Color.empty())
doc.save(ARTIFACTS_DIR + "WorkingWithTableStylesAndFormatting.apply_outline_border.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-Python-via-.NET.git.
doc = aw.Document(MY_DIR + "Tables.docx")
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table()
# Clear any existing borders from the table.
table.clear_borders()
# Set a green border around and inside the table.
table.set_borders(aw.LineStyle.SINGLE, 1.5, drawing.Color.green)
doc.save(ARTIFACTS_DIR + "WorkingWithTableStylesAndFormatting.build_table_with_borders.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-python

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-Python-via-.NET.git.
doc = aw.Document(MY_DIR + "Tables.docx")
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table()
# Retrieve the first row in the table.
first_row = table.first_row
first_row.row_format.borders.line_style = aw.LineStyle.NONE
first_row.row_format.height_rule = aw.HeightRule.AUTO
first_row.row_format.allow_break_across_pages = 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-python

auto-formatting-cell-level-aspose-words-python

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-Python-via-.NET.git.
doc = aw.Document(MY_DIR + "Tables.docx")
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table()
first_cell = table.first_row.first_cell
first_cell.cell_format.width = 30
first_cell.cell_format.orientation = aw.TextOrientation.DOWNWARD
first_cell.cell_format.shading.foreground_pattern_color = drawing.Color.light_green

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-Python-via-.NET.git.
doc = aw.Document()
builder = aw.DocumentBuilder(doc)
builder.start_table()
builder.insert_cell()
# Sets the amount of space (in points) to add to the left/top/right/bottom of the cell's contents.
builder.cell_format.set_paddings(30, 50, 30, 50)
builder.writeln("I'm a wonderful formatted cell.")
builder.end_row()
builder.end_table()
doc.save(ARTIFACTS_DIR + "WorkingWithTableStylesAndFormatting.cell_padding.docx")
view raw cell-padding.py 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-Python-via-.NET.git.
doc = aw.Document()
builder = aw.DocumentBuilder(doc)
table = builder.start_table()
builder.insert_cell()
row_format = builder.row_format
row_format.height = 100
row_format.height_rule = aw.HeightRule.EXACTLY
# These formatting properties are set on the table and are applied to all rows in the table.
table.left_padding = 30
table.right_padding = 30
table.top_padding = 30
table.bottom_padding = 30
builder.writeln("I'm a wonderful formatted row.")
builder.end_row()
builder.end_table()
doc.save(ARTIFACTS_DIR + "WorkingWithTableStylesAndFormatting.apply_row_formatting.docx")

Especificando 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 preferencial, 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-python

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

tables-applying-options-python

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-Python-via-.NET.git.
doc = aw.Document(MY_DIR + "Tables.docx")
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table()
# Autofit the first table to the page width.
table.auto_fit(aw.tables.AutoFitBehavior.AUTO_FIT_TO_WINDOW)
doc.save(ARTIFACTS_DIR + "WorkingWithTables.auto_fit_table_to_window.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-Python-via-.NET.git.
doc = aw.Document()
builder = aw.DocumentBuilder(doc)
# Insert a table row made up of three cells which have different preferred widths.
builder.start_table()
# Insert an absolute sized cell.
builder.insert_cell()
builder.cell_format.preferred_width = aw.tables.PreferredWidth.from_points(40)
builder.cell_format.shading.background_pattern_color = drawing.Color.light_yellow
builder.writeln("Cell at 40 points width")
# Insert a relative (percent) sized cell.
builder.insert_cell()
builder.cell_format.preferred_width = aw.tables.PreferredWidth.from_percent(20)
builder.cell_format.shading.background_pattern_color = drawing.Color.light_blue
builder.writeln("Cell at 20% width")
# Insert a auto sized cell.
builder.insert_cell()
builder.cell_format.preferred_width = aw.tables.PreferredWidth.AUTO
builder.cell_format.shading.background_pattern_color = drawing.Color.light_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(ARTIFACTS_DIR + "WorkingWithTables.preferred_width_settings.docx")

Encontrando 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-Python-via-.NET.git.
doc = aw.Document(MY_DIR + "Tables.docx")
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table()
table.allow_auto_fit = True
first_cell = table.first_row.first_cell
type_ = first_cell.cell_format.preferred_width.type
value = first_cell.cell_format.preferred_width.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-Python-via-.NET.git.
table.allow_auto_fit = 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-Python-via-.NET.git.
doc = aw.Document(MY_DIR + "Tables.docx")
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table()
# Autofit the first table to the page width.
table.auto_fit(aw.tables.AutoFitBehavior.AUTO_FIT_TO_WINDOW)
doc.save(ARTIFACTS_DIR + "WorkingWithTables.auto_fit_table_to_window.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-Python-via-.NET.git.
doc = aw.Document(MY_DIR + "Tables.docx")
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table()
table.auto_fit(aw.tables.AutoFitBehavior.AUTO_FIT_TO_CONTENTS)
doc.save(ARTIFACTS_DIR + "WorkingWithTables.auto_fit_table_to_contents.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-Python-via-.NET.git.
doc = aw.Document(MY_DIR + "Tables.docx")
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table()
# Disable autofitting on this table.
table.auto_fit(aw.tables.AutoFitBehavior.FIXED_COLUMN_WIDTHS)
doc.save(ARTIFACTS_DIR + "WorkingWithTables.auto_fit_table_to_fixed_column_widths.docx")

A 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-palavras-python

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-Python-via-.NET.git.
doc = aw.Document(MY_DIR + "Tables.docx")
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table()
table.allow_cell_spacing = True
table.cell_spacing = 2
doc.save(ARTIFACTS_DIR + "WorkingWithTableStylesAndFormatting.allow_cell_spacing.docx")

Aplicando 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-python

formatting-cell-color-aspose-words-python

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-Python-via-.NET.git.
doc = aw.Document()
builder = aw.DocumentBuilder(doc)
table = builder.start_table()
builder.insert_cell()
# Set the borders for the entire table.
table.set_borders(aw.LineStyle.SINGLE, 2.0, drawing.Color.black)
# Set the cell shading for this cell.
builder.cell_format.shading.background_pattern_color = drawing.Color.red
builder.writeln("Cell #1")
builder.insert_cell()
# Specify a different cell shading for the second cell.
builder.cell_format.shading.background_pattern_color = drawing.Color.green
builder.writeln("Cell #2")
builder.end_row()
# Clear the cell formatting from previous operations.
builder.cell_format.clear_formatting()
builder.insert_cell()
# Create larger borders for the first cell of this row. This will be different
# compared to the borders set for the table.
builder.cell_format.borders.left.line_width = 4.0
builder.cell_format.borders.right.line_width = 4.0
builder.cell_format.borders.top.line_width = 4.0
builder.cell_format.borders.bottom.line_width = 4.0
builder.writeln("Cell #3")
builder.insert_cell()
builder.cell_format.clear_formatting()
builder.writeln("Cell #4")
doc.save(ARTIFACTS_DIR + "WorkingWithTableStylesAndFormatting.format_table_and_cell_with_different_borders.docx")