Applica formattazione

Ogni elemento di una tabella può essere applicato con una formattazione diversa. Ad esempio, la formattazione della tabella verrà applicata all’intera tabella, la formattazione delle righe solo a righe particolari, la formattazione delle celle solo a determinate celle.

Aspose.Words fornisce una ricca API per recuperare e applicare la formattazione a una tabella. È possibile utilizzare i nodi Table, RowFormat e CellFormat per impostare la formattazione.

In questo articolo, parleremo di come applicare la formattazione a diversi nodi della tabella e quali impostazioni di formattazione della tabella Aspose.Words supportano.

Applicare la formattazione a diversi nodi

In questa sezione, esamineremo l’applicazione della formattazione a vari nodi della tabella.

Formattazione a livello di tabella

Per applicare la formattazione a una tabella, è possibile utilizzare le proprietà disponibili sul nodo Table corrispondente utilizzando le classi Table, PreferredWidth e TableCollection.

Le immagini seguenti mostrano una rappresentazione delle caratteristiche di formattazione Table in Microsoft Word e delle loro proprietà corrispondenti in Aspose.Words.

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

formatting-table-options-aspose-words-cpp

Nell’esempio di codice seguente viene illustrato come applicare un bordo contorno a una tabella:

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

L’esempio di codice seguente mostra come creare una tabella con tutti i bordi abilitati (griglia):

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

Formattazione a livello di riga

Livello riga

Le immagini seguenti mostrano una rappresentazione delle caratteristiche di formattazione Row in Microsoft Word e delle loro proprietà corrispondenti in Aspose.Words.

formatting-row-level-aspose-words-cpp

L’esempio di codice seguente mostra come modificare la formattazione della riga della tabella:

// 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);

Formattazione a livello di cella

La formattazione a livello di cella è controllata dalle classi Cell, CellFormat e CellCollection.

Le immagini seguenti mostrano una rappresentazione delle caratteristiche di formattazione Cell in Microsoft Word e delle loro proprietà corrispondenti in Aspose.Words.

formatting-cell-level-aspose-words-cpp

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

L’esempio di codice seguente mostra come modificare la formattazione di una cella di tabella:

// 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());

Il seguente esempio di codice mostra come impostare la quantità di spazio (in punti) da aggiungere a sinistra / in alto / a destra / in basso del contenuto della cella:

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

Specificare le altezze delle righe

Il modo più semplice per impostare l’altezza della riga è usare DocumentBuilder. Utilizzando le proprietà RowFormat appropriate, è possibile impostare l’impostazione di altezza predefinita o applicare un’altezza diversa per ogni riga della tabella.

In Aspose.Words, l’altezza della riga della tabella è controllata da:

  • la proprietà altezza riga- Height
  • la proprietà regola altezza per la riga specificata- HeightRule

Allo stesso tempo, è possibile impostare un’altezza diversa per ogni riga: ciò consente di controllare ampiamente le impostazioni della tabella.

Nell’esempio di codice riportato di seguito viene illustrato come creare una tabella contenente una singola cella e applicare la formattazione delle righe:

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

Specificare le larghezze di tabella e cella

Una tabella in un documento Microsoft Word fornisce diversi modi per ridimensionare la tabella e le singole celle. Queste proprietà consentono un controllo considerevole sull’aspetto e sul comportamento della tabella, in modo che Aspose.Words supporti il comportamento delle tabelle, come in Microsoft Word.

È importante sapere che gli elementi della tabella presentano diverse proprietà che possono influire sul modo in cui vengono calcolate le larghezze della tabella complessiva e delle singole celle:

  • Larghezza preferita sul tavolo
  • Larghezza preferita sulle singole celle
  • Consentire l’autofit sul tavolo

Questo articolo descrive in dettaglio come funzionano le varie proprietà di calcolo della larghezza della tabella e come ottenere il pieno controllo sul calcolo della larghezza della tabella. Questo è particolarmente utile sapere in questi casi in cui il layout della tabella non appare come previsto.

Come utilizzare la larghezza preferita

La larghezza desiderata di una tabella o di singole celle viene definita tramite la proprietà larghezza preferita, che è la dimensione che un elemento si sforza di adattare. Cioè, la larghezza preferita può essere specificata per l’intera tabella o per singole celle. In alcune situazioni potrebbe non essere possibile adattare esattamente questa larghezza, ma la larghezza effettiva sarà vicina a questo valore nella maggior parte dei casi.

Il tipo e il valore di larghezza preferiti appropriati vengono impostati utilizzando i metodi della classe PreferredWidth:

  • il metodo Auto per specificare auto o"nessuna larghezza preferita"
  • il metodo FromPercent per specificare una larghezza percentuale
  • il metodo FromPoints per specificare la larghezza in punti

Le immagini sottostanti mostrano una rappresentazione di preferred width setting features in Microsoft Word e delle loro proprietà corrispondenti in Aspose.Words.

formatting-table-properties-aspose-words-cpp

Un esempio di come queste opzioni vengono applicate a una tabella reale in un documento può essere visto nell’immagine qui sotto.

todo:image_alt_text

Specificare la larghezza della tabella o della cella preferita

In Aspose.Words, le larghezze di tabella e cella vengono impostate utilizzando le proprietà Table.PreferredWidth e CellFormat.PreferredWidth, con le opzioni disponibili nell’enumerazione PreferredWidthType:

  • Auto, che equivale a nessun set di larghezza preferito
  • Percent, che si adatta all’elemento rispetto allo spazio disponibile nella dimensione della finestra o del contenitore e ricalcola il valore quando la larghezza disponibile cambia
  • Points, che corrisponde a un elemento della larghezza specificata in punti

L’uso della proprietà Table.PreferredWidth regolerà la sua larghezza preferita rispetto al suo contenitore: pagina, colonna di testo o cella di tabella esterna se si tratta di una tabella nidificata.

L’esempio di codice seguente mostra come impostare la tabella su auto-fit al 50% della larghezza della pagina:

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

L’uso della proprietà CellFormat.PreferredWidth su una data cella regolerà la sua larghezza preferita.

Il seguente esempio di codice mostra come impostare le diverse impostazioni di larghezza preferite:

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

Trova il tipo di larghezza e il valore preferiti

È possibile utilizzare le proprietà Type e Value per trovare i dettagli di larghezza preferiti della tabella o della cella desiderata.

L’esempio di codice seguente mostra come recuperare il tipo di larghezza preferito di una cella di tabella:

// 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();

Come impostare Autofit

La proprietà AllowAutoFit consente alle celle di una tabella di crescere e ridursi in base a un criterio selezionato. Ad esempio, è possibile utilizzare l’opzione AutoFit to Window per adattare la tabella alla larghezza della pagina e l’opzione AutoFit to Content per consentire a ciascuna cella di crescere o ridursi in base al suo contenuto.

Per impostazione predefinita, Aspose.Words inserisce una nuova tabella usando AutoFit to Window. La tabella sarà dimensionata in base alla larghezza della pagina disponibile. Per ridimensionare una tabella, è possibile chiamare il metodo AutoFit. Questo metodo accetta un’enumerazione AutoFitBehavior che specifica il tipo di autofit applicato alla tabella.

È importante sapere che il metodo autofit è in realtà una scorciatoia che applica diverse proprietà alla tabella allo stesso tempo. Queste sono proprietà che in realtà danno alla tabella il comportamento osservato. Discuteremo queste proprietà per ogni opzione autofit.

L’esempio di codice seguente mostra come impostare una tabella per ridurre o aumentare ogni cella in base al suo contenuto:

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

AutoFit Tabella alla finestra

Quando si applica l’autofitting a una finestra a una tabella, le seguenti operazioni vengono effettivamente eseguite dietro le quinte:

  1. La proprietà Table.AllowAutoFit è abilitata per ridimensionare automaticamente le colonne per adattarle al contenuto disponibile, utilizzando un valore Table.PreferredWidth pari a 100%
  2. CellFormat.PreferredWidth viene rimosso da tutte le celle della tabella
  3. Le larghezze delle colonne vengono ricalcolate per il contenuto della tabella corrente: il risultato finale è una tabella che occupa l’intera larghezza disponibile
  4. La larghezza delle colonne nella tabella cambia automaticamente man mano che l’utente modifica il testo

L’esempio di codice seguente mostra come inserire automaticamente una tabella nella larghezza della pagina:

// 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 Tabella al contenuto

Quando la tabella viene autofittata del contenuto, i seguenti passaggi vengono effettivamente eseguiti dietro le quinte:

  1. La proprietà Table.AllowAutoFit è abilitata per ridimensionare automaticamente ogni cella in base al suo contenuto

  2. La larghezza della tabella preferita viene rimossa da Table.PreferredWidth, CellFormat.PreferredWidth viene rimossa per ogni cella della tabella

  3. Le larghezze di colonna vengono ricalcolate per il contenuto della tabella corrente: il risultato finale è una tabella in cui le larghezze di colonna e la larghezza dell’intera tabella vengono ridimensionate automaticamente per adattarsi al meglio al contenuto man mano che l’utente modifica il testo

L’esempio di codice seguente mostra come inserire automaticamente una tabella nel suo contenuto:

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

Disabilita AutoFit nella tabella e usa larghezze di colonna fisse

Se in una tabella è disabilitato l’autofit e vengono utilizzate invece larghezze di colonna fisse, vengono eseguite le seguenti operazioni:

  1. La proprietà Table.AllowAutoFit è disabilitata in modo che le colonne non crescano o si riducano al loro contenuto
  2. La larghezza preferita dell’intera tabella viene rimossa da Table.PreferredWidth, CellFormat.PreferredWidth viene rimossa da tutte le celle della tabella
  3. Il risultato finale è una tabella le cui larghezze di colonna sono determinate dalla proprietà CellFormat.Width e le cui colonne non vengono ridimensionate automaticamente quando l’utente inserisce del testo o quando la pagina viene ridimensionata

L’esempio di codice seguente mostra come disabilitare l’autofit e abilitare la larghezza fissa per la tabella specificata:

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

Ordine di precedenza nel calcolo della larghezza della cella

Aspose.Words consente agli utenti di definire la larghezza di una tabella o di una cella attraverso più oggetti, tra cui CellFormat – la sua proprietà Width è per lo più rimasta dalle versioni precedenti, tuttavia, è ancora utile per semplificare l’impostazione della larghezza della cella.

È importante sapere che la proprietà CellFormat.Width funziona in modo diverso a seconda di quale delle altre proprietà width esiste già nella tabella.

Aspose.Words utilizza l’ordine seguente per calcolare le larghezze delle celle:

Ordine Proprieta Descrizione
AllowAutoFit è determinato Se AutoFit è abilitato:
- la tabella può crescere oltre la larghezza preferita per accogliere il contenuto-di solito non si restringe al di sotto della larghezza preferita
- qualsiasi modifica al valore CellFormat.Width viene ignorata e la cella si adatta al suo contenuto
PreferredWidthType con un valore di Pointso Percent CellFormat.Width viene ignorato
PreferredWidthTypecon un valore di Auto Il valore da CellFormat.Width viene copiato e diventa la larghezza preferita della cella (in punti)

Consentire la spaziatura tra le celle

È possibile ottenere o impostare qualsiasi spazio aggiuntivo tra le celle della tabella simile all’opzione “Spaziatura celle” in Microsoft Word. Questo può essere fatto usando la proprietà AllowCellSpacing.

Un esempio di come queste opzioni vengono applicate a una tabella reale in un documento può essere visto nell’immagine qui sotto.

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

Il seguente esempio di codice mostra come impostare la spaziatura tra le celle:

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

Applicare bordi e ombreggiature

I bordi e l’ombreggiatura possono essere applicati all’intera tabella usando Table.SetBorder, Table.SetBorders e Table.SetShading o solo a celle specifiche usando CellFormat.Borders e CellFormat.Shading. Inoltre, i bordi delle righe possono essere impostati usando RowFormat.Borders, tuttavia l’ombreggiatura non può essere applicata in questo modo.

Le immagini qui sotto mostrano le impostazioni del bordo e dell’ombra in Microsoft Word e le loro proprietà corrispondenti in Aspose.Words.

formatting-border-line-aspose-words-cpp

formatting-cell-color-aspose-words-cpp

L’esempio di codice seguente mostra come formattare una tabella e una cella con bordi e sfumature diversi:

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