Lavorare con i paragrafi

Un paragrafo è un insieme di caratteri combinati in un blocco logico e che termina con un carattere speciale: un'interruzione di paragrafo. In Aspose.Words, un paragrafo è rappresentato dalla classe Paragraph.

Inserisci un paragrafo

Per inserire un nuovo paragrafo nel documento, infatti, è necessario inserire al suo interno un carattere di interruzione di paragrafo. DocumentBuilder.Writeln inserisce non solo una stringa di testo nel documento, ma aggiunge anche un’interruzione di paragrafo.

La formattazione corrente del carattere è specificata anche dalla proprietà Font e la formattazione corrente del paragrafo è determinata dalla proprietà ParagraphFormat. Nella sezione successiva entreremo più in dettaglio sulla formattazione dei paragrafi.

L’esempio di codice seguente mostra come inserire un paragrafo in un documento:

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

Formato paragrafo

La formattazione del paragrafo corrente è rappresentata dall’oggetto ParagraphFormat restituito dalla proprietà ParagraphFormat. Questo oggetto incapsula varie proprietà di formattazione dei paragrafi disponibili in Microsoft Word. Puoi facilmente ripristinare la formattazione di un paragrafo sul suo valore predefinito (stile normale, allineato a sinistra, senza rientro, senza spaziatura, senza bordi, senza ombreggiatura) chiamando ClearFormatting.

L’esempio di codice seguente mostra come impostare la formattazione del paragrafo:

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

Applica lo stile di paragrafo

Alcuni oggetti di formattazione, come Font o ParagraphFormat, supportano gli stili. Uno stile integrato o definito dall’utente è rappresentato da un oggetto Style, che contiene le proprietà di stile appropriate come nome, stile di base, carattere, formattazione del paragrafo di stile e così via.

Inoltre, l’oggetto Style espone la proprietà StyleIdentifier, che restituisce l’identificatore di stile indipendente dalle impostazioni locali rappresentato dal valore dell’enumerazione StyleIdentifier. Il fatto è che i nomi degli stili incorporati in Microsoft Word sono localizzati per lingue diverse. Utilizzando l’identificatore di stile, puoi trovare lo stile corretto indipendentemente dalla lingua del documento. I valori di enumerazione corrispondono agli stili Microsoft Word incorporati come Normal, Intestazione 1, Intestazione 2 e così via. Tutti gli stili definiti dall’utente sono impostati sul valore di enumerazione StyleIdentifier.User.

L’esempio di codice seguente mostra come applicare uno stile di paragrafo:

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

Inserisci separatore di stile per inserire stili di paragrafo diversi

È possibile aggiungere un separatore di stile alla fine di un paragrafo utilizzando la scorciatoia da tastiera Ctrl+Alt+Invio in Microsoft Word. Questa funzionalità consente di utilizzare due stili di paragrafo diversi nello stesso paragrafo logico stampato. Se desideri che parte del testo dall’inizio di una particolare intestazione venga visualizzato nel sommario, ma non vuoi che l’intera intestazione venga visualizzata nel sommario, puoi utilizzare questa funzione.

L’esempio di codice seguente mostra come inserire un separatore di stile per adattarlo a diversi stili di paragrafo:

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

Identificare il separatore dello stile di paragrafo

Aspose.Words espone la proprietà pubblica BreakIsStyleSeparator sulla classe Paragraph per identificare un paragrafo con un separatore di stile, come mostrato nell’esempio seguente:

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

Applicare bordi e ombreggiatura a un paragrafo

I confini in Aspose.Words sono rappresentati dalla classe BorderCollection: si tratta di una raccolta di oggetti Border a cui si accede tramite indice o tipo di confine. Il tipo di bordo è a sua volta rappresentato dall’enumerazione BorderType. Alcuni valori di enumerazione si applicano a più o a un solo elemento del documento. Ad esempio, BorderType.Bottom si applica a un paragrafo o a una cella di tabella, mentre BorderType.DiagonalDown specifica un bordo diagonale solo in una cella di tabella.

Sia la raccolta bordi che ogni bordo separato hanno attributi simili come colore, stile della linea, larghezza della linea, distanza dal testo e ombra facoltativa. Sono rappresentati da proprietà con lo stesso nome. Puoi ottenere diversi tipi di bordo combinando i valori delle proprietà. Inoltre, gli oggetti BorderCollection e Border consentono di reimpostare questi valori sui valori predefiniti chiamando il metodo ClearFormatting.

Aspose.Words ha anche la classe Shading che contiene attributi di ombreggiatura per gli elementi del documento. È possibile impostare la texture di ombreggiatura e i colori desiderati applicati allo sfondo e al primo piano di un elemento utilizzando il valore di enumerazione TextureIndex. TextureIndex consente inoltre di applicare modelli diversi all’oggetto Shading. Ad esempio, per impostare il colore di sfondo per un elemento del documento, utilizzare il valore TextureIndex.TextureSolid e impostare il colore di ombreggiatura in primo piano in modo appropriato.

L’esempio di codice seguente mostra come applicare bordi e ombreggiature a un paragrafo:

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

Contare le righe del paragrafo

Se desideri contare il numero di righe in un paragrafo per qualsiasi documento di Word, è possibile utilizzare il seguente esempio di codice:

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