Praca z akapitami
Akapit to zbiór znaków połączonych w logiczny blok i zakończony znakiem specjalnym – podziałem akapitu. W Aspose.Words akapit jest reprezentowany przez klasę Paragraph.
Wstaw akapit
Aby wstawić nowy akapit do dokumentu, musisz wstawić do niego znak podziału akapitu. DocumentBuilder.Writeln wstawia do dokumentu nie tylko ciąg tekstowy, ale także dodaje podział akapitu.
Bieżące formatowanie czcionki jest również określone przez właściwość Font, a bieżące formatowanie akapitu jest określane przez właściwość ParagraphFormat. W następnej sekcji omówimy bardziej szczegółowo formatowanie akapitu.
Poniższy przykład kodu pokazuje, jak wstawić akapit do dokumentu:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET | |
// The path to the documents directory. | |
string dataDir = RunExamples.GetDataDir_WorkingWithDocument(); | |
// Initialize document. | |
Document doc = new Document(); | |
DocumentBuilder builder = new DocumentBuilder(doc); | |
// Specify font formatting | |
Font font = builder.Font; | |
font.Size = 16; | |
font.Bold = true; | |
font.Color = System.Drawing.Color.Blue; | |
font.Name = "Arial"; | |
font.Underline = Underline.Dash; | |
// Specify paragraph formatting | |
ParagraphFormat paragraphFormat = builder.ParagraphFormat; | |
paragraphFormat.FirstLineIndent = 8; | |
paragraphFormat.Alignment = ParagraphAlignment.Justify; | |
paragraphFormat.KeepTogether = true; | |
builder.Writeln("A whole paragraph."); | |
dataDir = dataDir + "DocumentBuilderInsertParagraph_out.doc"; | |
doc.Save(dataDir); |
Formatuj akapit
Bieżące formatowanie akapitu jest reprezentowane przez obiekt ParagraphFormat zwracany przez właściwość ParagraphFormat. Obiekt ten zawiera różne właściwości formatowania akapitów dostępne w formacie Microsoft Word. Możesz łatwo przywrócić domyślne formatowanie akapitu – styl normalny, wyrównanie do lewej, bez wcięć, bez odstępów, bez obramowań i bez cieniowania – wywołując ClearFormatting.
Poniższy przykład kodu pokazuje, jak ustawić formatowanie akapitu:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET | |
Document doc = new Document(); | |
DocumentBuilder builder = new DocumentBuilder(doc); | |
// Set paragraph formatting properties | |
ParagraphFormat paragraphFormat = builder.ParagraphFormat; | |
paragraphFormat.Alignment = ParagraphAlignment.Center; | |
paragraphFormat.LeftIndent = 50; | |
paragraphFormat.RightIndent = 50; | |
paragraphFormat.SpaceAfter = 25; | |
// Output text | |
builder.Writeln("I'm a very nice formatted paragraph. I'm intended to demonstrate how the left and right indents affect word wrapping."); | |
builder.Writeln("I'm another nice formatted paragraph. I'm intended to demonstrate how the space after paragraph looks like."); | |
dataDir = dataDir + "DocumentBuilderSetParagraphFormatting_out.doc"; | |
doc.Save(dataDir); |
Zastosuj styl akapitu
Niektóre obiekty formatujące, takie jak Font lub ParagraphFormat, obsługują style. Jeden styl wbudowany lub zdefiniowany przez użytkownika jest reprezentowany przez obiekt Style, który zawiera odpowiednie właściwości stylu, takie jak nazwa, styl podstawowy, czcionka, formatowanie akapitu stylu i tak dalej.
Ponadto obiekt Style udostępnia właściwość StyleIdentifier, która zwraca niezależny od ustawień regionalnych identyfikator stylu reprezentowany przez wartość wyliczenia StyleIdentifier. Faktem jest, że nazwy wbudowanych stylów w Microsoft Word są zlokalizowane dla różnych języków. Używając identyfikatora stylu, możesz znaleźć właściwy styl niezależnie od języka dokumentu. Wartości wyliczenia odpowiadają wbudowanym stylom Microsoft Word, takim jak Normal, Nagłówek 1, Nagłówek 2 i tak dalej. Wszystkie style zdefiniowane przez użytkownika mają ustawioną wartość wyliczenia StyleIdentifier.User.
Poniższy przykład kodu pokazuje, jak zastosować styl akapitu:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET | |
Document doc = new Document(); | |
DocumentBuilder builder = new DocumentBuilder(doc); | |
// Set paragraph style | |
builder.ParagraphFormat.StyleIdentifier = StyleIdentifier.Title; | |
builder.Write("Hello"); | |
dataDir = dataDir + "DocumentBuilderApplyParagraphStyle_out.doc"; | |
doc.Save(dataDir); |
Wstaw separator stylów, aby umieścić różne style akapitów
Separator stylu można dodać na końcu akapitu za pomocą skrótu klawiaturowego Ctrl+Alt+Enter w formacie Microsoft Word. Ta funkcja umożliwia użycie dwóch różnych stylów akapitu w tym samym logicznie drukowanym akapicie. Jeśli chcesz, aby w spisie treści pojawił się tekst z początku danego nagłówka, ale nie chcesz, aby w spisie treści był pokazywany cały nagłówek, możesz skorzystać z tej funkcji.
Poniższy przykład kodu pokazuje, jak wstawić separator stylów, aby uwzględnić różne style akapitów:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET | |
Document doc = new Document(); | |
DocumentBuilder builder = new DocumentBuilder(doc); | |
Style paraStyle = builder.Document.Styles.Add(StyleType.Paragraph, "MyParaStyle"); | |
paraStyle.Font.Bold = false; | |
paraStyle.Font.Size = 8; | |
paraStyle.Font.Name = "Arial"; | |
// Append text with "Heading 1" style. | |
builder.ParagraphFormat.StyleIdentifier = StyleIdentifier.Heading1; | |
builder.Write("Heading 1"); | |
builder.InsertStyleSeparator(); | |
// Append text with another style. | |
builder.ParagraphFormat.StyleName = paraStyle.Name; | |
builder.Write("This is text with some other formatting "); | |
dataDir = dataDir + "InsertStyleSeparator_out.doc"; | |
// Save the document to disk. | |
doc.Save(dataDir); |
Zidentyfikuj separator stylu akapitu
Aspose.Words udostępnia publiczną właściwość BreakIsStyleSeparator klasy Paragraph
w celu identyfikacji akapitu za pomocą separatora stylu, jak pokazano w poniższym przykładzie:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET | |
// The path to the documents directory. | |
string dataDir = RunExamples.GetDataDir_RenderingAndPrinting(); | |
// Initialize document. | |
string fileName = "TestFile.doc"; | |
Document doc = new Document(dataDir + fileName); | |
foreach (Paragraph paragraph in doc.GetChildNodes(NodeType.Paragraph, true)) | |
{ | |
if (paragraph.BreakIsStyleSeparator) | |
{ | |
Console.WriteLine("Separator Found!"); | |
} | |
} |
Zastosuj obramowanie i cieniowanie do akapitu
Granice w Aspose.Words są reprezentowane przez klasę BorderCollection – jest to zbiór obiektów Border, do których dostęp można uzyskać poprzez indeks lub typ obramowania. Typ obramowania jest z kolei reprezentowany przez wyliczenie BorderType. Niektóre wartości wyliczenia dotyczą wielu lub tylko jednego elementu dokumentu. Na przykład BorderType.Bottom dotyczy akapitu lub komórki tabeli, podczas gdy BorderType.DiagonalDown określa ukośne obramowanie tylko w komórce tabeli.
Zarówno kolekcja obramowań, jak i każda oddzielna ramka mają podobne atrybuty, takie jak kolor, styl linii, szerokość linii, odległość od tekstu i opcjonalny cień. Są one reprezentowane przez właściwości o tej samej nazwie. Łącząc wartości właściwości, można uzyskać różne typy obramowań. Dodatkowo obiekty BorderCollection i Border umożliwiają przywrócenie tych wartości do wartości domyślnych poprzez wywołanie metody ClearFormatting.
Aspose.Words ma również klasę Shading, która zawiera atrybuty cieniowania dla elementów dokumentu. Można ustawić żądaną teksturę cieniowania i kolory stosowane do tła i pierwszego planu elementu, korzystając z wartości wyliczenia TextureIndex. TextureIndex umożliwia także zastosowanie różnych wzorców do obiektu Shading. Na przykład, aby ustawić kolor tła elementu dokumentu, użyj wartości TextureIndex.TextureSolid i ustaw odpowiedni kolor cieniowania pierwszego planu.
Poniższy przykład kodu pokazuje, jak zastosować obramowanie i cieniowanie do akapitu:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET | |
Document doc = new Document(); | |
DocumentBuilder builder = new DocumentBuilder(doc); | |
// Set paragraph borders | |
BorderCollection borders = builder.ParagraphFormat.Borders; | |
borders.DistanceFromText = 20; | |
borders[BorderType.Left].LineStyle = LineStyle.Double; | |
borders[BorderType.Right].LineStyle = LineStyle.Double; | |
borders[BorderType.Top].LineStyle = LineStyle.Double; | |
borders[BorderType.Bottom].LineStyle = LineStyle.Double; | |
// Set paragraph shading | |
Shading shading = builder.ParagraphFormat.Shading; | |
shading.Texture = TextureIndex.TextureDiagonalCross; | |
shading.BackgroundPatternColor = System.Drawing.Color.LightCoral; | |
shading.ForegroundPatternColor = System.Drawing.Color.LightSalmon; | |
builder.Write("I'm a formatted paragraph with double border and nice shading."); | |
dataDir = dataDir + "DocumentBuilderApplyBordersAndShadingToParagraph_out.doc"; | |
doc.Save(dataDir); |
Policz wiersze akapitu
Jeśli chcesz policzyć liczbę wierszy w akapicie dowolnego dokumentu programu Word, można użyć następującego przykładowego kodu:
// The path to the documents directory. | |
string dataDir = RunExamples.GetDataDir_WorkingWithDocument(); | |
string fileName = "Properties.doc"; | |
Document document = new Document(dataDir + fileName); | |
var collector = new LayoutCollector(document); | |
var it = new LayoutEnumerator(document); | |
foreach (Paragraph paragraph in document.GetChildNodes(NodeType.Paragraph, true)) | |
{ | |
var paraBreak = collector.GetEntity(paragraph); | |
object stop = null; | |
var prevItem = paragraph.PreviousSibling; | |
if (prevItem != null) | |
{ | |
var prevBreak = collector.GetEntity(prevItem); | |
if (prevItem is Paragraph) | |
{ | |
it.Current = collector.GetEntity(prevItem); // para break | |
it.MoveParent(); // last line | |
stop = it.Current; | |
} | |
else if (prevItem is Table) | |
{ | |
var table = (Table)prevItem; | |
it.Current = collector.GetEntity(table.LastRow.LastCell.LastParagraph); // cell break | |
it.MoveParent(); // cell | |
it.MoveParent(); // row | |
stop = it.Current; | |
} | |
else | |
{ | |
throw new Exception(); | |
} | |
} | |
it.Current = paraBreak; | |
it.MoveParent(); | |
// We move from line to line in a paragraph. | |
// When paragraph spans multiple pages the we will follow across them. | |
var count = 1; | |
while (it.Current != stop) | |
{ | |
if (!it.MovePreviousLogical()) | |
break; | |
count++; | |
} | |
const int MAX_CHARS = 16; | |
var paraText = paragraph.GetText(); | |
if (paraText.Length > MAX_CHARS) | |
paraText = $"{paraText.Substring(0, MAX_CHARS)}..."; | |
Console.WriteLine($"Paragraph '{paraText}' has {count} line(-s)."); | |
} |