Travailler avec des Styles
La classe StyleCollection est utilisée pour gérer les paramètres intégrés et appliquer les paramètres définis par l’utilisateur aux styles.
Comment extraire du Contenu en fonction des Styles
À un niveau simple, la récupération du contenu basé sur les styles d’un document Word peut être utile pour identifier, répertorier et compter les paragraphes et les suites de texte formatés avec un style spécifique. Par exemple, vous devrez peut-être identifier des types particuliers de contenu dans le document, tels que des exemples, des titres, des références, des mots clés, des noms de figures et des études de cas.
Pour aller plus loin, cela peut également être utilisé pour tirer parti de la structure du document, définie par les styles qu’il utilise, pour réaffecter le document à une autre sortie, telle que HTML. C’est en fait ainsi que la documentation Aspose est construite, mettant Aspose.Words à l’épreuve. Un outil créé à l’aide de Aspose.Words prend les documents Word source et les divise en rubriques à certains niveaux d’en-tête. Un fichier XML est produit en utilisant Aspose.Words qui est utilisé pour construire l’arborescence de navigation que vous pouvez voir à gauche. Et puis Aspose.Words convertit chaque sujet en HTML.
La solution pour récupérer du texte formaté avec des styles spécifiques dans un document Word est généralement économique et simple en utilisant Aspose.Words.
La Solution
Pour illustrer la facilité avec laquelle Aspose.Words gère la récupération du contenu en fonction des styles, examinons un exemple. Dans cet exemple, nous allons récupérer du texte formaté avec un style de paragraphe spécifique et un style de caractère à partir d’un exemple de document Word. À un niveau élevé, cela impliquera:
- Ouverture d’un document Word à l’aide de la classe
Document
. - Obtenir des collections de tous les paragraphes et de toutes les exécutions dans le document.
- Sélection uniquement des paragraphes et des passages requis. Plus précisément, nous récupérerons le texte formaté avec le style de paragraphe “En-tête 1” et le style de caractère “Accentuation intense” à partir de cet exemple de document Word.
Dans cet exemple de document, le texte formaté avec le style de paragraphe “En-tête 1 “est ‘Onglet Insertion” ‘ “Styles rapides” et “Thème”, et le texte formaté avec le style de caractère “Accentuation intense” est les différentes occurrences de texte bleu, en italique et en gras telles que “galeries” et “aspect général”.
Le Code
L’implémentation d’une requête basée sur le style est assez simple dans le modèle d’objet de document Aspose.Words, car elle utilise simplement des outils déjà en place. Deux méthodes de classe sont implémentées pour cette solution: ParagraphsByStyleName – Cette méthode récupère un tableau des paragraphes du document qui ont un nom de style spécifique. RunsByStyleName - Cette méthode récupère un tableau de ces exécutions dans le document qui ont un nom de style spécifique. Ces deux méthodes sont très similaires, les seules différences étant les types de nœuds et la représentation des informations de style dans les nœuds de paragraphe et d’exécution. Voici une implémentation de ParagraphsByStyleName. Ci-dessous, l’exemple trouve tous les paragraphes formatés avec le style spécifié.
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
std::vector<System::SharedPtr<Paragraph>> ParagraphsByStyleName(System::SharedPtr<Document> doc, System::String const &styleName) | |
{ | |
// Create an array to collect paragraphs of the specified style. | |
std::vector<System::SharedPtr<Paragraph>> paragraphsWithStyle; | |
// Get all paragraphs from the document. | |
System::SharedPtr<NodeCollection> paragraphs = doc->GetChildNodes(NodeType::Paragraph, true); | |
// Look through all paragraphs to find those with the specified style. | |
for (System::SharedPtr<Paragraph> paragraph : System::IterateOver<System::SharedPtr<Paragraph>>(paragraphs)) | |
{ | |
if (paragraph->get_ParagraphFormat()->get_Style()->get_Name() == styleName) | |
{ | |
paragraphsWithStyle.push_back(paragraph); | |
} | |
} | |
return paragraphsWithStyle; | |
} |
Cette implémentation utilise également la méthode Document.GetChildNodes
de la classe Document
, qui renvoie une collection de tous les nœuds avec le type spécifié, qui dans ce cas dans tous les paragraphes.
Notez que le deuxième paramètre de la méthode Document.GetChildNodes est défini sur true. Cela force la méthode Document.GetChildNodes à sélectionner récursivement parmi tous les nœuds enfants, plutôt que de sélectionner uniquement les enfants immédiats.
Il convient également de souligner que la collection paragraphs ne crée pas de surcharge immédiate car les paragraphes ne sont chargés dans cette collection que lorsque vous accédez à des éléments qu’ils contiennent. Ensuite, tout ce que vous avez à faire est de parcourir la collection, en utilisant la norme pour chaque opérateur et d’ajouter des paragraphes qui ont le style spécifié au tableau paragraphsWithStyle. Le nom du style Paragraph
se trouve dans le Style. Propriété Name de l’objet Paragraph.ParagraphFormat
. L’implémentation de RunsByStyleName est presque la même, bien que nous utilisions évidemment NodeType.Run
pour récupérer les nœuds d’exécution. La propriété Font.Style
d’un objet Run
est utilisée pour accéder aux informations de style dans les nœuds Run. L’exemple below code trouve toutes les exécutions formatées avec le style spécifié.
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
std::vector<System::SharedPtr<Run>> RunsByStyleName(System::SharedPtr<Document> doc, System::String const &styleName) | |
{ | |
// Create an array to collect runs of the specified style. | |
std::vector<System::SharedPtr<Run>> runsWithStyle; | |
// Get all runs from the document. | |
System::SharedPtr<NodeCollection> runs = doc->GetChildNodes(NodeType::Run, true); | |
// Look through all runs to find those with the specified style. | |
for (System::SharedPtr<Run> run : System::IterateOver<System::SharedPtr<Run>>(runs)) | |
{ | |
if (run->get_Font()->get_Style()->get_Name() == styleName) | |
{ | |
runsWithStyle.push_back(run); | |
} | |
} | |
return runsWithStyle; | |
} |
Lorsque les deux requêtes sont implémentées, il vous suffit de passer un objet document et de spécifier les noms de style du contenu que vous souhaitez récupérer: Exemple ci-dessous exécutez des requêtes et affichez les résultats. Vous pouvez télécharger le fichier modèle de cet exemple à partir d’ici.
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
// The path to the documents directory. | |
System::String inputDataDir = GetInputDataDir_WorkingWithStyles(); | |
// Open the document. | |
System::SharedPtr<Document> doc = System::MakeObject<Document>(inputDataDir + u"TestFile.doc"); | |
// Define style names as they are specified in the Word document. | |
const System::String paraStyle = u"Heading 1"; | |
const System::String runStyle = u"Intense Emphasis"; | |
// Collect paragraphs with defined styles. | |
// Show the number of collected paragraphs and display the text of this paragraphs. | |
std::vector<System::SharedPtr<Paragraph>> paragraphs = ParagraphsByStyleName(doc, paraStyle); | |
std::cout << "Paragraphs with \"" << paraStyle.ToUtf8String() << "\" styles (" << paragraphs.size() << "):" << std::endl; | |
for (System::SharedPtr<Paragraph> paragraph : paragraphs) | |
{ | |
std::cout << paragraph->ToString(SaveFormat::Text).ToUtf8String(); | |
} | |
std::cout << std::endl; | |
// Collect runs with defined styles. | |
// Show the number of collected runs and display the text of this runs. | |
std::vector<System::SharedPtr<Run>> runs = RunsByStyleName(doc, runStyle); | |
std::cout << "Runs with \"" << runStyle.ToUtf8String() << "\" styles (" << runs.size() << "):" << std::endl; | |
for (System::SharedPtr<Run> run : runs) | |
{ | |
std::cout << run->get_Range()->get_Text().ToUtf8String() << std::endl; | |
} |
Résultat Final
Lorsque tout est terminé, l’exécution de l’échantillon affichera la sortie suivante:
Comme vous pouvez le voir, il s’agit d’un exemple très simple, montrant le nombre et le texte des paragraphes collectés et s’exécute dans l’exemple de document Word.
Procédure pas à pas pour insérer et utiliser le champ Table des matières
Souvent, vous travaillerez avec des documents contenant une table des matières (table des matières). En utilisant Aspose.Words, vous pouvez insérer votre propre table des matières ou reconstruire complètement la table des matières existante dans le document en utilisant seulement quelques lignes de code. Cet article explique comment utiliser le champ Table des matières et démontre:
- Comment insérer un tout nouveau
TOC
- Mettez à jour TOCs nouveau ou existant dans le document.
- Spécifiez des commutateurs pour contrôler le formatage et la structure globale de la table des matières.
- Comment modifier les styles et l’apparence de la table des matières.
- Comment supprimer un champ
TOC
entier ainsi que toutes les entrées du document.
Insérer des champs TC
Souvent, une ligne de texte spécifique est désignée pour le TOC
et est marquée d’un champ TC
. Le moyen le plus simple de le faire dans MS Word est de surligner le texte et d’appuyer sur ALT+SHIFT+O. Cela crée automatiquement un champ TC
en utilisant le texte sélectionné. La même technique peut être accomplie par le code. Le code ci-dessous trouvera le texte correspondant à l’entrée et insérera un champ TC
à la même position que le texte. Le code est basé sur la même technique utilisée dans l’article. L’exemple ci-dessous montre comment rechercher et insérer un champ TC
dans le texte d’un document.
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
System::SharedPtr<Document> doc = System::MakeObject<Document>(); | |
System::SharedPtr<FindReplaceOptions> options = System::MakeObject<FindReplaceOptions>(); | |
// Highlight newly inserted content. | |
options->get_ApplyFont()->set_HighlightColor(System::Drawing::Color::get_DarkOrange()); | |
options->set_ReplacingCallback(System::MakeObject<InsertTCFieldHandler>(u"Chapter 1", u"\\l 1")); | |
// Insert a TC field which displays "Chapter 1" just before the text "The Beginning" in the document. | |
doc->get_Range()->Replace(System::MakeObject<System::Text::RegularExpressions::Regex>(u"The Beginning"), u"", options); |
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
class InsertTCFieldHandler : public IReplacingCallback | |
{ | |
typedef InsertTCFieldHandler ThisType; | |
typedef IReplacingCallback BaseType; | |
typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo; | |
public: | |
InsertTCFieldHandler(const System::String& text, const System::String& switches) | |
: mFieldText(text), mFieldSwitches(switches) {} | |
InsertTCFieldHandler(const System::String& switches) | |
: mFieldText(System::String::Empty), mFieldSwitches(switches) {} | |
ReplaceAction Replacing(System::SharedPtr<ReplacingArgs> args) override; | |
private: | |
System::String mFieldText; | |
System::String mFieldSwitches; | |
}; | |
ReplaceAction InsertTCFieldHandler::Replacing(System::SharedPtr<ReplacingArgs> args) | |
{ | |
// Create a builder to insert the field. | |
System::SharedPtr<DocumentBuilder> builder = System::MakeObject<DocumentBuilder>(System::DynamicCast<Document>(args->get_MatchNode()->get_Document())); | |
// Move to the first node of the match. | |
builder->MoveTo(args->get_MatchNode()); | |
// If the user specified text to be used in the field as display text then use that, otherwise use the | |
// Match string as the display text. | |
System::String insertText; | |
if (!System::String::IsNullOrEmpty(mFieldText)) | |
{ | |
insertText = mFieldText; | |
} | |
else | |
{ | |
insertText = args->get_Match()->get_Value(); | |
} | |
// Insert the TC field before this node using the specified string as the display text and user defined switches. | |
builder->InsertField(System::String::Format(u"TC \"{0}\" {1}", insertText, mFieldSwitches)); | |
// We have done what we want so skip replacement. | |
return ReplaceAction::Skip; | |
} |
Modifier une Table des matières
Modifier la mise en forme des styles
Le formatage des entrées dans le TOC
n’utilise pas les styles d’origine des entrées marquées, à la place, chaque niveau est formaté en utilisant un style TOC
équivalent. Par exemple, le premier niveau du TOC
est formaté avec le style TOC1, le deuxième niveau formaté avec le style TOC2 et ainsi de suite. Cela signifie que pour changer l’apparence des TOC
, ces styles doivent être modifiés. Dans Aspose.Words, ces styles sont représentés par les paramètres régionaux indépendants StyleIdentifier.TOC1
à StyleIdentifier.TOC9
et peuvent être récupérés à partir de la collection Document.Styles
à l’aide de ces identifiants. Une fois que le style approprié du document a été récupéré, la mise en forme de ce style peut être modifiée. Toute modification de ces styles sera automatiquement reflétée sur le TOCs dans le document. L’exemple below code modifie une propriété de formatage utilisée dans le style TOC
de premier niveau.
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
System::SharedPtr<Document> doc = System::MakeObject<Document>(); | |
// Retrieve the style used for the first level of the TOC and change the formatting of the style. | |
doc->get_Styles()->idx_get(StyleIdentifier::Toc1)->get_Font()->set_Bold(true); |
Il est également utile de noter que tout formatage direct d’un paragraphe (défini sur le paragraphe lui-même et non dans le style) marqué pour inclure le TOC
sera copié dans l’entrée de la table des matières. Par exemple, si le style d’en-tête 1 est utilisé pour marquer le contenu du TOC
et que ce style a une mise en forme en gras tandis que le paragraphe a également une mise en forme en italique directement appliquée. L’entrée TOC
résultante ne sera pas en gras car cela fait partie de la mise en forme du style, mais elle sera en italique car elle est directement formatée sur le paragraphe. Vous pouvez également contrôler la mise en forme des séparateurs utilisés entre chaque entrée et le numéro de page. Par défaut, il s’agit d’une ligne pointillée qui est répartie sur la numérotation des pages à l’aide d’un caractère de tabulation et d’un taquet de tabulation droit aligné près de la marge de droite.
En utilisant la classe Style
récupérée pour le niveau TOC
particulier que vous souhaitez modifier, vous pouvez également modifier leur apparence dans le document. Pour changer la façon dont cela apparaît, il faut d’abord appeler Style.ParagraphFormat
pour récupérer la mise en forme du paragraphe pour le style. À partir de là, les taquets de tabulation peuvent être récupérés en appelant ParagraphFormat.TabStops
et le taquet de tabulation approprié modifié. En utilisant cette même technique, l’onglet lui-même peut être déplacé ou supprimé complètement. L’exemple below code montre comment modifier la position du taquet de tabulation de droite dans les paragraphes associés TOC
. Vous pouvez télécharger le fichier modèle de cet exemple à partir d’ici.
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
// The path to the documents directories. | |
System::String inputDataDir = GetInputDataDir_WorkingWithStyles(); | |
System::String outputDataDir = GetOutputDataDir_WorkingWithStyles(); | |
// Open the document. | |
System::SharedPtr<Document> doc = System::MakeObject<Document>(inputDataDir + u"Document.TableOfContents.doc"); | |
// Iterate through all paragraphs in the document | |
for (System::SharedPtr<Paragraph> para : System::IterateOver<System::SharedPtr<Paragraph>>(doc->GetChildNodes(NodeType::Paragraph, true))) | |
{ | |
// Check if this paragraph is formatted using the TOC result based styles. This is any style between TOC and TOC9. | |
if (para->get_ParagraphFormat()->get_Style()->get_StyleIdentifier() >= StyleIdentifier::Toc1 && para->get_ParagraphFormat()->get_Style()->get_StyleIdentifier() <= StyleIdentifier::Toc9) | |
{ | |
// Get the first tab used in this paragraph, this should be the tab used to align the page numbers. | |
System::SharedPtr<TabStop> tab = para->get_ParagraphFormat()->get_TabStops()->idx_get(0); | |
// Remove the old tab from the collection. | |
para->get_ParagraphFormat()->get_TabStops()->RemoveByPosition(tab->get_Position()); | |
// Insert a new tab using the same properties but at a modified position. | |
// We could also change the separators used (dots) by passing a different Leader type | |
para->get_ParagraphFormat()->get_TabStops()->Add(tab->get_Position() - 50, tab->get_Alignment(), tab->get_Leader()); | |
} | |
} | |
System::String outputPath = outputDataDir + u"ChangeTOCTabStops.doc"; | |
doc->Save(outputPath); |
Suppression d’une Table des matières du document
Une table des matières peut être supprimée du document en supprimant tous les nœuds trouvés entre les nœuds FieldStart
et FieldEnd du champ TOC
. Le code ci-dessous le démontre. La suppression du champ TOC
est plus simple qu’un champ normal car nous ne gardons pas trace des champs imbriqués. Au lieu de cela, nous vérifions que le nœud FieldEnd
est de type FieldType.FieldTOC
, ce qui signifie que nous avons rencontré la fin de la table des matières actuelle. Cette technique peut être utilisée dans ce cas sans se soucier des champs imbriqués, car nous pouvons supposer que tout document correctement formé n’aura pas de champ TOC
entièrement imbriqué dans un autre champ TOC
. Tout d’abord, les FieldStart
nœuds de chaque TOC
sont collectés et stockés. Le TOC
spécifié est ensuite énuméré afin que tous les nœuds du champ soient visités et stockés. Les nœuds sont ensuite supprimés du document. L’exemple below code montre comment supprimer un TOC
spécifié d’un document. Vous pouvez télécharger le fichier modèle de cet exemple à partir d’ici.
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
// The path to the documents directories. | |
System::String inputDataDir = GetInputDataDir_WorkingWithStyles(); | |
System::String outputDataDir = GetOutputDataDir_WorkingWithStyles(); | |
// Open a document which contains a TOC. | |
System::SharedPtr<Document> doc = System::MakeObject<Document>(inputDataDir + u"Document.TableOfContents.doc"); | |
// Remove the first table of contents from the document. | |
RemoveTableOfContents(doc, 0); | |
System::String outputPath = outputDataDir + u"RemoveTOCFromDocument.doc"; | |
// Save the output. | |
doc->Save(outputPath); |
Insérer un Séparateur de Style pour Mettre Différents Styles de Paragraphe
Le séparateur de style peut être ajouté à la fin d’un paragraphe à l’aide du raccourci clavier Ctrl + Alt + Entrée dans MS Word. Cette fonctionnalité permet d’utiliser deux styles de paragraphe différents dans un paragraphe imprimé logique. Si vous souhaitez qu’un texte du début d’un en-tête particulier apparaisse dans une Table des matières mais que vous ne souhaitez pas que l’en-tête entier apparaisse dans la Table des matières, vous pouvez utiliser cette fonctionnalité. L’exemple below code montre comment insérer un séparateur de style pour mettre différents styles de paragraphe.
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
System::SharedPtr<Document> doc = System::MakeObject<Document>(); | |
System::SharedPtr<DocumentBuilder> builder = System::MakeObject<DocumentBuilder>(doc); | |
System::SharedPtr<Style> paraStyle = builder->get_Document()->get_Styles()->Add(StyleType::Paragraph, u"MyParaStyle"); | |
paraStyle->get_Font()->set_Bold(false); | |
paraStyle->get_Font()->set_Size(8); | |
paraStyle->get_Font()->set_Name(u"Arial"); | |
// Append text with "Heading 1" style. | |
builder->get_ParagraphFormat()->set_StyleIdentifier(StyleIdentifier::Heading1); | |
builder->Write(u"Heading 1"); | |
builder->InsertStyleSeparator(); | |
// Append text with another style. | |
builder->get_ParagraphFormat()->set_StyleName(paraStyle->get_Name()); | |
builder->Write(u"This is text with some other formatting "); | |
System::String outputPath = outputDataDir + u"InsertStyleSeparator.doc"; | |
// Save the document to disk. | |
doc->Save(outputPath); |
Copier tous les styles du Modèle
Il y a des cas où vous souhaitez copier tous les styles d’un document dans un autre. Vous pouvez utiliser la méthode Document.CopyStylesFromTemplate
pour copier des styles du modèle spécifié dans un document. Lorsque des styles sont copiés d’un modèle vers un document, les styles portant le même nom dans le document sont redéfinis pour correspondre aux descriptions de style du modèle. Les styles uniques du modèle sont copiés dans le document. Les styles uniques du document restent intacts. L’exemple below code montre comment copier des styles d’un document dans un autre.
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
System::String fileName = inputDataDir + u"template.docx"; | |
System::SharedPtr<Document> doc = System::MakeObject<Document>(fileName); | |
// Open the document. | |
System::SharedPtr<Document> target = System::MakeObject<Document>(inputDataDir + u"TestFile.doc"); | |
target->CopyStylesFromTemplate(doc); | |
System::String outputPath = outputDataDir + u"CopyStyles.doc"; | |
doc->Save(outputPath); |