Sütun ve Satırlarla Çalışma
Tabloların nasıl çalıştığı üzerinde daha fazla denetim için sütunları ve satırları nasıl değiştireceğinizi öğrenin.
Tablo Öğesi Dizinini Bulun
Sütunlar, satırlar ve hücreler, seçilen belge düğümüne dizini tarafından erişilerek yönetilir. Herhangi bir düğümün dizinini bulmak, öğe türündeki tüm alt düğümlerin üst düğümden toplanmasını ve ardından koleksiyonda istenen düğümün dizinini bulmak için IndexOf yöntemini kullanmayı içerir.
Belgedeki Tablonun Dizinini Bulma
Bazen bir belgedeki belirli bir tabloda değişiklik yapmanız gerekebilir. Bunu yapmak için, bir tabloya dizinine göre başvurabilirsiniz.
Aşağıdaki kod örneği, bir belgedeki bir tablonun dizininin nasıl alınacağını gösterir:
// 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); |
Tablodaki Bir Satırın Dizinini Bulun
Benzer şekilde, seçili bir tablodaki belirli bir satırda değişiklik yapmanız gerekebilir. Bunu yapmak için, bir satıra dizinine göre de başvurabilirsiniz.
Aşağıdaki kod örneği, bir tablodaki bir satırın dizininin nasıl alınacağını gösterir:
// 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()); |
Satırdaki Bir Hücrenin Dizinini Bulun
Son olarak, belirli bir hücrede değişiklik yapmanız gerekebilir ve bunu hücre dizinine göre de yapabilirsiniz.
Aşağıdaki kod örneği, bir satırdaki bir hücrenin dizininin nasıl alınacağını gösterir:
// 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)); |
Sütunlarla Çalışma
Aspose.Words Belge Nesnesi Modelinde (DOM), Table düğümü Row düğümden ve ardından Cell düğümden oluşur. Bu nedenle, Aspose.Words ‘ün Document
Nesne Modelinde, Word belgelerinde olduğu gibi, sütun kavramı yoktur.
Tasarım gereği, Microsoft Word ve Aspose.Words içindeki tablo satırları tamamen bağımsızdır ve temel özellikler ve işlemler yalnızca tablonun satırlarında ve hücrelerinde bulunur. Bu, tablolara bazı ilginç özelliklere sahip olma yeteneği verir:
- Her tablo satırı tamamen farklı sayıda hücreye sahip olabilir
- Dikey olarak, her satırın hücreleri farklı genişliklere sahip olabilir
- Farklı satır biçimlerine ve hücre sayısına sahip tabloları birleştirmek mümkündür
Sütunlar üzerinde gerçekleştirilen tüm işlemler aslında satır hücrelerini sütunlara uygulanıyormuş gibi görünecek şekilde toplu olarak değiştirerek işlemi gerçekleştiren “kısayollar” dır. Diğer bir deyişle, yalnızca aynı tablo satırı hücre dizini üzerinde yineleyerek sütunlar üzerinde işlemler gerçekleştirebilirsiniz.
Aşağıdaki kod örneği, bir tablonun “sütununu” oluşturan hücreleri toplayan bir cephe sınıfını kanıtlayarak bu tür işlemleri basitleştirir:
// 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; | |
} | |
}; |
Aşağıdaki kod örneği, tabloya boş bir sütunun nasıl ekleneceğini gösterir:
// 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))); | |
} | |
Aşağıdaki kod örneği, bir belgedeki bir tablodan bir sütunun nasıl kaldırılacağını gösterir:
// 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(); |
Satırları Başlık Satırları Olarak Belirtin
Tablo birkaç bölüme ayrılmışsa, tablodaki ilk satırı yalnızca ilk sayfada veya her sayfada Üstbilgi Satırı olarak yinelemeyi seçebilirsiniz. Aspose.Words’de, HeadingFormat özelliğini kullanarak her sayfadaki Başlık Satırını tekrarlayabilirsiniz.
Tablonun başında bu tür satırlar birbiri ardına bulunuyorsa, birden çok başlık satırını da işaretleyebilirsiniz. Bunu yapmak için HeadingFormat özelliklerini bu satırlara uygulamanız gerekir.
Aşağıdaki kod örneği, sonraki sayfalarda yinelenen Üstbilgi Satırlarını içeren bir tablonun nasıl oluşturulacağını gösterir:
// 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"); |
Tabloların ve Satırların Sayfalar Arasında Bölünmesini Önleyin
Bir tablonun içeriğinin sayfalar arasında bölünmemesi gereken zamanlar vardır. Örneğin, bir başlık bir tablonun üzerindeyse, düzgün görünümü korumak için başlık ve tablo her zaman aynı sayfada bir arada tutulmalıdır.
Bu işlevselliği elde etmek için yararlı olan iki ayrı teknik vardır:
Allow row break across pages
, tablo satırlarına uygulanır- tablo hücrelerindeki paragraflara uygulanan
Keep with next
Varsayılan olarak, yukarıdaki özellikler devre dışıdır.
Bir Satırın Sayfalar Arasında Bölünmesini Engelle
Bu, bir satırdaki hücrelerin içindeki içeriğin bir sayfaya bölünmesini kısıtlamayı içerir. Microsoft Word ‘te bu, Tablo Özellikleri altında “Satırın sayfalar arasında kesilmesine izin ver” seçeneği olarak bulunabilir. Aspose.Words ‘te bu, Row‘nin RowFormat nesnesinin altında RowFormat.AllowBreakAcrossPages özelliği olarak bulunur.
Aşağıdaki kod örneği, bir tablodaki her satır için sayfalar arasında satır kesmenin nasıl devre dışı bırakılacağını gösterir:
// 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"); |
Bir Tablonun Sayfalar Arasında Bölünmemesini Sağlayın
Tablonun sayfalar arasında bölünmesini durdurmak için, tabloda yer alan içeriğin bir arada kalmasını istediğimizi belirtmemiz gerekir.
Bunu yapmak için Aspose.Words, kullanıcıların bir tablo seçmesine ve tablo hücrelerindeki her paragraf için KeepWithNext parametresini true olarak etkinleştirmesine olanak tanıyan bir yöntem kullanır. Bunun istisnası, tablodaki false olarak ayarlanması gereken son paragraftır.
Aşağıdaki kod örneği, bir tablonun aynı sayfada birlikte kalacak şekilde nasıl ayarlanacağını gösterir:
// 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"); |