Werken met kolommen en Rijen
Lees hoe u kolommen en Rijen kunt bewerken voor meer controle over hoe tabellen werken.
Zoek de tabel Element Index
Kolommen, rijen en cellen worden beheerd door toegang te krijgen tot het geselecteerde documentknooppunt via de index. Het vinden van de index van een knooppunt houdt in dat alle onderliggende knooppunten van het elementtype van de ouderknooppunt worden verzameld en vervolgens de IndexOf - methode wordt gebruikt om de index van de gewenste knooppunt in de verzameling te vinden.
De Index van een tabel in een Document zoeken
Soms moet u wijzigingen aanbrengen in een bepaalde tabel in een document. Om dit te doen, kunt u verwijzen naar een tabel door zijn index.
Het volgende codevoorbeeld toont hoe u de index van een tabel in een document kunt ophalen:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git. | |
auto table = System::ExplicitCast<Table>(doc->GetChild(NodeType::Table, 0, true)); | |
SharedPtr<NodeCollection> allTables = doc->GetChildNodes(NodeType::Table, true); | |
int tableIndex = allTables->IndexOf(table); |
Zoek de Index van een rij in een tabel
Op dezelfde manier moet u mogelijk wijzigingen aanbrengen in een specifieke rij in een geselecteerde tabel. Om dit te doen, kunt u ook verwijzen naar een rij door zijn index.
Het volgende codevoorbeeld laat zien hoe u de index van een rij in een tabel kunt ophalen:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git. | |
int rowIndex = table->IndexOf(table->get_LastRow()); |
Zoek de Index van een cel in een Rij
Ten slotte moet u mogelijk wijzigingen aanbrengen in een specifieke cel, en u kunt dit ook doen met celindex.
Het volgende codevoorbeeld laat zien hoe u de index van een cel op een Rij kunt ophalen:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git. | |
int cellIndex = row->IndexOf(row->get_Cells()->idx_get(4)); |
Werken met kolommen
In het Aspose.Words Document Object Model (DOM) bestaat het Table knooppunt uit Row knooppunten en vervolgens Cell knooppunten. In het Document
objectmodel van Aspose.Words, zoals in Word documenten, is er dus geen concept van een kolom.
De tabelrijen in Microsoft Word en Aspose.Words zijn volledig onafhankelijk en de basiseigenschappen en bewerkingen zijn alleen opgenomen in de rijen en cellen van de tabel. Dit geeft tabellen de mogelijkheid om een aantal interessante attributen te hebben:
- Elke tabelrij kan een heel ander aantal cellen hebben
- Verticaal kunnen de cellen van elke rij verschillende breedtes hebben
- Het is mogelijk om tabellen met verschillende rijformaten en het aantal cellen te verbinden
Alle bewerkingen die op kolommen worden uitgevoerd, zijn eigenlijk “snelkoppelingen” die de bewerking uitvoeren door gezamenlijk rijcellen zodanig te veranderen dat het lijkt alsof ze op kolommen worden toegepast. Dat wil zeggen, U kunt bewerkingen op kolommen uitvoeren door simpelweg over dezelfde celindex van de tabelrij te herhalen.
Het volgende codevoorbeeld vereenvoudigt dergelijke bewerkingen door een facade-klasse te bewijzen die de cellen verzamelt die een “kolom” van een tabel vormen:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git. | |
/// <summary> | |
/// Represents a facade object for a column of a table in a Microsoft Word document. | |
/// </summary> | |
class Column : public System::Object | |
{ | |
public: | |
/// <summary> | |
/// Returns the cells which make up the column. | |
/// </summary> | |
ArrayPtr<SharedPtr<Cell>> get_Cells() | |
{ | |
return GetColumnCells()->ToArray(); | |
} | |
/// <summary> | |
/// Returns a new column facade from the table and supplied zero-based index. | |
/// </summary> | |
static SharedPtr<WorkingWithTables::Column> FromIndex(SharedPtr<Table> table, int columnIndex) | |
{ | |
return WorkingWithTables::Column::MakeObject(table, columnIndex); | |
} | |
/// <summary> | |
/// Returns the index of the given cell in the column. | |
/// </summary> | |
int IndexOf(SharedPtr<Cell> cell) | |
{ | |
return GetColumnCells()->IndexOf(cell); | |
} | |
/// <summary> | |
/// Inserts a brand new column before this column into the table. | |
/// </summary> | |
SharedPtr<WorkingWithTables::Column> InsertColumnBefore() | |
{ | |
ArrayPtr<SharedPtr<Cell>> columnCells = get_Cells(); | |
if (columnCells->get_Length() == 0) | |
{ | |
throw System::ArgumentException(u"Column must not be empty"); | |
} | |
// Create a clone of this column. | |
for (SharedPtr<Cell> cell : columnCells) | |
{ | |
cell->get_ParentRow()->InsertBefore(cell->Clone(false), cell); | |
} | |
// This is the new column. | |
auto column = WorkingWithTables::Column::MakeObject(columnCells[0]->get_ParentRow()->get_ParentTable(), mColumnIndex); | |
// We want to make sure that the cells are all valid to work with (have at least one paragraph). | |
for (SharedPtr<Cell> cell : column->get_Cells()) | |
{ | |
cell->EnsureMinimum(); | |
} | |
// Increase the index which this column represents since there is now one extra column in front. | |
mColumnIndex++; | |
return column; | |
} | |
/// <summary> | |
/// Removes the column from the table. | |
/// </summary> | |
void Remove() | |
{ | |
for (SharedPtr<Cell> cell : get_Cells()) | |
{ | |
cell->Remove(); | |
} | |
} | |
/// <summary> | |
/// Returns the text of the column. | |
/// </summary> | |
String ToTxt() | |
{ | |
auto builder = System::MakeObject<System::Text::StringBuilder>(); | |
for (SharedPtr<Cell> cell : get_Cells()) | |
{ | |
builder->Append(cell->ToString(SaveFormat::Text)); | |
} | |
return builder->ToString(); | |
} | |
private: | |
int mColumnIndex; | |
SharedPtr<Table> mTable; | |
Column(SharedPtr<Table> table, int columnIndex) : mColumnIndex(0) | |
{ | |
if (table == nullptr) | |
{ | |
throw System::ArgumentException(u"table"); | |
} | |
mTable = table; | |
mColumnIndex = columnIndex; | |
} | |
MEMBER_FUNCTION_MAKE_OBJECT(Column, CODEPORTING_ARGS(SharedPtr<Table> table, int columnIndex), CODEPORTING_ARGS(table, columnIndex)); | |
/// <summary> | |
/// Provides an up-to-date collection of cells which make up the column represented by this facade. | |
/// </summary> | |
SharedPtr<System::Collections::Generic::List<SharedPtr<Cell>>> GetColumnCells() | |
{ | |
SharedPtr<System::Collections::Generic::List<SharedPtr<Cell>>> columnCells = | |
System::MakeObject<System::Collections::Generic::List<SharedPtr<Cell>>>(); | |
for (const auto& row : System::IterateOver<Row>(mTable->get_Rows())) | |
{ | |
SharedPtr<Cell> cell = row->get_Cells()->idx_get(mColumnIndex); | |
if (cell != nullptr) | |
{ | |
columnCells->Add(cell); | |
} | |
} | |
return columnCells; | |
} | |
}; |
Het volgende codevoorbeeld laat zien hoe u een lege kolom in een tabel invoegt:
// 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<WorkingWithTables::Column> column = WorkingWithTables::Column::FromIndex(table, 0); | |
// Print the plain text of the column to the screen. | |
std::cout << column->ToTxt() << std::endl; | |
// Create a new column to the left of this column. | |
// This is the same as using the "Insert Column Before" command in Microsoft Word. | |
SharedPtr<WorkingWithTables::Column> newColumn = column->InsertColumnBefore(); | |
for (SharedPtr<Cell> cell : newColumn->get_Cells()) | |
{ | |
cell->get_FirstParagraph()->AppendChild(MakeObject<Run>(doc, String(u"Column Text ") + newColumn->IndexOf(cell))); | |
} | |
Het volgende codevoorbeeld toont hoe u een kolom uit een tabel in een document verwijdert:
// 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, 1, true)); | |
SharedPtr<WorkingWithTables::Column> column = WorkingWithTables::Column::FromIndex(table, 2); | |
column->Remove(); |
Rijen opgeven als Koprijen
U kunt ervoor kiezen om de eerste rij in de tabel als koprij alleen op de eerste pagina of op elke pagina te herhalen als de tabel in meerdere is verdeeld. In Aspose.Words kunt u de koprij op elke pagina herhalen met de eigenschap HeadingFormat.
U kunt ook meerdere koprijen markeren als deze rijen zich na elkaar aan het begin van de tabel bevinden. Hiervoor moet u de eigenschappen HeadingFormat op deze rijen toepassen.
Het volgende codevoorbeeld laat zien hoe u een tabel kunt maken met Koprijen die op Volgende pagina ' s worden herhaald:
// 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->get_RowFormat()->set_HeadingFormat(true); | |
builder->get_ParagraphFormat()->set_Alignment(ParagraphAlignment::Center); | |
builder->get_CellFormat()->set_Width(100); | |
builder->InsertCell(); | |
builder->Writeln(u"Heading row 1"); | |
builder->EndRow(); | |
builder->InsertCell(); | |
builder->Writeln(u"Heading row 2"); | |
builder->EndRow(); | |
builder->get_CellFormat()->set_Width(50); | |
builder->get_ParagraphFormat()->ClearFormatting(); | |
for (int i = 0; i < 50; i++) | |
{ | |
builder->InsertCell(); | |
builder->get_RowFormat()->set_HeadingFormat(false); | |
builder->Write(u"Column 1 Text"); | |
builder->InsertCell(); | |
builder->Write(u"Column 2 Text"); | |
builder->EndRow(); | |
} | |
doc->Save(ArtifactsDir + u"WorkingWithTables.RepeatRowsOnSubsequentPages.docx"); |
Voorkomen dat tabellen en Rijen Over pagina ' s heen breken
Er zijn momenten waarop de inhoud van een tabel niet over pagina ' s moet worden verdeeld. Als een titel bijvoorbeeld boven een tabel staat, moeten de titel en de tabel altijd samen op dezelfde pagina worden gehouden om de juiste uitstraling te behouden.
Er zijn twee afzonderlijke technieken die nuttig zijn om deze functionaliteit te bereiken:
Allow row break across pages
, dat wordt toegepast op tabelrijenKeep with next
, dat wordt toegepast op alinea ' s in tabelcellen
Standaard zijn de bovenstaande eigenschappen uitgeschakeld.
Voorkomen dat een Rij Over pagina ' s heen breekt
Dit houdt in dat inhoud in de cellen van een rij niet over een pagina wordt gesplitst. In Microsoft Word kan dit worden gevonden onder Tabeleigenschappen als de optie “rij toestaan om over pagina ’s te breken”. In Aspose.Words wordt dit gevonden onder het RowFormat object van een Row als de eigenschap RowFormat.AllowBreakAcrossPages.
Het volgende codevoorbeeld laat zien hoe u het breken van rijen over pagina ' s voor elke rij in een tabel uitschakelt:
// 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"Table spanning two pages.docx"); | |
auto table = System::ExplicitCast<Table>(doc->GetChild(NodeType::Table, 0, true)); | |
// Disable breaking across pages for all rows in the table. | |
for (const auto& row : System::IterateOver<Row>(table->get_Rows())) | |
{ | |
row->get_RowFormat()->set_AllowBreakAcrossPages(false); | |
} | |
doc->Save(ArtifactsDir + u"WorkingWithTables.RowFormatDisableBreakAcrossPages.docx"); |
Voorkomen dat een tabel Over pagina ' s {#keep-a-table-from-breaking-across-pages}heen breekt
Als u wilt voorkomen dat de tabel Over pagina ' s wordt gesplitst, moeten we opgeven dat de inhoud in de tabel bij elkaar moet blijven.
Hiervoor gebruikt Aspose.Words een methode waarmee gebruikers een tabel kunnen selecteren en de parameter KeepWithNext voor elke alinea in de tabelcellen kunnen inschakelen. De uitzondering is de laatste alinea in de tabel, die moet worden ingesteld op false.
Het volgende codevoorbeeld laat zien hoe u een tafel kunt instellen om op dezelfde pagina bij elkaar te blijven:
// 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"Table spanning two pages.docx"); | |
auto table = System::ExplicitCast<Table>(doc->GetChild(NodeType::Table, 0, true)); | |
// We need to enable KeepWithNext for every paragraph in the table to keep it from breaking across a page, | |
// except for the last paragraphs in the last row of the table. | |
for (const auto& cell : System::IterateOver<Cell>(table->GetChildNodes(NodeType::Cell, true))) | |
{ | |
cell->EnsureMinimum(); | |
for (const auto& para : System::IterateOver<Paragraph>(cell->get_Paragraphs())) | |
{ | |
if (!(cell->get_ParentRow()->get_IsLastRow() && para->get_IsEndOfCell())) | |
{ | |
para->get_ParagraphFormat()->set_KeepWithNext(true); | |
} | |
} | |
} | |
doc->Save(ArtifactsDir + u"WorkingWithTables.KeepTableTogether.docx"); |