count good changes detection error

staropramen

ASCOfficeDocFile/DocDocxConverter/NumberingMapping.cpp

@@ -672,7 +672,7 @@ namespace DocFileFormat
 	{
 		if (grpprlChpx)
 		{
-			unsigned int cp = 0;
+			unsigned int index = 0;
 			bool isPictureBullet = false;
 
 			for (std::list<SinglePropertyModifier>::const_iterator iter = grpprlChpx->grpprl->begin(); iter != grpprlChpx->grpprl->end(); ++iter)
@@ -681,7 +681,7 @@ namespace DocFileFormat
 				{
 					case sprmCPbiIBullet:
 					{
-						cp = FormatUtils::BytesToUInt32(iter->Arguments, 0, iter->argumentsSize);
+						index = FormatUtils::BytesToUInt32(iter->Arguments, 0, iter->argumentsSize);
 					}break;
 
 					case sprmCPbiGrf:
@@ -694,7 +694,7 @@ namespace DocFileFormat
 			if (isPictureBullet)
 			{
 				m_pXmlWriter->WriteNodeBegin(_T("w:lvlPicBulletId"), TRUE);
-				m_pXmlWriter->WriteAttribute(_T("w:val"), FormatUtils::IntToWideString(cp));
+				m_pXmlWriter->WriteAttribute(_T("w:val"), FormatUtils::IntToWideString(index));
 				m_pXmlWriter->WriteNodeEnd(_T(""), TRUE);  
 			}
 		}

ASCOfficeDocFile/DocDocxConverter/VMLPictureMapping.cpp

@@ -419,9 +419,7 @@ namespace DocFileFormat
 			m_pXmlWriter->WriteString(m_imageData->GetXMLString());
 		}
 
-		if (!m_isInlinePicture)
-		{
-			//borders
+		{//borders			
 			writePictureBorder( L"bordertop",		pict->brcTop );
 			writePictureBorder( L"borderleft",		pict->brcLeft );
 			writePictureBorder( L"borderbottom",	pict->brcBottom );

ASCOfficeDocFile/DocDocxConverter/WordDocument.cpp

@@ -371,9 +371,9 @@ namespace DocFileFormat
 
                 if ( ( bookmarkName != NULL ) && ( *bookmarkName == L"_PictureBullets" ) )
 				{
-					for (unsigned int j = BookmarkStartEndCPs[i].first, k = 0; j < this->Text->size(); ++j, ++k )
+					for (unsigned int j = BookmarkStartEndCPs[i].first, k = 0; j < Text->size(); ++j, ++k )
 					{
-						if ( this->Text->at( j ) == 1 )
+						if ( Text->at( j ) == 1 )
 						{
 							PictureBulletsCPsMap.insert (std::make_pair( k, j ));
 						}
@@ -424,7 +424,7 @@ namespace DocFileFormat
 				int cp = SectionPlex->CharacterPositions[i + 1];
 
 				//Get the SEPX
-				VirtualStreamReader wordReader( this->WordDocumentStream, sed->fcSepx, bOlderVersion);
+				VirtualStreamReader wordReader( WordDocumentStream, sed->fcSepx, bOlderVersion);
 
 				//!!!TODO: cbSepx is the size in bytes of the rest properties part!!!
 				short cbSepx	=	wordReader.ReadInt16();
@@ -672,7 +672,7 @@ namespace DocFileFormat
 
 			//last fkp? 
 			//use full table
-			if ( i++ == ( this->AllChpxFkps->size() - 1 ) )
+			if ( i++ == ( AllChpxFkps->size() - 1 ) )
 			{
 				max = fkp->rgfcSize;
 			}

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/DXF.cpp

@@ -66,7 +66,7 @@ int DXF::serialize(std::wostream & stream)
     {
 		CP_XML_NODE(L"dxf")
 		{
-			xfprops.serialize(CP_XML_STREAM());
+			xfprops.serialize(CP_XML_STREAM(), true);
 		}
 	}
 	return 0;

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/TxO.cpp

@@ -219,7 +219,7 @@ int TxO::serialize_rPr	(std::wostream & _stream, int iFmt, std::wstring namespac
 	if (!pGlobalWorkbookInfoPtr->m_arFonts) return 0;
 
 	int sz = pGlobalWorkbookInfoPtr->m_arFonts->size();
-	if (iFmt - 1 > sz || iFmt < 1) return 0;
+	if (iFmt - 1 >= sz || iFmt < 1) return 0;
 
 	Font * font = dynamic_cast<Font*>(pGlobalWorkbookInfoPtr->m_arFonts->at(iFmt-1).get());
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_structures/DXFN.cpp

@@ -93,7 +93,6 @@ void DXFN::load(CFRecord& record)
 
 	if(ibitAtrNum)
 	{
-		dxfnum.setIsUserDefined(fIfmtUser);
 		record >> dxfnum;
 	}
 	if(ibitAtrFnt)

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_structures/DXFNum.cpp

@@ -39,18 +39,6 @@ namespace XLS
 {
 
 
-void DXFNum::setIsUserDefined(const bool is_user_defined)
-{
-	is_user_defined_ = is_user_defined;
-}
-
-
-const bool DXFNum::getIsUserDefined() const
-{
-    return true == is_user_defined_;
-}
-
-
 BiffStructurePtr DXFNum::clone()
 {
 	return BiffStructurePtr(new DXFNum(*this));
@@ -58,11 +46,13 @@ BiffStructurePtr DXFNum::clone()
 
 void DXFNum::load(CFRecord& record)
 {
-	if ((is_user_defined_) && (*is_user_defined_))
+	if (!parent) return;
+
+	if (parent->fIfmtUser)
 	{
 		record >> user_defined;
 	}
-	else
+	if (!parent->ifmtNinch)//else
 	{
 		record >> fmt_id;
 	}
@@ -71,7 +61,7 @@ void DXFNum::load(CFRecord& record)
 
 int DXFNum::serialize(std::wostream & stream)
 {
-	if (parent->ifmtNinch && parent->fIfmtUser) return 0;
+	if (!parent) return 0;
 
 	CP_XML_WRITER(stream)    
     {
@@ -79,7 +69,8 @@ int DXFNum::serialize(std::wostream & stream)
 		{	
 			if (!parent->ifmtNinch)
 				CP_XML_ATTR(L"numFmtId", fmt_id.ifmt);
- 			if (!parent->fIfmtUser)
+ 			
+			if (parent->fIfmtUser)
  				CP_XML_ATTR(L"formatCode", /*xml::utils::replace_text_to_xml*/(user_defined.fmt.value()));
 		}
 	}

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_structures/DXFNum.h

@@ -50,12 +50,8 @@ public:
 	
 	virtual void load(CFRecord& record);
 
-
 	int serialize(std::wostream & stream);
 
-	void		setIsUserDefined(const bool is_user_defined); 
-	const bool	getIsUserDefined() const; 
-
 	_CP_OPT(bool)	is_user_defined_;
 	
 	DXFNumIFmt		fmt_id;

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_structures/XFProp.cpp

@@ -169,6 +169,23 @@ static void serialize_val_prop(std::wostream & stream, const std::wstring & name
 		}
 	}
 }
+static void serialize_val_attr(CP_ATTR_NODE, const std::wstring & name, BiffStructurePtr & val)
+{
+	if (val == NULL)	return;
+	if (name.empty())	return;
+
+	BIFF_DWORD* dword = dynamic_cast<BIFF_DWORD*>(val.get());
+	if (dword)	CP_XML_ATTR(name.c_str(), *dword->value());
+
+	BIFF_WORD*	word = dynamic_cast<BIFF_WORD*>(val.get());
+	if (word)	CP_XML_ATTR(name.c_str(), *word->value());
+
+	BIFF_BYTE*	byte_ = dynamic_cast<BIFF_BYTE*>(val.get());
+	if (byte_)	CP_XML_ATTR(name.c_str(), *byte_->value());
+
+	LPWideString* str_ = dynamic_cast<LPWideString*>(val.get());
+	if (str_)	CP_XML_ATTR(name.c_str(), xml::utils::replace_text_to_xml(str_->value()));
+}
 static void serialize_border_prop(std::wostream & stream, const std::wstring & name, BiffStructurePtr & val)
 {
 	if (name.empty())	return;
@@ -206,39 +223,49 @@ static void serialize_border_prop(std::wostream & stream, const std::wstring & n
 
 void XFProp::serialize_attr(CP_ATTR_NODE)
 {
-	if (xfPropType == 0)
+	switch(xfPropType)
 	{
-		BIFF_BYTE* byte_ = dynamic_cast<BIFF_BYTE*>(xfPropDataBlob.get());
-		if (!byte_)	return;
+		case 0x0000:
+		{
+			BIFF_BYTE* byte_ = dynamic_cast<BIFF_BYTE*>(xfPropDataBlob.get());
+			if (!byte_)	return;
 
-		switch(*byte_)
-		{		
-			case 2:		CP_XML_ATTR(L"patternType", L"pct50");					break; //50% gray
-			case 3:		CP_XML_ATTR(L"patternType", L"pct75");					break; //75% gray
-			case 4:		CP_XML_ATTR(L"patternType", L"pct25");					break; //25% gray
-			case 5:		CP_XML_ATTR(L"patternType", L"horzStripe");				break; //Horizontal stripe
-			case 6:		CP_XML_ATTR(L"patternType", L"vertStripe");				break; //Vertical stripe
-			case 7:		CP_XML_ATTR(L"patternType", L"reverseDiagStripe");		break; //Reverse diagonal stripe
-			case 8:		CP_XML_ATTR(L"patternType", L"diagStripe");				break; //Diagonal stripe
-			case 9:		CP_XML_ATTR(L"patternType", L"diagCross");				break; //Diagonal crosshatch
-			case 10:	CP_XML_ATTR(L"patternType", L"trellis");				break; //Thick Diagonal crosshatch
-			case 11:	CP_XML_ATTR(L"patternType", L"thinHorzStripe");			break; //Thin horizontal stripe
-			case 12:	CP_XML_ATTR(L"patternType", L"thinVertStripe");			break; //Thin vertical stripe
-			case 13:	CP_XML_ATTR(L"patternType", L"thinReverseDiagStripe");	break; //Thin reverse diagonal stripe
-			case 14:	CP_XML_ATTR(L"patternType", L"thinDiagStripe");			break; //Thin diagonal stripe
-			case 15:	CP_XML_ATTR(L"patternType", L"thinHorzCross");			break; //Thin horizontal crosshatch
-			case 16:	CP_XML_ATTR(L"patternType", L"thinDiagCross");			break; //Thin diagonal crosshatch
-			case 17:	CP_XML_ATTR(L"patternType", L"gray125");				break; //12.5% gray
-			case 18:	CP_XML_ATTR(L"patternType", L"gray0625");				break; //6.25% gray
-			default:
-						CP_XML_ATTR(L"patternType", L"solid");		
-		}
+			switch(*byte_)
+			{		
+				case 2:		CP_XML_ATTR(L"patternType", L"pct50");					break; //50% gray
+				case 3:		CP_XML_ATTR(L"patternType", L"pct75");					break; //75% gray
+				case 4:		CP_XML_ATTR(L"patternType", L"pct25");					break; //25% gray
+				case 5:		CP_XML_ATTR(L"patternType", L"horzStripe");				break; //Horizontal stripe
+				case 6:		CP_XML_ATTR(L"patternType", L"vertStripe");				break; //Vertical stripe
+				case 7:		CP_XML_ATTR(L"patternType", L"reverseDiagStripe");		break; //Reverse diagonal stripe
+				case 8:		CP_XML_ATTR(L"patternType", L"diagStripe");				break; //Diagonal stripe
+				case 9:		CP_XML_ATTR(L"patternType", L"diagCross");				break; //Diagonal crosshatch
+				case 10:	CP_XML_ATTR(L"patternType", L"trellis");				break; //Thick Diagonal crosshatch
+				case 11:	CP_XML_ATTR(L"patternType", L"thinHorzStripe");			break; //Thin horizontal stripe
+				case 12:	CP_XML_ATTR(L"patternType", L"thinVertStripe");			break; //Thin vertical stripe
+				case 13:	CP_XML_ATTR(L"patternType", L"thinReverseDiagStripe");	break; //Thin reverse diagonal stripe
+				case 14:	CP_XML_ATTR(L"patternType", L"thinDiagStripe");			break; //Thin diagonal stripe
+				case 15:	CP_XML_ATTR(L"patternType", L"thinHorzCross");			break; //Thin horizontal crosshatch
+				case 16:	CP_XML_ATTR(L"patternType", L"thinDiagCross");			break; //Thin diagonal crosshatch
+				case 17:	CP_XML_ATTR(L"patternType", L"gray125");				break; //12.5% gray
+				case 18:	CP_XML_ATTR(L"patternType", L"gray0625");				break; //6.25% gray
+							CP_XML_ATTR(L"patternType", L"solid");		
+			}
+		}break;
+		case 0x0003:
+		{
+			XFPropGradient * grad_ = dynamic_cast<XFPropGradient*>(xfPropDataBlob.get());
+			if (grad_) grad_->serialize_attr(CP_GET_XML_NODE());
+ 		}break;
+		case 0x0026:
+		{
+			serialize_val_attr(CP_GET_XML_NODE(), L"formatCode",	xfPropDataBlob);		
+		}break;
+		case 0x0029:
+		{
+			serialize_val_attr(CP_GET_XML_NODE(), L"numFmtId",	xfPropDataBlob);	
+		}break;	
 	}
-	if (xfPropType == 3)
-	{
-		XFPropGradient * grad_ = dynamic_cast<XFPropGradient*>(xfPropDataBlob.get());
-		if (grad_) grad_->serialize_attr(CP_GET_XML_NODE());
- 	}
 }
 int XFProp::serialize(std::wostream & stream)
 {

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_structures/XFProp.h

@@ -52,9 +52,8 @@ public:
 
 	virtual void load(CFRecord& record);
 
-
-	int		serialize(std::wostream & stream);
-	void	serialize_attr(CP_ATTR_NODE);
+	int		serialize		(std::wostream & stream);
+	void	serialize_attr	(CP_ATTR_NODE);
 
 	unsigned short		xfPropType;
 	unsigned short		cb;

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_structures/XFProps.cpp

@@ -110,7 +110,7 @@ void XFProps::load(CFRecord& record)
 		}
 	}
 }
-int XFProps::serialize(std::wostream & stream)
+int XFProps::serialize(std::wostream & stream, bool dxf)
 {
 	CP_XML_WRITER(stream)    
     {
@@ -130,7 +130,14 @@ int XFProps::serialize(std::wostream & stream)
 			{	
 				for (int i = 0; i < arXFPropNumFmt.size(); i++)
 				{
-					arXFPropNumFmt[i].serialize(CP_XML_STREAM());
+					if (dxf)
+					{
+						arXFPropNumFmt[i].serialize_attr(CP_GET_XML_NODE());
+					}
+					else
+					{
+						arXFPropNumFmt[i].serialize(CP_XML_STREAM());
+					}
 				}
 			}
 		}

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_structures/XFProps.h

@@ -52,7 +52,8 @@ public:
 
 	unsigned short		cprops;
 
-	int serialize(std::wostream & stream);
+	int serialize(std::wostream & stream){ return serialize(stream, false) ; }
+	int serialize(std::wostream & stream, bool dxf);
 	
 	std::vector<XFProp> arXFPropFont;
 	std::vector<XFProp> arXFPropNumFmt;

ASCOfficeXlsFile2/source/XlsXlsxConverter/XlsConverter.cpp

@@ -435,12 +435,16 @@ void XlsConverter::convert(XLS::WorksheetSubstream* sheet)
 
 	convert((XLS::OBJECTS*)sheet->m_OBJECTS.get(), sheet);
 
-	if (sheet->m_arNote.size() > 0 && xls_global_info->Version < 0x0600)
+	if (!sheet->m_arNote.empty() && xls_global_info->Version < 0x0600)
 	{
+		xlsx_context->get_drawing_context().start_drawing(0);
 		for (int i = 0 ; i < sheet->m_arNote.size(); i++)
 		{
-			convert(dynamic_cast<XLS::Note*>(sheet->m_arNote[i].get()));
+			xlsx_context->get_drawing_context().start_drawing(0x0019);
+				convert(dynamic_cast<XLS::Note*>(sheet->m_arNote[i].get()));
+			xlsx_context->get_drawing_context().end_drawing();
 		}
+		xlsx_context->get_drawing_context().end_group();
 	}
 
 	if (sheet->m_PAGESETUP)
@@ -1704,11 +1708,6 @@ void XlsConverter::convert(XLS::Note* note)
 
 	note->note_sh.calculate();
 
-	if (xls_global_info->Version < 0x0600)
-	{
-		xlsx_context->get_comments_context().start_comment();
-	}
-
 	xlsx_context->get_comments_context().set_ref	(note->note_sh.ref_, note->note_sh.col, note->note_sh.row);
 	xlsx_context->get_comments_context().set_author	(note->note_sh.stAuthor);
 	xlsx_context->get_comments_context().set_visibly(note->note_sh.fShow);
@@ -1720,9 +1719,8 @@ void XlsConverter::convert(XLS::Note* note)
 	if (xls_global_info->Version < 0x0600)
 	{
 		//todooo размеры произвольные .. можно сделать оценку по размеру строки
-		xlsx_context->get_drawing_context().set_child_anchor(120, 64, note->note_sh.x_/ 12700. , note->note_sh.y_/ 12700.);
-		xlsx_context->get_comments_context().set_content(std::wstring(L"<t>") + note->note_sh.stText.value() + std::wstring(L"</t>"));
-		xlsx_context->get_comments_context().end_comment();
+		xlsx_context->get_drawing_context().set_child_anchor(note->note_sh.x_ , note->note_sh.y_, 120 * 12700., 64 * 12700.);
+		xlsx_context->get_drawing_context().set_text(std::wstring(L"<t>") + note->note_sh.stText.value() + std::wstring(L"</t>"));
 	}
 }
 

ASCOfficeXlsFile2/source/XlsXlsxConverter/xlsx_comments.cpp

@@ -63,8 +63,6 @@ public:
 
 	void serialize(std::wostream & strm)
     {
-		//std::sort(xlsx_comment_.begin(), xlsx_comment_.end(), sort_()); - излишне
-        
 		CP_XML_WRITER(strm)
         {
             CP_XML_NODE(L"comments")
@@ -73,27 +71,27 @@ public:
 
 				CP_XML_NODE(L"authors")
 				{
-					BOOST_FOREACH(std::wstring const & a, author_list_)
+					for (int i = 0 ; i < author_list_.size(); i++)
 					{
 						CP_XML_NODE(L"author")
 						{
-							CP_XML_STREAM() << a;
+							CP_XML_STREAM() << author_list_[i];
 						}
 					}
 				}
 
 				CP_XML_NODE(L"commentList")
 				{
-					BOOST_FOREACH(_xlsx_comment const & c, xlsx_comment_)
+					for (int i = 0 ; i < xlsx_comment_.size(); i++)
 					{
 						CP_XML_NODE(L"comment")
 						{
-							CP_XML_ATTR(L"ref", c.ref_);
-							CP_XML_ATTR(L"authorId", c.author_);
+							CP_XML_ATTR(L"ref", xlsx_comment_[i].ref_);
+							CP_XML_ATTR(L"authorId", xlsx_comment_[i].author_);
 							
 							CP_XML_NODE(L"text")
 							{
-								CP_XML_STREAM() << c.content_;
+								CP_XML_STREAM() << xlsx_comment_[i].content_;
 							}
 						} 					
 					}
@@ -106,14 +104,16 @@ public:
     {
         return ( xlsx_comment_.empty());
     }
+
     void add(_xlsx_comment & c)
     {
 		bool find = false;
-		for (long i=0;i<author_list_.size();i++)
+
+		for (long i = 0; i < author_list_.size(); i++)
 		{		
 			if (c.author_ == author_list_[i])
 			{
-				find=true;
+				find = true;
 				c.author_ = boost::lexical_cast<std::wstring>(i);
 				break;
 			}

ASCOfficeXlsFile2/source/XlsXlsxConverter/xlsx_comments.h

@@ -70,13 +70,13 @@ class xlsx_comments
 public:
     xlsx_comments();
     ~xlsx_comments();
-    static xlsx_comments_ptr create();
 
-public:
     void add(_xlsx_comment & d);
     bool empty() const;
 
-   void serialize(std::wostream & strm);    
+	void serialize(std::wostream & strm);    
+	
+	static xlsx_comments_ptr create();
 
 private:
     class Impl;

ASCOfficeXlsFile2/source/XlsXlsxConverter/xlsx_drawing_context.cpp

@@ -340,7 +340,7 @@ bool xlsx_drawing_context::start_drawing(int type)
 external_items::Type xlsx_drawing_context::getType()
 {
 	if (current_drawing_states == NULL)		return external_items::typeUnknown;
-	if (current_drawing_states->size() < 1) return external_items::typeUnknown;
+	if (current_drawing_states->empty()) return external_items::typeUnknown;
 
 	return current_drawing_states->back()->type;
 }
@@ -366,7 +366,8 @@ void xlsx_drawing_context::start_comment()
 
 	current_drawing_states->push_back(create_drawing_state());
 
-	current_drawing_states->back()->type = external_items::typeComment;
+	current_drawing_states->back()->type			= external_items::typeComment;
+	//current_drawing_states->back()->vmlwrite_mode_	= true; это только для HF !!!
 	
 	count_object++;
 
@@ -435,29 +436,29 @@ void xlsx_drawing_context::start_shape(int type)
 
 void xlsx_drawing_context::set_id(int id)
 {
-	if (current_drawing_states == NULL)		return;
-	if (current_drawing_states->size() < 1) return;
+	if (current_drawing_states == NULL) return;
+	if (current_drawing_states->empty()) return;
 	
 	current_drawing_states->back()->id = id;
 }
 void xlsx_drawing_context::set_FlipH()
 {
-	if (current_drawing_states == NULL)		return;
-	if (current_drawing_states->size() < 1) return;
+	if (current_drawing_states == NULL) return;
+	if (current_drawing_states->empty()) return;
 	
 	current_drawing_states->back()->flipH = true;
 }
 void xlsx_drawing_context::set_FlipV()
 {
 	if (current_drawing_states == NULL)		return;
-	if (current_drawing_states->size() < 1) return;
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->flipV = true;
 }
 void xlsx_drawing_context::set_shape_id(int id)
 {
-	if (current_drawing_states == NULL)		return;
-	if (current_drawing_states->size() < 1) return;
+	if (current_drawing_states == NULL) return;
+	if (current_drawing_states->empty()) return;
 	
 	if (current_drawing_states->back()->bTextBox)	return;
 
@@ -465,13 +466,15 @@ void xlsx_drawing_context::set_shape_id(int id)
 }
 void xlsx_drawing_context::set_object_visible	(bool val)
 {
-	if (current_drawing_states == NULL);
+	if (current_drawing_states == NULL) return;
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->object.visible = val;
 }
 void xlsx_drawing_context::set_object_anchor	(int col, int row)
 {
-	if (current_drawing_states == NULL);
+	if (current_drawing_states == NULL) return;
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->object.col = col;
 	current_drawing_states->back()->object.row = row;
@@ -484,8 +487,9 @@ void xlsx_drawing_context::set_object_id(int val)
 
 void xlsx_drawing_context::end_drawing()
 {
-	if (current_drawing_states == NULL)		return;
-	if (current_drawing_states->size() < 1) return;
+	if (current_drawing_states == NULL) return;
+	if (current_drawing_states->empty()) return;
+
 	if (current_drawing_states->back()->type == external_items::typeGroup)  return;
 	
 	end_drawing(current_drawing_states->back());
@@ -566,6 +570,7 @@ void xlsx_drawing_context::end_drawing(_drawing_state_ptr & drawing_state)
 void xlsx_drawing_context::serialize_group()
 {
 	if (current_drawing_states == NULL) return;
+	if (current_drawing_states->empty()) return;
 
 	_drawing_state_ptr & drawing_state = current_drawing_states->front();
 	std::wstringstream strm;
@@ -719,14 +724,18 @@ void xlsx_drawing_context::serialize_shape_comment(_drawing_state_ptr & drawing_
 				CP_XML_NODE(L"x:MoveWithCells"){}
 				CP_XML_NODE(L"x:SizeWithCells"){}
 
-				std::wstringstream strmAnchor;
-				strmAnchor	<< drawing_state->sheet_anchor.colFrom	<< L", " << (int)(2 * drawing_state->sheet_anchor.xFrom / 12700.)	<< L", " 
-						<< drawing_state->sheet_anchor.rwFrom	<< L", " << (int)(2 * drawing_state->sheet_anchor.yFrom / 12700.)		<< L", " 
-						<< drawing_state->sheet_anchor.colTo	<< L", " << (int)(2 * drawing_state->sheet_anchor.xTo / 12700.)			<< L", " 
-						<< drawing_state->sheet_anchor.rwTo		<< L", " << (int)(2 * drawing_state->sheet_anchor.yTo / 12700.); 
-				if (!strmAnchor.str().empty())
-				{
-					CP_XML_NODE(L"x:Anchor"){CP_XML_CONTENT(strmAnchor.str());}
+				if (drawing_state->sheet_anchor.xFrom >= 0 && drawing_state->sheet_anchor.yFrom > 0)
+				{//old xls don't have this
+					std::wstringstream strmAnchor;
+					strmAnchor	
+							<< drawing_state->sheet_anchor.colFrom	<< L", " << (int)(2 * drawing_state->sheet_anchor.xFrom / 12700.)	<< L", " 
+							<< drawing_state->sheet_anchor.rwFrom	<< L", " << (int)(2 * drawing_state->sheet_anchor.yFrom / 12700.)	<< L", " 
+							<< drawing_state->sheet_anchor.colTo	<< L", " << (int)(2 * drawing_state->sheet_anchor.xTo / 12700.)		<< L", " 
+							<< drawing_state->sheet_anchor.rwTo		<< L", " << (int)(2 * drawing_state->sheet_anchor.yTo / 12700.); 
+					if (!strmAnchor.str().empty())
+					{
+						CP_XML_NODE(L"x:Anchor"){CP_XML_CONTENT(strmAnchor.str());}
+					}
 				}
 				CP_XML_NODE(L"x:AutoFill")	{CP_XML_CONTENT("False");}
 				CP_XML_NODE(L"x:Row")		{CP_XML_CONTENT(drawing_state->object.row);}
@@ -1742,6 +1751,7 @@ void xlsx_drawing_context::set_sheet_anchor(int colFrom, int xFrom, int rwFrom,
 void xlsx_drawing_context::set_child_anchor(int x, int y, int cx, int cy)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->child_anchor.x	= x;
 	current_drawing_states->back()->child_anchor.y	= y;
@@ -1751,6 +1761,7 @@ void xlsx_drawing_context::set_child_anchor(int x, int y, int cx, int cy)
 void xlsx_drawing_context::set_group_anchor(int x, int y, int cx, int cy)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->group_anchor.x	= x;
 	current_drawing_states->back()->group_anchor.y	= y;
@@ -1760,6 +1771,8 @@ void xlsx_drawing_context::set_group_anchor(int x, int y, int cx, int cy)
 void xlsx_drawing_context::set_absolute_anchor(double x, double y, double cx, double cy)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
+
 	if (current_drawing_states->back()->type_anchor != 0) return;	
 
 	current_drawing_states->back()->absolute_anchor.x	= x;
@@ -1773,12 +1786,14 @@ void xlsx_drawing_context::set_absolute_anchor(double x, double y, double cx, do
 void xlsx_drawing_context::set_fill_texture_mode(int val)
 {
 	if (current_drawing_states == NULL) return;
+	if (current_drawing_states->empty()) return;
 		
 	current_drawing_states->back()->fill.texture_mode = (_texture_mode)val;
 }
 void xlsx_drawing_context::set_fill_texture(const std::wstring & str)
 {
 	if (current_drawing_states == NULL) return;
+	if (current_drawing_states->empty()) return;
 	
 	if (str.empty()) return;
 
@@ -1788,6 +1803,7 @@ void xlsx_drawing_context::set_fill_texture(const std::wstring & str)
 void xlsx_drawing_context::set_crop_top	(double val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 	
 	current_drawing_states->back()->fill.texture_crop[1] = val;
     current_drawing_states->back()->fill.texture_crop_enabled = true;
@@ -1795,6 +1811,7 @@ void xlsx_drawing_context::set_crop_top	(double val)
 void xlsx_drawing_context::set_crop_bottom(double val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->fill.texture_crop[3] = val;
     current_drawing_states->back()->fill.texture_crop_enabled = true;
@@ -1802,6 +1819,7 @@ void xlsx_drawing_context::set_crop_bottom(double val)
 void xlsx_drawing_context::set_crop_left (double val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->fill.texture_crop[0] = val;
     current_drawing_states->back()->fill.texture_crop_enabled = true;
@@ -1809,6 +1827,7 @@ void xlsx_drawing_context::set_crop_left (double val)
 void xlsx_drawing_context::set_crop_right (double val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->fill.texture_crop[2] = val;
     current_drawing_states->back()->fill.texture_crop_enabled = true;
@@ -1816,12 +1835,14 @@ void xlsx_drawing_context::set_crop_right (double val)
 void xlsx_drawing_context::set_rotation (double val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->rotation = val;
 }
 void xlsx_drawing_context::set_line_color (int nColor, const std::wstring & sColor)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->line.fill.color.sRGB = sColor;
 	current_drawing_states->back()->line.fill.color.nRGB = nColor;
@@ -1829,6 +1850,7 @@ void xlsx_drawing_context::set_line_color (int nColor, const std::wstring & sCol
 void xlsx_drawing_context::set_line_color (int index, int type)
 {
 	if (current_drawing_states == NULL) return;
+	if (current_drawing_states->empty()) return;
 	
 	_color color;
 	if (type == 3)
@@ -1853,18 +1875,21 @@ void xlsx_drawing_context::set_line_color (int index, int type)
 void xlsx_drawing_context::set_fill_angle (double val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->fill.angle = val;
 }
 void xlsx_drawing_context::set_fill_focus (int val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->fill.focus = val;
 }
 void xlsx_drawing_context::set_fill_color (int nColor, const std::wstring & sColor, bool background)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	if (background)	
 	{
@@ -1880,6 +1905,7 @@ void xlsx_drawing_context::set_fill_color (int nColor, const std::wstring & sCol
 void xlsx_drawing_context::set_fill_color (int index, int type, bool background)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 	
 	_color color;
 	if (type == 3)
@@ -1904,7 +1930,7 @@ void xlsx_drawing_context::set_fill_color (int index, int type, bool background)
 void xlsx_drawing_context::set_fill_opacity	(double val, bool background)
 {
 	if (current_drawing_states == NULL) return;
-	
+	if (current_drawing_states->empty()) return;
 	
 	if (background)	current_drawing_states->back()->fill.opacity2	= val;
 	else			current_drawing_states->back()->fill.opacity	= val;
@@ -1912,7 +1938,7 @@ void xlsx_drawing_context::set_fill_opacity	(double val, bool background)
 void xlsx_drawing_context::add_fill_colors(double position, const std::wstring & col)
 {
 	if (current_drawing_states == NULL) return;
-	
+	if (current_drawing_states->empty()) return;
 
 	_color color;
 	color.sRGB = col;
@@ -1921,6 +1947,7 @@ void xlsx_drawing_context::add_fill_colors(double position, const std::wstring &
 void xlsx_drawing_context::add_fill_colors(double position, int index, int type)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	_color color;
 	color.index = index;
@@ -1931,6 +1958,7 @@ void xlsx_drawing_context::add_fill_colors(double position, int index, int type)
 void xlsx_drawing_context::set_fill_type (int val)
 {
 	if (current_drawing_states == NULL) return;
+	if (current_drawing_states->empty()) return;
 	
 	current_drawing_states->back()->fill.type = (_fill_type) val;
 }
@@ -1938,6 +1966,7 @@ void xlsx_drawing_context::set_fill_type (int val)
 void xlsx_drawing_context::set_line_dash(int val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	switch (val)
 	{
@@ -1958,6 +1987,7 @@ void xlsx_drawing_context::set_line_dash(int val)
 void xlsx_drawing_context::set_line_type (int val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	switch(val)
 	{
@@ -1970,6 +2000,7 @@ void xlsx_drawing_context::set_line_type (int val)
 void xlsx_drawing_context::set_line_style (int val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	switch(val)
 	{
@@ -1984,6 +2015,7 @@ void xlsx_drawing_context::set_line_style (int val)
 void xlsx_drawing_context::set_line_width (int val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->line.width = val;
 }
@@ -1991,48 +2023,58 @@ void xlsx_drawing_context::set_line_width (int val)
 void xlsx_drawing_context::set_line_arrow(bool val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->line.arrow.enabled = val;
 }
 void xlsx_drawing_context::set_arrow_start (int val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->line.arrow.start = val;
 }
 void xlsx_drawing_context::set_arrow_end (int val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->line.arrow.end = val;
 }
 void xlsx_drawing_context::set_arrow_start_width (int val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->line.arrow.start_width = val;
 }
 void xlsx_drawing_context::set_arrow_end_width (int val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->line.arrow.end_width = val;
 }
 void xlsx_drawing_context::set_arrow_start_length (int val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->line.arrow.start_length = val;
 }
 void xlsx_drawing_context::set_arrow_end_length (int val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->line.arrow.end_length = val;
 }
 //----------------------------------------------------------------------
 void xlsx_drawing_context::set_fill_old_version (_UINT32 val)
 {
+	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
+
 	unsigned char backColorIdx		= GETBITS(val, 0, 7);
 	unsigned char patternColorIdx	= GETBITS(val, 8,15);
 	unsigned char pattern			= GETBITS(val,16,23);
@@ -2086,6 +2128,9 @@ void xlsx_drawing_context::set_line_old_version (_UINT32 val)
 }
 void xlsx_drawing_context::set_flag_old_version(_UINT16 val, _UINT16 val2)
 {
+	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
+
 	unsigned short flips_flag = 0;
 	if (current_drawing_states->back()->shape_id == MSOSPT::msosptArc)
 	{
@@ -2144,6 +2189,7 @@ void xlsx_drawing_context::set_flag_old_version(_UINT16 val, _UINT16 val2)
 void xlsx_drawing_context::set_hyperlink(const std::wstring & link, const std::wstring & display, bool is_external)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	std::wstring sId			= std::wstring(L"hId") + boost::lexical_cast<std::wstring>(hlinks_.size()+1);
 	std::wstring link_correct	= link;
@@ -2161,72 +2207,84 @@ void xlsx_drawing_context::set_hyperlink(const std::wstring & link, const std::w
 void xlsx_drawing_context::set_wordart_text(const std::wstring & text)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->wordart.text = text;
 }
 void xlsx_drawing_context::set_wordart_font(const std::wstring & val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->wordart.font = val;
 }
 void xlsx_drawing_context::set_wordart_size	(int val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->wordart.size = val;
 }
 void xlsx_drawing_context::set_text_align (int val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->text.align = val;
 }
 void xlsx_drawing_context::set_text_vert_align (int val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->text.vert_align = val;
 }
 void xlsx_drawing_context::set_text_vertical (int val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->text.vertical = val;
 }
 void xlsx_drawing_context::set_text_margin(RECT & val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->text.margins = val;
 }
 void xlsx_drawing_context::set_text_fit_shape(bool val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->text.fit_shape = val;
 }
 void xlsx_drawing_context::set_wordart_bold	(bool val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->wordart.bold = val;
 }
 void xlsx_drawing_context::set_wordart_italic (bool val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->wordart.italic = val;
 }
 void xlsx_drawing_context::set_wordart_underline (bool val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->wordart.underline = val;
 }
 void xlsx_drawing_context::set_wordart_strike(bool val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->wordart.strike = val;
 }
@@ -2234,86 +2292,101 @@ void xlsx_drawing_context::set_wordart_strike(bool val)
 void xlsx_drawing_context::set_wordart_vertical	(bool val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->wordart.vertical = val;
 }
 void xlsx_drawing_context::set_wordart_spacing	(double val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->wordart.spacing = val;
 }
 void xlsx_drawing_context::set_text (const std::wstring & text)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->text.content = text;
 }
 void xlsx_drawing_context::set_text_wrap (int val)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->text.wrap = val;
 }
 void xlsx_drawing_context::set_custom_rect(_rect & rect)
 {
 	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->custom_rect = rect;
 }
 void xlsx_drawing_context::set_properties(const std::wstring & str)
 {
-	if (current_drawing_states == NULL) return;
+	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 	
 	current_drawing_states->back()->shape = str;
 }
 void xlsx_drawing_context::set_custom_verticles (std::vector<ODRAW::MSOPOINT> & points)
 {
-	if (current_drawing_states == NULL) return;
+	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->custom_verticles = points;
 }
 void xlsx_drawing_context::set_custom_guides (std::vector<ODRAW::MSOSG> & guides)
 {
-	if (current_drawing_states == NULL) return;
+	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
+
 	if (current_drawing_states->back()->shape_id == MSOSPT::msosptNotchedCircularArrow) return;
 	
 	current_drawing_states->back()->custom_guides = guides;
 }
 void xlsx_drawing_context::set_custom_segments (std::vector<ODRAW::MSOPATHINFO> & segments)
 {
-	if (current_drawing_states == NULL) return;
+	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 	
 	current_drawing_states->back()->custom_segments = segments;
 }
 void xlsx_drawing_context::set_custom_adjustHandles(std::vector<ODRAW::ADJH> & handles)
 {
-	if (current_drawing_states == NULL) return;
+	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 	
 	current_drawing_states->back()->custom_adjustHandles = handles;
 }
 void xlsx_drawing_context::set_custom_adjustValues(std::vector<_CP_OPT(int)> & values)
 {
-	if (current_drawing_states == NULL) return;
+	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->custom_adjustValues = values;
 }
 void xlsx_drawing_context::set_custom_path (int type_path)
 {
-	if (current_drawing_states == NULL) return;
+	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->custom_path = type_path;
 }
 //----------------------------------------------------------------------------------------------------------
 bool xlsx_drawing_context::get_mode_vmlwrite ()
 {//comment, shapes in header/footer, ....
-	if (current_drawing_states == NULL) return false;
+	if (current_drawing_states == NULL) return false;	
+	if (current_drawing_states->empty()) return false;
 
 	return current_drawing_states->back()->vmlwrite_mode_;
 }
 void xlsx_drawing_context::set_mode_vmlwrite (bool val)
 {//comment, shapes in header/footer, ....
-	if (current_drawing_states == NULL) return;
+	if (current_drawing_states == NULL) return;	
+	if (current_drawing_states->empty()) return;
 
 	current_drawing_states->back()->vmlwrite_mode_ = val;
 }

DesktopEditor/doctrenderer/doctrenderer.cpp

@@ -768,7 +768,7 @@ namespace NSDoctRenderer
                                     _LOGGING_ERROR_(L"change", strException);
 
                                     char buffer[50];
-                                    sprintf(buffer, "index=\"%d\"", pNative->m_nCurrentChangesNumber);
+                                    sprintf(buffer, "index=\"%d\"", pNative->m_nCurrentChangesNumber - 1);
                                     std::string s(buffer);
                                     strError = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)s.c_str(), (LONG)s.length());
                                     bIsBreak = true;

DocxRenderer/DocxRenderer.h

@@ -0,0 +1,209 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2016
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia,
+ * EU, LV-1021.
+ *
+ * The  interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+ */
+#ifndef _PDF_WRITER_PDFRENDERER_H
+#define _PDF_WRITER_PDFRENDERER_H
+
+#include "../DesktopEditor/graphics/IRenderer.h"
+#include <string>
+#include <vector>
+#include <algorithm>
+
+#ifndef DOCXRENDERER_USE_DYNAMIC_LIBRARY
+#define DOCXRENDERER_DECL_EXPORT
+#else
+#include "../DesktopEditor/common/base_export.h"
+#define DOCXRENDERER_DECL_EXPORT Q_DECL_EXPORT
+#endif
+
+class CFontManager;
+class CApplicationFonts;
+
+namespace NSDocxRenderer
+{
+    enum TextAssociationType
+    {
+        TextAssociationTypeDefault	= 0,
+        TextAssociationTypeLine		= 1,
+        TextAssociationTypeNoFrames	= 2,
+        TextAssociationTypeBlock	= 3
+    };
+}
+
+class DOCXRENDERER_DECL_EXPORT CDocxRenderer : public IRenderer
+{
+public:
+    CDocxRenderer(CApplicationFonts* pAppFonts);
+    ~CDocxRenderer();
+
+    void         CreateFile(const std::wstring& wsPath);
+    void         Close();
+
+    void         SetTextAssociationType(const NSDocxRenderer::TextAssociationType& eType);
+
+	void         SetTempFolder(const std::wstring& wsPath);
+	//----------------------------------------------------------------------------------------
+	// Тип рендерера
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT get_Type(LONG* lType);
+	//----------------------------------------------------------------------------------------
+	// Функции для работы со страницей
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT NewPage();
+	virtual HRESULT get_Height(double* dHeight);
+	virtual HRESULT put_Height(const double& dHeight);
+	virtual HRESULT get_Width(double* dWidth);
+	virtual HRESULT put_Width(const double& dWidth);
+	virtual HRESULT get_DpiX(double* dDpiX);
+	virtual HRESULT get_DpiY(double* dDpiY);
+	//----------------------------------------------------------------------------------------
+	// Функции для работы с Pen
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT get_PenColor(LONG* lColor);
+	virtual HRESULT put_PenColor(const LONG& lColor);
+	virtual HRESULT get_PenAlpha(LONG* lAlpha);
+	virtual HRESULT put_PenAlpha(const LONG& lAlpha);
+	virtual HRESULT get_PenSize(double* dSize);
+	virtual HRESULT put_PenSize(const double& dSize);
+	virtual HRESULT get_PenDashStyle(BYTE* nDashStyle);
+	virtual HRESULT put_PenDashStyle(const BYTE& nDashStyle);
+	virtual HRESULT get_PenLineStartCap(BYTE* nCapStyle);
+	virtual HRESULT put_PenLineStartCap(const BYTE& nCapStyle);
+	virtual HRESULT get_PenLineEndCap(BYTE* nCapStyle);
+	virtual HRESULT put_PenLineEndCap(const BYTE& nCapStyle);
+	virtual HRESULT get_PenLineJoin(BYTE* nJoinStyle);
+	virtual HRESULT put_PenLineJoin(const BYTE& nJoinStyle);
+	virtual HRESULT get_PenDashOffset(double* dOffset);
+	virtual HRESULT put_PenDashOffset(const double& dOffset);
+	virtual HRESULT get_PenAlign(LONG* lAlign);
+	virtual HRESULT put_PenAlign(const LONG& lAlign);
+	virtual HRESULT get_PenMiterLimit(double* dMiter);
+	virtual HRESULT put_PenMiterLimit(const double& dMiter);
+	virtual HRESULT PenDashPattern(double* pPattern, LONG lCount);
+	//----------------------------------------------------------------------------------------
+	// Функции для работы с Brush
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT get_BrushType(LONG* lType);
+	virtual HRESULT put_BrushType(const LONG& lType);
+	virtual HRESULT get_BrushColor1(LONG* lColor);
+	virtual HRESULT put_BrushColor1(const LONG& lColor);
+	virtual HRESULT get_BrushAlpha1(LONG* lAlpha);
+	virtual HRESULT put_BrushAlpha1(const LONG& lAlpha);
+	virtual HRESULT get_BrushColor2(LONG* lColor);
+	virtual HRESULT put_BrushColor2(const LONG& lColor);
+	virtual HRESULT get_BrushAlpha2(LONG* lAlpha);
+	virtual HRESULT put_BrushAlpha2(const LONG& lAlpha);
+	virtual HRESULT get_BrushTexturePath(std::wstring* wsPath);
+	virtual HRESULT put_BrushTexturePath(const std::wstring& wsPath);
+	virtual HRESULT get_BrushTextureMode(LONG* lMode);
+	virtual HRESULT put_BrushTextureMode(const LONG& lMode);
+	virtual HRESULT get_BrushTextureAlpha(LONG* lAlpha);
+	virtual HRESULT put_BrushTextureAlpha(const LONG& lAlpha);
+	virtual HRESULT get_BrushLinearAngle(double* dAngle);
+	virtual HRESULT put_BrushLinearAngle(const double& dAngle);
+	virtual HRESULT BrushRect(const INT& nVal, const double& dLeft, const double& dTop, const double& dWidth, const double& dHeight);
+	virtual HRESULT BrushBounds(const double& dLeft, const double& dTop, const double& dWidth, const double& dHeight);
+	virtual HRESULT put_BrushGradientColors(LONG* pColors, double* pPositions, LONG lCount);
+	//----------------------------------------------------------------------------------------
+	// Функции для работы со шрифтами
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT get_FontName(std::wstring* wsName);
+	virtual HRESULT put_FontName(const std::wstring& wsName);
+	virtual HRESULT get_FontPath(std::wstring* wsPath);
+	virtual HRESULT put_FontPath(const std::wstring& wsPath);
+	virtual HRESULT get_FontSize(double* dSize);
+	virtual HRESULT put_FontSize(const double& dSize);
+	virtual HRESULT get_FontStyle(LONG* lStyle);
+	virtual HRESULT put_FontStyle(const LONG& lStyle);
+	virtual HRESULT get_FontStringGID(INT* bGid);
+	virtual HRESULT put_FontStringGID(const INT& bGid);
+	virtual HRESULT get_FontCharSpace(double* dSpace);
+	virtual HRESULT put_FontCharSpace(const double& dSpace);
+	virtual HRESULT get_FontFaceIndex(int* lFaceIndex);
+	virtual HRESULT put_FontFaceIndex(const int& lFaceIndex);
+	//----------------------------------------------------------------------------------------
+	// Функции для вывода текста
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT CommandDrawTextCHAR  (const LONG& lUnicode,                   const double& dX, const double& dY, const double& dW, const double& dH);
+	virtual HRESULT CommandDrawTextExCHAR(const LONG& lUnicode, const LONG& lGid, const double& dX, const double& dY, const double& dW, const double& dH);
+	virtual HRESULT CommandDrawText      (const std::wstring& wsUnicodeText,                                                           const double& dX, const double& dY, const double& dW, const double& dH);
+	virtual HRESULT CommandDrawTextEx    (const std::wstring& wsUnicodeText, const unsigned int* pGids, const unsigned int nGidsCount, const double& dX, const double& dY, const double& dW, const double& dH);
+	//----------------------------------------------------------------------------------------
+	// Маркеры команд
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT BeginCommand(const DWORD& lType);
+	virtual HRESULT EndCommand(const DWORD& lType);
+	//----------------------------------------------------------------------------------------
+	// Функции для работы с патом
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT PathCommandMoveTo(const double& dX, const double& dY);
+	virtual HRESULT PathCommandLineTo(const double& dX, const double& dY);
+	virtual HRESULT PathCommandLinesTo(double* pPoints, const int& nCount);
+	virtual HRESULT PathCommandCurveTo(const double& dX1, const double& dY1, const double& dX2, const double& dY2, const double& dXe, const double& dYe);
+	virtual HRESULT PathCommandCurvesTo(double* pPoints, const int& nCount);
+	virtual HRESULT PathCommandArcTo(const double& dX, const double& dY, const double& dW, const double& dH, const double& dStartAngle, const double& dSweepAngle);
+	virtual HRESULT PathCommandClose();
+	virtual HRESULT PathCommandEnd();
+	virtual HRESULT DrawPath(const LONG& lType);
+	virtual HRESULT PathCommandStart();
+	virtual HRESULT PathCommandGetCurrentPoint(double* dX, double* dY);
+	virtual HRESULT PathCommandTextCHAR  (const LONG& lUnicode,                   const double& dX, const double& dY, const double& dW, const double& dH);
+	virtual HRESULT PathCommandTextExCHAR(const LONG& lUnicode, const LONG& lGid, const double& dX, const double& dY, const double& dW, const double& dH);
+	virtual HRESULT PathCommandText      (const std::wstring& wsUnicodeText,                                                           const double& dX, const double& dY, const double& dW, const double& dH);
+	virtual HRESULT PathCommandTextEx    (const std::wstring& wsUnicodeText, const unsigned int* pGids, const unsigned int nGidsCount, const double& dX, const double& dY, const double& dW, const double& dH);
+	//----------------------------------------------------------------------------------------
+	// Функции для вывода изображений
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT DrawImage(IGrObject* pImage, const double& dX, const double& dY, const double& dW, const double& dH);
+	virtual HRESULT DrawImageFromFile(const std::wstring& wsImagePath, const double& dX, const double& dY, const double& dW, const double& dH, const BYTE& nAlpha = 255);
+	//----------------------------------------------------------------------------------------
+	// Функции для выставления преобразования
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT SetTransform(const double& dM11, const double& dM12, const double& dM21, const double& dM22, const double& dX, const double& dY);
+	virtual HRESULT GetTransform(double* dM11, double* dM12, double* dM21, double* dM22, double* dX, double* dY);
+	virtual HRESULT ResetTransform();
+	//----------------------------------------------------------------------------------------
+	// Тип клипа
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT get_ClipMode(LONG* lMode);
+	virtual HRESULT put_ClipMode(const LONG& lMode);
+	//----------------------------------------------------------------------------------------
+	// Дополнительные функции
+	//----------------------------------------------------------------------------------------
+	virtual HRESULT CommandLong(const LONG& lType, const LONG& lCommand);
+	virtual HRESULT CommandDouble(const LONG& lType, const double& dCommand);
+	virtual HRESULT CommandString(const LONG& lType, const std::wstring& sCommand);
+
+private:
+    CDocxRenderer_Private* m_pInternal;
+};
+
+#endif // _PDF_WRITER_PDFRENDERER_H

DocxRenderer/DocxRenderer.pro

@@ -0,0 +1,53 @@
+QT       -= core gui
+
+VERSION = 1.0.0.4
+TARGET = DocxRenderer
+TEMPLATE = lib
+
+CONFIG += shared
+CONFIG += plugin
+
+CONFIG += core_static_link_libstd
+
+CORE_ROOT_DIR = $$PWD/..
+PWD_ROOT_DIR = $$PWD
+include(../Common/base.pri)
+
+DEFINES += DOCXRENDERER_USE_DYNAMIC_LIBRARY
+
+CONFIG += build_all_zlib build_zlib_as_sources
+include(../OfficeUtils/OfficeUtils.pri)
+
+CONFIG += build_cximage_zlib_disable
+include(../DesktopEditor/Qt_build/graphics/project/graphics.pri)
+include(../DesktopEditor/xml/build/qt/libxml2.pri)
+
+#UnicodeConverter
+LIBS += -L$$CORE_BUILDS_LIBRARIES_PATH -lUnicodeConverter
+
+core_windows {
+
+LIBS += -lgdi32 \
+        -ladvapi32 \
+        -luser32 \
+        -lshell32
+}
+
+HEADERS += \
+    src/resources/resources.h
+
+HEADERS += \
+    src/logic/Common.h \
+    src/logic/Document.h \
+    src/logic/ElementImage.h \
+    src/logic/ElementParagraph.h \
+    src/logic/ElementShape.h \
+    src/logic/FontManager.h \
+    src/logic/FontManagerBase.h \
+    src/logic/Page.h
+
+HEADERS += \
+    DocxRenderer.h
+
+SOURCES += \
+    DocxRenderer.cpp

DocxRenderer/src/logic/Common.h

@@ -0,0 +1,518 @@
+#pragma once
+
+#ifndef AVSINLINE
+#if defined(_MSC_VER)
+#define AVSINLINE __forceinline
+#else
+#define AVSINLINE inline
+#endif
+#endif
+
+#include "../../Common/TemporaryCS.h"
+#include "../Graphics/Matrix.h"
+#include "../Graphics/Structures.h"
+#include "StringWriter.h"
+#include "CalculatorCRC32.h"
+
+namespace NSDocxRenderer
+{
+	AVSINLINE LONG ConvertColor(LONG lBGR)
+	{
+		return (0x00FFFFFF & (((lBGR & 0xFF) << 16) | (lBGR & 0x0000FF00) | ((lBGR >> 16) & 0xFF)));
+	} 
+
+	AVSINLINE void CorrectString(CString& strValue)
+	{
+		strValue.Replace(_T("&"),	_T("&amp;"));			
+		strValue.Replace(_T("'"),	_T("&apos;"));
+		strValue.Replace(_T("<"),	_T("&lt;"));
+		strValue.Replace(_T(">"),	_T("&gt;"));
+		strValue.Replace(_T("\""),	_T("&quot;"));
+	}
+
+	class CBaseItem
+	{
+	public:
+		enum ElemType
+		{
+			etParagraph	= 0,
+			etImage		= 1,
+			etShape		= 2
+		};
+
+		ElemType m_eType;
+
+		CBaseItem()
+		{
+			m_eType = etShape;
+		}
+
+		virtual void ToXml(NSDocxRenderer::CStringWriter& oWriter) = 0;
+	};
+
+	class CImageManager
+	{
+	public:
+		CAtlMap<CString, CImageInfo>	m_mapImagesFile;
+		CAtlMap<DWORD, CImageInfo>		m_mapImageData;
+
+		CString							m_strDstMedia;
+
+		LONG							m_lMaxSizeImage;
+		LONG							m_lNextIDImage;
+
+		CCalculatorCRC32				m_oCRC;
+
+	public:
+
+		CImageManager()
+		{
+			m_strDstMedia	= _T("");
+			m_lMaxSizeImage = 800;
+			m_lNextIDImage	= 0;
+		}
+
+		AVSINLINE void NewDocument()
+		{
+			m_strDstMedia	= _T("");
+			m_lMaxSizeImage = 800;
+			m_lNextIDImage	= 0;
+
+			m_mapImageData.RemoveAll();
+			m_mapImagesFile.RemoveAll();
+		}
+
+	public:
+		CImageInfo WriteImage(IUnknown* punkImage, double& x, double& y, double& width, double& height)
+		{
+			if (height < 0)
+			{
+				FlipY(punkImage);
+				height = -height;
+				y -= height;
+			}
+			
+			return GenerateImageID(punkImage);
+		}
+		CImageInfo WriteImage(CString& strFile, double& x, double& y, double& width, double& height)
+		{
+			return GenerateImageID(strFile);
+		}
+	
+	protected:
+		inline void CopyFile(CString& strFileSrc, CString& strFileDst)
+		{
+			CDirectory::CopyFile(strFileSrc, strFileDst, NULL, NULL);
+		}
+		void SaveImage(CString& strFileSrc, CImageInfo& oInfo)
+		{
+			CString strLoadXml = _T("<transforms><ImageFile-LoadImage sourcepath=\"") + strFileSrc + _T("\"/></transforms>");
+
+			ImageStudio::IImageTransforms* pTransform = NULL;
+			CoCreateInstance(ImageStudio::CLSID_ImageTransforms, NULL, CLSCTX_INPROC_SERVER, ImageStudio::IID_IImageTransforms, (void**)&pTransform);
+
+			VARIANT_BOOL vbRes = VARIANT_FALSE;
+			BSTR bsLoad = strLoadXml.AllocSysString();
+			pTransform->SetXml(bsLoad, &vbRes);
+			SysFreeString(bsLoad);
+
+			pTransform->Transform(&vbRes);
+
+			VARIANT var;
+			var.punkVal = NULL;
+			pTransform->GetResult(0, &var);
+
+			if (NULL == var.punkVal)
+			{
+				RELEASEINTERFACE(pTransform);
+				return;
+			}
+
+			MediaCore::IAVSUncompressedVideoFrame* pFrame = NULL;
+			var.punkVal->QueryInterface(MediaCore::IID_IAVSUncompressedVideoFrame, (void**)&pFrame);
+
+			RELEASEINTERFACE((var.punkVal));
+
+			if (NULL == pFrame)
+			{
+				RELEASEINTERFACE(pTransform);
+				return;
+			}
+
+			LONG lWidth		= 0;
+			LONG lHeight	= 0;
+			pFrame->get_Width(&lWidth);
+			pFrame->get_Height(&lHeight);
+
+			oInfo.m_eType = GetImageType(pFrame);
+
+			RELEASEINTERFACE(pFrame);
+
+			CString strSaveItem = _T("");
+			strSaveItem.Format(_T("\\image%d."), oInfo.m_lID);
+			if (itJPG == oInfo.m_eType)
+			{
+				strSaveItem = _T("<ImageFile-SaveAsJpeg destinationpath=\"") + m_strDstMedia + strSaveItem + _T("jpg\" format=\"888\"/>");
+			}
+			else
+			{
+				strSaveItem = _T("<ImageFile-SaveAsPng destinationpath=\"") + m_strDstMedia + strSaveItem + _T("png\" format=\"888\"/>");
+			}
+
+			CString strXml = _T("");
+
+			if ((lWidth <= m_lMaxSizeImage) && (lHeight <= m_lMaxSizeImage))
+			{
+				strXml = _T("<transforms>") + strSaveItem + _T("</transforms>");
+			}
+			else
+			{
+				LONG lW = 0;
+				LONG lH = 0;
+				double dAspect = (double)lWidth / lHeight;
+
+				if (lWidth >= lHeight)
+				{
+					lW = m_lMaxSizeImage;
+					lH = (LONG)((double)lW / dAspect);
+				}
+				else
+				{
+					lH = m_lMaxSizeImage;
+					lW = (LONG)(dAspect * lH);
+				}
+
+				CString strResize = _T("");
+				strResize.Format(_T("<ImageTransform-TransformResize width=\"%d\" height=\"%d\"/>"), lW, lH);
+
+				strXml = _T("<transforms>") + strResize + strSaveItem + _T("</transforms>");
+			}
+			
+			VARIANT_BOOL vbSuccess = VARIANT_FALSE;
+			BSTR bsXml = strXml.AllocSysString();
+			pTransform->SetXml(bsXml, &vbSuccess);
+			SysFreeString(bsXml);
+
+			pTransform->Transform(&vbSuccess);
+
+			RELEASEINTERFACE(pTransform);
+		}
+		void SaveImage(IUnknown* punkImage, CImageInfo& oInfo)
+		{
+			MediaCore::IAVSUncompressedVideoFrame* pFrame = NULL;
+			punkImage->QueryInterface(MediaCore::IID_IAVSUncompressedVideoFrame, (void**)&pFrame);
+
+			if (NULL == pFrame)
+				return;
+
+			LONG lWidth		= 0;
+			LONG lHeight	= 0;
+			pFrame->get_Width(&lWidth);
+			pFrame->get_Height(&lHeight);
+
+			oInfo.m_eType = GetImageType(pFrame);
+
+			RELEASEINTERFACE(pFrame);
+			
+			ImageStudio::IImageTransforms* pTransform = NULL;
+			CoCreateInstance(ImageStudio::CLSID_ImageTransforms, NULL ,CLSCTX_INPROC_SERVER, ImageStudio::IID_IImageTransforms, (void**)&pTransform);
+
+			VARIANT var;
+			var.vt = VT_UNKNOWN;
+			var.punkVal = punkImage;
+			pTransform->SetSource(0, var);
+
+			CString strSaveItem = _T("");
+			strSaveItem.Format(_T("\\image%d."), oInfo.m_lID);
+			if (itJPG == oInfo.m_eType)
+			{
+				strSaveItem = _T("<ImageFile-SaveAsJpeg destinationpath=\"") + m_strDstMedia + strSaveItem + _T("jpg\" format=\"888\"/>");
+			}
+			else
+			{
+				strSaveItem = _T("<ImageFile-SaveAsPng destinationpath=\"") + m_strDstMedia + strSaveItem + _T("png\" format=\"888\"/>");
+			}
+
+			CString strXml = _T("");
+			if ((lWidth <= m_lMaxSizeImage) && (lHeight <= m_lMaxSizeImage))
+			{
+				strXml = _T("<transforms>") + strSaveItem + _T("</transforms>");
+			}
+			else
+			{
+				LONG lW = 0;
+				LONG lH = 0;
+				double dAspect = (double)lWidth / lHeight;
+
+				if (lWidth >= lHeight)
+				{
+					lW = m_lMaxSizeImage;
+					lH = (LONG)((double)lW / dAspect);
+				}
+				else
+				{
+					lH = m_lMaxSizeImage;
+					lW = (LONG)(dAspect * lH);
+				}
+
+				CString strResize = _T("");
+				strResize.Format(_T("<ImageTransform-TransformResize width=\"%d\" height=\"%d\"/>"), lW, lH);
+
+				strXml = _T("<transforms>") + strResize + strSaveItem + _T("</transforms>");
+			}
+			
+			VARIANT_BOOL vbSuccess = VARIANT_FALSE;
+			BSTR bsXml = strXml.AllocSysString();
+			pTransform->SetXml(bsXml, &vbSuccess);
+			SysFreeString(bsXml);
+
+			pTransform->Transform(&vbSuccess);
+
+			RELEASEINTERFACE(pTransform);
+		}
+
+		CImageInfo GenerateImageID(IUnknown* punkData)
+		{
+			CImageInfo oInfo;
+
+			if (NULL == punkData)
+				return oInfo;
+
+			MediaCore::IAVSUncompressedVideoFrame* pFrame = NULL;
+			punkData->QueryInterface(MediaCore::IID_IAVSUncompressedVideoFrame, (void**)&pFrame);
+
+			BYTE* pBuffer = NULL;
+			LONG lLen = 0;
+
+			pFrame->get_Buffer(&pBuffer);
+			pFrame->get_BufferSize(&lLen);
+
+			DWORD dwSum = m_oCRC.Calc(pBuffer, lLen);
+
+			CAtlMap<DWORD, CImageInfo>::CPair* pPair = m_mapImageData.Lookup(dwSum);
+			if (NULL == pPair)
+			{
+				// <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+				++m_lNextIDImage;
+				
+				oInfo.m_lID = m_lNextIDImage;
+				SaveImage(punkData, oInfo);
+				m_mapImageData.SetAt(dwSum, oInfo);
+			}
+			else
+			{
+				oInfo = pPair->m_value;
+			}
+
+			RELEASEINTERFACE(pFrame);
+
+			return oInfo;
+		}
+
+		CImageInfo GenerateImageID(CString& strFileName)
+		{
+			CImageInfo oInfo;
+			CAtlMap<CString, CImageInfo>::CPair* pPair = m_mapImagesFile.Lookup(strFileName);
+
+			if (NULL == pPair)
+			{
+				// <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+				++m_lNextIDImage;
+				
+				oInfo.m_lID = m_lNextIDImage;
+				SaveImage(strFileName, oInfo);
+				m_mapImagesFile.SetAt(strFileName, oInfo);
+			}
+			else
+			{
+				oInfo = pPair->m_value;
+			}
+
+			return oInfo;
+		}
+
+		ImageType GetImageType(MediaCore::IAVSUncompressedVideoFrame* pFrame)
+		{
+			LONG lWidth		= 0;
+			LONG lHeight	= 0;
+			BYTE* pBuffer	= NULL;
+
+			pFrame->get_Width(&lWidth);
+			pFrame->get_Height(&lHeight);
+			pFrame->get_Buffer(&pBuffer);
+
+			BYTE* pBufferMem = pBuffer + 3;
+			LONG lCountPix = lWidth * lHeight;
+
+			for (LONG i = 0; i < lCountPix; ++i, pBufferMem += 4)
+			{
+				if (255 != *pBufferMem)
+					return itPNG;
+			}
+			return itJPG;
+		}
+
+		void FlipY(IUnknown* punkImage)
+		{
+			if (NULL == punkImage)
+				return;
+
+			MediaCore::IAVSUncompressedVideoFrame* pFrame = NULL;
+			punkImage->QueryInterface(MediaCore::IID_IAVSUncompressedVideoFrame, (void**)&pFrame);
+
+			if (NULL == pFrame)
+				return;
+
+			BYTE* pBuffer	= NULL;
+			LONG lWidth		= 0;
+			LONG lHeight	= 0;
+			LONG lStride	= 0;
+
+			pFrame->get_Buffer(&pBuffer);
+			pFrame->get_Width(&lWidth);
+			pFrame->get_Height(&lHeight);
+			pFrame->get_Stride(0, &lStride);
+
+			if (lStride < 0)
+				lStride = -lStride;
+			
+			if ((lWidth * 4) != lStride)
+			{
+				RELEASEINTERFACE(pFrame);
+				return;
+			}
+
+			BYTE* pBufferMem = new BYTE[lStride];
+
+			BYTE* pBufferEnd = pBuffer + lStride * (lHeight - 1);
+
+			LONG lCountV = lHeight / 2;
+
+			for (LONG lIndexV = 0; lIndexV < lCountV; ++lIndexV)
+			{
+				memcpy(pBufferMem, pBuffer, lStride);
+				memcpy(pBuffer, pBufferEnd, lStride);
+				memcpy(pBufferEnd, pBufferMem, lStride);
+				
+				pBuffer		+= lStride;
+				pBufferEnd	-= lStride;
+			}
+
+			RELEASEARRAYOBJECTS(pBufferMem);
+			RELEASEINTERFACE(pFrame);
+		}
+
+		void FlipX(IUnknown* punkImage)
+		{
+			if (NULL == punkImage)
+				return;
+
+			MediaCore::IAVSUncompressedVideoFrame* pFrame = NULL;
+			punkImage->QueryInterface(MediaCore::IID_IAVSUncompressedVideoFrame, (void**)&pFrame);
+
+			if (NULL == pFrame)
+				return;
+
+			BYTE* pBuffer	= NULL;
+			LONG lWidth		= 0;
+			LONG lHeight	= 0;
+			LONG lStride	= 0;
+
+			pFrame->get_Buffer(&pBuffer);
+			pFrame->get_Width(&lWidth);
+			pFrame->get_Height(&lHeight);
+			pFrame->get_Stride(0, &lStride);
+
+			if (lStride < 0)
+				lStride = -lStride;
+			
+			if ((lWidth * 4) != lStride)
+			{
+				RELEASEINTERFACE(pFrame);
+				return;
+			}
+
+			DWORD* pBufferDWORD	= (DWORD*)pBuffer;
+
+			LONG lW2 = lWidth / 2;
+			for (LONG lIndexV = 0; lIndexV < lHeight; ++lIndexV)
+			{
+				DWORD* pMem1 = pBufferDWORD;
+				DWORD* pMem2 = pBufferDWORD + lWidth - 1;
+				
+				LONG lI = 0;
+				while (lI < lW2)
+				{
+					DWORD dwMem = *pMem1;
+					*pMem1++ = *pMem2;
+					*pMem2-- = dwMem;
+				}
+			}
+
+			RELEASEINTERFACE(pFrame);
+		}
+
+	};
+}
+
+namespace NSDocxRenderer
+{
+	// 2-byte number
+    inline short little_endian_2_big_endian( short s )
+    {
+		return ( ( s >> 8) & 0xff ) + ( ( s << 8 ) & 0xff00 );
+    }
+
+    /*========================================================================================================*/
+
+    // 4-byte number
+    inline int little_endian_2_big_endian( int i )
+    {
+		return ( ( i & 0xff ) << 24 ) + ( ( i & 0xff00 ) << 8 ) + ( ( i & 0xff0000 ) >> 8 ) + ( ( i >> 24 ) & 0xff );
+    }
+
+	AVSINLINE CString ToHexString( unsigned int ui )
+    {
+		CString strRes = _T("");
+		strRes.Format(_T("%08X"), ui);
+		return strRes;
+    }
+
+	/*========================================================================================================*/
+
+    AVSINLINE CString ToHexString( short s )
+    {
+		CString strRes = _T("");
+		strRes.Format(_T("%04X"), s);
+		return strRes;
+    }
+
+	/*========================================================================================================*/
+	
+	AVSINLINE CString ToHexString( unsigned short us )
+    {
+		CString strRes = _T("");
+		strRes.Format(_T("%04X"), us);
+		return strRes;
+    }
+
+	/*========================================================================================================*/
+
+    AVSINLINE CString ToHexString( char c )
+    {
+		CString strRes = _T("");
+		strRes.Format(_T("%02X"), c);
+		return strRes;
+    }
+
+	/*========================================================================================================*/
+	
+	AVSINLINE CString ToHexString( BYTE uc )
+    {
+		CString strRes = _T("");
+		strRes.Format(_T("%02X"), uc);
+		return strRes;
+    }
+
+	/*========================================================================================================*/
+}

DocxRenderer/src/logic/ElementImage.h

@@ -0,0 +1,87 @@
+#pragma once
+#include "Common.h"
+
+namespace NSDocxRenderer
+{
+	static _bstr_t g_bstr_image_1			= L"<w:r><w:pict><v:shape id=\"\" type=\"\" style=\"position:absolute;";
+	static _bstr_t g_bstr_image_2			= L"z-index:-1;mso-position-horizontal-relative:page;mso-position-vertical-relative:page\" filled=\"f\">";
+	static _bstr_t g_bstr_image_3			= L"</v:shape></w:pict></w:r>";
+
+	static CString g_string_image_position			= _T("margin-left:%.2lfmm;margin-top:%.2lfmm;width:%.2lfmm;height:%.2lfmm;");
+	static CString g_string_image_position_rotate	= _T("margin-left:%.2lfmm;margin-top:%.2lfmm;width:%.2lfmm;height:%.2lfmm;rotation:%d;");
+	static CString g_string_image_rid				= _T("<v:imagedata r:id=\"rId%d\" o:title=\"\"/>");
+
+	class CImage : public CBaseItem
+	{
+	public:
+		CString m_strPath;
+		LONG	m_lID;
+
+		double m_dLeft;
+		double m_dTop;
+		double m_dWidth;
+		double m_dHeight;
+
+		double m_dRotate;
+
+	public:
+		CImage()
+		{
+			m_eType		= etImage;
+			m_strPath	= _T("");
+			m_lID		= -1;
+		}
+		CImage(const CImage& oSrc)
+		{
+			*this = oSrc;
+		}
+		CImage(const CImageInfo& oInfo, const CString& strDstMedia)
+		{
+			m_eType		= etImage;
+			m_strPath	= strDstMedia;
+			m_lID		= oInfo.m_lID;
+		}
+		CImage& operator=(const CImage& oSrc)
+		{
+			m_eType		= etImage;
+			m_strPath	= oSrc.m_strPath;
+			m_lID		= oSrc.m_lID;
+
+			m_dLeft		= oSrc.m_dLeft;
+			m_dTop		= oSrc.m_dTop;
+			m_dWidth	= oSrc.m_dWidth;
+			m_dHeight	= oSrc.m_dHeight;
+
+			m_dRotate	= oSrc.m_dRotate;
+
+			return *this;
+		}
+
+		virtual void ToXml(NSDocxRenderer::CStringWriter& oWriter)
+		{
+			oWriter.WriteString(g_bstr_image_1);
+
+			if (0.0 == m_dRotate)
+			{
+				CString strPosition = _T("");
+				strPosition.Format(g_string_image_position, m_dLeft, m_dTop, m_dWidth, m_dHeight);
+				oWriter.WriteString(strPosition);
+			}
+			else
+			{
+				CString strPosition = _T("");
+				strPosition.Format(g_string_image_position_rotate, m_dLeft, m_dTop, m_dWidth, m_dHeight, (int)m_dRotate);
+				oWriter.WriteString(strPosition);
+			}
+
+			oWriter.WriteString(g_bstr_image_2);
+
+			CString strRid = _T("");
+			strRid.Format(g_string_image_rid, 10 + m_lID);
+
+			oWriter.WriteString(strRid);
+
+			oWriter.WriteString(g_bstr_image_3);
+		}
+	};
+}

DocxRenderer/src/logic/ElementParagraph.h

@@ -0,0 +1,669 @@
+#pragma once
+#include "Common.h"
+
+//#include "../../Common/DocxFormat/Source/DocxFormat/Logic/Paragraph.h"
+#include "FontManager.h"
+
+namespace NSDocxRenderer
+{
+	const double c_dMMToDx	 = 72 * 20 / 25.4;
+
+	// <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> T <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> IsBigger, IsBiggerOrEqual
+	template<typename T> 
+	void SortElements(CAtlArray<T*>& oArray)
+	{
+		int nSize = (int)oArray.GetCount();
+
+		// handle 0, 1 and 2 elements
+		if (nSize <= 1)
+			return;
+		if (nSize == 2)
+		{
+			if (oArray[0]->IsBigger(oArray[1]))
+			{
+				T* pTemp	= oArray[0];
+				oArray[0]	= oArray[1];
+				oArray[1]	= pTemp;
+			}
+			return;
+		}
+
+		T* tTemp;
+
+		// arrange elements as tree with greater elements appearing first
+		int nIndex = (nSize >> 1) - 1, nCurr = 0, nNext = 0;
+		int nLast = nSize - 1;
+		int nHalf = nSize >> 1;
+		do
+		{
+			// save element at start of chain
+			tTemp = oArray[nIndex];
+
+			nCurr = nIndex;
+			while (nCurr < nHalf)
+			{
+				nNext = (nCurr << 1) + 1;
+				if (nNext < nLast && (oArray[nNext + 1]->IsBigger(oArray[nNext])))
+					nNext++;
+				if (tTemp->IsBiggerOrEqual(oArray[nNext]))
+					break;
+
+				// promote element in chain
+				oArray[nCurr] = oArray[nNext];
+				nCurr = nNext;
+			}
+
+			// restore element at end of chain
+			oArray[nCurr] = tTemp;
+		}
+		while (nIndex--);
+
+		// sequentially reduce tree size by removing maximum element and rebalancing
+		nIndex = nSize;
+		while (--nIndex)
+		{
+			// save element at start of chain
+			tTemp = oArray[nIndex];
+			oArray[nIndex] = oArray[0];
+
+			nCurr = 0;
+			nLast = nIndex - 1;
+			nHalf = nIndex >> 1;
+			while (nCurr < nHalf)
+			{
+				nNext = (nCurr << 1) + 1;
+				if (nNext < nLast && (oArray[nNext + 1]->IsBigger(oArray[nNext])))
+					nNext++;
+				if (tTemp->IsBiggerOrEqual(oArray[nNext]))
+					break;
+
+				// promote element in chain
+				oArray[nCurr] = oArray[nNext];
+				nCurr = nNext;
+			}
+
+			// restore element at end of chain
+			oArray[nCurr] = tTemp;
+		}
+	}
+
+	static _bstr_t g_bstr_text_run_Start				= L"<w:r><w:rPr>";
+	static _bstr_t g_bstr_text_run_PropEnd				= L"</w:rPr>";
+	static _bstr_t g_bstr_text_run_End					= L"</w:r>";
+
+	static _bstr_t g_bstr_text_run_text1				= L"<w:t xml:space=\"preserve\">";
+	static _bstr_t g_bstr_text_run_text2				= L"</w:t>";
+
+	static _bstr_t g_bstr_text_bold_true				= L"<w:b w:val=\"true\"/>";
+	static _bstr_t g_bstr_text_italic_true				= L"<w:i w:val=\"true\"/>";
+
+	static CString g_string_text_font_size				= _T("<w:sz w:val=\"%d\"/><w:szCs w:val=\"%d\"/>");
+	static CString g_string_text_font_name				= _T("<w:rFonts w:ascii=\"%s\" w:hAnsi=\"%s\" w:cs=\"%s\"/>");
+
+	static CString g_string_text_color					= _T("<w:color w:val=\"%06x\"/>");
+
+	static CString g_string_text_paragraph_noframes		= _T("<w:pPr><w:spacing w:before=\"%d\" w:line=\"%d\" w:lineRule=\"exact\"/><w:ind w:left=\"%d\"/></w:pPr>");
+	static _bstr_t g_bstr_text_par_start				= L"<w:p>";
+	static _bstr_t g_bstr_text_par_end					= L"</w:p>";
+
+	static CString g_string_spacing_character			= _T("<w:spacing w:val=\"%d\"/>");
+	static CString g_string_spacing_character2			= _T("<w:spacing w:val=\"%.3lfpt\"/>");
+
+	static CString g_string_par_props_mode2				= _T("<w:pPr><w:framePr w:hAnchor=\"page\" w:vAnchor=\"page\" w:x=\"%d\" w:y=\"%d\"/></w:pPr>");
+
+	AVSINLINE void DeleteSpaces(CString& strText)
+	{
+		int nLen   = strText.GetLength();
+		int nStart = 0;
+
+		while ((nStart < nLen) && (TCHAR(' ') == strText[nStart]))
+			++nStart;
+
+		if (nStart == nLen)
+		{
+			strText = _T("");
+			return;
+		}
+		
+		int nEnd = nLen - 1;
+		while ((nEnd > nStart) && (TCHAR(' ') == strText[nEnd]))
+			--nEnd;
+
+		strText = strText.Mid(nStart, nEnd - nStart + 1);
+	}
+
+	class CContText
+	{
+	public:
+		NSStructures::CFont		m_oFont;
+		NSStructures::CBrush	m_oBrush;
+
+		CString m_strPickFontName;
+		LONG	m_lPickFontStyle;
+
+		CString m_strText;
+		CString m_strGidText;
+
+		double m_dX;
+		double m_dY;
+		double m_dWidth;
+		double m_dHeight;
+
+		double m_dWidthWithoutSpaces;
+		double m_dLeftWithoutSpaces;
+
+		double m_dPosition;
+		double m_dSpaceWidthMM;
+
+		double m_dCalculateWidth;
+
+	public:
+		CContText()
+		{
+			m_strText		= _T("");
+			m_strGidText	= _T("");
+
+			m_strPickFontName	= _T("");
+			m_lPickFontStyle	= 0;
+
+			m_dX			= 0;
+			m_dY			= 0;
+			m_dWidth		= 0;
+			m_dHeight		= 0;
+
+			m_dWidthWithoutSpaces	= 0;
+			m_dLeftWithoutSpaces	= 0;
+
+			m_dPosition		= 0;
+			m_dSpaceWidthMM	= 0;
+
+			m_dCalculateWidth = 0;
+		}
+		~CContText()
+		{
+		}
+
+		AVSINLINE void Clear()
+		{
+		}
+
+		CContText(const CContText& oSrc)
+		{
+			*this = oSrc;
+		}
+		CContText& operator=(const CContText& oSrc)
+		{
+			m_oFont		= oSrc.m_oFont;
+			m_oBrush	= oSrc.m_oBrush;
+
+			m_strText	 = oSrc.m_strText;
+			m_strGidText = oSrc.m_strGidText;
+
+			m_strPickFontName	= oSrc.m_strPickFontName;
+			m_lPickFontStyle	= oSrc.m_lPickFontStyle;
+
+			m_dX		= oSrc.m_dX;
+			m_dY		= oSrc.m_dY;
+			m_dWidth	= oSrc.m_dWidth;
+			m_dHeight	= oSrc.m_dHeight;
+
+			m_dWidthWithoutSpaces	= oSrc.m_dWidthWithoutSpaces;
+			m_dLeftWithoutSpaces	= oSrc.m_dLeftWithoutSpaces;
+
+			m_dPosition = oSrc.m_dPosition;
+			m_dSpaceWidthMM = oSrc.m_dSpaceWidthMM;
+
+			m_dCalculateWidth = oSrc.m_dCalculateWidth;
+
+			return *this;
+		}
+
+		AVSINLINE bool IsBigger(const CContText* oSrc)
+		{
+			return (m_dX > oSrc->m_dX) ? true : false;
+		}
+		AVSINLINE bool IsBiggerOrEqual(const CContText* oSrc)
+		{
+			return (m_dX >= oSrc->m_dX) ? true : false;
+		}
+
+		AVSINLINE void Write(NSDocxRenderer::CStringWriter& oWriter, CFontManagerLight* pManagerLight, bool bIsAddSpace = false)
+		{
+			oWriter.WriteString(g_bstr_text_run_Start);
+
+			if (m_dWidth != m_dWidthWithoutSpaces)
+			{
+				DeleteSpaces(m_strText);
+				m_dWidth = m_dWidthWithoutSpaces;
+			}
+			
+			if (_T("") == m_strPickFontName)
+			{
+				if (m_oFont.Bold)
+					oWriter.WriteString(g_bstr_text_bold_true);
+				if (m_oFont.Italic)
+					oWriter.WriteString(g_bstr_text_italic_true);
+
+				if (bIsAddSpace)
+				{
+					m_dWidth  += m_dSpaceWidthMM;
+					m_strText += _T(" ");
+				}
+			}
+			else
+			{
+				if (0x01 == (0x01 & m_lPickFontStyle))
+					oWriter.WriteString(g_bstr_text_bold_true);
+				if (0x02 == (0x02 & m_lPickFontStyle))
+					oWriter.WriteString(g_bstr_text_italic_true);
+
+				if (bIsAddSpace)
+				{
+					m_dWidth  += pManagerLight->GetSpaceWidth();
+					m_strText += _T(" ");
+				}
+
+				// <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>...
+				double ___dSize = (double)((LONG)(m_oFont.Size * 2)) / 2;
+				pManagerLight->LoadFont(m_strPickFontName, m_lPickFontStyle, ___dSize, FALSE);
+				double dWidth = pManagerLight->MeasureStringWidth(m_strText);
+
+				if (fabs(dWidth - m_dWidth) > 2)
+				{
+					double dSpacing = (m_dWidth - dWidth) / (m_strText.GetLength() + 1);
+					dSpacing *= c_dMMToDx;
+
+					CString strSpacing = _T("");
+					strSpacing.Format(g_string_spacing_character, (LONG)dSpacing);
+					oWriter.WriteString(strSpacing);
+				}
+			}
+
+			CString strSize = _T("");
+			LONG lSize = (LONG)(2 * m_oFont.Size);
+			strSize.Format(g_string_text_font_size, lSize, lSize);
+			oWriter.WriteString(strSize);
+
+			CString strName = _T("");
+
+			if (_T("") == m_strPickFontName)
+				strName.Format(g_string_text_font_name, m_oFont.Name, m_oFont.Name, m_oFont.Name);
+			else
+				strName.Format(g_string_text_font_name, m_strPickFontName, m_strPickFontName, m_strPickFontName);
+
+			oWriter.WriteString(strName);
+
+			CString strColor = _T("");
+			strColor.Format(g_string_text_color, ConvertColor(m_oBrush.Color1));
+			oWriter.WriteString(strColor);
+
+			oWriter.WriteString(g_bstr_text_run_PropEnd);
+
+			oWriter.WriteString(g_bstr_text_run_text1);
+
+			CString strText = m_strText;
+			CorrectString(strText);
+
+			oWriter.WriteString(strText);
+			oWriter.WriteString(g_bstr_text_run_text2);
+
+			oWriter.WriteString(g_bstr_text_run_End);
+		}
+
+		AVSINLINE void WriteTo(double dSpacingMM, NSDocxRenderer::CStringWriter& oWriter, CFontManagerLight* pManagerLight)
+		{
+			oWriter.WriteString(g_bstr_text_run_Start);
+
+			double dSpaceMMSize = m_dSpaceWidthMM;
+			if (_T("") == m_strPickFontName)
+			{
+				if (m_oFont.Bold)
+					oWriter.WriteString(g_bstr_text_bold_true);
+				if (m_oFont.Italic)
+					oWriter.WriteString(g_bstr_text_italic_true);
+			}
+			else
+			{
+				if (0x01 == (0x01 & m_lPickFontStyle))
+					oWriter.WriteString(g_bstr_text_bold_true);
+				if (0x02 == (0x02 & m_lPickFontStyle))
+					oWriter.WriteString(g_bstr_text_italic_true);
+
+				dSpaceMMSize = pManagerLight->GetSpaceWidth();
+			}
+
+			CString strSize = _T("");
+			LONG lSize = (LONG)(2 * m_oFont.Size);
+			strSize.Format(g_string_text_font_size, lSize, lSize);
+			oWriter.WriteString(strSize);
+
+			CString strName = _T("");
+
+			if (_T("") == m_strPickFontName)
+				strName.Format(g_string_text_font_name, m_oFont.Name, m_oFont.Name, m_oFont.Name);
+			else
+				strName.Format(g_string_text_font_name, m_strPickFontName, m_strPickFontName, m_strPickFontName);
+
+			oWriter.WriteString(strName);
+
+			CString strColor = _T("");
+			strColor.Format(g_string_text_color, ConvertColor(m_oBrush.Color1));
+			oWriter.WriteString(strColor);
+
+			LONG lSpacing = (LONG)((dSpacingMM - dSpaceMMSize) * c_dMMToDx);
+			CString strSpacing = _T("");
+			strSpacing.Format(g_string_spacing_character, lSpacing);
+			oWriter.WriteString(strSpacing);
+
+			oWriter.WriteString(g_bstr_text_run_PropEnd);
+
+			oWriter.WriteString(g_bstr_text_run_text1);
+
+			CString strText = _T(" ");
+			oWriter.WriteString(strText);
+			oWriter.WriteString(g_bstr_text_run_text2);
+
+			oWriter.WriteString(g_bstr_text_run_End);
+		}
+	};
+	
+	class CTextLine
+	{
+	public:
+		CAtlArray<CContText*> m_arConts;
+
+		double m_dBaselinePos;
+		double m_dBaselineOffset;
+
+		double m_dX;
+		double m_dY;
+		double m_dWidth;
+		double m_dHeight;
+
+	public:
+		CTextLine() : m_arConts()
+		{
+			m_dBaselinePos	= 0;
+			
+			m_dX			= 0;
+			m_dY			= 0;
+			m_dWidth		= 0;
+			m_dHeight		= 0;
+		}
+		AVSINLINE void Clear()
+		{
+			size_t nCount = m_arConts.GetCount();
+			for (size_t i = 0; i < nCount; ++i)
+			{
+				CContText* pText = m_arConts[i];
+				RELEASEOBJECT(pText);
+			}
+			m_arConts.RemoveAll();
+		}
+
+		~CTextLine()
+		{
+			Clear();
+		}
+
+		CTextLine(const CTextLine& oSrc)
+		{
+			*this = oSrc;
+		}
+		CTextLine& operator=(const CTextLine& oSrc)
+		{
+			Clear();
+			size_t nCount = oSrc.m_arConts.GetCount();
+			for (size_t i = 0; i < nCount; ++i)
+			{
+				m_arConts.Add(new CContText(*oSrc.m_arConts[i]));
+			}
+
+			m_dBaselinePos	= oSrc.m_dBaselinePos;
+			m_dX			= oSrc.m_dX;
+			m_dY			= oSrc.m_dY;
+			m_dWidth		= oSrc.m_dWidth;
+			m_dHeight		= oSrc.m_dHeight;
+		}
+
+		AVSINLINE void AddCont(CContText* pCont, double dBaselineOffset)
+		{
+			if (0 == m_arConts.GetCount())
+				m_dBaselineOffset = dBaselineOffset;
+
+			if ( ( pCont->m_dX > 0 ) && ( ( m_dX == 0 ) || ( pCont->m_dX < m_dX ) ) )
+				m_dX = pCont->m_dX;
+
+			if (m_dHeight < pCont->m_dHeight)
+				m_dHeight = pCont->m_dHeight;
+
+			m_arConts.Add(pCont);
+		}
+
+		AVSINLINE bool IsBigger(const CTextLine* oSrc)
+		{
+			return (m_dBaselinePos > oSrc->m_dBaselinePos) ? true : false;
+		}
+		AVSINLINE bool IsBiggerOrEqual(const CTextLine* oSrc)
+		{
+			return (m_dBaselinePos >= oSrc->m_dBaselinePos) ? true : false;
+		}
+
+		AVSINLINE void SortConts()
+		{
+			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> m_dX
+			SortElements(m_arConts);
+		}
+
+		void Merge(CTextLine* pTextLine)
+		{
+			size_t nCount = pTextLine->m_arConts.GetCount();
+			if (0 != nCount)
+			{
+				if (pTextLine->m_dX < m_dX)
+				{
+					m_dX = pTextLine->m_dX;
+				}
+				if (pTextLine->m_dBaselinePos < m_dBaselinePos)
+				{
+					m_dHeight = (m_dBaselinePos - pTextLine->m_dBaselinePos + pTextLine->m_dHeight);
+				}
+				else
+				{
+					m_dHeight = (pTextLine->m_dBaselinePos - m_dBaselinePos + m_dHeight);
+				}
+
+				double dSubPosition = m_dBaselinePos - pTextLine->m_dBaselinePos;
+				
+				for (size_t i = 0; i < nCount; ++i)
+				{
+					pTextLine->m_arConts[i]->m_dPosition = dSubPosition;
+					m_arConts.Add(pTextLine->m_arConts[i]);
+				}
+			}			
+		}
+
+		void ToXml(NSDocxRenderer::CStringWriter& oWriter, CFontManagerLight* pManagerLight)
+		{
+			size_t nCountConts = m_arConts.GetCount();
+
+			if (0 == nCountConts)
+				return;
+
+			CContText* pPrev = m_arConts[0];
+			double dDelta = 0;
+
+			for (size_t i = 1; i < nCountConts; ++i)
+			{
+				CContText* pCurrent = m_arConts[i];
+
+				if (0 == pCurrent->m_dWidthWithoutSpaces)
+					continue;
+
+				dDelta = pCurrent->m_dLeftWithoutSpaces - (pPrev->m_dLeftWithoutSpaces + pPrev->m_dWidthWithoutSpaces);
+
+				if (dDelta < 0.5)
+				{
+					// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> (font/brush)
+					pPrev->Write(oWriter, pManagerLight);
+					pPrev  = pCurrent;
+				}
+				//else if (dDelta < 2 * pPrev->m_dSpaceWidthMM)
+				//{
+				//	// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>-<2D><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
+				//	pPrev->Write(oWriter, pManagerLight, true);
+				//	pPrev = pCurrent;
+				//}
+				else
+				{
+					// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>. <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+					pPrev->Write(oWriter, pManagerLight);
+					pPrev->WriteTo(dDelta, oWriter, pManagerLight);
+					pPrev = pCurrent;
+				}
+			}
+
+			pPrev->Write(oWriter, pManagerLight);
+		}
+	};
+
+	class CParagraph : public CBaseItem
+	{
+	public: 
+		// text frame properties
+		bool		m_bIsTextFrameProperties;
+
+		// geometry paragraph
+		double		m_dLeft;
+		double		m_dTop;
+		double		m_dWidth;
+		double		m_dHeight;
+
+		CFontManagerLight* m_pManagerLight;
+
+		double		m_dSpaceBefore;
+		TextAssociationType m_eTextAssociationType;
+
+		CAtlArray<CTextLine*> m_arLines;
+
+	public:
+		CParagraph(const TextAssociationType& eType) : m_arLines()
+		{
+			m_eType = etParagraph;
+
+			m_bIsTextFrameProperties	= false;
+
+			m_dLeft		= 0.0;
+			m_dTop		= 0.0;
+			m_dWidth	= 0.0;
+			m_dHeight	= 0.0;
+
+			m_dSpaceBefore = 0.0;
+
+			m_pManagerLight = NULL;
+			m_eTextAssociationType = eType;
+		}
+		CParagraph(const CParagraph& oSrc)
+		{
+			*this = oSrc;
+		}
+		~CParagraph()
+		{
+			Clear();
+		}
+
+		AVSINLINE void Clear()
+		{
+			size_t nCount = m_arLines.GetCount();
+			for (size_t i = 0; i < nCount; ++i)
+			{
+				CTextLine* pText = m_arLines[i];
+				RELEASEOBJECT(pText);
+			}
+			m_arLines.RemoveAll();
+
+			m_pManagerLight = NULL;
+		}
+
+		CParagraph& operator=(const CParagraph& oSrc)
+		{
+			m_eType = etParagraph;
+
+			m_bIsTextFrameProperties	= oSrc.m_bIsTextFrameProperties;
+
+			m_dLeft		= oSrc.m_dLeft;
+			m_dTop		= oSrc.m_dTop;
+			m_dWidth	= oSrc.m_dWidth;
+			m_dHeight	= oSrc.m_dHeight;
+
+			m_dSpaceBefore	= oSrc.m_dSpaceBefore;
+
+			m_eTextAssociationType		= oSrc.m_eTextAssociationType;
+
+			Clear();
+			size_t nCount = oSrc.m_arLines.GetCount();
+			for (size_t i = 0; i < nCount; ++i)
+			{
+				m_arLines.Add(new CTextLine(*oSrc.m_arLines[i]));
+			}
+
+			m_pManagerLight = oSrc.m_pManagerLight;
+
+			return *this;
+		}
+
+		virtual void ToXml(NSDocxRenderer::CStringWriter& oWriter)
+		{
+			oWriter.WriteString(g_bstr_text_par_start);
+
+			switch (m_eTextAssociationType)
+			{
+			case TextAssociationTypeDefault:
+			case TextAssociationTypeLine:
+				{
+					LONG lX		= (LONG)(m_dLeft * c_dMMToDx);
+					LONG lY		= (LONG)(m_dTop * c_dMMToDx);
+
+					CString strTextProps = _T("");
+					strTextProps.Format(g_string_par_props_mode2, lX, lY);
+					oWriter.WriteString(strTextProps);
+					break;
+				}
+			case TextAssociationTypeBlock:
+				{
+					LONG lX		= (LONG)(m_dLeft * c_dMMToDx);
+					LONG lY		= (LONG)(m_dTop * c_dMMToDx);
+
+					CString strTextProps = _T("");
+					strTextProps.Format(g_string_par_props_mode2, lX, lY);
+					oWriter.WriteString(strTextProps);
+					break;
+				}
+			case TextAssociationTypeNoFrames:
+				{
+					LONG lSpaceBefore	= (LONG)(m_dSpaceBefore * c_dMMToDx);
+					LONG lHeight		= (LONG)(m_dHeight * c_dMMToDx);
+					LONG lLeft			= (LONG)(m_dLeft * c_dMMToDx);
+					
+					CString strParProperties = _T("");
+					strParProperties.Format(g_string_text_paragraph_noframes, lSpaceBefore, lHeight, lLeft);
+
+					oWriter.WriteString(strParProperties);
+					break;
+				}
+			default:
+				break;
+			}
+
+			size_t nCount = m_arLines.GetCount();
+			for (size_t i = 0; i < nCount; ++i)
+			{
+				CTextLine* pTextLine = m_arLines[i];
+				pTextLine->SortConts();
+				pTextLine->ToXml(oWriter, m_pManagerLight);
+			}
+
+			oWriter.WriteString(g_bstr_text_par_end);
+		}
+	};
+}

DocxRenderer/src/logic/ElementShape.h

@@ -0,0 +1,385 @@
+#pragma once
+#include "Common.h"
+
+namespace NSDocxRenderer
+{
+	static _bstr_t g_vml_bstr_ClosePath			= L"x";
+	static _bstr_t g_vml_bstr_EndPath			= L"e";
+	static _bstr_t g_vml_bstr_NoFill			= L"nf";
+	static _bstr_t g_vml_bstr_NoStroke			= L"ns";
+	static CString g_vml_string_MoveTo			= _T("m%d,%d");
+	static CString g_vml_string_LineTo			= _T("l%d,%d");
+	static CString g_vml_string_CurveTo			= _T("c%d,%d %d,%d %d,%d");
+
+	static _bstr_t g_bstr_shape1				= L"<w:r><w:pict><v:shape id=\"\" o:spid=\"\" style=\"position:absolute;";
+	static _bstr_t g_bstr_shape2				= L"z-index:-1;mso-position-horizontal-relative:page;mso-position-vertical-relative:page;\"";
+	static CString g_string_shape_position		= _T("margin-left:%.2lfmm;margin-top:%.2lfmm;width:%.2lfmm;height:%.2lfmm;");
+
+	static CString g_string_shape_geometry		= _T(" coordsize=\"%d,%d\" path=\"%s\" fillcolor=\"#%06x\" strokecolor=\"#%06x\" strokeweight=\"%.2lfmm\">");
+
+	static CString g_string_tx_rid				= _T("<v:imagedata r:id=\"rId%d\" o:title=\"\"/>");
+	static CString g_string_fill_opacity		= _T("<v:fill opacity=\"%.2lf\"/>");
+	static CString g_string_stroke_opacity		= _T("<v:stroke opacity=\"%.2lf\"/>");
+
+	static _bstr_t g_bstr_shape3				= L"<w10:wrap anchorx=\"page\" anchory=\"page\"/></v:shape></w:pict></w:r>";
+
+	class CVectorGraphics
+	{
+	public:
+		double*	m_pData;
+		size_t	m_lSize;
+
+		double*	m_pDataCur;
+		size_t	m_lSizeCur;
+
+	public:
+		double m_dLeft;
+		double m_dTop;
+		double m_dRight;
+		double m_dBottom;
+
+	public:
+		CVectorGraphics()
+		{
+			m_pData = NULL;
+			m_lSize = 0;
+
+			m_pDataCur	= m_pData;
+			m_lSizeCur	= m_lSize;
+
+			End();
+		}
+		~CVectorGraphics()
+		{
+			RELEASEMEM(m_pData);
+		}
+
+		AVSINLINE void AddSize(size_t nSize)
+		{
+			if (NULL == m_pData)
+			{
+				m_lSize = max(nSize, 500);				
+				m_pData = (double*)malloc(m_lSize * sizeof(double));
+				
+				m_lSizeCur = 0;
+				m_pDataCur = m_pData;
+				return;
+			}
+
+			if ((m_lSizeCur + nSize) > m_lSize)
+			{
+				while ((m_lSizeCur + nSize) > m_lSize)
+				{
+					m_lSize *= 2;
+				}
+
+				double* pRealloc = (double*)realloc(m_pData, m_lSize * sizeof(double));
+				if (NULL != pRealloc)
+				{
+					// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+					m_pData		= pRealloc;
+					m_pDataCur	= m_pData + m_lSizeCur;
+				}
+				else
+				{
+					double* pMalloc = (double*)malloc(m_lSize * sizeof(double));
+					memcpy(pMalloc, m_pData, m_lSizeCur * sizeof(double));
+
+					free(m_pData);
+					m_pData		= pMalloc;
+					m_pDataCur	= m_pData + m_lSizeCur;
+				}
+			}
+		}
+
+	public:
+		AVSINLINE void MoveTo(const double& x1, const double& y1)
+		{
+			AddSize(3);
+			*m_pDataCur = 0;	++m_pDataCur;
+
+			*m_pDataCur = x1;	++m_pDataCur;
+			*m_pDataCur = y1;	++m_pDataCur;
+
+			m_lSizeCur += 3;
+
+			CheckPoint(x1, y1);			
+		}
+		AVSINLINE void LineTo(const double& x1, const double& y1)
+		{
+			AddSize(3);
+			*m_pDataCur = 1;	++m_pDataCur;
+
+			*m_pDataCur = x1;	++m_pDataCur;
+			*m_pDataCur = y1;	++m_pDataCur;
+
+			m_lSizeCur += 3;
+
+			CheckPoint(x1, y1);
+		}
+		AVSINLINE void CurveTo(const double& x1, const double& y1, const double& x2, const double& y2, const double& x3, const double& y3)
+		{
+			AddSize(7);
+			*m_pDataCur = 2;	++m_pDataCur;
+
+			*m_pDataCur = x1;	++m_pDataCur;
+			*m_pDataCur = y1;	++m_pDataCur;
+			*m_pDataCur = x2;	++m_pDataCur;
+			*m_pDataCur = y2;	++m_pDataCur;
+			*m_pDataCur = x3;	++m_pDataCur;
+			*m_pDataCur = y3;	++m_pDataCur;
+
+			m_lSizeCur += 7;
+
+			CheckPoint(x1, y1);
+			CheckPoint(x2, y2);
+			CheckPoint(x3, y3);
+		}
+		AVSINLINE void Close()
+		{
+			AddSize(1);
+			*m_pDataCur = 3;	++m_pDataCur;
+
+			m_lSizeCur += 1;
+		}
+
+		AVSINLINE size_t GetCurSize()
+		{
+			return m_lSizeCur;
+		}
+
+		AVSINLINE void Clear()
+		{
+			RELEASEMEM(m_pData);
+			
+			m_pData = NULL;
+			m_lSize = 0;
+
+			m_pDataCur	= m_pData;
+			m_lSizeCur	= 0;
+		}
+		AVSINLINE void ClearNoAttack()
+		{
+			m_pDataCur	= m_pData;
+			m_lSizeCur	= 0;
+		}
+
+		AVSINLINE void End()
+		{
+			ClearNoAttack();
+
+			m_dLeft		= 0xFFFFFF;
+			m_dTop		= 0xFFFFFF;
+			m_dRight	= -0xFFFFFF;
+			m_dBottom	= -0xFFFFFF;
+		}
+
+		AVSINLINE void CheckPoint(const double& x, const double& y)
+		{
+			if (m_dLeft > x)
+				m_dLeft = x;
+			if (m_dRight < x)
+				m_dRight = x;
+			if (m_dTop > y)
+				m_dTop = y;
+			if (m_dBottom < y)
+				m_dBottom = y;
+		}
+	};
+
+	class CShape : public CBaseItem
+	{
+	public:
+		CString m_strPath;
+		NSStructures::CBrush	m_oBrush;
+		NSStructures::CPen		m_oPen;
+
+		double m_dLeft;
+		double m_dTop;
+		double m_dWidth;
+		double m_dHeight;
+		
+		bool m_bIsFill;
+		bool m_bIsStroke;
+
+		LONG m_lCoordSizeX;
+		LONG m_lCoordSizeY;
+
+		LONG m_lTxId;
+
+	public:
+		CShape()
+		{
+			m_dLeft		= 0;
+			m_dTop		= 0;
+			m_dWidth	= 0;
+			m_dHeight	= 0;
+			
+			m_bIsFill	= false;
+			m_bIsStroke	= false;
+
+			m_lCoordSizeX	= 100000;
+			m_lCoordSizeY	= 100000;
+
+			m_lTxId			= -1;
+		}
+
+		CShape(const CShape& oSrc)
+		{
+			*this = oSrc;
+		}
+
+		CShape& operator=(const CShape& oSrc)
+		{
+			m_eType		= etShape;
+			m_strPath	= oSrc.m_strPath;
+
+			m_oBrush	= oSrc.m_oBrush;
+			m_oPen		= oSrc.m_oPen;
+
+			m_dLeft		= oSrc.m_dLeft;
+			m_dTop		= oSrc.m_dTop;
+			m_dWidth	= oSrc.m_dWidth;
+			m_dHeight	= oSrc.m_dHeight;
+
+			m_bIsFill	= oSrc.m_bIsFill;
+			m_bIsStroke	= oSrc.m_bIsStroke;
+
+			m_lTxId		= oSrc.m_lTxId;
+
+			return *this;
+		}
+
+		void CreateFromVectorData(CVectorGraphics* pVector, NSDocxRenderer::CStringWriter& oWriter, const LONG& lCoordSize, LONG lType)
+		{
+			m_dLeft		= pVector->m_dLeft;
+			m_dTop		= pVector->m_dTop;
+			m_dWidth	= pVector->m_dRight - m_dLeft;
+			m_dHeight	= pVector->m_dBottom - m_dTop;
+
+			m_lCoordSizeX = lCoordSize;
+			m_lCoordSizeY = lCoordSize;
+			
+			size_t nCount = pVector->GetCurSize();
+			double* pData = pVector->m_pData;
+			while (nCount > 0)
+			{
+				double dType = *pData++;
+				if (0 == dType)
+				{
+					LONG lX = (LONG)((*pData - m_dLeft) * lCoordSize / m_dWidth);
+					++pData;
+					LONG lY = (LONG)((*pData - m_dTop) * lCoordSize / m_dHeight);
+					++pData;
+
+					CString strPath = _T("");
+					strPath.Format(g_vml_string_MoveTo, lX, lY);
+
+					oWriter.WriteString(strPath);
+
+					nCount -= 3;
+				}
+				else if (1 == dType)
+				{
+					LONG lX = (LONG)((*pData - m_dLeft) * lCoordSize / m_dWidth);
+					++pData;
+					LONG lY = (LONG)((*pData - m_dTop) * lCoordSize / m_dHeight);
+					++pData;
+
+					CString strPath = _T("");
+					strPath.Format(g_vml_string_LineTo, lX, lY);
+
+					oWriter.WriteString(strPath);
+
+					nCount -= 3;
+				}
+				else if (2 == dType)
+				{
+					LONG lX1 = (LONG)((*pData - m_dLeft) * lCoordSize / m_dWidth);
+					++pData;
+					LONG lY1 = (LONG)((*pData - m_dTop) * lCoordSize / m_dHeight);
+					++pData;
+
+					LONG lX2 = (LONG)((*pData - m_dLeft) * lCoordSize / m_dWidth);
+					++pData;
+					LONG lY2 = (LONG)((*pData - m_dTop) * lCoordSize / m_dHeight);
+					++pData;
+
+					LONG lX3 = (LONG)((*pData - m_dLeft) * lCoordSize / m_dWidth);
+					++pData;
+					LONG lY3 = (LONG)((*pData - m_dTop) * lCoordSize / m_dHeight);
+					++pData;
+
+					CString strPath = _T("");
+					strPath.Format(g_vml_string_CurveTo, lX1, lY1, lX2, lY2, lX3, lY3);
+
+					oWriter.WriteString(strPath);
+
+					nCount -= 7;
+				}
+				else
+				{
+					oWriter.WriteString(g_vml_bstr_ClosePath);
+					--nCount;
+				}
+			}
+
+			if (0x00 == (lType & 0x01))
+				oWriter.WriteString(g_vml_bstr_NoStroke);
+			if (0x00 == (lType >> 8))
+				oWriter.WriteString(g_vml_bstr_NoFill);
+
+			oWriter.WriteString(g_vml_bstr_EndPath);
+
+			m_strPath = oWriter.GetData();
+			oWriter.ClearNoAttack();
+		}
+
+		virtual void ToXml(NSDocxRenderer::CStringWriter& oWriter)
+		{
+			oWriter.WriteString(g_bstr_shape1);
+
+			CString strPosition = _T("");
+			strPosition.Format(g_string_shape_position, m_dLeft, m_dTop, m_dWidth, m_dHeight);
+			oWriter.WriteString(strPosition);
+
+			oWriter.WriteString(strPosition);
+			oWriter.WriteString(g_bstr_shape2);
+
+			CString strStyle = _T("");
+			strStyle.Format(g_string_shape_geometry, m_lCoordSizeX, m_lCoordSizeY, m_strPath, ConvertColor(m_oBrush.Color1), ConvertColor(m_oPen.Color), m_oPen.Size);
+			oWriter.WriteString(strStyle);
+
+			if (c_BrushTypeTexture == m_oBrush.Type)
+			{
+				CString strImage = _T("");
+				strImage.Format(g_string_tx_rid, 10 + m_lTxId);
+				oWriter.WriteString(strImage);
+
+				if (0xFF != m_oBrush.TextureAlpha)
+				{
+					CString strFillOpacity = _T("");
+					strFillOpacity.Format(g_string_fill_opacity, (double)m_oBrush.TextureAlpha / 255.0);
+					oWriter.WriteString(strFillOpacity);
+				}
+			}
+			else
+			{
+				if (0xFF != m_oBrush.Alpha1)
+				{
+					CString strFillOpacity = _T("");
+					strFillOpacity.Format(g_string_fill_opacity, (double)m_oBrush.Alpha1 / 255.0);
+					oWriter.WriteString(strFillOpacity);
+				}
+				if (0xFF != m_oPen.Alpha)
+				{
+					CString strPenOpacity = _T("");
+					strPenOpacity.Format(g_string_stroke_opacity, (double)m_oPen.Alpha / 255.0);
+					oWriter.WriteString(strPenOpacity);
+				}
+			}
+
+			oWriter.WriteString(g_bstr_shape3);
+		}
+	};
+}

DocxRenderer/src/logic/FontManager.h

@@ -0,0 +1,354 @@
+#pragma once
+#include "Common.h"
+#include "FontManagerBase.h"
+
+namespace NSDocxRenderer
+{
+	using namespace NSFontManager;
+
+	const double c_dDpiX		= 72.0;
+	const double c_dDpiY		= 72.0;
+
+	enum TextAssociationType
+	{
+		TextAssociationTypeDefault	= 0,
+		TextAssociationTypeLine		= 1,
+		TextAssociationTypeNoFrames	= 2,
+		TextAssociationTypeBlock	= 3
+	};
+
+	class CFontTableEntry
+	{
+	public:
+		CString							m_strFamilyName;
+		CString							m_strPANOSE;
+		LONG							m_lStyle;
+		CAtlArray<DWORD>				m_arSignature;
+		bool							m_bIsFixedWidth;
+
+	public:
+		CFontTableEntry() : m_arSignature()
+		{
+			m_strFamilyName		= _T("");
+			m_strPANOSE			= _T("");
+			m_lStyle			= 0;
+			m_bIsFixedWidth		= false;
+		}
+		~CFontTableEntry()
+		{
+		}
+		CFontTableEntry(const CFontTableEntry& oSrc)
+		{
+			*this = oSrc;
+		}
+		CFontTableEntry& operator =(const CFontTableEntry& oSrc)
+		{
+			m_strFamilyName	= oSrc.m_strFamilyName;
+			m_strPANOSE		= oSrc.m_strPANOSE;
+			m_lStyle		= oSrc.m_lStyle;
+			m_arSignature.Copy(oSrc.m_arSignature);
+			m_bIsFixedWidth	= oSrc.m_bIsFixedWidth;
+
+			return *this;
+		}
+	};
+
+	class CFontTable
+	{
+	public:
+		CAtlMap<CString, CFontTableEntry> m_mapTable;
+
+	public:
+		CFontTable() : m_mapTable()
+		{
+		}
+	};
+
+	class CFontManager : public CFontManagerBase
+	{
+	public:
+		NSStructures::CFont*			m_pFont;
+		NSDocxRenderer::CMatrix*		m_pTransform;
+		double							m_dSpaceWidthMM;
+
+	public:
+		CFontTable						m_oFontTable;
+
+	public:
+		CFontManager() : m_pFont(NULL), CFontManagerBase()
+		{
+			m_pTransform = NULL;
+
+			m_dSpaceWidthMM = 0;
+		}
+		virtual ~CFontManager()
+		{
+		}
+
+	public:
+		AVSINLINE void Init()
+		{
+			m_oFontTable.m_mapTable.RemoveAll();
+		}
+		AVSINLINE void AddFontToMap()
+		{
+			CAtlMap<CString, CFontTableEntry>::CPair* pPair = m_oFontTable.m_mapTable.Lookup(m_oFont.m_strFamilyName);
+			if (NULL == pPair)
+			{
+				CFontTableEntry oEntry;
+				oEntry.m_strFamilyName	= m_oFont.m_strFamilyName;
+				oEntry.m_strPANOSE		= m_oFont.m_strPANOSE;
+				oEntry.m_lStyle			= m_oFont.m_lStyle;
+				oEntry.m_bIsFixedWidth	= m_oFont.m_bIsFixedWidth;
+				oEntry.m_arSignature.Copy(m_oFont.m_arSignature);
+
+				m_oFontTable.m_mapTable.SetAt(m_oFont.m_strFamilyName, oEntry);
+			}
+		}
+
+	public:
+		virtual void LoadFont(long lFaceIndex = 0, bool bNeedAddToMap = true)
+		{
+			if (NULL == m_pManager)
+				return;
+
+			double dSize = m_pFont->Size;
+			double dSizeFont = dSize * ((m_pTransform->m_agg_mtx.sx + m_pTransform->m_agg_mtx.sy) / 2);
+
+			double dPix = m_pFont->CharSpace / c_dPixToMM;
+
+			m_pFont->Size = dSizeFont;
+
+			if (m_pFont->IsEqual2(&m_oFont.m_oFont))
+			{
+				m_pFont->Size = dSize;
+				m_pManager->SetCharSpacing(dPix);
+				m_pManager->SetStringGID(m_oFont.m_oFont.StringGID);
+				return;
+			}
+
+			m_oFont.m_oFont	= *m_pFont;
+			m_pFont->Size = dSize;
+
+			bool bIsPath = false;
+
+			if (_T("") == m_pFont->Path)
+			{
+				CFontManagerBase::LoadFontByName(m_oFont.m_oFont.Name, m_oFont.m_oFont.Size, m_oFont.m_oFont.GetStyle(), c_dDpiX, c_dDpiY);
+			}
+			else
+			{
+				CFontManagerBase::LoadFontByFile(m_oFont.m_oFont.Path, m_oFont.m_oFont.Size, c_dDpiX, c_dDpiY, lFaceIndex);
+
+				m_pFont->SetStyle(m_oFont.m_lStyle);
+				m_oFont.m_oFont.SetStyle(m_oFont.m_lStyle);
+
+				bIsPath = true;
+			}
+
+			long lGid = 0;
+			m_pManager->GetStringGID(&lGid);
+			m_pManager->SetStringGID(FALSE);
+			
+			m_pManager->LoadString(L" ", 0, 0);
+			float _x = 0;
+			float _y = 0;
+			float _w = 0;
+			float _h = 0;
+
+			m_pManager->MeasureString2(&_x, &_y, &_w, &_h);
+
+			m_dSpaceWidthMM = (double)_w * c_dPixToMM;
+			if (0 >= m_dSpaceWidthMM)
+			{
+				m_dSpaceWidthMM = 1.0;
+			}
+
+			m_pManager->SetStringGID(lGid);
+
+			LoadFontMetrics();
+			LoadFontParams(bIsPath);
+
+			if (bNeedAddToMap)
+				AddFontToMap();
+		}
+		
+		AVSINLINE void MeasureString(const CString& strText, double x, double y, double& dBoxX, double& dBoxY, double& dBoxWidth, double& dBoxHeight, MeasureType measureType)
+		{
+			BSTR bsText = strText.AllocSysString();
+			MeasureString(bsText, x, y, dBoxX, dBoxY, dBoxWidth, dBoxHeight, measureType);
+			SysFreeString(bsText);
+		}
+		AVSINLINE void MeasureStringUNICODE(const CString& strText, double x, double y, double& dBoxX, double& dBoxY, double& dBoxWidth, double& dBoxHeight, MeasureType measureType)
+		{
+			m_pManager->SetStringGID(FALSE);
+			MeasureString(strText, x, y, dBoxX, dBoxY, dBoxWidth, dBoxHeight, measureType);
+			m_pManager->SetStringGID(TRUE);
+		}
+		AVSINLINE void MeasureStringUNICODE(BSTR strText, double x, double y, double& dBoxX, double& dBoxY, double& dBoxWidth, double& dBoxHeight, MeasureType measureType)
+		{
+			m_pManager->SetStringGID(FALSE);
+			MeasureString(strText, x, y, dBoxX, dBoxY, dBoxWidth, dBoxHeight, measureType);
+			m_pManager->SetStringGID(TRUE);
+		}
+		void MeasureString(BSTR bsText, double x, double y, double& dBoxX, double& dBoxY, double& dBoxWidth, double& dBoxHeight, MeasureType measureType)
+		{
+			LoadFont();
+
+			dBoxX		= 0;
+			dBoxY		= 0;
+			dBoxWidth	= 0;
+			dBoxHeight	= 0;
+
+			if (NULL == m_pManager)
+				return;
+
+			m_pManager->LoadString(bsText, (float)x, (float)y);
+
+			float fx		= 0;
+			float fy		= 0;
+			float fwidth	= 0;
+			float fheight	= 0;
+
+			if (MeasureTypeGlyph == measureType)
+			{
+				m_pManager->MeasureString(&fx, &fy, &fwidth, &fheight);
+			}
+			else if (MeasureTypePosition == measureType)
+			{
+				m_pManager->MeasureString2(&fx, &fy, &fwidth, &fheight);
+			}
+
+			dBoxX		= (double)fx;
+			dBoxY		= (double)fy;
+			dBoxWidth	= (double)fwidth;
+			dBoxHeight	= (double)fheight;
+
+			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+			dBoxX		*= c_dPixToMM;
+			dBoxY		*= c_dPixToMM;
+			dBoxWidth	*= c_dPixToMM;
+			dBoxHeight	*= c_dPixToMM;
+		}
+
+
+		__forceinline double GetBaseLineOffset()
+		{
+			LoadFont();
+
+			double d1 = 3 * (m_oFont.m_dLineSpacing - m_oFont.m_dDescent) - m_oFont.m_dAscent;
+			d1 /= 2.0;
+
+			d1 *= (m_oFont.m_oFont.Size / m_oFont.m_dEmHeight);
+			return d1;
+		}
+
+		__forceinline double GetFontHeight()
+		{
+			return c_dPtToMM * (m_oFont.m_dLineSpacing * m_oFont.m_oFont.Size ) / m_oFont.m_dEmHeight;
+		}
+
+		__forceinline void SetStringGid(const LONG& lGid)
+		{
+			if (NULL != m_pManager)
+				m_pManager->SetStringGID(lGid);
+		}
+
+		__forceinline void GenerateFontName2(CString& strText)
+		{
+			bool bIsNeedAddToMap = CFontManagerBase::GenerateFontName(strText);
+
+			if (bIsNeedAddToMap)
+			{
+				CAtlMap<CString, CFontTableEntry>::CPair* pPair = m_oFontTable.m_mapTable.Lookup(m_strCurrentPickFont);
+				if (NULL == pPair)
+				{
+					CFontTableEntry oEntry;
+					oEntry.m_strFamilyName	= m_strCurrentPickFont;
+					oEntry.m_strPANOSE		= m_oFont.m_strPANOSE;
+					oEntry.m_lStyle			= m_oFont.m_lStyle;
+					oEntry.m_bIsFixedWidth	= m_oFont.m_bIsFixedWidth;
+					oEntry.m_arSignature.Copy(m_oFont.m_arSignature);
+
+					m_oFontTable.m_mapTable.SetAt(m_oFont.m_oFont.Path, oEntry);
+				}
+			}
+		}
+	};
+
+	class CFontManagerLight
+	{
+	private:
+		CString m_strFontName;
+		LONG	m_lFontStyle;
+		double	m_dSize;
+
+		double	m_dSpaceWidth;
+
+		AVSGraphics::IASCFontManager*	m_pManager;
+	
+	public:
+		CFontManagerLight()
+		{
+			m_strFontName	= _T("");
+			m_lFontStyle	= 0;
+			m_dSize			= 0;
+			m_dSpaceWidth	= 0;
+
+			m_pManager = NULL;
+			CoCreateInstance(AVSGraphics::CLSID_CASCFontManager, NULL, CLSCTX_ALL, AVSGraphics::IID_IASCFontManager, (void**)&m_pManager);
+
+			m_pManager->Initialize(L"");
+			m_pManager->SetDefaultFont(L"Arial");
+		}
+		~CFontManagerLight()
+		{
+			RELEASEINTERFACE(m_pManager);
+		}
+
+		AVSINLINE double GetSpaceWidth()
+		{
+			return m_dSpaceWidth;
+		}
+
+	public:
+		AVSINLINE void LoadFont(CString& strFontName, LONG& lStyle, double& dSize, const BOOL& bIsGID)
+		{
+			if ((strFontName == m_strFontName) && (lStyle == m_lFontStyle) && (dSize == m_dSize))
+			{
+				m_pManager->SetStringGID(bIsGID);
+				return;
+			}
+
+			m_strFontName	= strFontName;
+			m_lFontStyle	= lStyle;
+			m_dSize			= dSize;
+
+			BSTR bsName = m_strFontName.AllocSysString();
+			m_pManager->LoadFontByName(bsName, (float)m_dSize, m_lFontStyle, c_dDpiX, c_dDpiY);
+			SysFreeString(bsName);
+
+			CString strSpace = _T(" ");
+			m_dSpaceWidth = MeasureStringWidth(strSpace);
+
+			m_pManager->SetStringGID(bIsGID);
+		}
+
+		AVSINLINE double MeasureStringWidth(CString& sText)
+		{
+			BSTR bsText = sText.AllocSysString();
+			m_pManager->LoadString(bsText, (float)0, (float)0);
+			SysFreeString(bsText);
+
+			float fx		= 0;
+			float fy		= 0;
+			float fwidth	= 0;
+			float fheight	= 0;
+
+			m_pManager->MeasureString2(&fx, &fy, &fwidth, &fheight);
+
+			return fwidth * c_dPixToMM;
+		}
+	};
+
+}

DocxRenderer/src/logic/Page.h

@@ -0,0 +1,762 @@
+#pragma once
+#include "ElementShape.h"
+#include "ElementParagraph.h"
+#include "ElementImage.h"
+
+namespace NSDocxRenderer
+{
+	const double STANDART_STRING_HEIGHT_MM		= 4.2333333333333334;
+	const double THE_SAME_STRING_Y_PRECISION_MM = 0.01;
+
+	static _bstr_t g_bstr_sectStart			= L"<w:p><w:pPr><w:sectPr>";
+	static _bstr_t g_bstr_lastSect			= L"<w:type w:val=\"continuous\"/>";
+	static _bstr_t g_bstr_sectEnd			= L"<w:pgMar w:top=\"0\" w:right=\"0\" w:bottom=\"0\" w:left=\"0\"/></w:sectPr><w:spacing w:line=\"1\" w:lineRule=\"exact\"/></w:pPr></w:p>";
+	static CString g_string_sectSizeVer		= _T("<w:pgSz w:w=\"%d\" w:h=\"%d\" w:orient=\"portrait\"/>");
+	static CString g_string_sectSizeHor		= _T("<w:pgSz w:w=\"%d\" w:h=\"%d\" w:orient=\"landscape\"/>");
+
+	static _bstr_t g_bstr_drawingParStart	= L"<w:p><w:pPr><w:spacing w:line=\"1\" w:lineRule=\"exact\"/></w:pPr>";
+	static _bstr_t g_bstr_ParEnd			= L"</w:p>";
+
+	static CString g_bstr_lastsection1		= L"<w:sectPr>";
+	static CString g_bstr_lastsection2		= L"<w:pgMar w:top=\"0\" w:right=\"0\" w:bottom=\"0\" w:left=\"0\" w:header=\"0\" w:footer=\"0\" w:gutter=\"0\"/></w:sectPr>";
+
+	AVSINLINE bool IsUnicodeSymbol( WCHAR symbol )
+	{
+		bool result = false;
+
+		if ( ( 0x0009 == symbol ) || ( 0x000A == symbol ) || ( 0x000D == symbol ) ||
+		   ( ( 0x0020 <= symbol ) && ( 0xD7FF >= symbol ) ) || ( ( 0xE000 <= symbol ) && ( symbol <= 0xFFFD ) ) ||
+		   ( ( 0x10000 <= symbol ) && symbol ) )
+		{
+			result = true;  
+		}
+
+		return result;		  
+	}
+
+	class CPage
+	{
+	public:
+		NSStructures::CFont*		m_pFont;
+		NSStructures::CPen*			m_pPen;
+		NSStructures::CBrush*		m_pBrush;
+		NSStructures::CShadow*		m_pShadow;
+		NSStructures::CEdgeText*	m_pEdgeText;
+
+		NSDocxRenderer::CMatrix*					m_pTransform;
+		AVSGraphics::IASCGraphicSimpleComverter*	m_pSimpleGraphicsConverter;
+
+		CVectorGraphics				m_oVector;
+
+		double m_dWidth;
+		double m_dHeight;
+
+		LONG						m_lCurrentCommand;
+
+		CAtlArray<CBaseItem*>	m_arGraphicItems;
+		CAtlArray<CParagraph*>	m_arParagraphs;
+
+		CAtlArray<CTextLine*> m_arTextLine;
+		CTextLine* m_pCurrentLine;
+
+		CFontManager		m_oManager;
+		CFontManagerLight	m_oManagerLight;
+
+		TextAssociationType m_eTextAssociationType;
+
+		NSDocxRenderer::CStringWriter m_oWriterVML;
+
+		bool m_bIsDeleteTextClipPage;
+
+	public:
+		CPage() : m_oManager(), m_oManagerLight()
+		{
+			m_pFont			= NULL;
+			m_pBrush		= NULL;
+			m_pPen			= NULL;
+			m_pShadow		= NULL;
+			m_pEdgeText		= NULL;
+
+			m_pTransform	= NULL;
+			m_pSimpleGraphicsConverter	= NULL;
+
+			m_dWidth		= 0;
+			m_dHeight		= 0;
+
+			m_pCurrentLine	= NULL;
+			m_eTextAssociationType = TextAssociationTypeNoFrames;
+
+			m_bIsDeleteTextClipPage = true;
+		}
+
+	public:
+		AVSINLINE void Init(NSStructures::CFont* pFont, NSStructures::CPen* pPen, NSStructures::CBrush* pBrush,
+			NSStructures::CShadow* pShadow, NSStructures::CEdgeText* pEdge, NSDocxRenderer::CMatrix* pMatrix, AVSGraphics::IASCGraphicSimpleComverter* pSimple)
+		{
+			m_pFont		= pFont;
+			m_pPen		= pPen;
+			m_pBrush	= pBrush;
+			m_pShadow	= pShadow;
+			m_pEdgeText	= pEdge;
+
+			m_pTransform				= pMatrix;
+			m_pSimpleGraphicsConverter	= pSimple;
+
+			m_oManager.m_pFont			= m_pFont;
+			m_oManager.m_pTransform		= m_pTransform;
+
+			m_pCurrentLine = NULL;
+
+			m_oWriterVML.AddSize(1000, 1000);
+		}
+
+		AVSINLINE void Clear()
+		{
+			size_t nCount = 0;
+
+			nCount = m_arTextLine.GetCount();
+			for (size_t i = 0; i < nCount; ++i)
+			{
+				CTextLine* pTemp = m_arTextLine[i];
+				RELEASEOBJECT(pTemp);
+			}
+			m_arTextLine.RemoveAll();
+
+			nCount = m_arGraphicItems.GetCount();
+			for (size_t i = 0; i < nCount; ++i)
+			{
+				CBaseItem* pTemp = m_arGraphicItems[i];
+				RELEASEOBJECT(pTemp);
+			}
+			m_arGraphicItems.RemoveAll();
+
+			nCount = m_arParagraphs.GetCount();
+			for (size_t i = 0; i < nCount; ++i)
+			{
+				CParagraph* pTemp = m_arParagraphs[i];
+				RELEASEOBJECT(pTemp);
+			}
+			m_arParagraphs.RemoveAll();
+
+			m_pCurrentLine = NULL;
+
+			m_oWriterVML.ClearNoAttack();
+		}
+
+		~CPage()
+		{
+			Clear();
+		}
+
+		AVSINLINE void SetCurrentLineByBaseline(const double& dBaseLinePos)
+		{
+			if ((NULL == m_pCurrentLine) || (TextAssociationTypeDefault == m_eTextAssociationType))
+			{
+				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> (<28> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+				m_pCurrentLine = new CTextLine();
+
+				m_pCurrentLine->m_dBaselinePos = dBaseLinePos;
+				m_arTextLine.Add(m_pCurrentLine);
+				return;
+			}
+			if (fabs(m_pCurrentLine->m_dBaselinePos - dBaseLinePos) <= THE_SAME_STRING_Y_PRECISION_MM)
+			{
+				return;
+			}
+			size_t nCount = m_arTextLine.GetCount();
+			for (size_t i = 0; i < nCount; ++i)
+			{
+				if (fabs(m_arTextLine[i]->m_dBaselinePos - dBaseLinePos) <= THE_SAME_STRING_Y_PRECISION_MM)
+				{
+					m_pCurrentLine = m_arTextLine[i];
+					return;
+				}
+			}
+
+			// <20><><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> - <20><> <20><><EFBFBD><EFBFBD> - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
+			m_pCurrentLine = new CTextLine();
+			m_pCurrentLine->m_dBaselinePos = dBaseLinePos;
+			m_arTextLine.Add(m_pCurrentLine);
+			return;
+		}
+
+		// image commands
+		AVSINLINE void WriteImage(CImageInfo& oInfo, double& fX, double& fY, double& fWidth, double& fHeight)
+		{
+			CImage* pImage = new CImage(oInfo, _T(""));
+
+			double dRotation = m_pTransform->z_Rotation();
+
+			if (fabs(dRotation) < 5.0)
+			{
+				double x1 = fX;
+				double y1 = fY;
+				double x2 = fX + fWidth;
+				double y2 = fY + fHeight;
+
+				m_pTransform->TransformPoint(x1, y1);
+				m_pTransform->TransformPoint(x2, y2);
+
+				if (x1 <= x2)
+				{
+					pImage->m_dLeft		= x1;
+					pImage->m_dWidth	= x2 - x1;
+				}
+				else
+				{
+					pImage->m_dLeft		= x2;
+					pImage->m_dWidth	= x1 - x2;
+				}
+
+				if (y1 <= y2)
+				{
+					pImage->m_dTop		= y1;
+					pImage->m_dHeight	= y2 - y1;
+				}
+				else
+				{
+					pImage->m_dTop		= y2;
+					pImage->m_dHeight	= y1 - y2;
+				}
+
+				pImage->m_dRotate = 0.0;
+			}
+			else
+			{
+				double x1 = fX;
+				double y1 = fY;
+				double x2 = fX + fWidth;
+				double y2 = fY + fHeight;
+
+				NSDocxRenderer::CMatrix oTemp  = *m_pTransform;
+		
+				double dCx = (x1 + x2) / 2;
+				double dCy = (y1 + y2) / 2;
+				m_pTransform->TransformPoint(dCx, dCy);
+				oTemp.RotateAt(-dRotation, dCx, dCy, Aggplus::MatrixOrderAppend);
+
+				oTemp.TransformPoint(x1, y1);
+				oTemp.TransformPoint(x2, y2);
+
+				if (x1 <= x2)
+				{
+					pImage->m_dLeft		= x1;
+					pImage->m_dWidth	= x2 - x1;
+				}
+				else
+				{
+					pImage->m_dLeft		= x2;
+					pImage->m_dWidth	= x1 - x2;
+				}
+
+				if (y1 <= y2)
+				{
+					pImage->m_dTop		= y1;
+					pImage->m_dHeight	= y2 - y1;
+				}
+				else
+				{
+					pImage->m_dTop		= y2;
+					pImage->m_dHeight	= y1 - y2;
+				}
+
+				pImage->m_dRotate = dRotation;
+			}
+
+			m_arGraphicItems.Add(pImage);
+		}
+
+		// path commands
+		AVSINLINE void MoveTo(double& dX, double& dY)
+		{
+			m_pTransform->TransformPoint(dX, dY);
+			m_oVector.MoveTo(dX, dY);
+
+		}
+		AVSINLINE void LineTo(double& dX, double& dY)
+		{
+			m_pTransform->TransformPoint(dX, dY);
+			m_oVector.LineTo(dX, dY);
+		}
+		AVSINLINE void CurveTo(double& x1, double& y1, double& x2, double& y2, double& x3, double& y3)
+		{
+			m_pTransform->TransformPoint(x1, y1);
+			m_pTransform->TransformPoint(x2, y2);
+			m_pTransform->TransformPoint(x3, y3);
+
+			m_oVector.CurveTo(x1, y1, x2, y2, x3, y3);
+		}
+		AVSINLINE void Start()
+		{			
+		}
+		AVSINLINE void End()
+		{
+			m_oVector.End();
+			m_oWriterVML.ClearNoAttack();
+		}
+		AVSINLINE void Close()
+		{
+			m_oVector.Close();
+		}
+		AVSINLINE void DrawPath(LONG lType, LONG lTxId)
+		{
+			if ((m_oVector.m_dLeft <= m_oVector.m_dRight) && (m_oVector.m_dTop <= m_oVector.m_dBottom))
+			{
+				CShape* pShape = new CShape();
+
+				pShape->m_lTxId		= lTxId;
+
+				pShape->m_oPen		= *m_pPen;
+				pShape->m_oBrush	= *m_pBrush;
+
+				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
+				double dScaleTransform = (m_pTransform->m_agg_mtx.sx + m_pTransform->m_agg_mtx.sy) / 2.0;
+				pShape->m_oPen.Size *= dScaleTransform;
+
+				if ((lType & 0x01) == 0x00)
+				{
+					if ((fabs(m_oVector.m_dLeft - m_oVector.m_dRight) < 0.3) || (fabs(m_oVector.m_dTop - m_oVector.m_dBottom) < 0.3))
+					{
+						lType = 0x01;
+						pShape->m_bIsStroke  = true;
+						pShape->m_oPen.Color = m_pBrush->Color1;
+						pShape->m_oPen.Alpha = m_pBrush->Alpha1;
+						//pShape->m_oPen.Size	 = max(pShape->m_oPen.Size, 1);	
+					}
+				}
+
+				pShape->CreateFromVectorData(&m_oVector, m_oWriterVML, 100000, lType);
+				m_arGraphicItems.Add(pShape);
+			}
+		}
+
+		AVSINLINE void WriteText(BSTR bsText, BSTR bsGid, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset, bool bIsPDFAnalyzer)
+		{
+			double dTextX = fX;
+			double dTextY = fY;
+			double dTextR = fX + fWidth;
+			double dTextB = fY + fHeight;
+
+			m_pTransform->TransformPoint(dTextX, dTextY);
+			m_pTransform->TransformPoint(dTextR, dTextB);
+			
+			double dTextW = dTextR - dTextX;
+			double dTextH = dTextB - dTextY;
+
+			CString strText = _T("");
+
+			if ((bsText != NULL) && (bsGid != NULL))
+			{
+				UINT lLen = SysStringLen(bsText);
+				for (unsigned int i = 0; i < lLen; ++i)
+				{
+					if ( IsUnicodeSymbol( bsText[i] ) )
+					{
+						strText += bsText[i];
+					}
+					else
+					{
+						strText += _T(" ");
+					}
+				}
+			}
+			else
+			{
+				strText = (CString)bsText;
+			}
+
+			bool bIsPath = ((NULL == bsGid) && !bIsPDFAnalyzer) ? false : true;
+
+			m_oManager.LoadFont(0, !bIsPath);
+			
+			if (bIsPath)
+				m_oManager.GenerateFontName2(strText);
+
+			if ((0 == dTextW) || (dTextW > 5 * m_oManager.m_dSpaceWidthMM))
+			{
+				double _x = 0;
+				double _y = 0;
+				double _w = 0;
+				double _h = 0;
+
+				if (NULL != bsGid)
+				{
+					m_oManager.SetStringGid(1);
+					m_oManager.MeasureString(bsGid, dTextX, dTextY, _x, _y, _w, _h, CFontManager::MeasureTypePosition);
+				}
+				else
+				{
+					// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> xps)
+					m_oManager.SetStringGid(0);
+					m_oManager.MeasureString(bsText, dTextX, dTextY, _x, _y, _w, _h, CFontManager::MeasureTypePosition);
+				}
+
+				dTextW = _w;
+				//dTextW *= c_dPixToMM;
+			}
+
+			double dBaseLinePos = dTextY + fBaseLineOffset;
+			dTextH = m_oManager.GetFontHeight();
+
+			SetCurrentLineByBaseline(dBaseLinePos);
+
+			CContText* pLastCont = NULL;
+			size_t nCountConts = m_pCurrentLine->m_arConts.GetCount();
+			if (nCountConts != 0)
+				pLastCont = m_pCurrentLine->m_arConts[nCountConts - 1];
+
+			if (NULL == pLastCont)
+			{
+				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD>
+				CContText* pCont = new CContText();
+
+				pCont->m_dX = dTextX;
+				pCont->m_dY = dBaseLinePos;
+
+				pCont->m_dWidth		= dTextW;
+				pCont->m_dHeight	= dTextH;
+
+				if (_T(" ") == strText)
+				{
+					pCont->m_dWidthWithoutSpaces	= 0;
+					pCont->m_dLeftWithoutSpaces		= dTextX + dTextW;
+				}
+				else
+				{
+					pCont->m_dWidthWithoutSpaces	= dTextW;
+					pCont->m_dLeftWithoutSpaces		= dTextX;
+				}
+
+				pCont->m_strText	= strText;
+
+				pCont->m_oFont		= m_oManager.m_oFont.m_oFont;
+				pCont->m_oBrush		= *m_pBrush;
+
+				if (bIsPath)
+				{
+					pCont->m_strPickFontName	= m_oManager.m_strCurrentPickFont;
+					pCont->m_lPickFontStyle		= m_oManager.m_lCurrentPictFontStyle;
+				}
+
+				pCont->m_dSpaceWidthMM = m_oManager.m_dSpaceWidthMM;
+				
+				m_pCurrentLine->AddCont(pCont, m_oManager.m_oFont.m_dBaselineOffset);
+				return;
+			}
+			
+			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
+			//if (m_lCurrentCommand == c_nTextType && pLastCont->m_oFont.IsEqual(&m_oManager.m_oFontOld) && pLastCont->m_oBrush.IsEqual(m_pBrush))
+			//{
+			//	// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+			//	pLastCont->m_strText += strText;
+			//	pLastCont->m_dWidth	= (dTextX + dTextW - pLastCont->m_dX);
+			//	return;
+			//}
+			
+			double dRight = pLastCont->m_dX + pLastCont->m_dWidth;
+
+			if (pLastCont->m_oFont.IsEqual(&m_oManager.m_oFont.m_oFont) && pLastCont->m_oBrush.IsEqual(m_pBrush))
+			{
+				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>. <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+				if (fabs(dRight - dTextX) < 0.5)
+				{
+					// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
+					pLastCont->m_strText += strText;
+					pLastCont->m_dWidth	= (dTextX + dTextW - pLastCont->m_dX);
+
+					if (_T(" ") != strText)
+					{
+						if (0 == pLastCont->m_dWidthWithoutSpaces)
+							pLastCont->m_dLeftWithoutSpaces = dTextX;
+						
+						pLastCont->m_dWidthWithoutSpaces = dTextX + dTextW - pLastCont->m_dLeftWithoutSpaces;
+					}
+					else if (0 == pLastCont->m_dWidthWithoutSpaces)
+					{
+						pLastCont->m_dLeftWithoutSpaces = dTextX + dTextW;
+					}
+
+					return;
+				}
+				else if ((dRight < dTextX) && ((dTextX - dRight) < m_oManager.m_dSpaceWidthMM))
+				{
+					// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+					pLastCont->m_strText += (_T(" ") + strText);
+					pLastCont->m_dWidth	= (dTextX + dTextW - pLastCont->m_dX);
+
+					if (_T(" ") != strText)
+					{
+						if (0 == pLastCont->m_dWidthWithoutSpaces)
+							pLastCont->m_dLeftWithoutSpaces = dTextX;
+
+						pLastCont->m_dWidthWithoutSpaces = dTextX + dTextW - pLastCont->m_dLeftWithoutSpaces;
+					}
+					else if (0 == pLastCont->m_dWidthWithoutSpaces)
+					{
+						pLastCont->m_dLeftWithoutSpaces = dTextX + dTextW;
+					}
+
+					return;
+				}
+			}
+			
+			// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><> (<28><><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD>)
+			// <20><><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>... <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
+			CContText* pCont = new CContText();
+
+			pCont->m_dX = dTextX;
+			pCont->m_dY = dBaseLinePos;
+
+			pCont->m_dWidth		= dTextW;
+			pCont->m_dHeight	= dTextH;
+
+			if (_T(" ") == strText)
+			{
+				pCont->m_dWidthWithoutSpaces	= 0;
+				pCont->m_dLeftWithoutSpaces		= dTextX + dTextW;
+			}
+			else
+			{
+				pCont->m_dWidthWithoutSpaces	= dTextW;
+				pCont->m_dLeftWithoutSpaces		= dTextX;
+			}
+
+			pCont->m_strText	= strText;
+
+			pCont->m_oFont		= m_oManager.m_oFont.m_oFont;
+			pCont->m_oBrush		= *m_pBrush;
+
+			if (bIsPath)
+			{
+				pCont->m_strPickFontName	= m_oManager.m_strCurrentPickFont;
+				pCont->m_lPickFontStyle		= m_oManager.m_lCurrentPictFontStyle;
+			}
+
+			pCont->m_dSpaceWidthMM = m_oManager.m_dSpaceWidthMM;
+			
+			m_pCurrentLine->AddCont(pCont, m_oManager.m_oFont.m_dBaselineOffset);
+		}
+
+		void Build()
+		{
+			if (m_bIsDeleteTextClipPage)
+			{
+				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+				size_t nCount = m_arTextLine.GetCount();
+				for (size_t i = 0; i < nCount; ++i)
+				{
+					CTextLine* pTextLine = m_arTextLine[i];
+
+					double _top = pTextLine->m_dBaselinePos - pTextLine->m_dHeight;
+					double _bottom = pTextLine->m_dBaselinePos;
+
+					if (_top >= m_dHeight || _bottom <= 0)
+					{
+						m_arTextLine.RemoveAt(i);
+						--i;
+						--nCount;
+					}
+				}
+			}
+
+			switch (m_eTextAssociationType)
+			{
+			case TextAssociationTypeDefault:
+			case TextAssociationTypeLine:
+				{
+					size_t nCount = m_arTextLine.GetCount();
+					for (size_t i = 0; i < nCount; ++i)
+					{
+						CTextLine* pTextLine = m_arTextLine[i];
+
+						CParagraph* pParagraph = new CParagraph(m_eTextAssociationType);
+						pParagraph->m_pManagerLight = &m_oManagerLight;
+						pParagraph->m_bIsTextFrameProperties = true;
+
+						pParagraph->m_dLeft	= pTextLine->m_dX;
+						pParagraph->m_dTop	= pTextLine->m_dBaselinePos - pTextLine->m_dHeight + pTextLine->m_dBaselineOffset;
+
+						pParagraph->m_arLines.Add(pTextLine);
+
+						m_arParagraphs.Add(pParagraph);
+					}
+
+					// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
+					m_arTextLine.RemoveAll();
+					break;
+				}
+			case TextAssociationTypeBlock:
+				{
+					size_t nCount = m_arTextLine.GetCount();
+
+					if (0 == nCount)
+						break;
+
+					CTextLine* pFirstLine = m_arTextLine[0];
+
+					CParagraph* pParagraph = new CParagraph(m_eTextAssociationType);
+					pParagraph->m_pManagerLight = &m_oManagerLight;
+					pParagraph->m_bIsTextFrameProperties = true;
+					
+					pParagraph->m_dLeft	= pFirstLine->m_dX;
+					pParagraph->m_dTop	= pFirstLine->m_dBaselinePos - pFirstLine->m_dHeight + pFirstLine->m_dBaselineOffset;
+
+					pParagraph->m_arLines.Add(pFirstLine);
+
+					m_arParagraphs.Add(pParagraph);
+					
+					for (size_t i = 1; i < nCount; ++i)
+					{
+						CTextLine* pTextLine = m_arTextLine[i];
+
+						CParagraph* pParagraph = new CParagraph(m_eTextAssociationType);
+						pParagraph->m_pManagerLight = &m_oManagerLight;
+						pParagraph->m_bIsTextFrameProperties = true;
+
+						if (((fabs(pTextLine->m_dBaselinePos - pTextLine->m_dHeight - pFirstLine->m_dBaselinePos) > STANDART_STRING_HEIGHT_MM) && (pTextLine->m_dX == pFirstLine->m_dX)) ||
+							((pTextLine->m_dX != pFirstLine->m_dX) && (pTextLine->m_dBaselinePos != pFirstLine->m_dBaselinePos)))
+						{
+							pParagraph->m_dLeft	= pTextLine->m_dX;
+							pParagraph->m_dTop	= pTextLine->m_dBaselinePos - pTextLine->m_dHeight + pTextLine->m_dBaselineOffset;
+						}
+						else
+						{
+							pParagraph->m_dLeft	= pFirstLine->m_dX;
+							pParagraph->m_dTop	= pFirstLine->m_dBaselinePos - pFirstLine->m_dHeight + pFirstLine->m_dBaselineOffset;
+						}
+
+						pFirstLine = pTextLine;
+
+						pParagraph->m_arLines.Add(pTextLine);
+						m_arParagraphs.Add(pParagraph);
+					}
+
+					// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
+					m_arTextLine.RemoveAll();
+					break;
+				}
+			case TextAssociationTypeNoFrames:
+				{
+					SortElements(m_arTextLine);
+					Merge(STANDART_STRING_HEIGHT_MM / 3);
+
+					double previousStringOffset = 0;
+					size_t nCount = m_arTextLine.GetCount();
+					for (size_t i = 0; i < nCount; ++i)
+					{
+						CTextLine* pTextLine = m_arTextLine[i];
+
+						CParagraph* pParagraph = new CParagraph(m_eTextAssociationType);
+						pParagraph->m_pManagerLight = &m_oManagerLight;
+						pParagraph->m_bIsTextFrameProperties = false;
+
+						pParagraph->m_dLeft	= pTextLine->m_dX;
+						
+						double dBeforeSpacing = (pTextLine->m_dBaselinePos - previousStringOffset - pTextLine->m_dHeight + pTextLine->m_dBaselineOffset);
+
+						pParagraph->m_dSpaceBefore = max(dBeforeSpacing, 0);
+
+						double dHeight = 1;
+						if (pTextLine->m_dHeight != 0)
+						{
+							dHeight = pTextLine->m_dHeight;
+
+							if (dBeforeSpacing < 0)
+								dHeight += dBeforeSpacing;
+						}
+
+						pParagraph->m_dHeight = dHeight;
+
+						previousStringOffset = pTextLine->m_dBaselinePos + pTextLine->m_dBaselineOffset;
+
+						pParagraph->m_arLines.Add(pTextLine);
+						m_arParagraphs.Add(pParagraph);
+					}
+
+					m_arTextLine.RemoveAll();
+					break;
+				}
+			}
+		}
+
+		void Merge(double dAffinity)
+		{
+			size_t nCount = m_arTextLine.GetCount();
+			if (1 < nCount)
+			{
+				CTextLine* pPrev = m_arTextLine[0];
+				for (size_t i = 1; i < nCount; ++i)
+				{
+					CTextLine* pNext = m_arTextLine[i];
+
+					if (fabs(pNext->m_dBaselinePos - pPrev->m_dBaselinePos) < dAffinity)
+					{
+						pPrev->Merge(pNext);
+
+						pNext->m_arConts.RemoveAll();
+						RELEASEOBJECT(pNext);
+
+						m_arTextLine.RemoveAt(i);
+						--i;
+						--nCount;
+						continue;
+					}
+					pPrev = pNext;
+				}
+			}
+		}
+
+		void Write(NSDocxRenderer::CStringWriter& oWriter)
+		{
+			// drawings
+			size_t nCountDrawings = m_arGraphicItems.GetCount();
+			if (0 != nCountDrawings)
+			{
+				oWriter.WriteString(g_bstr_drawingParStart);
+
+				for (size_t i = 0; i < nCountDrawings; ++i)
+				{
+					m_arGraphicItems[i]->ToXml(oWriter);
+				}
+
+				oWriter.WriteString(g_bstr_ParEnd);
+			}
+
+			size_t nCountParagraphs = m_arParagraphs.GetCount();
+			for (size_t i = 0; i < nCountParagraphs; ++i)
+			{
+				m_arParagraphs[i]->ToXml(oWriter);
+			}
+		}
+
+		AVSINLINE void WriteSectionToFile(bool bLastPage, NSDocxRenderer::CStringWriter& oWriter)
+		{
+			// section
+			LONG lWidthDx  = (LONG)(m_dWidth * c_dMMToDx);
+			LONG lHeightDx = (LONG)(m_dHeight * c_dMMToDx);
+
+			if (!bLastPage)
+				oWriter.WriteString(g_bstr_sectStart);
+			else
+				oWriter.WriteString(g_bstr_lastsection1);
+				
+			if (lWidthDx >= lHeightDx)
+			{
+				CString strSize = _T("");
+				strSize.Format(g_string_sectSizeHor, lWidthDx, lHeightDx);
+				oWriter.WriteString(strSize);
+			}
+			else
+			{
+				CString strSize = _T("");
+				strSize.Format(g_string_sectSizeVer, lWidthDx, lHeightDx);
+				oWriter.WriteString(strSize);
+			}
+
+			if (!bLastPage)
+				oWriter.WriteString(g_bstr_sectEnd);
+			else
+				oWriter.WriteString(g_bstr_lastsection2);
+		}
+	};
+}

DocxRenderer/src/tmp/ASCDocxRenderer.cpp

@@ -0,0 +1,851 @@
+// AVSDocxRenderer.cpp : Implementation of CAVSDocxRenderer
+
+#include "stdafx.h"
+#include "ASCDocxRenderer.h"
+
+
+// CAVSDocxRenderer
+
+STDMETHODIMP CAVSDocxRenderer::get_Type(LONG* lType)
+{
+	return S_OK;
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::NewPage()
+{
+	return m_oDocument.NewPage();
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_Height(double* dHeight)
+{
+	return m_oDocument.get_Height(dHeight);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_Height(double dHeight)
+{
+	return m_oDocument.put_Height(dHeight);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_Width(double* dWidth)
+{
+	return m_oDocument.get_Width(dWidth);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_Width(double dWidth)
+{
+	return m_oDocument.put_Width(dWidth);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_DpiX(double* dDpiX)
+{
+	return m_oDocument.get_DpiX(dDpiX);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_DpiY(double* dDpiY)
+{
+	return m_oDocument.get_DpiY(dDpiY);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::SetPen(BSTR bsXML)
+{
+	return m_oDocument.SetPen(bsXML);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenColor(LONG* lColor)
+{
+	return m_oDocument.get_PenColor(lColor);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenColor(LONG lColor)
+{
+	return m_oDocument.put_PenColor(lColor);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenAlpha(LONG* lAlpha)
+{
+	return m_oDocument.get_PenAlpha(lAlpha);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenAlpha(LONG lAlpha)
+{
+	return m_oDocument.put_PenAlpha(lAlpha);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenSize(double* dSize)
+{
+	return m_oDocument.get_PenSize(dSize);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenSize(double dSize)
+{
+	return m_oDocument.put_PenSize(dSize);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenDashStyle(BYTE* val)
+{
+	return m_oDocument.get_PenDashStyle(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenDashStyle(BYTE val)
+{
+	return m_oDocument.put_PenDashStyle(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenLineStartCap(BYTE* val)
+{
+	return m_oDocument.get_PenLineStartCap(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenLineStartCap(BYTE val)
+{
+	return m_oDocument.put_PenLineStartCap(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenLineEndCap(BYTE* val)
+{
+	return m_oDocument.get_PenLineEndCap(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenLineEndCap(BYTE val)
+{
+	return m_oDocument.put_PenLineEndCap(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenLineJoin(BYTE* val)
+{
+	return m_oDocument.get_PenLineJoin(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenLineJoin(BYTE val)
+{
+	return m_oDocument.put_PenLineJoin(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenDashOffset(double* val)
+{
+	return m_oDocument.get_PenDashOffset(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenDashOffset(double val)
+{
+	return m_oDocument.put_PenDashOffset(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenAlign(LONG* val)
+{
+	return m_oDocument.get_PenAlign(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenAlign(LONG val)
+{
+	return m_oDocument.put_PenAlign(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_PenMiterLimit(double* val)
+{
+	return m_oDocument.get_PenMiterLimit(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_PenMiterLimit(double val)
+{
+	return m_oDocument.put_PenMiterLimit(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PenDashPattern(SAFEARRAY* pPattern)
+{
+	return m_oDocument.PenDashPattern(pPattern);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::SetBrush(BSTR bsXML)
+{
+	return m_oDocument.SetBrush(bsXML);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_BrushType(LONG* lType)
+{
+	return m_oDocument.get_BrushType(lType);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_BrushType(LONG lType)
+{
+	return m_oDocument.put_BrushType(lType);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_BrushColor1(LONG* lColor)
+{
+	return m_oDocument.get_BrushColor1(lColor);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_BrushColor1(LONG lColor)
+{
+	return m_oDocument.put_BrushColor1(lColor);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_BrushAlpha1(LONG* lAlpha)
+{
+	return m_oDocument.get_BrushAlpha1(lAlpha);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_BrushAlpha1(LONG lAlpha)
+{
+	return m_oDocument.put_BrushAlpha1(lAlpha);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_BrushColor2(LONG* lColor)
+{
+	return m_oDocument.get_BrushColor2(lColor);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_BrushColor2(LONG lColor)
+{
+	return m_oDocument.put_BrushColor2(lColor);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_BrushAlpha2(LONG* lAlpha)
+{
+	return m_oDocument.get_BrushAlpha2(lAlpha);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_BrushAlpha2(LONG lAlpha)
+{
+	return m_oDocument.put_BrushAlpha2(lAlpha);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_BrushTexturePath(BSTR* bsPath)
+{
+	return m_oDocument.get_BrushTexturePath(bsPath);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_BrushTexturePath(BSTR bsPath)
+{
+	return m_oDocument.put_BrushTexturePath(bsPath);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_BrushTextureMode(LONG* lMode)
+{
+	return m_oDocument.get_BrushTextureMode(lMode);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_BrushTextureMode(LONG lMode)
+{
+	return m_oDocument.put_BrushTextureMode(lMode);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_BrushTextureAlpha(LONG* lTxAlpha)
+{
+	return m_oDocument.get_BrushTextureAlpha(lTxAlpha);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_BrushTextureAlpha(LONG lTxAlpha)
+{
+	return m_oDocument.put_BrushTextureAlpha(lTxAlpha);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_BrushLinearAngle(double* dAngle)
+{
+	return m_oDocument.get_BrushLinearAngle(dAngle);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_BrushLinearAngle(double dAngle)
+{
+	return m_oDocument.put_BrushLinearAngle(dAngle);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::BrushRect(BOOL val, double left, double top, double width, double height)
+{
+	return m_oDocument.BrushRect(val, left, top, width, height);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::SetFont(BSTR bsXML)
+{
+	return m_oDocument.SetFont(bsXML);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_FontName(BSTR* bsName)
+{
+	return m_oDocument.get_FontName(bsName);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_FontName(BSTR bsName)
+{
+	return m_oDocument.put_FontName(bsName);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_FontPath(BSTR* bsName)
+{
+	return m_oDocument.get_FontPath(bsName);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_FontPath(BSTR bsName)
+{
+	return m_oDocument.put_FontPath(bsName);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_FontSize(double* dSize)
+{
+	return m_oDocument.get_FontSize(dSize);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_FontSize(double dSize)
+{
+	return m_oDocument.put_FontSize(dSize);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_FontStyle(LONG* lStyle)
+{
+	return m_oDocument.get_FontStyle(lStyle);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_FontStyle(LONG lStyle)
+{
+	return m_oDocument.put_FontStyle(lStyle);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_FontStringGID(BOOL* bGID)
+{
+	return m_oDocument.get_FontStringGID(bGID);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_FontStringGID(BOOL bGID)
+{
+	return m_oDocument.put_FontStringGID(bGID);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_FontCharSpace(double* dSpace)
+{
+	return m_oDocument.get_FontCharSpace(dSpace);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_FontCharSpace(double dSpace)
+{
+	return m_oDocument.put_FontCharSpace(dSpace);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::SetShadow(BSTR bsXML)
+{
+	return m_oDocument.SetShadow(bsXML);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_ShadowDistanceX(double* val)
+{
+	return m_oDocument.get_ShadowDistanceX(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_ShadowDistanceX(double val)
+{
+	return m_oDocument.put_ShadowDistanceX(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_ShadowDistanceY(double* val)
+{
+	return m_oDocument.get_ShadowDistanceY(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_ShadowDistanceY(double val)
+{
+	return m_oDocument.put_ShadowDistanceY(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_ShadowBlurSize(double* val)
+{
+	return m_oDocument.get_ShadowBlurSize(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_ShadowBlurSize(double val)
+{
+	return m_oDocument.put_ShadowBlurSize(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_ShadowColor(LONG* val)
+{
+	return m_oDocument.get_ShadowColor(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_ShadowColor(LONG val)
+{
+	return m_oDocument.put_ShadowColor(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_ShadowAlpha(LONG* val)
+{
+	return m_oDocument.get_ShadowAlpha(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_ShadowAlpha(LONG val)
+{
+	return m_oDocument.put_ShadowAlpha(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_ShadowVisible(BOOL* val)
+{
+	return m_oDocument.get_ShadowVisible(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_ShadowVisible(BOOL val)
+{
+	return m_oDocument.put_ShadowVisible(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::SetEdgeText(BSTR bsXML)
+{
+	return m_oDocument.SetEdgeText(bsXML);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_EdgeVisible(LONG* val)
+{
+	return m_oDocument.get_EdgeVisible(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_EdgeVisible(LONG val)
+{
+	return m_oDocument.put_EdgeVisible(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_EdgeColor(LONG* val)
+{
+	return m_oDocument.get_EdgeColor(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_EdgeColor(LONG val)
+{
+	return m_oDocument.put_EdgeColor(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_EdgeAlpha(LONG* val)
+{
+	return m_oDocument.get_EdgeAlpha(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_EdgeAlpha(LONG val)
+{
+	return m_oDocument.put_EdgeAlpha(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_EdgeDist(double* val)
+{
+	return m_oDocument.get_EdgeDist(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_EdgeDist(double val)
+{
+	return m_oDocument.put_EdgeDist(val);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::CommandDrawText(BSTR bsText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset)
+{
+	return m_oDocument.CommandDrawText(bsText, fX, fY, fWidth, fHeight, fBaseLineOffset);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::CommandDrawTextEx(BSTR bsUnicodeText, BSTR bsGidText, BSTR bsSourceCodeText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset, DWORD lFlags)
+{
+	return m_oDocument.CommandDrawTextEx(bsUnicodeText, bsGidText, bsSourceCodeText, fX, fY, fWidth, fHeight, fBaseLineOffset, lFlags);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::BeginCommand(DWORD lType)
+{
+	return m_oDocument.BeginCommand(lType);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::EndCommand(DWORD lType)
+{
+	return m_oDocument.EndCommand(lType);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandMoveTo(double fX, double fY)
+{
+	return m_oDocument.PathCommandMoveTo(fX, fY);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandLineTo(double fX, double fY)
+{
+	return m_oDocument.PathCommandLineTo(fX, fY);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandLinesTo(SAFEARRAY* pPoints)
+{
+	return m_oDocument.PathCommandLinesTo(pPoints);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandCurveTo(double fX1, double fY1, double fX2, double fY2, double fX3, double fY3)
+{
+	return m_oDocument.PathCommandCurveTo(fX1, fY1, fX2, fY2, fX3, fY3);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandCurvesTo(SAFEARRAY* pPoints)
+{
+	return m_oDocument.PathCommandCurvesTo(pPoints);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandArcTo(double fX, double fY, double fWidth, double fHeight, double fStartAngle, double fSweepAngle)
+{
+	return m_oDocument.PathCommandArcTo(fX, fY, fWidth, fHeight, fStartAngle, fSweepAngle);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandClose()
+{
+	return m_oDocument.PathCommandClose();
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandEnd()
+{
+	return m_oDocument.PathCommandEnd();
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::DrawPath(long nType)
+{
+	return m_oDocument.DrawPath(nType);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandStart()
+{
+	return m_oDocument.PathCommandStart();
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandGetCurrentPoint(double* fX, double* fY)
+{
+	return m_oDocument.PathCommandGetCurrentPoint( fX, fY );
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::GetCommandParams(double* dAngle, double* dLeft, double* dTop, double* dWidth, double* dHeight, DWORD* lFlags)
+{
+	return m_oDocument.GetCommandParams( dAngle, dLeft, dTop, dWidth, dHeight, lFlags );
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::SetCommandParams(double dAngle, double dLeft, double dTop, double dWidth, double dHeight, DWORD lFlags)
+{
+	return m_oDocument.SetCommandParams( dAngle, dLeft, dTop, dWidth, dHeight, lFlags );
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::DrawImage(IUnknown* pInterface, double fX, double fY, double fWidth, double fHeight)
+{
+	return m_oDocument.DrawImage( pInterface, fX, fY, fWidth, fHeight);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::DrawImageFromFile(BSTR bstrVal, double fX, double fY, double fWidth, double fHeight)
+{
+	return m_oDocument.DrawImageFromFile( bstrVal, fX, fY, fWidth, fHeight);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::SetAdditionalParam(BSTR ParamName, VARIANT ParamValue)
+{
+	CString sParamName = ParamName;
+	if ( _T("SourceRendererType") == sParamName && VT_I4 == ParamValue.vt )
+	{
+		m_oDocument.m_bIsNeedPDFTextAnalyzer = ( ParamValue.lVal == c_nPDFWriter ? true : false );
+	}
+	return S_OK;
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::GetAdditionalParam(BSTR ParamName, VARIANT* ParamValue)
+{
+	return S_OK;
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::SetTransform(double dA, double dB, double dC, double dD, double dE, double dF)
+{
+	return m_oDocument.SetTransform( dA, dB, dC, dD, dE, dF );
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::GetTransform(double *pdA, double *pdB, double *pdC, double *pdD, double *pdE, double *pdF)
+{
+	return m_oDocument.GetTransform( pdA, pdB, pdC, pdD, pdE, pdF );
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::ResetTransform(void)
+{
+	return m_oDocument.ResetTransform();
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::get_ClipMode(LONG* plMode)
+{
+	return m_oDocument.get_ClipMode(plMode);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::put_ClipMode(LONG lMode)
+{
+	return m_oDocument.put_ClipMode(lMode);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandText(BSTR bsText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset)
+{
+	return m_oDocument.PathCommandText(bsText, fX, fY, fWidth, fHeight, fBaseLineOffset);
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::PathCommandTextEx(BSTR bsUnicodeText, BSTR bsGidText, BSTR bsSourceCodeText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset, DWORD lFlags)
+{
+	return m_oDocument.PathCommandTextEx( bsUnicodeText, bsGidText, bsSourceCodeText, fX, fY, fWidth, fHeight, fBaseLineOffset, lFlags );
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::Initialize(BSTR bsXMLOptions)
+{
+	BaseInitialize(bsXMLOptions);
+
+	IUnknown* punkRenderer = NULL;
+	this->QueryInterface(IID_IUnknown, (void**)&punkRenderer);
+
+	m_oDocument.CreateDocument(punkRenderer, m_strTempFileDir);
+
+	RELEASEINTERFACE(punkRenderer);
+
+	return S_OK;
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::Save()
+{
+	m_oDocument.Close();
+	return S_OK;
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::CreateOfficeFile(BSTR bsXMLOptions)
+{
+	BaseInitialize(bsXMLOptions);
+
+	IUnknown* punkRenderer = NULL;
+	this->QueryInterface(IID_IUnknown, (void**)&punkRenderer);
+
+	m_oDocument.CreateDocument(punkRenderer, m_strTempFileDir);
+
+	RELEASEINTERFACE(punkRenderer);
+
+	return S_OK;
+}
+
+/*========================================================================================================*/
+
+STDMETHODIMP CAVSDocxRenderer::CloseFile()
+{
+	m_oDocument.Close();
+	return S_OK;
+}
+
+/*========================================================================================================*/

DocxRenderer/src/tmp/ASCDocxRenderer.h

@@ -0,0 +1,239 @@
+// AVSDocxRenderer.h : Declaration of the CAVSDocxRenderer
+
+#pragma once
+#include "stdafx.h"
+#include "resource.h"       // main symbols
+
+#include "Logic/Document.h"
+
+#if defined(_WIN32_WCE) && !defined(_CE_DCOM) && !defined(_CE_ALLOW_SINGLE_THREADED_OBJECTS_IN_MTA)
+#error "Single-threaded COM objects are not properly supported on Windows CE platform, such as the Windows Mobile platforms that do not include full DCOM support. Define _CE_ALLOW_SINGLE_THREADED_OBJECTS_IN_MTA to force ATL to support creating single-thread COM object's and allow use of it's single-threaded COM object implementations. The threading model in your rgs file was set to 'Free' as that is the only threading model supported in non DCOM Windows CE platforms."
+#endif
+
+// IAVSDocxRenderer
+[object, uuid("5BEC40F1-CA4F-4275-BCC8-D4ABF47D896D"), dual, pointer_default(unique)]
+__interface IAVSDocxRenderer : IASCRenderer
+{
+	[id(11001)]  HRESULT Initialize([in]BSTR bsXMLOptions);
+	[id(11002)]  HRESULT Save();
+};
+
+[object, uuid("84411C25-B8A1-4f16-A37A-9C142FBE8D26"), dual, pointer_default(unique)]
+__interface IAVSDocxRenderer2 : IDispatch
+{
+	[id(12001)]  HRESULT CreateOfficeFile([in]BSTR bstrFileName);
+	[id(12002)]  HRESULT CloseFile();
+};
+
+// CAVSDocxRenderer
+[coclass, default(IAVSDocxRenderer), threading(apartment), vi_progid("AVSOfficeDocxRenderer.AVSDocxRenderer"), progid("AVSOfficeDocxRenderer.AVSDocxRenderer.1"), version(1.0), uuid("77B37E21-16F0-4BCC-8901-DFD89B962174")]
+class ATL_NO_VTABLE CAVSDocxRenderer :
+	public IAVSDocxRenderer,
+	public IAVSDocxRenderer2
+{
+public:
+	CAVSDocxRenderer()
+	{
+	}
+
+    DECLARE_PROTECT_FINAL_CONSTRUCT()
+
+	HRESULT FinalConstruct()
+	{
+		m_strDstFilePath	= _T("");
+		m_strTempFileDir	= _T("");
+		m_strTempFileName	= _T("");
+
+		InitializeCriticalSection(&m_oCS);
+
+		return S_OK;
+	}
+
+	void FinalRelease()
+	{
+		CloseFile();
+		DeleteCriticalSection(&m_oCS);
+	}
+
+public:
+    // IASCRenderer Methods
+
+	// <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>-----------------------------------------------------------------------------
+	STDMETHOD(get_Type)(LONG* lType);
+
+	//-------- <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> --------------------------------------------------
+	STDMETHOD(NewPage)();
+	STDMETHOD(get_Height)(double* dHeight);
+	STDMETHOD(put_Height)(double dHeight);
+	STDMETHOD(get_Width)(double* dWidth);
+	STDMETHOD(put_Width)(double dWidth);
+	STDMETHOD(get_DpiX)(double* dDpiX);
+	STDMETHOD(get_DpiY)(double* dDpiY);
+	//-------- <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ----------------------------------------------
+	STDMETHOD(SetPen)(BSTR bsXML);
+
+    STDMETHOD(get_PenColor)(LONG* lColor);
+	STDMETHOD(put_PenColor)(LONG lColor);
+	STDMETHOD(get_PenAlpha)(LONG* lAlpha);
+	STDMETHOD(put_PenAlpha)(LONG lAlpha);
+	STDMETHOD(get_PenSize)(double* dSize);
+	STDMETHOD(put_PenSize)(double dSize);
+	STDMETHOD(get_PenDashStyle)(BYTE* val);
+	STDMETHOD(put_PenDashStyle)(BYTE val);
+	STDMETHOD(get_PenLineStartCap)(BYTE* val);
+	STDMETHOD(put_PenLineStartCap)(BYTE val);
+	STDMETHOD(get_PenLineEndCap)(BYTE* val);
+	STDMETHOD(put_PenLineEndCap)(BYTE val);
+	STDMETHOD(get_PenLineJoin)(BYTE* val);
+	STDMETHOD(put_PenLineJoin)(BYTE val);
+	STDMETHOD(get_PenDashOffset)(double* val);
+	STDMETHOD(put_PenDashOffset)(double val);
+	STDMETHOD(get_PenAlign)(LONG* val);
+	STDMETHOD(put_PenAlign)(LONG val);
+	STDMETHOD(get_PenMiterLimit)(double* val);
+	STDMETHOD(put_PenMiterLimit)(double val);
+	STDMETHOD(PenDashPattern)(SAFEARRAY* pPattern);
+
+	STDMETHOD(SetBrush)(BSTR bsXML);
+
+	STDMETHOD(get_BrushType)(LONG* lType);
+	STDMETHOD(put_BrushType)(LONG lType);
+	STDMETHOD(get_BrushColor1)(LONG* lColor);
+	STDMETHOD(put_BrushColor1)(LONG lColor);
+	STDMETHOD(get_BrushAlpha1)(LONG* lAlpha);
+	STDMETHOD(put_BrushAlpha1)(LONG lAlpha);
+	STDMETHOD(get_BrushColor2)(LONG* lColor);
+	STDMETHOD(put_BrushColor2)(LONG lColor);
+	STDMETHOD(get_BrushAlpha2)(LONG* lAlpha);
+	STDMETHOD(put_BrushAlpha2)(LONG lAlpha);
+	STDMETHOD(get_BrushTexturePath)(BSTR* bsPath);
+	STDMETHOD(put_BrushTexturePath)(BSTR bsPath);
+	STDMETHOD(get_BrushTextureMode)(LONG* lMode);
+	STDMETHOD(put_BrushTextureMode)(LONG lMode);
+	STDMETHOD(get_BrushTextureAlpha)(LONG* lTxAlpha);
+	STDMETHOD(put_BrushTextureAlpha)(LONG lTxAlpha);
+	STDMETHOD(get_BrushLinearAngle)(double* dAngle);
+	STDMETHOD(put_BrushLinearAngle)(double dAngle);
+	STDMETHOD(BrushRect)(BOOL val, double left, double top, double width, double height);
+
+	STDMETHOD(SetFont)(BSTR bsXML);
+
+    STDMETHOD(get_FontName)(BSTR* bsName);
+	STDMETHOD(put_FontName)(BSTR bsName);
+	STDMETHOD(get_FontPath)(BSTR* bsName);
+	STDMETHOD(put_FontPath)(BSTR bsName);
+	STDMETHOD(get_FontSize)(double* dSize);
+	STDMETHOD(put_FontSize)(double dSize);
+	STDMETHOD(get_FontStyle)(LONG* lStyle);
+	STDMETHOD(put_FontStyle)(LONG lStyle);
+	STDMETHOD(get_FontStringGID)(BOOL* bGID);
+	STDMETHOD(put_FontStringGID)(BOOL bGID);
+	STDMETHOD(get_FontCharSpace)(double* dSpace);
+	STDMETHOD(put_FontCharSpace)(double dSpace);
+
+	STDMETHOD(SetShadow)(BSTR bsXML);
+
+    STDMETHOD(get_ShadowDistanceX)(double* val);
+	STDMETHOD(put_ShadowDistanceX)(double val);
+	STDMETHOD(get_ShadowDistanceY)(double* val);
+	STDMETHOD(put_ShadowDistanceY)(double val);
+	STDMETHOD(get_ShadowBlurSize)(double* val);
+	STDMETHOD(put_ShadowBlurSize)(double val);
+	STDMETHOD(get_ShadowColor)(LONG* val);
+	STDMETHOD(put_ShadowColor)(LONG val);
+	STDMETHOD(get_ShadowAlpha)(LONG* val);
+	STDMETHOD(put_ShadowAlpha)(LONG val);
+	STDMETHOD(get_ShadowVisible)(BOOL* val);
+	STDMETHOD(put_ShadowVisible)(BOOL val);
+
+	STDMETHOD(SetEdgeText)(BSTR bsXML);
+
+    STDMETHOD(get_EdgeVisible)(LONG* val);
+	STDMETHOD(put_EdgeVisible)(LONG val);
+	STDMETHOD(get_EdgeColor)(LONG* val);
+	STDMETHOD(put_EdgeColor)(LONG val);
+	STDMETHOD(get_EdgeAlpha)(LONG* val);
+	STDMETHOD(put_EdgeAlpha)(LONG val);
+	STDMETHOD(get_EdgeDist)(double* val);
+	STDMETHOD(put_EdgeDist)(double val);
+
+    //-------- <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> --------------------------------------------------------
+	STDMETHOD(CommandDrawText)(BSTR bsText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset);
+	STDMETHOD(CommandDrawTextEx)(BSTR bsUnicodeText, BSTR bsGidText, BSTR bsSourceCodeText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset, DWORD lFlags);
+	//-------- <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ---------------------------------------------------------------
+	STDMETHOD(BeginCommand)(DWORD lType);
+	STDMETHOD(EndCommand)(DWORD lType);
+    //-------- <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> Graphics Path -----------------------------------------------
+	STDMETHOD(PathCommandMoveTo)(double fX, double fY);
+	STDMETHOD(PathCommandLineTo)(double fX, double fY);
+	STDMETHOD(PathCommandLinesTo)(SAFEARRAY* pPoints);
+	STDMETHOD(PathCommandCurveTo)(double fX1, double fY1, double fX2, double fY2, double fX3, double fY3);
+	STDMETHOD(PathCommandCurvesTo)(SAFEARRAY* pPoints);
+	STDMETHOD(PathCommandArcTo)(double fX, double fY, double fWidth, double fHeight, double fStartAngle, double fSweepAngle);
+	STDMETHOD(PathCommandClose)();
+	STDMETHOD(PathCommandEnd)();
+	STDMETHOD(DrawPath)(long nType);
+	STDMETHOD(PathCommandStart)();
+	STDMETHOD(PathCommandGetCurrentPoint)(double* fX, double* fY);
+
+	STDMETHOD(PathCommandText)(BSTR bsText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset);
+	STDMETHOD(PathCommandTextEx)(BSTR bsUnicodeText, BSTR bsGidText, BSTR bsSourceCodeText, double fX, double fY, double fWidth, double fHeight, double fBaseLineOffset, DWORD lFlags);
+	
+	STDMETHOD(GetCommandParams)(double* dAngle, double* dLeft, double* dTop, double* dWidth, double* dHeight, DWORD* lFlags);
+	STDMETHOD(SetCommandParams)(double dAngle, double dLeft, double dTop, double dWidth, double dHeight, DWORD lFlags);
+    //-------- <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> --------------------------------------------------
+	STDMETHOD(DrawImage)(IUnknown* pInterface, double fX, double fY, double fWidth, double fHeight);
+	STDMETHOD(DrawImageFromFile)(BSTR bstrVal, double fX, double fY, double fWidth, double fHeight);
+	//------------------------------------------------------------------------------------------
+	STDMETHOD(SetAdditionalParam)(BSTR ParamName, VARIANT ParamValue);
+	STDMETHOD(GetAdditionalParam)(BSTR ParamName, VARIANT* ParamValue);
+
+    STDMETHOD(SetTransform)(double dA, double dB, double dC, double dD, double dE, double dF);
+	STDMETHOD(GetTransform)(double *pdA, double *pdB, double *pdC, double *pdD, double *pdE, double *pdF);
+	STDMETHOD(ResetTransform)(void);
+	STDMETHOD(get_ClipMode)(LONG* plMode);
+	STDMETHOD(put_ClipMode)(LONG lMode);
+
+public:
+    //IAVSDocxRenderer Methods
+	STDMETHOD(Initialize)(BSTR bsXMLOptions);
+    STDMETHOD(Save)();
+
+public:
+	//IAVSDocxRenderer2 Methods
+	STDMETHOD(CreateOfficeFile)(BSTR bsFileName);
+    STDMETHOD(CloseFile)();
+
+private:
+	AVSGraphics::IASCFontManager*	m_pFontManager;
+	
+	NSDocxRenderer::CDocument m_oDocument;
+
+	CRITICAL_SECTION m_oCS;
+
+	CString m_strDstFilePath;
+	CString m_strTempFileDir;
+	CString m_strTempFileName;
+
+	void BaseInitialize(BSTR bsXMLOptions)
+	{
+		m_oDocument.m_oCurrentPage.m_eTextAssociationType = NSDocxRenderer::TextAssociationTypeNoFrames;
+		XmlUtils::CXmlReader oXmlReader;
+
+		if( TRUE == oXmlReader.OpenFromXmlString( bsXMLOptions ) )
+		{
+			if( TRUE == oXmlReader.ReadRootNode( _T( "DocxRenderer" ) ) )
+			{
+				m_strTempFileDir = oXmlReader.ReadNodeAttributeOrValue( _T( "destinationpath" ) );
+
+				CString textFormatting = oXmlReader.ReadNodeAttributeOrValue( _T( "textformatting" ) );
+
+				if ( !textFormatting.IsEmpty() )
+				{
+					m_oDocument.m_oCurrentPage.m_eTextAssociationType = (NSDocxRenderer::TextAssociationType)XmlUtils::GetInteger(textFormatting);
+				}
+			}
+		}
+	}
+};
+

X2tConverter/src/ASCConverters.cpp

@@ -669,6 +669,26 @@ namespace NExtractTools
            NSFile::CFileBinary::Remove(sPdfBinFile);
        return nRes;
    }
+	std::wstring getExtentionByRasterFormat(int format)
+	{
+		std::wstring sExt;
+		switch(format)
+		{
+			case 1:
+				sExt = L".bmp";
+			break;
+			case 2:
+				sExt = L".gif";
+			break;
+			case 3:
+				sExt = L".jpg";
+			break;
+			default:
+				sExt = L".png";
+			break;
+		}
+		return sExt;
+	}
 	//doct_bin -> image
 	int doct_bin2image(NSDoctRenderer::DoctRendererFormat::FormatFile eFromType, const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, bool bPaid, const std::wstring &sThemeDir, InputParams& params)
 	{
@@ -731,9 +751,7 @@ namespace NExtractTools
 			{
 				sThumbnailDir = sTemp + FILE_SEPARATOR_STR + L"thumbnails";
 				FileSystem::Directory::CreateDirectory(sThumbnailDir);
-				std::wstring::size_type pos = sTo.find_last_of('.');
-				std::wstring sExt = std::wstring::npos == pos ? L"" : sTo.substr(pos);
-				imageWriter.m_sFileName = sThumbnailDir + FILE_SEPARATOR_STR + L"image" + sExt;
+				imageWriter.m_sFileName = sThumbnailDir + FILE_SEPARATOR_STR + L"image" + getExtentionByRasterFormat(imageWriter.m_nRasterFormat);
 			}
 			BYTE* pData;
 			DWORD nBytesCount;
@@ -1747,9 +1765,7 @@ namespace NExtractTools
 				{
 					sThumbnailDir = sTemp + FILE_SEPARATOR_STR + L"thumbnails";
 					FileSystem::Directory::CreateDirectory(sThumbnailDir);
-					std::wstring::size_type pos = sTo.find_last_of('.');
-
-					sFileToExt = std::wstring::npos == pos ? L"" : sTo.substr(pos);
+					sFileToExt = getExtentionByRasterFormat(nRasterFormat);
 				}
 				int nPagesCount = pReader->GetPagesCount();
 				if (bIsOnlyFirst)
@@ -1879,7 +1895,7 @@ namespace NExtractTools
            NSDoctRenderer::DoctRendererFormat::FormatFile eFromType = NSDoctRenderer::DoctRendererFormat::FormatFile::DOCT;
            nRes = doct_bin2pdf(eFromType, sFrom, sTo, sTemp, bPaid, sThemeDir, params);
        }
-       else if(AVS_OFFICESTUDIO_FILE_IMAGE == nFormatTo)
+       else if(0 != (AVS_OFFICESTUDIO_FILE_IMAGE & nFormatTo))
        {
            NSDoctRenderer::DoctRendererFormat::FormatFile eFromType = NSDoctRenderer::DoctRendererFormat::FormatFile::DOCT;
            nRes = doct_bin2image(eFromType, sFrom, sTo, sTemp, bPaid, sThemeDir, params);
@@ -2047,7 +2063,7 @@ namespace NExtractTools
            NSDoctRenderer::DoctRendererFormat::FormatFile eFromType = NSDoctRenderer::DoctRendererFormat::FormatFile::XLST;
            nRes = doct_bin2pdf(eFromType, sFrom, sTo, sTemp, bPaid, sThemeDir, params);
        }
-       else if(AVS_OFFICESTUDIO_FILE_IMAGE == nFormatTo)
+       else if(0 != (AVS_OFFICESTUDIO_FILE_IMAGE & nFormatTo))
        {
            NSDoctRenderer::DoctRendererFormat::FormatFile eFromType = NSDoctRenderer::DoctRendererFormat::FormatFile::XLST;
            nRes = doct_bin2image(eFromType, sFrom, sTo, sTemp, bPaid, sThemeDir, params);
@@ -2176,7 +2192,7 @@ namespace NExtractTools
            NSDoctRenderer::DoctRendererFormat::FormatFile eFromType = NSDoctRenderer::DoctRendererFormat::FormatFile::PPTT;
            nRes = doct_bin2pdf(eFromType, sFrom, sTo, sTemp, bPaid, sThemeDir, params);
        }
-       else if(AVS_OFFICESTUDIO_FILE_IMAGE == nFormatTo)
+       else if(0 != (AVS_OFFICESTUDIO_FILE_IMAGE & nFormatTo))
        {
            NSDoctRenderer::DoctRendererFormat::FormatFile eFromType = NSDoctRenderer::DoctRendererFormat::FormatFile::PPTT;
            nRes = doct_bin2image(eFromType, sFrom, sTo, sTemp, bPaid, sThemeDir, params);
@@ -2306,7 +2322,7 @@ namespace NExtractTools
            oHtmlRenderer.CloseFile();
            RELEASEOBJECT(pReader);
        }
-	   else if(AVS_OFFICESTUDIO_FILE_IMAGE == nFormatTo)
+	   else if(0 != (AVS_OFFICESTUDIO_FILE_IMAGE & nFormatTo))
 	   {
 		   IOfficeDrawingFile* pReader = NULL;
 		   nRes = PdfDjvuXpsToImage(&pReader, sFrom, nFormatFrom, sTo, sTemp, params, &oApplicationFonts);

X2tConverter/src/cextracttools.cpp

@@ -293,6 +293,10 @@ namespace NExtractTools
         }
         oBuilder.WriteString(_T("</Changes>"));
         oBuilder.WriteString(sMailMerge);
+		if (NULL != params.m_oThumbnail && (NULL == params.m_oThumbnail->first || true == *params.m_oThumbnail->first))
+		{
+			oBuilder.WriteString(_T("<OnlyOnePage>1</OnlyOnePage>"));
+		}
         oBuilder.WriteString(_T("</Settings>"));
         return oBuilder.GetData();
     }