#include "Spire.Pdf.o.h";

using namespace Spire::Pdf;
using namespace std;

int main() {

	//Specify input and output file paths
	wstring inputFile = L"C:\\Users\\Administrator\\Desktop\\sample.pdf";
	wstring outputFile = L"C:\\Users\\Administrator\\Desktop\\Output\\ToImage";

	//Create a PdfDocument object
	PdfDocument* doc = new PdfDocument();

	//Load a PDF file
	doc->LoadFromFile(inputFile.c_str());

	//Convert a specific page as image
	boost::intrusive_ptr<Stream> image = doc->SaveAsImage(0, PdfImageType::Bitmap);

	//Write image to a .jpg file
	wstring fileName = outputFile + L".jpg";
	image->Save(fileName.c_str());

	doc->Close();
	delete doc;
}

#include "Spire.Pdf.o.h";

using namespace Spire::Pdf;
using namespace std;

int main() {

	//Specify input and output file paths
	wstring inputFile = L"C:\\Users\\Administrator\\Desktop\\sample.pdf";
	wstring outputFile = L"C:\\Users\\Administrator\\Desktop\\Output\\ToImg-";

	//Create a PdfDocument object
	PdfDocument* doc = new PdfDocument();

	//Load a PDF file
	doc->LoadFromFile(inputFile.c_str());

	//Iterate through the pages in the document
	for (int i = 0; i < doc->GetPages()->GetCount(); i++) {

		//Save a specific page as image
		boost::intrusive_ptr<Stream> image = doc->SaveAsImage(i);

		//Write image to a .jpg file
		wstring fileName = outputFile + to_wstring(i) + L".jpg";
		image->Save(fileName.c_str());
	}
	doc->Close();
	delete doc;
}

#include "Spire.Presentation.o.h";

using namespace Spire::Presentation;
using namespace std;

int main()
{
	//Specify the input and output file paths
	std::wstring inputFile = L"Data\\sample.pptx";
	std::wstring outputFile = L"Output\\PowerPointToPDF.pdf";

	//Create a Presentation object
	intrusive_ptr⁢Presentation> ppt = new Presentation();

	//Load a PowerPoint document from disk
	ppt->LoadFromFile(inputFile.c_str());

	//Save the document to PDF
	ppt->SaveToFile(outputFile.c_str(), FileFormat::PDF);

	ppt->Dispose();

}

#include "Spire.Presentation.o.h";

using namespace Spire::Presentation;
using namespace std;

int main()
{
	//Specify the input and output file paths
	std::wstring inputFile = L"Data\\sample.pptx";
	std::wstring outputFile = L"Output\\SlideToPDF.pdf";

	//Create a Presentation object
	intrusive_ptr⁢Presentation> ppt = new Presentation();

	//Load a PowerPoint document from disk
	ppt->LoadFromFile(inputFile.c_str());

	//Get the second slide
	intrusive_ptr slide = ppt->GetSlides()->GetItem(1);

	//Save the second slide to PDF
	slide->SaveToFile(outputFile.c_str(), FileFormat::PDF);
	ppt->Dispose();
}

#include "Spire.Presentation.o.h";

using namespace Spire::Presentation;
using namespace std;

int main()
{
	//Specify the input and output file paths
	std::wstring inputFile = L"Data\\sample.pptx";
	std::wstring outputFile = L"Output\\ToPdfWithSpecificPageSize.pdf";

	//Create a Presentation object
	intrusive_ptr⁢Presentation> ppt = new Presentation();

	//Load a PowerPoint document from disk
	ppt->LoadFromFile(inputFile.c_str());

	//Set the slide size to A4
	ppt->GetSlideSize()->SetType(SlideSizeType::A4);

	//Set the slide orientation to Landscape
	ppt->GetSlideSize()->SetOrientation(SlideOrienation::Landscape);

	//Save the document to PDF
	ppt->SaveToFile(outputFile.c_str(), FileFormat::PDF);

	ppt->Dispose();
}

#include "Spire.Pdf.o.h";

using namespace std;
using namespace Spire::Pdf;

int main()
{
	//Specify input file and output file paths
	wstring inputFilePath = L"C:\\Users\\Administrator\\Desktop\\sample.pdf";
	wstring outputFilePath = L"C:\\Users\\Administrator\\Desktop\\ImageWatermark.pdf";

	//Create a PdfDocument object
	PdfDocument* doc = new PdfDocument();

	//Load a PDF file
	doc->LoadFromFile(inputFilePath.c_str());

	//Load an image
	boost::intrusive_ptr image = PdfImage::FromFile(L"C:\\Users\\Administrator\\Desktop\\logo.png");

	//Get image height and width
	int imgHeight = image->GetHeight();
	int imgWidth = image->GetWidth();

	//Traverse through the pages in the document
	for (size_t i = 0; i < doc->GetPages()->GetCount(); i++)
	{
		//Get a specific page
		boost::intrusive_ptr page = doc->GetPages()->GetItem(i);

		//Set the page transparency
		page->GetCanvas()->SetTransparency(0.5);

		//Get the page width and height
		float pageWidth = page->GetActualSize()->GetWidth();
		float pageHeight = page->GetActualSize()->GetHeight();

		//Draw image at the center of the page
		RectangleF* rect = new RectangleF((float)(pageWidth - imgWidth) / 2, (float)(pageHeight - imgHeight) / 2, imgWidth, imgHeight);
		page->GetCanvas()->DrawImage(image, rect);
	}

	//Save the document
	doc->SaveToFile(outputFilePath.c_str());
	doc->Close();
	delete doc;
}

#include "Spire.Pdf.o.h";

using namespace std;
using namespace Spire::Pdf;

static void InsertTiledImagetWatermark(PdfPageBase* page, PdfImage* image, int rowNum, int columnNum)
{
	//Get page height and width
	float height = page->GetActualSize()->GetHeight();
	float width = page->GetActualSize()->GetWidth();

	//Get image heigh and width
	float imgHeight = image->GetHeight();
	float imgWidth = image->GetWidth();

	//Create a tiling brush
	PdfTilingBrush* brush = new PdfTilingBrush(new SizeF(width / columnNum, height / rowNum));

	//Set transparency
	brush->GetGraphics()->SetTransparency(0.5f);

	//Translate coordinate system to a certain position
	brush->GetGraphics()->TranslateTransform((brush->GetSize()->GetWidth() - imgWidth) / 2, (brush->GetSize()->GetHeight() - imgHeight) / 2);

	//Draw image on the brush at the specified coordinates
	brush->GetGraphics()->DrawImage(image, 0.0, 0.0);

	//Draw rectangle that covers the whole page with the brush
	page->GetCanvas()->DrawRectangle(brush, 0, 0, width, height);
}

int main()
{
	//Specify input file and output file paths
	wstring inputFilePath = L"C:\\Users\\Administrator\\Desktop\\sample.pdf";
	wstring outputFilePath = L"C:\\Users\\Administrator\\Desktop\\TiledImageWatermark.pdf";

	//Create a PdfDocument object
	PdfDocument* doc = new PdfDocument();

	//Load a PDF file
	doc->LoadFromFile(inputFilePath.c_str());

	//Load an image
	PdfImage* image = PdfImage::FromFile(L"C:\\Users\\Administrator\\Desktop\\small-logo.png");

	//Traverse through the pages in the document
	for (size_t i = 0; i < doc->GetPages()->GetCount(); i++)
	{
		//Get a specific page
		PdfPageBase* page = doc->GetPages()->GetItem(i);

		//Add tiled image watermark to the page
		InsertTiledImagetWatermark(page, image, 4, 4);
	}

	//Save the document
	doc->SaveToFile(outputFilePath.c_str());
	doc->Close();
	delete doc;
}

#include "Spire.Xls.o.h"

using namespace Spire::Xls;

int main()
{
	//Specify input file path and name
	std::wstring data_path = L"Data\\";
	std::wstring inputFile = data_path + L"input.xlsx";

	//Specify output file path and name
	std::wstring outputPath = L"Output\\";
	std::wstring outputFile = outputPath + L"ToHtml.html";

	//Create a Workbook object
	intrusive_ptr<Workbook> workbook = new Workbook();

	//Load an Excel document from disk
	workbook->LoadFromFile(inputFile.c_str());

	//Save the whole Excel workbook to Html
	workbook->SaveToHtml(outputFile.c_str());
	workbook->Dispose();
}

#include "Spire.Xls.o.h"

using namespace Spire::Xls;

int main()
{
	//Specify input file path and name
	std::wstring data_path = L"Data\\";
	std::wstring inputFile = data_path + L"sample.xlsx";

	//Specify output file path and name
	std::wstring outputPath = L"Output\\";
	std::wstring outputFile = outputPath + L"ExcelToHtml.html";

	//Create a Workbook object
	intrusive_ptr<Workbook> workbook = new Workbook();

	//Load an Excel document from disk
	workbook->LoadFromFile(inputFile.c_str());

	//Get the first worksheet
	intrusive_ptr<Worksheet> sheet = dynamic_pointer_cast<Worksheet>(workbook->GetWorksheets()->Get(0));

	//Set embedded image as true
	intrusive_ptr<HTMLOptions> options = new HTMLOptions();
	options->SetImageEmbedded(true);

	//Save the worksheet to HTML
	sheet->SaveToHtml(outputFile.c_str(), options);
	workbook->Dispose();
}

#include "Spire.Xls.o.h" 

using namespace Spire::Xls;

int main()
{
	//Specify input file path and name
	std::wstring data_path = L"Data\\";
	std::wstring inputFile = data_path + L"sample.xlsx";

	//Specify output file path and name
	std::wstring outputPath = L"Output\\";
	std::wstring outputFile = outputPath + L"ToHtmlStream.html";

	//Create a Workbook object
	intrusive_ptr<Workbook> workbook = new Workbook();

	//Load an Excel document from disk
	workbook->LoadFromFile(inputFile.c_str());

	//Get the first worksheet
	intrusive_ptr<Worksheet> sheet = dynamic_pointer_cast<Worksheet>(workbook->GetWorksheets()->Get(0));

	//Set embedded image as true
	intrusive_ptr<HTMLOptions> options = new HTMLOptions();
	options->SetImageEmbedded(true);

	//Create a stream
	intrusive_ptr<Stream> stream = new Stream();

	//Save worksheet to html stream
	sheet->SaveToHtml(stream, options);
	workbook->Dispose();

	stream->Save(outputFile.c_str());
}

"#include ""Spire.Pdf.o.h"";

using namespace std;
using namespace Spire::Pdf;
using namespace Spire::Common;

int main()
{
	//Specify input file and output file paths
	wstring inputFilePath = L""C:\\Users\\Administrator\\Desktop\\sample.pdf"";
	wstring outputFilePath = L""Output\\SingleLineTextWatermark.pdf"";

	//Create a PdfDocument object
	PdfDocument* doc = new PdfDocument();

	//Load a PDF file
	doc->LoadFromFile(inputFilePath.c_str());

	//Create a true type font
	PdfTrueTypeFont* font = new PdfTrueTypeFont(L""Arial"", 50.0f, PdfFontStyle::Bold, true);

	//Create a brush
	PdfBrush* brush = PdfBrushes::GetDarkGray();

	//Specify watermark text
	wstring text = L""CONFIDENTIAL"";

	//Measure the text size
	SizeF textSize = font->MeasureString(text.c_str());

	//Calculate two offsets, which are used to calculate the translation amount of coordinate system
	float offset1 = (float)(textSize.GetWidth() * sqrt(2) / 4);
	float offset2 = (float)(textSize.GetHeight() * sqrt(2) / 4);

	//Traverse through the pages in the document
	for (size_t i = 0; i < doc->GetPages()->GetCount(); i++)
	{
		//Get a specific page
		PdfPageBase* page = doc->GetPages()->GetItem(i);

		//Set the page transparency
		page->GetCanvas()->SetTransparency(0.8);

		//Translate the coordinate system to a specified coordinate
		page->GetCanvas()->TranslateTransform(page->GetCanvas()->GetSize()->GetWidth() / 2 - offset1 - offset2, page->GetCanvas()->GetSize()->GetHeight() / 2 + offset1 - offset2);

		//Rotate the coordinate system 45 degrees counterclockwise
		page->GetCanvas()->RotateTransform(-45);

		//Draw watermark text on the page
		page->GetCanvas()->DrawString(text.c_str(), font, brush, 0, 0, new PdfStringFormat(PdfTextAlignment::Left));
	}

	//Save the document
	doc->SaveToFile(outputFilePath.c_str());
	doc->Close();
	delete doc;
}"

#include "Spire.Pdf.o.h";

using namespace std;
using namespace Spire::Pdf;

static void InsertTiledTextWatermark(PdfPageBase* page, wstring watermarkText, PdfTrueTypeFont* font, int rowNum, int columnNum)
{
	//Measure text size
	SizeF textSize = font->MeasureString(watermarkText.c_str());

	//Calculate two offsets, which are used to calculate the translation amount of coordinate system
	float offset1 = (float)(textSize.GetWidth() * sqrt(2) / 4);
	float offset2 = (float)(textSize.GetHeight() * sqrt(2) / 4);

	//Get page height and width
	float height = page->GetActualSize()->GetHeight();
	float width = page->GetActualSize()->GetWidth();

	//Create a tiling brush
	PdfTilingBrush* brush = new PdfTilingBrush(new SizeF(width / columnNum, height / rowNum));
	brush->GetGraphics()->SetTransparency(0.5f);
	brush->GetGraphics()->TranslateTransform(brush->GetSize()->GetWidth() / 2 - offset1 - offset2, brush->GetSize()->GetHeight() / 2 + offset1 - offset2);
	brush->GetGraphics()->RotateTransform(-45);

	//Draw watermark text on the brush
	brush->GetGraphics()->DrawString(watermarkText.c_str(), font, PdfBrushes::GetRed(), 0, 0, new PdfStringFormat(PdfTextAlignment::Left));

	//Draw a rectangle (that covers the whole page) using the tiling brush
	page->GetCanvas()->DrawRectangle(brush, new RectangleF(new PointF(0, 0), page->GetActualSize()));
}

int main()
{
	//Specify input file and output file paths
	wstring inputFilePath = L"C:\\Users\\Administrator\\Desktop\\sample.pdf";
	wstring outputFilePath = L"Output\\MultiLineTextWatermark.pdf";

	//Create a PdfDocument object
	PdfDocument* doc = new PdfDocument();

	//Load a PDF file
	doc->LoadFromFile(inputFilePath.c_str());

	//Specify watermark text
	wstring text = L"CONFIDENTIAL";

	//Creat a true type font
	PdfTrueTypeFont* font = new PdfTrueTypeFont(L"Arial", 20.0f, PdfFontStyle::Bold, true);

	//Traverse through the pages in the document
	for (size_t i = 0; i < doc->GetPages()->GetCount(); i++)
	{
		//Call the custom method to insert multi-line text watermark
                boost::intrusive_ptr page = doc->GetPages()->GetItem(i);
                InsertTiledTextWatermark(page.get(), text.c_str(), font, 3, 3);"
	}

	//Save the document
	doc->SaveToFile(outputFilePath.c_str());
	doc->Close();
	delete doc;
}

#include "Spire.Pdf.o.h";

using namespace Spire::Pdf;
using namespace std;

int main() {

    //Specify input file path
    wstring inputPdfPath = L"C:\\Users\\Administrator\\Desktop\\Sample.pdf";
    wstring inputFilePath = L"C:\\Users\\Administrator\\Desktop\\Data.xlsx";

    //Specify output file path
    wstring outputFilePath = L"Output\\Attachment.pdf";

    //Create a PdfDocument object
    PdfDocument* doc = new PdfDocument();

    //Load a sample PDF file
    doc->LoadFromFile(inputPdfPath.c_str());

    //Create a PdfAttachment object based on an external file
    PdfAttachment* attachment = new PdfAttachment(inputFilePath.c_str());

    //Add the attachment to PDF
    doc->GetAttachments()->Add(attachment);

    //Save to file
doc->SaveToFile(outputFilePath.c_str());
delete doc;
}

#include "Spire.Pdf.o.h";

using namespace Spire::Pdf;
using namespace std;

int main() {

    //Specify input file path
    wstring inputPdfPath = L"C:\\Users\\Administrator\\Desktop\\Attachment.pdf";
    wstring inputFilePath = L"C:\\Users\\Administrator\\Desktop\\Report.docx";

    //Specify output file path
    wstring outputFilePath = L"Output\\AnnotationAttachment.pdf";

    //Create a PdfDocument object
    PdfDocument* doc = new PdfDocument();

    //Load a sample PDF file
    doc->LoadFromFile(inputPdfPath.c_str());

    //Get a specific page
    boost::intrusive_ptr<PdfPageBase> page = doc->GetPages()->GetItem(0);

    //Draw a label on PDF
    wstring label = L"Here is the report:";
    PdfTrueTypeFont* font = new PdfTrueTypeFont(L"Arial", 13.0f, PdfFontStyle::Bold, true);
    float x = 35;
    float y = doc->GetPages()->GetItem(0)->GetActualSize()->GetHeight() - 220;
    page->GetCanvas()->DrawString(label.c_str(), font, PdfBrushes::GetRed(), x, y);

    //Convert the file to be attached to stream
    ifstream is1(inputFilePath.c_str(), ifstream::in | ios::binary);
    is1.seekg(0, is1.end);
    int length1 = is1.tellg();
    is1.seekg(0, is1.beg);
    char* buffer1 = new  char[length1];
    is1.read(buffer1, length1);
    Stream* stream = new Spire::Pdf::Stream((unsigned char*)buffer1, length1);
    boost::intrusive_ptr <SizeF> size = font->MeasureString(label.c_str());
    RectangleF* bounds = new RectangleF((float)(x + size->GetWidth() + 5), (float)y, 10, 15);

    //Create a PdfAttachmentAnnotation object based on the file
    PdfAttachmentAnnotation* annotation = new PdfAttachmentAnnotation(bounds, L"Report.docx", stream);
    annotation->SetColor(new PdfRGBColor(Spire::Pdf::Color::GetDarkOrange()));
    annotation->SetFlags(PdfAnnotationFlags::ReadOnly);
    annotation->SetIcon(PdfAttachmentIcon::Graph);
    annotation->SetText(L"Click here to open the file");

    //Add the attachment annotation to PDF
    page->GetAnnotationsWidget()->Add(annotation);

    //Save to file
    doc->SaveToFile(outputFilePath.c_str());
    delete doc;
}

#include "Spire.Pdf.o.h";

using namespace Spire::Pdf;
using namespace std;

int main() {

	//Specify input file path
	wstring inputPdfPath = L"C:\\Users\\Administrator\\Desktop\\Sample.pdf";

	//Specify output file path
	wstring outputFilePath = L"Output\\DeleteAttachments.pdf";

	//Create a PdfDocument object
	PdfDocument* doc = new PdfDocument();

	//Load a PDF file
	doc->LoadFromFile(inputPdfPath.c_str());

	//Get all attachments
	boost::intrusive_ptr<PdfAttachmentCollection> attachments = doc->GetAttachments();

	//Delete all attachments
	attachments->Clear();

	//Delete a specific attachment
	//attachments->RemoveAt(0);

	//Save the document
	doc->SaveToFile(outputFilePath.c_str());
	doc->Close();
	delete doc;
}

#include "Spire.Pdf.o.h";

using namespace Spire::Pdf;
using namespace std;

int main() {

    //Specify input file path
    wstring inputPdfPath = L"C:\\Users\\Administrator\\Desktop\\AnnotationAttachment.pdf";

    //Specify output file path
    wstring outputFilePath = L"Output\\DeleteAnnotationAttachments.pdf";

    //Create a PdfDocument object
    PdfDocument* doc = new PdfDocument();

    //Load a PDF file
    doc->LoadFromFile(inputPdfPath.c_str());

    //Loop through the pages
    for (int i = 0; i < doc->GetPages()->GetCount(); i++)
    {
        //Get the annotation collection
        boost::intrusive_ptr <PdfAnnotationCollection> annotationCollection = doc->GetPages()->GetItem(i)->GetAnnotationsWidget();
           

        //Loop through the annotations
        for (int j = 0; j < annotationCollection->GetCount(); j++)
        {
            //Get a specific annotation
            boost::intrusive_ptr <PdfAnnotation> annotation = annotationCollection->GetItem(j);

            //Determine if the annotation is an instance of PdfAttachmentAnnotationWidget
            wstring content;
            wchar_t nm_w[100];
            swprintf(nm_w, 100, L"%hs", typeid(PdfAttachmentAnnotationWidget).name());
            LPCWSTR_S newName = nm_w;
            if (wcscmp(newName, annotation->GetInstanceTypeName()) == 0) {

                //Remove the annotation attachment 
                annotationCollection->RemoveAt(j);
            }
        }
    }

    //Save the document
    doc->SaveToFile(outputFilePath.c_str());
    doc->Close();
    delete doc;
}

#include "Spire.Doc.o.h"

using namespace Spire::Doc;

int main()
{
	//Initialize an instance of the Document class
	intrusive_ptr<Document> document = new Document();
	//Load a Word document
	document->LoadFromFile(L"Sample.docx");

	//Get the document's background
	intrusive_ptr <Background> background = document->GetBackground();
	//Set the background type as color
	background->SetType(BackgroundType::Color);
	//Set the background color
	background->SetColor(Color::GetAliceBlue());

	//Save the result document
	document->SaveToFile(L"AddBackgroundColor.docx", FileFormat::Docx2013);
	document->Close();
}

#include "Spire.Doc.o.h"

using namespace Spire::Doc;

int main()
{
	//Initialize an instance of the Document class
	intrusive_ptr <Document> document = new Document();
	//Load a Word document
	document->LoadFromFile(L"Sample.docx");

	//Get the document's background
	intrusive_ptr <Background> background = document->GetBackground();
	//Set the background type as gradient
	background->SetType(BackgroundType::Gradient);

	//Specify two gradient colors 
	background->GetGradient()->SetColor1(Color::GetWhite());
	background->GetGradient()->SetColor2(Color::GetLightBlue());

	//Set gradient shading variant and style
	background->GetGradient()->SetShadingVariant(GradientShadingVariant::ShadingDown);
	background->GetGradient()->SetShadingStyle(GradientShadingStyle::Horizontal);

	//Save the result document
	document->SaveToFile(L"AddGradientBackground.docx", FileFormat::Docx2013);
	document->Close();
}

#include "Spire.Doc.o.h"

using namespace Spire::Doc;

int main()
{
	//Initialize an instance of the Document class
	intrusive_ptr <Document> document = new Document();
	//Load a Word document
	document->LoadFromFile(L"Sample.docx");

	//Get the document's background
	intrusive_ptr <Background> background = document->GetBackground();
	//Set the background type as picture
	background->SetType(BackgroundType::Picture);

	//Set the background picture
	background->SetPicture(L"background.png");

	//Save the result document
	document->SaveToFile(L"AddBackgroundPicture.docx", FileFormat::Docx2013);
	document->Close();
}

#include "Spire.Doc.o.h"

using namespace Spire::Doc;

int main() {
 //Specify input file path and name
 std::wstring input_path = L"Data\\";
 std::wstring inputFile = input_path + L"Input.docx";

 //Specify output file path and name
 std::wstring output_path = L"Output\\";
 std::wstring outputFile = output_path + L"InsertPageBreak.docx";

 //Create a Document instance
 intrusive_ptr<Document> document = new Document();

 //Load a Word document from disk
 document->LoadFromFile(inputFile.c_str());

 //Get the first section
 intrusive_ptr<Section> section = document->GetSections()->GetItemInSectionCollection(0);

 //Get the 2nd paragraph in the section
 intrusive_ptr <Paragraph> paragraph = section->GetParagraphs()->GetItemInParagraphCollection(1);

 //Insert a page break after the paragraph
 paragraph->AppendBreak(BreakType::PageBreak);

 //Save the result document
 document->SaveToFile(outputFile.c_str(), FileFormat::Docx2013);
 document->Close();
}

#include "Spire.Doc.o.h"

using namespace Spire::Doc;

int main() {
 //Specify input file path and name
 std::wstring input_path = L"Data\\";
 std::wstring inputFile = input_path + L"Input.docx";

 //Specify output file path and name
 std::wstring output_path = L"Output\\";
 std::wstring outputFile = output_path + L"InsertPageBreakAfterText.docx";

 //Create a Document instance
 intrusive_ptr<Document> document = new Document();

 //Load a Word document from disk
 document->LoadFromFile(inputFile.c_str());

 //Find a specified text
 intrusive_ptr<TextSelection> selection = document->FindString(L"infrastructure", true, true);

 //Get the text range of the specified text
 intrusive_ptr<TextRange> range = selection->GetAsOneRange();

 //Get the paragraph where the text range is located
 intrusive_ptr<Paragraph> paragraph = range->GetOwnerParagraph();

 //Get the position index of the text range in the paragraph
 int index = paragraph->GetChildObjects()->IndexOf(range);

 //Create a page break
 intrusive_ptr<Break> pageBreak = new Break(document, BreakType::PageBreak);

 //Insert a page break after the specified text
 paragraph->GetChildObjects()->Insert(index + 1, pageBreak);

 //Save to result document
 document->SaveToFile(outputFile.c_str(), FileFormat::Docx2013);
 document->Close();
}

#include "Spire.Doc.o.h"

using namespace Spire::Doc;

int main() {
 //Specify input file path and name
 std::wstring input_path = L"Data\\";
 std::wstring inputFile = input_path + L"InsertPageBreak.docx";

 //Specify output file path and name
 std::wstring output_path = L"Output\\";
 std::wstring outputFile = output_path + L"RemovePageBreaks.docx";

 //Create a Document instance
 intrusive_ptr<Document> document = new Document();

 //Load a Word document from disk
 document->LoadFromFile(inputFile.c_str());

 //Traverse through each paragraph in the first section of the document
 for (int j = 0; j < document->GetSections()->GetItemInSectionCollection(0)->GetParagraphs()->GetCount(); j++)
 {
  intrusive_ptr<Paragraph> p = document->GetSections()->GetItemInSectionCollection(0)->GetParagraphs()->GetItemInParagraphCollection(j);

  //Traverse through each child object of a paragraph
  for (int i = 0; i < p->GetChildObjects()->GetCount(); i++)
  {
   intrusive_ptr <DocumentObject> obj = p->GetChildObjects()->GetItem(i);

   //Determine whether the child object type is a page break
   if (Object::CheckType<Break>(obj) && (Object::Dynamic_cast<Break>(obj))->GetBreakType() == BreakType::PageBreak)
   {
    //Remove the page break from the paragraph
    p->GetChildObjects()->Remove(obj);
   }
  }
 }

 //Save the result document
 document->SaveToFile(outputFile.c_str(), FileFormat::Docx2013);
 document->Close();
}

#include "Spire.Doc.o.h";

using namespace Spire::Doc;
using namespace std;

int main() {

 //Specify input file path
 wstring inputFilePath = L"C:\\Users\\Administrator\\Desktop\\sample.docx";

 //Specify output file path and name
 wstring outputPath = L"Output\\";
 wstring outputFile = outputPath + L"ToPDF.pdf";

 //Create a Document object
 intrusive_ptr<Document> document = new Document();

 //Load a Word file
 document->LoadFromFile(inputFilePath.c_str());

 //Save the document to PDF
 document->SaveToFile(outputFile.c_str(), FileFormat::PDF);
 document->Close();
}

#include "Spire.Doc.o.h";

using namespace Spire::Doc;
using namespace std;

int main() {

 //Specify input file path
 wstring inputFilePath = L"C:\\Users\\Administrator\\Desktop\\sample.docx";

 //Specify output file path and name
 wstring outputPath = L"Output\\";
 wstring outputFile = outputPath + L"ToPDF.pdf";

 //Create a Document object
 intrusive_ptr<Document> document = new Document();

 //Load a Word file
 document->LoadFromFile(inputFilePath.c_str());

 //Create a ToPdfParameterList object
 intrusive_ptr<ToPdfParameterList> parameters = new ToPdfParameterList();

 //Create bookmarks from Word headings
 parameters->SetCreateWordBookmarksUsingHeadings(true);

 //Create bookmarks in PDF from existing bookmarks in Word
 //parameters->SetCreateWordBookmarks(true);

 //Save the document to PDF
 document->SaveToFile(outputFile.c_str(), parameters);
 document->Close();
}

#include "Spire.Doc.o.h";

using namespace Spire::Doc;
using namespace std;

int main() {

 //Specify input file path
 wstring inputFilePath = L"C:\\Users\\Administrator\\Desktop\\sample.docx";

 //Specify output file path and name
 wstring outputPath = L"Output\\";
 wstring outputFile = outputPath + L"ToPDF.pdf";

 //Create a Document object
 intrusive_ptr<Document> document = new Document();

 //Load a Word file
 document->LoadFromFile(inputFilePath.c_str());

 //Create a ToPdfParameterList object
 intrusive_ptr<ToPdfParameterList> parameters = new ToPdfParameterList();

 //Embed fonts used in Word in generated PDF
 parameters->SetIsEmbeddedAllFonts(true);

 //Save the document to PDF
 document->SaveToFile(outputFile.c_str(), parameters);
 document->Close();
}

#include "Spire.Doc.o.h";

using namespace Spire::Doc;
using namespace std;

int main() {

 //Specify input file path
 wstring inputFilePath = L"C:\\Users\\Administrator\\Desktop\\sample.docx";

 //Specify output file path and name
 wstring outputPath = L"Output\\";
 wstring outputFile = outputPath + L"ToPDF.pdf";

 //Create a Document object
 intrusive_ptr<Document> document = new Document();

 //Load a Word file
 document->LoadFromFile(inputFilePath.c_str());

 //Compress image to 40% of the original quality
 document->SetJPEGQuality(40);

 //Preserve original image quality
 //document->SetJPEGQuality(100);

 //Save the document to PDF
 document->SaveToFile(outputFile.c_str(), FileFormat::PDF);
 document->Close();
}

#include "Spire.Doc.o.h"

using namespace Spire::Doc;

int main() {
 //Specify input file path and name
 std::wstring data_path = L"Data\\";
 std::wstring inputFile = data_path + L"input.docx";

 //Specify output file path and name
 std::wstring outputPath = L"Output\\";
 std::wstring outputFile = outputPath + L"GetText.txt";

 //Create a Document instance
 intrusive_ptr<Document> document = new Document();

 //Load a sample Word document from disk
 document->LoadFromFile(inputFile.c_str());

 //Get text from the document
 std::wstring text = document->GetText();

 //Create a new TXT File to save the extracted text
 std::wofstream write(outputFile);
 write << text;
 write.close();
 document->Close();
}

#include "Spire.Doc.o.h"
#include <deque>

using namespace Spire::Doc;

int main() {
 //Specify input file path and name
 std::wstring data_path = L"Data\\";
 std::wstring inputFile = data_path + L"input.docx";

 //Specify output file path and name
 std::wstring outputPath = L"Output\\";
 std::wstring outputFile = outputPath + L"ExtractImage/";

 //Load a sample Word document
 intrusive_ptr<Document> document = new Document();
 document->LoadFromFile(inputFile.c_str());

 //Append the document to the end of the deque
 std::deque<intrusive_ptr<ICompositeObject>> nodes;
 nodes.push_back(document);

 //Create a vector of images list
 std::vector<std::vector<byte>> images;

 //Traverse through all child objects of the document
 while (nodes.size() > 0)
 {
  intrusive_ptr<ICompositeObject> node = nodes.front();
  nodes.pop_front();
  for (int i = 0; i < node->GetChildObjects()->GetCount(); i++)
  {
   intrusive_ptr<IDocumentObject> child = node->GetChildObjects()->GetItem(i);
   if (child->GetDocumentObjectType() == DocumentObjectType::Picture)
   {
    intrusive_ptr<DocPicture> picture = Object::Dynamic_cast<DocPicture>(child);
    std::vector<byte> imageByte = picture->GetImageBytes();
    images.push_back(imageByte);
   }
   else if (Object::CheckType<ICompositeObject>(child))
   {
    nodes.push_back(boost::dynamic_pointer_cast<ICompositeObject>(child));
   }
  }
 }
 //Save the images out of the document
 for (size_t i = 0; i < images.size(); i++)
 {
  std::wstring fileName = L"Image-" + std::to_wstring(i) + L".png";
  std::ofstream outFile(fileName, std::ios::binary);
  if (outFile.is_open())
  {
   outFile.write(reinterpret_cast<const char*>(images[i].data()), images[i].size());
   outFile.close();
  }
 }
 document->Close();
}