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.
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.
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.
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-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"); |
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.
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.
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.
Um exemplo de como essas opções são aplicadas a uma tabela real em um documento pode ser visto na figura abaixo.
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:
- 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%
- 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.
- 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
- 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:
-
A propriedade Table.AllowAutoFit está habilitada para redimensionar automaticamente cada célula de acordo com seu conteúdo
-
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. -
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:
- Table.AllowAutoFit a propriedade está desativada para que as colunas não aumentem ou diminuam para o seu conteúdo
- A largura preferida de toda a tabela é removida de Table.PreferredWidth, CellFormat.PreferredWidth é removida de todas as células da tabela
- 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.

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.
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"); |