Trabalhando com parágrafos

Um parágrafo é um conjunto de caracteres combinados em um bloco lógico e terminando com um caractere especial – uma quebra de parágrafo. No Aspose.Words, um parágrafo é representado pela classe Paragraph.

Insira um parágrafo

Para inserir um novo parágrafo no documento, na verdade, você precisa inserir um caractere de quebra de parágrafo nele. DocumentBuilder.Writeln insere não apenas uma sequência de texto no documento, mas também adiciona uma quebra de parágrafo.

A formatação atual da fonte também é especificada pela propriedade Font e a formatação atual do parágrafo é determinada pela propriedade ParagraphFormat. Na próxima seção, entraremos em mais detalhes sobre a formatação de parágrafos.

O exemplo de código a seguir mostra como inserir um parágrafo em um 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);

Parágrafo de formato

A formatação atual do parágrafo é representada pelo objeto ParagraphFormat retornado pela propriedade ParagraphFormat. Este objeto encapsula várias propriedades de formatação de parágrafo disponíveis em Microsoft Word. Você pode redefinir facilmente a formatação de um parágrafo para seu padrão – estilo normal, alinhado à esquerda, sem recuo, sem espaçamento, sem bordas, sem sombreamento – chamando ClearFormatting.

O exemplo de código a seguir mostra como definir a formatação de parágrafo:

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

Aplicar estilo de parágrafo

Alguns objetos de formatação, como Font ou ParagraphFormat, suportam estilos. Um estilo interno ou definido pelo usuário é representado por um objeto Style, que contém as propriedades de estilo apropriadas, como nome, estilo base, fonte, estilo de formatação de parágrafo e assim por diante.

Além disso, o objeto Style expõe a propriedade StyleIdentifier, que retorna o identificador de estilo independente de localidade representado pelo valor de enumeração StyleIdentifier. O fato é que os nomes dos estilos integrados no Microsoft Word estão localizados para diferentes idiomas. Usando o identificador de estilo, você pode encontrar o estilo correto, independentemente do idioma do documento. Os valores de enumeração correspondem aos estilos Microsoft Word integrados, como Normal, Título 1, Título 2 e assim por diante. Todos os estilos definidos pelo usuário são definidos com o valor de enumeração StyleIdentifier.User.

O exemplo de código a seguir mostra como aplicar um estilo de parágrafo:

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

Insira o separador de estilo para colocar diferentes estilos de parágrafo

Um separador de estilo pode ser adicionado ao final de um parágrafo usando o atalho de teclado Ctrl+Alt+Enter em Microsoft Word. Este recurso permite usar dois estilos de parágrafo diferentes no mesmo parágrafo lógico impresso. Se você deseja que algum texto do início de um título específico apareça no índice, mas não deseja que o título inteiro apareça no índice, você pode usar esta função.

O exemplo de código a seguir mostra como inserir um separador de estilo para acomodar diferentes estilos de parágrafo:

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

Identificar o separador de estilo de parágrafo

Aspose.Words expõe a propriedade pública BreakIsStyleSeparator na classe Paragraph para identificar um parágrafo com um separador de estilo, conforme mostrado no exemplo abaixo:

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

Aplicar bordas e sombreamento a um parágrafo

As bordas em Aspose.Words são representadas pela classe BorderCollection – esta é uma coleção de objetos Border que são acessados por índice ou por tipo de borda. O tipo de borda, por sua vez, é representado pela enumeração BorderType. Alguns valores de enumeração se aplicam a vários ou apenas um elemento do documento. Por exemplo, BorderType.Bottom se aplica a um parágrafo ou célula de tabela, enquanto BorderType.DiagonalDown especifica uma borda diagonal apenas em uma célula de tabela.

Tanto a coleção de bordas quanto cada borda separada possuem atributos semelhantes, como cor, estilo de linha, largura da linha, distância do texto e sombra opcional. Eles são representados por propriedades com o mesmo nome. Você pode obter diferentes tipos de bordas combinando valores de propriedades. Além disso, os objetos BorderCollection e Border permitem redefinir esses valores para seus valores padrão chamando o método ClearFormatting.

Observe que quando as propriedades da borda são redefinidas para seus valores padrão, a borda fica invisível.

Aspose.Words também possui a classe Shading que contém atributos de sombreamento para elementos do documento. Você pode definir a textura e as cores de sombreamento desejadas que são aplicadas ao plano de fundo e ao primeiro plano de um elemento usando o valor de enumeração TextureIndex. TextureIndex também permite aplicar padrões diferentes ao objeto Shading. Por exemplo, para definir a cor de fundo de um elemento do documento, utilize o valor TextureIndex.TextureSolid e defina a cor de sombreamento do primeiro plano conforme apropriado.

O exemplo de código a seguir mostra como aplicar bordas e sombreamento a um parágrafo:

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

Contar linhas de parágrafo

Se você quiser contar o número de linhas em um parágrafo de qualquer documento do Word, o seguinte exemplo de código pode ser usado:

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