Lavorare con stili e temi
La classe StyleCollection viene utilizzata per gestire le impostazioni integrate e applicare agli stili le impostazioni definite dall’utente.
Accesso agli stili
Puoi ottenere una raccolta di stili definiti nel documento utilizzando la proprietà Document.Styles. Questa raccolta contiene sia gli stili incorporati che quelli definiti dall’utente in un documento. Uno stile particolare può essere ottenuto tramite il suo nome/alias, identificatore di stile o indice. Nell’esempio di codice seguente viene illustrato come ottenere l’accesso alla raccolta di stili definiti nel 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(); | |
// Load the template document. | |
Document doc = new Document(dataDir + "TestFile.doc"); | |
// Get styles collection from document. | |
StyleCollection styles = doc.Styles; | |
string styleName = ""; | |
// Iterate through all the styles. | |
foreach (Style style in styles) | |
{ | |
if (styleName == "") | |
{ | |
styleName = style.Name; | |
} | |
else | |
{ | |
styleName = styleName + ", " + style.Name; | |
} | |
} |
Come estrarre il contenuto in base agli stili
A livello semplice, recuperare il contenuto in base agli stili da un documento Word può essere utile per identificare, elencare e contare paragrafi e sequenze di testo formattate con uno stile specifico. Ad esempio, potrebbe essere necessario identificare particolari tipi di contenuto nel documento, come esempi, titoli, riferimenti, parole chiave, nomi di figure e casi di studio.
Per fare qualche passo ulteriore, questo può anche essere utilizzato per sfruttare la struttura del documento, definita dagli stili che utilizza, per riutilizzare il documento per un altro output, come HTML. Questo è infatti il modo in cui viene costruita la documentazione di Aspose, mettendo alla prova Aspose.Words. Uno strumento creato utilizzando Aspose.Words prende i documenti Word di origine e li divide in argomenti a determinati livelli di intestazione. Viene prodotto un file XML utilizzando Aspose.Words che viene utilizzato per costruire l’albero di navigazione che puoi vedere a sinistra. E poi Aspose.Words converte ogni argomento in HTML.
La soluzione per recuperare testo formattato con stili specifici in un documento Word è in genere economica e semplice utilizzando Aspose.Words.
La soluzione
Per illustrare con quanta facilità Aspose.Words gestisce il recupero dei contenuti in base agli stili, diamo un’occhiata a un esempio. In questo esempio, recupereremo il testo formattato con uno stile di paragrafo e uno stile di carattere specifici da un documento Word di esempio. Ad alto livello, ciò comporterà:# Aprire un documento Word utilizzando la classe Document.# Ottenere raccolte di tutti i paragrafi e tutte le sequenze nel documento.# Selezionando solo i paragrafi e le sequenze richiesti. Nello specifico, recupereremo il testo formattato con lo stile di paragrafo “Intestazione 1” e lo stile di carattere “Enfasi intensa” da questo documento Word di esempio.
In questo documento di esempio, il testo formattato con lo stile di paragrafo “Intestazione 1” è “Inserisci scheda”, “Stili rapidi” e “Tema”, mentre il testo formattato con lo stile di carattere “Enfasi intensa” presenta diverse istanze di blu, testo in corsivo e in grassetto come “gallerie” e “aspetto generale”.
Il codice
L’implementazione di una query basata su stile è abbastanza semplice nel modello di oggetti del documento Aspose.Words, poiché utilizza semplicemente strumenti già presenti. Per questa soluzione sono implementati due metodi di classe: ParagraphsByStyleName – Questo metodo recupera un array di quei paragrafi in il documento che ha un nome di stile specifico. RunsByStyleName – Questo metodo recupera un array di quelle esecuzioni nel documento che hanno un nome di stile specifico. Entrambi questi metodi sono molto simili, le uniche differenze sono i tipi di nodo e la rappresentazione dello stile informazioni all’interno del paragrafo ed esegui i nodi. Ecco un’implementazione di ParagraphsByStyleName: nell’esempio seguente trovi tutti i paragrafi formattati con lo stile specificato.
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET | |
public static ArrayList ParagraphsByStyleName(Document doc, string styleName) | |
{ | |
// Create an array to collect paragraphs of the specified style. | |
ArrayList paragraphsWithStyle = new ArrayList(); | |
// Get all paragraphs from the document. | |
NodeCollection paragraphs = doc.GetChildNodes(NodeType.Paragraph, true); | |
// Look through all paragraphs to find those with the specified style. | |
foreach (Paragraph paragraph in paragraphs) | |
{ | |
if (paragraph.ParagraphFormat.Style.Name == styleName) | |
paragraphsWithStyle.Add(paragraph); | |
} | |
return paragraphsWithStyle; | |
} |
Questa implementazione utilizza anche il metodo Document.GetChildNodes
della classe Document
, che restituisce una raccolta di tutti i nodi con il tipo specificato, che in questo caso in tutti i paragrafi.
Si noti che il secondo parametro del metodo Document.GetChildNodes è impostato su true. Ciò impone al metodo Document.GetChildNodes di selezionare ricorsivamente da tutti i nodi figlio, anziché selezionare solo i nodi figli immediati.
Vale anche la pena sottolineare che la raccolta paragrafi non crea un sovraccarico immediato poiché i paragrafi vengono caricati in questa raccolta solo quando si accede agli elementi al loro interno. Quindi, tutto ciò che devi fare è esaminare la raccolta, utilizzando l’operatore foreach standard e aggiungere i paragrafi con lo stile specificato all’array paragrafosWithStyle. Il nome dello stile Paragraph
si trova nella proprietà Style.Name dell’oggetto Paragraph.ParagraphFormat. L’implementazione di RunsByStyleName è quasi la stessa, anche se ovviamente utilizziamo NodeType.Run per recuperare i nodi di esecuzione. La proprietà Font.Style di un oggetto Run viene utilizzata per accedere alle informazioni sullo stile nei nodi Run. Nell’esempio seguente trovi tutte le esecuzioni formattate con lo stile specificato.
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET | |
public static ArrayList RunsByStyleName(Document doc, string styleName) | |
{ | |
// Create an array to collect runs of the specified style. | |
ArrayList runsWithStyle = new ArrayList(); | |
// Get all runs from the document. | |
NodeCollection runs = doc.GetChildNodes(NodeType.Run, true); | |
// Look through all runs to find those with the specified style. | |
foreach (Run run in runs) | |
{ | |
if (run.Font.Style.Name == styleName) | |
runsWithStyle.Add(run); | |
} | |
return runsWithStyle; | |
} |
Quando entrambe le query vengono implementate, tutto ciò che devi fare è passare un oggetto documento e specificare i nomi di stile del contenuto che desideri recuperare: nell’esempio seguente esegui query e visualizza i risultati. È possibile scaricare il file modello di questo esempio da Qui.
// 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_WorkingWithStyles(); | |
string fileName = "TestFile.doc"; | |
// Open the document. | |
Document doc = new Document(dataDir + fileName); | |
// Define style names as they are specified in the Word document. | |
const string paraStyle = "Heading 1"; | |
const string runStyle = "Intense Emphasis"; | |
// Collect paragraphs with defined styles. | |
// Show the number of collected paragraphs and display the text of this paragraphs. | |
ArrayList paragraphs = ParagraphsByStyleName(doc, paraStyle); | |
Console.WriteLine(string.Format("Paragraphs with \"{0}\" styles ({1}):", paraStyle, paragraphs.Count)); | |
foreach (Paragraph paragraph in paragraphs) | |
Console.Write(paragraph.ToString(SaveFormat.Text)); | |
// Collect runs with defined styles. | |
// Show the number of collected runs and display the text of this runs. | |
ArrayList runs = RunsByStyleName(doc, runStyle); | |
Console.WriteLine(string.Format("\nRuns with \"{0}\" styles ({1}):", runStyle, runs.Count)); | |
foreach (Run run in runs) | |
Console.WriteLine(run.Range.Text); |
Risultato finale
Al termine, l’esecuzione dell’esempio visualizzerà il seguente output:
Come puoi vedere, questo è un esempio molto semplice, che mostra il numero e il testo dei paragrafi raccolti e delle sequenze nel documento Word di esempio.
Copia tutti gli stili dal modello
Ci sono casi in cui desideri copiare tutti gli stili da un documento a un altro. È possibile utilizzare il metodo Document.CopyStylesFromTemplate
per copiare gli stili dal modello specificato a un documento. Quando gli stili vengono copiati da un modello a un documento, gli stili con nomi simili nel documento vengono ridefiniti per corrispondere alle descrizioni di stile nel modello. Gli stili univoci del modello vengono copiati nel documento. Gli stili univoci nel documento rimangono intatti. L’esempio di Below code mostra come copiare gli stili da un documento all’altro.
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET | |
string fileName = dataDir + "template.docx"; | |
Document doc = new Document(fileName); | |
// Open the document. | |
Document target = new Document(dataDir + "TestFile.doc"); | |
target.CopyStylesFromTemplate(doc); | |
dataDir = dataDir + RunExamples.GetOutputFilePath(fileName); | |
doc.Save(dataDir); |
Come manipolare le proprietà del tema
Abbiamo aggiunto API di base in Aspose.Words per accedere alle proprietà del tema del documento. Per ora, questo API include i seguenti oggetti pubblici:
- Tema
- Caratteri tematici
- Colori del tema
Ecco come puoi ottenere le proprietà del tema:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET | |
Document doc = new Document(dataDir); | |
Theme theme = doc.Theme; | |
// Major (Headings) font for Latin characters. | |
Console.WriteLine(theme.MajorFonts.Latin); | |
// Minor (Body) font for EastAsian characters. | |
Console.WriteLine(theme.MinorFonts.EastAsian); | |
// Color for theme color Accent 1. | |
Console.WriteLine(theme.Colors.Accent1); |
Ed ecco come puoi impostare le proprietà del tema:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET | |
Document doc = new Document(dataDir); | |
Theme theme = doc.Theme; | |
// Set Times New Roman font as Body theme font for Latin Character. | |
theme.MinorFonts.Latin = "Times New Roman"; | |
// Set Color.Gold for theme color Hyperlink. | |
theme.Colors.Hyperlink = Color.Gold; |