Travailler avec des paragraphes

Un paragraphe est un ensemble de caractères combinés en un bloc logique et se terminant par un caractère spécial – un saut de paragraphe. Dans Aspose.Words, un paragraphe est représenté par la classe Paragraph.

Insérer un paragraphe

Pour insérer un nouveau paragraphe dans le document, en effet, vous devez y insérer un caractère de saut de paragraphe. DocumentBuilder.Writeln insère non seulement une chaîne de texte dans le document, mais ajoute également un saut de paragraphe.

Le formatage actuel de la police est également spécifié par la propriété Font et le formatage actuel du paragraphe est déterminé par la propriété ParagraphFormat. Dans la section suivante, nous entrerons plus en détail sur le formatage des paragraphes.

L’exemple de code suivant montre comment insérer un paragraphe dans un document:

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

Formater le paragraphe

La mise en forme actuelle du paragraphe est représentée par l’objet ParagraphFormat renvoyé par la propriété ParagraphFormat. Cet objet encapsule diverses propriétés de formatage de paragraphe disponibles en Microsoft Word. Vous pouvez facilement réinitialiser la mise en forme d’un paragraphe à sa valeur par défaut – style normal, aligné à gauche, sans indentation, sans espacement, sans bordures, sans ombrage – en appelant ClearFormatting.

L’exemple de code suivant montre comment définir la mise en forme des paragraphes:

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

Appliquer le style de paragraphe

Certains objets de mise en forme, tels que Font ou ParagraphFormat, prennent en charge les styles. Un style intégré ou défini par l’utilisateur est représenté par un objet Style, qui contient les propriétés de style appropriées telles que le nom, le style de base, la police, le formatage du paragraphe de style, etc.

De plus, l’objet Style expose la propriété StyleIdentifier, qui renvoie l’identifiant de style indépendant des paramètres régionaux représenté par la valeur d’énumération StyleIdentifier. Le fait est que les noms des styles intégrés dans Microsoft Word sont localisés pour différentes langues. Grâce à l’identifiant de style, vous pouvez trouver le style correct quelle que soit la langue du document. Les valeurs d’énumération correspondent aux styles Microsoft Word intégrés tels que Normal, Heading 1, Heading 2, etc. Tous les styles définis par l’utilisateur sont définis sur la valeur d’énumération StyleIdentifier.User.

L’exemple de code suivant montre comment appliquer un style de paragraphe:

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

Insérer un séparateur de style pour mettre différents styles de paragraphe

Un séparateur de style peut être ajouté à la fin d’un paragraphe à l’aide du raccourci clavier Ctrl+Alt+Entrée dans Microsoft Word. Cette fonctionnalité vous permet d’utiliser deux styles de paragraphe différents dans le même paragraphe imprimé logique. Si vous souhaitez qu’un texte du début d’un titre particulier apparaisse dans la table des matières, mais que vous ne souhaitez pas que le titre entier apparaisse dans la table des matières, vous pouvez utiliser cette fonction.

L’exemple de code suivant montre comment insérer un séparateur de style pour s’adapter à différents styles de paragraphe:

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

Identifier le séparateur de style de paragraphe

Aspose.Words expose la propriété publique BreakIsStyleSeparator sur la classe Paragraph pour identifier un paragraphe avec un séparateur de style, comme indiqué dans l’exemple ci-dessous:

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

Appliquer des bordures et un ombrage à un paragraphe

Les bordures dans Aspose.Words sont représentées par la classe BorderCollection – il s’agit d’une collection d’objets Border accessibles par index ou par type de bordure. Le type de bordure est à son tour représenté par l’énumération BorderType. Certaines valeurs d’énumération s’appliquent à plusieurs ou à un seul élément de document. Par exemple, BorderType.Bottom s’applique à un paragraphe ou à une cellule de tableau, tandis que BorderType.DiagonalDown spécifie une bordure diagonale dans une cellule de tableau uniquement.

La collection de bordures et chaque bordure distincte ont des attributs similaires tels que la couleur, le style de ligne, la largeur de ligne, la distance par rapport au texte et l’ombre facultative. Ils sont représentés par des propriétés du même nom. Vous pouvez obtenir différents types de bordures en combinant les valeurs des propriétés. De plus, les objets BorderCollection et Border permettent de réinitialiser ces valeurs à leurs valeurs par défaut en appelant la méthode ClearFormatting.

Aspose.Words possède également la classe Shading qui contient des attributs d’ombrage pour les éléments du document. Vous pouvez définir la texture d’ombrage et les couleurs souhaitées qui sont appliquées à l’arrière-plan et au premier plan d’un élément à l’aide de la valeur d’énumération TextureIndex. TextureIndex vous permet également d’appliquer différents modèles à l’objet Shading. Par exemple, pour définir la couleur d’arrière-plan d’un élément de document, utilisez la valeur TextureIndex.TextureSolid et définissez la couleur d’ombrage du premier plan selon vos besoins.

L’exemple de code suivant montre comment appliquer des bordures et un ombrage à un paragraphe:

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

Compter les lignes de paragraphe

Si vous souhaitez compter le nombre de lignes dans un paragraphe pour n’importe quel document Word, l’exemple de code suivant peut être utilisé:

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