Lucrați cu coloane și rânduri
Pentru mai mult control asupra modului în care funcționează tabelele, aflați cum să manipulați coloanele și rândurile.
Găsiți indexul elementului de tabel
Coloanele, rândurile și celulele sunt gestionate accesând nodul documentului selectat prin indexul său. Găsirea indexului oricărui nod implică colectarea tuturor nodurilor copil de tipul elementului de la nodul părinte și apoi utilizarea metodei IndexOf pentru a găsi indexul nodului dorit în colecție.
Găsiți indexul unui tabel într - un Document
Uneori poate fi necesar să faceți modificări la un anumit tabel dintr-un document. Pentru a face acest lucru, vă puteți referi la un tabel după indexul său.
Următorul exemplu de cod arată cum să recuperați indexul unui tabel dintr - un document:
// 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); |
Găsiți indexul unui rând dintr-un tabel
În mod similar, poate fi necesar să faceți modificări la un anumit rând dintr-un tabel selectat. Pentru a face acest lucru, vă puteți referi și la un rând prin indexul său.
Următorul exemplu de cod arată cum să recuperați indexul unui rând dintr-un tabel:
// 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()); |
Găsiți indexul unei celule într-un rând
În cele din urmă, poate fi necesar să faceți modificări la o anumită celulă și puteți face acest lucru și prin indexul celulei.
Următorul exemplu de cod arată cum să recuperați indexul unei celule într-un rând:
// 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)); |
Lucrați cu coloane
În modelul obiectului Document Aspose.Words (DOM), nodul Table este format din noduri Row și apoi noduri Cell. Astfel, în modelul de Obiect Document
al Aspose.Words, ca și în documentele Word, nu există niciun concept de coloană.
Prin proiectare, rândurile tabelului din Microsoft Word și Aspose.Words sunt complet independente, iar proprietățile și operațiile de bază sunt conținute numai în rândurile și celulele tabelului. Acest lucru oferă tabelelor posibilitatea de a avea câteva atribute interesante:
- Fiecare rând de tabel poate avea un număr complet diferit de celule
- Pe verticală, celulele fiecărui rând pot avea lățimi diferite
- Este posibil să se alăture tabele cu diferite formate rând și numărul de celule
Orice operațiuni efectuate pe coloane sunt de fapt “scurtături” care efectuează operația schimbând colectiv celulele rândurilor în așa fel încât să pară că sunt aplicate coloanelor. Adică, puteți efectua operații pe coloane prin simpla iterare a aceluiași index de celule de rând de tabel.
Următorul exemplu de cod simplifică astfel de operații prin dovedirea unei clase de fațadă care colectează celulele care alcătuiesc o" coloană " a unui tabel:
// 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; | |
} | |
}; |
Următorul exemplu de cod arată cum să inserați o coloană goală într-un tabel:
// 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))); | |
} | |
Următorul exemplu de cod arată cum să eliminați o coloană dintr-un tabel dintr-un document:
// 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(); |
Specificați rândurile ca rânduri de antet
Puteți alege să repetați primul rând din tabel ca rând de antet numai pe prima pagină sau pe fiecare pagină dacă tabelul este împărțit în mai multe. În Aspose.Words, puteți repeta rândul de antet pe fiecare pagină folosind proprietatea HeadingFormat.
De asemenea, puteți marca mai multe rânduri de antet dacă astfel de rânduri sunt situate unul după altul la începutul tabelului. Pentru a face acest lucru, trebuie să aplicați proprietățile HeadingFormat acestor rânduri.
Următorul exemplu de cod arată cum se construiește un tabel care include rânduri de antet care se repetă în paginile următoare:
// 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"); |
Păstrați tabele și rânduri de rupere peste pagini
Există momente în care conținutul unui tabel nu trebuie împărțit pe pagini. De exemplu, dacă un titlu este deasupra unui tabel, titlul și tabelul ar trebui să fie întotdeauna păstrate împreună pe aceeași pagină pentru a păstra aspectul adecvat.
Există două tehnici separate care sunt utile pentru a realiza această funcționalitate:
Allow row break across pages
, care se aplică rândurilor de tabelKeep with next
, care se aplică paragrafelor din celulele tabelului
În mod implicit, proprietățile de mai sus sunt dezactivate.
Păstrați un rând de rupere peste pagini
Aceasta implică restricționarea conținutului din interiorul celulelor unui rând de a fi împărțit pe o pagină. În Microsoft Word, Acest lucru poate fi găsit sub proprietățile tabelului ca opțiune"permiteți rândului să se rupă între pagini". În Aspose.Words Acest lucru se găsește sub obiectul RowFormat al unui Row ca proprietate RowFormat.AllowBreakAcrossPages.
Următorul exemplu de cod arată cum să dezactivați ruperea rândurilor pe pagini pentru fiecare rând dintr-un tabel:
// 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"); |
Păstrați un tabel de rupere peste pagini
Pentru a opri împărțirea tabelului între pagini, trebuie să specificăm că dorim ca conținutul conținut în tabel să rămână împreună.
Pentru a face acest lucru, Aspose.Words folosește o metodă, care permite utilizatorilor să selecteze un tabel și să activeze parametrul KeepWithNext la true pentru fiecare paragraf din celulele tabelului. Excepția este ultimul paragraf din tabel, care ar trebui setat la fals.
Următorul exemplu de cod arată cum să setați un tabel pentru a rămâne împreună pe aceeași pagină:
// 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"); |