Lucrul cu stiluri
Clasa StyleCollection este utilizată pentru a gestiona setările încorporate și pentru a aplica setările definite de utilizator stilurilor.
Cum să extrageți conținut pe baza stilurilor
La un nivel simplu, preluarea conținutului pe baza stilurilor dintr-un document Word poate fi utilă pentru identificarea, listarea și numărarea paragrafelor și a rulărilor de text formatate cu un anumit stil. De exemplu, poate fi necesar să identificați anumite tipuri de conținut din document, cum ar fi exemple, titluri, referințe, cuvinte cheie, nume de figuri și studii de caz.
Pentru a face acest lucru câțiva pași mai departe, acest lucru poate fi, de asemenea, utilizat pentru a valorifica structura documentului, definită de stilurile pe care le folosește, pentru a reutiliza documentul pentru o altă ieșire, cum ar fi HTML. Acesta este de fapt modul în care este construită documentația Aspose, punând Aspose.Words la încercare. Un instrument construit folosind Aspose.Words ia documentele Word sursă și le împarte în subiecte la anumite niveluri de titlu. Un fișier XML este produs folosind Aspose.Words care este folosit pentru a construi arborele de navigare pe care îl puteți vedea în stânga. Și apoi Aspose.Words convertește fiecare subiect în HTML.
Soluția pentru recuperarea textului formatat cu stiluri specifice într-un document Word este de obicei economică și simplă folosind Aspose.Words.
Soluția
Pentru a ilustra cât de ușor gestionează Aspose.Words preluarea conținutului pe baza stilurilor, să ne uităm la un exemplu. În acest exemplu, vom prelua text formatat cu un anumit stil de paragraf și un stil de caractere dintr-un exemplu de document Word. La un nivel înalt, acest lucru va implica:
- Deschiderea unui document Word folosind clasa
Document
. - Obținerea colecțiilor tuturor paragrafelor și a tuturor rulărilor din document.
- Selectarea numai paragrafele necesare și se execută. Mai exact, vom prelua textul formatat cu stilul de paragraf ‘Heading 1 ‘și stilul de caractere ‘intens accent’ din acest exemplu de document Word.
În acest exemplu de document, textul formatat cu stilul de paragraf’ Heading 1 ' este ‘Insert Tab’, ' Quick Styles ‘și’ Theme’, iar textul formatat cu stilul de caractere' Intense accounts ‘este format din mai multe instanțe de text Albastru, cursiv, aldin, cum ar fi’ galerii ‘și’look general’.
Codul
Implementarea unei interogări bazate pe stil este destul de simplă în modelul obiectului document Aspose.Words, deoarece folosește pur și simplu instrumente care sunt deja în vigoare. Pentru această soluție sunt implementate două metode de clasă: ParagraphsByStyleName - această metodă preia o serie de paragrafe din document care au un nume de stil specific. RunsByStyleName - această metodă preia o matrice a acelor rulări din document care au un nume de stil specific. Ambele metode sunt foarte similare, singurele diferențe fiind tipurile de noduri și reprezentarea informațiilor de stil în cadrul nodurilor paragraf și run. Iată o implementare a ParagraphsByStyleName. Exemplul de mai jos găsiți toate paragrafele formatate cu stilul specificat.
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; | |
} |
Această implementare utilizează, de asemenea, metoda Document.GetChildNodes
a clasei Document
, care returnează o colecție a tuturor nodurilor cu tipul specificat, care în acest caz în toate paragrafele.
Rețineți că al doilea parametru al metodei Document.GetChildNodes este setat la true. Acest lucru forțează metoda Document.GetChildNodes să selecteze recursiv din toate nodurile copil, mai degrabă decât să selecteze doar copiii imediati.
De asemenea, merită subliniat faptul că colecția paragrafe nu creează o cheltuială imediată, deoarece paragrafele sunt încărcate în această colecție numai atunci când accesați articole din ele. Apoi, tot ce trebuie să faceți este să Parcurgeți colecția, folosind standardul pentru fiecare operator și să adăugați paragrafe care au stilul specificat la matricea paragraphsWithStyle. Numele stilului Paragraph
poate fi găsit în stil. Proprietatea numelui obiectului Paragraph.ParagraphFormat
. Implementarea RunsByStyleName este aproape aceeași, deși evident folosim NodeType.Run
pentru a prelua nodurile run. Proprietatea Font.Style
a unui obiect Run
este utilizată pentru a accesa informații de stil în nodurile Run. Exemplul below code găsește toate rulările formatate cu stilul specificat.
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; | |
} |
Când ambele interogări sunt implementate, tot ce trebuie să faceți este să treceți un obiect document și să specificați numele stilului conținutului pe care doriți să îl preluați: mai jos exemplu rulați interogări și afișați rezultatele. Puteți descărca fișierul șablon al acestui exemplu de aici.
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; | |
} |
Rezultatul Final
Când totul se face, rularea eșantionului va afișa următoarea ieșire:
După cum puteți vedea, acesta este un exemplu foarte simplu, care arată numărul și textul paragrafelor colectate și rulează în documentul Word eșantion.
Cum să inserați și să lucrați cu câmpul cuprins
Adesea veți lucra cu documente care conțin un cuprins (TOC). Folosind Aspose.Words puteți introduce propriul Cuprins sau puteți reconstrui complet cuprinsul existent în document folosind doar câteva linii de cod. Acest articol prezintă modul de lucru cu câmpul cuprins și demonstrează:
- Cum se introduce un brand nou
TOC
- Actualizați TOCs nou sau existent în document.
- Specificați comutatoare pentru a controla formatarea și structura generală f TOC.
- Cum se modifică stilurile și aspectul cuprinsului.
- Cum să eliminați un întreg câmp
TOC
împreună cu toate intrările din document.
Introduceți TC Câmpuri
Adesea, o linie specifică de text este desemnată pentru TOC
și este marcată cu un câmp TC
. Modul simplu de a face acest lucru în MS Word este să evidențiați textul și să apăsați ALT+SHIFT+O. Aceasta creează automat un câmp TC
folosind textul selectat. Aceeași tehnică poate fi realizată prin cod. Codul de mai jos va găsi textul care se potrivește cu intrarea și va introduce un câmp TC
în aceeași poziție cu textul. Codul se bazează pe aceeași tehnică utilizată în articol. Exemplul de mai jos arată cum să găsiți și să inserați un câmp TC
la textul dintr-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; | |
} |
Modificați un cuprins
Modificați formatarea stilurilor
Formatarea intrărilor din TOC
nu utilizează stilurile originale ale intrărilor marcate, în schimb, fiecare nivel este formatat folosind un stil echivalent TOC
. De exemplu, primul nivel din TOC
este formatat cu stilul TOC1, al doilea nivel formatat cu stilul TOC2 și așa mai departe. Aceasta înseamnă că pentru a schimba aspectul TOC
aceste stiluri trebuie modificate. În Aspose.Words aceste stiluri sunt reprezentate de locale independent StyleIdentifier.TOC1
până la StyleIdentifier.TOC9
și pot fi recuperate din colecția Document.Styles
folosind acești identificatori. Odată ce stilul corespunzător al documentului a fost preluat, formatarea pentru acest stil poate fi modificată. Orice modificare a acestor stiluri va fi reflectată automat pe TOCs din document. Exemplul below code modifică o proprietate de formatare utilizată în primul nivel TOC
stil.
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); |
De asemenea, este util să rețineți că orice formatare directă a unui paragraf (definit pe paragraful în sine și nu în stil) marcat pentru a fi inclus TOC
va fi copiat în intrarea din TOC. De exemplu, dacă stilul Heading 1 este folosit pentru a marca conținutul pentru TOC
și acest stil are formatare cu caractere aldine, în timp ce paragraful are, de asemenea, formatare cursivă aplicată direct acestuia. Intrarea TOC
rezultată nu va fi aldină, deoarece face parte din formatarea stilului, dar va fi cursivă, deoarece aceasta este formatată direct în paragraf. De asemenea, puteți controla formatarea separatoarelor utilizate între fiecare intrare și numărul paginii. În mod implicit, aceasta este o linie punctată care este răspândită în numerotarea paginilor folosind un caracter de filă și un stop de filă din dreapta aliniat aproape de marginea din dreapta.
Folosind clasa Style
recuperată pentru nivelul TOC
pe care doriți să îl modificați, puteți modifica și modul în care acestea apar în document. Pentru a schimba modul în care apare mai întâi Style.ParagraphFormat
trebuie apelat pentru a prelua formatarea paragrafului pentru stil. Din aceasta, opririle de filă pot fi recuperate apelând ParagraphFormat.TabStops
și opritorul de filă corespunzător modificat. Folosind aceeași tehnică, fila în sine poate fi mutată sau eliminată cu totul. Exemplul below code arată cum să modificați poziția opritorului de filă din dreapta în paragrafele legate de TOC
. Puteți descărca fișierul șablon al acestui exemplu de aici.
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); |
Eliminarea unui cuprins din Document
Un cuprins poate fi eliminat din document prin eliminarea tuturor nodurilor găsite între nodul FieldStart
și FieldEnd din câmpul TOC
. Codul de mai jos demonstrează acest lucru. Eliminarea câmpului TOC
este mai simplă decât un câmp normal, deoarece nu ținem evidența câmpurilor imbricate. În schimb, verificăm nodul FieldEnd
este de tip FieldType.FieldTOC
ceea ce înseamnă că am întâlnit sfârșitul curentului TOC. Această tehnică poate fi utilizată în acest caz fără a vă îngrijora de câmpurile imbricate, deoarece putem presupune că orice document format corect nu va avea un câmp TOC
complet imbricat în interiorul unui alt câmp TOC
. În primul rând, nodurile FieldStart
ale fiecărui TOC
sunt colectate și stocate. TOC
specificat este apoi enumerat astfel încât toate nodurile din câmp sunt vizitate și stocate. Nodurile sunt apoi eliminate din document. Exemplul below code demonstrează cum să eliminați un TOC
specificat dintr-un document. Puteți descărca fișierul șablon al acestui exemplu de aici.
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); |
Inserați Separator de stil pentru a pune diferite stiluri de paragraf
Separatorul de stil poate fi adăugat la sfârșitul unui paragraf folosind comanda rapidă de la tastatură Ctrl + Alt + Enter în MS Word. Această caracteristică permite două stiluri diferite de paragraf utilizate într-un paragraf tipărit logic. Dacă doriți ca un text de la începutul unui anumit titlu să apară într-un cuprins, dar nu doriți ca întregul titlu să apară în Cuprins, puteți utiliza această caracteristică. Exemplul below code arată cum să inserați un separator de stil pentru a pune diferite stiluri de paragraf.
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); |
Copiați toate stilurile din șablon
Există cazuri în care doriți să copiați toate stilurile dintr-un document în altul. Puteți utiliza metoda Document.CopyStylesFromTemplate
pentru a copia stiluri din șablonul specificat într-un document. Când stilurile sunt copiate dintr-un șablon într-un document, stilurile cu nume similare din document sunt redefinite pentru a se potrivi descrierilor de stil din șablon. Stilurile unice din șablon sunt copiate în document. Stilurile unice din document rămân intacte. Exemplul below code arată cum să copiați stiluri dintr-un document în altul.
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); |