.

ASCOfficeOdfFile/OdfFileTest/OdfFileTest.vcproj

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="windows-1251"?>
 <VisualStudioProject
 	ProjectType="Visual C++"
-	Version="8.00"
+	Version="8,00"
 	Name="OdfFileReaderTest"
 	ProjectGUID="{C2882DDD-07E6-4314-AD4B-48F43F38D722}"
 	RootNamespace="ASCOfficeOdfFileTest"

ASCOfficePPTFile/PPTFormatLib/PPTXWriter/ShapeWriter.cpp

@@ -293,21 +293,79 @@ NSPresentationEditor::CShapeWriter::CShapeWriter()
 	m_pImageElement = NULL;
 	m_pShapeElement = NULL;
 }
-std::wstring	NSPresentationEditor::CShapeWriter::ConvertLine(CPen & pen)
+std::wstring NSPresentationEditor::CShapeWriter::ConvertLine(CPen & pen)
 {
 	NSPresentationEditor::CStringWriter line_writer;
 
-	std::wstring str = std::to_wstring(	(int)(pen.Size * 36000));
-	line_writer.WriteString(L"<a:ln w=\"" + str + L"\">");
+	std::wstring strL;
+	switch(pen.LineStyle)
+	{
+		case 1: strL = L"  cmpd=\"dbl\"";		break;
+		case 2: strL = L"  cmpd=\"thickThin\""; break;
+		case 3: strL = L"  cmpd=\"thinThick\"";	break;
+		case 4: strL = L"  cmpd=\"tri\"";		break;
+	}
+	line_writer.WriteString(L"<a:ln w=\"" + std::to_wstring((int)(pen.Size * 36000)) + L"\"" + strL + L">");
 
 	line_writer.WriteString(L"<a:solidFill>");
 		line_writer.WriteString(ConvertColor(pen.Color, pen.Alpha));
 	line_writer.WriteString(L"</a:solidFill>");
 
-	line_writer.WriteString(L"<a:round/><a:headEnd/><a:tailEnd/></a:ln>");
+	switch(pen.DashStyle)
+	{
+		case 1:	line_writer.WriteString(L"<a:prstDash val=\"sysDash\"/>");			break;
+		case 2:	line_writer.WriteString(L"<a:prstDash val=\"sysDot\"/>");			break;
+		case 3:	line_writer.WriteString(L"<a:prstDash val=\"sysDashDot\"/>");		break;
+		case 4:	line_writer.WriteString(L"<a:prstDash val=\"sysDashDotDot\"/>");	break;
+		case 5:	line_writer.WriteString(L"<a:prstDash val=\"dot\"/>");				break;
+		case 6:	line_writer.WriteString(L"<a:prstDash val=\"dash\"/>");				break;
+		case 7:	line_writer.WriteString(L"<a:prstDash val=\"lgDash\"/>");			break;
+		case 8:	line_writer.WriteString(L"<a:prstDash val=\"dashDot\"/>");			break;
+		case 9:	line_writer.WriteString(L"<a:prstDash val=\"lgDashDot\"/>");		break;
+		case 10:line_writer.WriteString(L"<a:prstDash val=\"lgDashDotDot\"/>");		break;
+	}
+	switch(pen.LineJoin)
+	{
+		case 0:	line_writer.WriteString(L"<a:bevel/>");	break;
+		case 1:	line_writer.WriteString(L"<a:miter/>");	break;
+		case 2:	line_writer.WriteString(L"<a:round/>");	break;
+	}
+
+	line_writer.WriteString(L"<a:headEnd" + ConvertLineEnd(pen.LineStartCap, pen.LineStartLength, pen.LineStartWidth)	+ L"/>");
+	line_writer.WriteString(L"<a:tailEnd" + ConvertLineEnd(pen.LineEndCap, pen.LineEndLength, pen.LineEndWidth)			+ L"/>");
+		
+	line_writer.WriteString(L"</a:ln>");
 
 	return line_writer.GetData();
 }
+std::wstring NSPresentationEditor::CShapeWriter::ConvertLineEnd(unsigned char cap, unsigned char length, unsigned char width)
+{
+	if (cap < 1) return L"";
+
+	std::wstring sResult;
+
+	switch(cap)
+	{
+		case 1: sResult += L" type=\"triangle\"";	break;
+		case 2: sResult += L" type=\"stealth\"";	break;
+		case 3: sResult += L" type=\"diamond\"";	break;
+		case 4: sResult += L" type=\"oval\"";		break;
+		case 5: sResult += L" type=\"arrow\"";		break;
+	}
+	switch(length)
+	{
+		case 0: sResult += L" len=\"sm\"";	break;
+		case 1: sResult += L" len=\"med\"";	break;
+		case 2: sResult += L" len=\"lg\"";	break;
+	}
+	switch(width)
+	{
+		case 0: sResult += L" w=\"sm\"";	break;
+		case 1: sResult += L" w=\"med\"";	break;
+		case 2: sResult += L" w=\"lg\"";	break;
+	}
+	return sResult;
+}
 std::wstring	NSPresentationEditor::CShapeWriter::ConvertBrush(CBrush & brush)
 {
 	NSPresentationEditor::CStringWriter brush_writer;
@@ -1168,7 +1226,8 @@ std::wstring NSPresentationEditor::CShapeWriter::ConvertShape()
 			}
 		m_oWriter.WriteString(std::wstring(L">"));
 
-        m_oWriter.WriteString(L"<a:off x=\"" + std::to_wstring((int)m_pShapeElement->m_rcBoundsOriginal.left) + L"\" y=\"" + std::to_wstring((int)m_pShapeElement->m_rcBoundsOriginal.top) + L"\"/>");
+        m_oWriter.WriteString(L"<a:off x=\"" + std::to_wstring((int)m_pShapeElement->m_rcBoundsOriginal.left) + 
+								L"\" y=\"" + std::to_wstring((int)m_pShapeElement->m_rcBoundsOriginal.top) + L"\"/>");
 
 		int width	= m_pShapeElement->m_rcBoundsOriginal.right - m_pShapeElement->m_rcBoundsOriginal.left;
 		int height	= m_pShapeElement->m_rcBoundsOriginal.bottom - m_pShapeElement->m_rcBoundsOriginal.top;

ASCOfficePPTFile/PPTFormatLib/PPTXWriter/ShapeWriter.h

@@ -213,6 +213,7 @@ namespace NSPresentationEditor
             std::wstring	ConvertShadow	(CShadow	& shadow);
             std::wstring	ConvertBrush	(CBrush		& brush);
     static	std::wstring	ConvertColor	(CColor		& color, long alpha);
+			std::wstring ConvertLineEnd(unsigned char cap, unsigned char length, unsigned char width);
 // тип рендерера-----------------------------------------------------------------------------
     virtual HRESULT get_Type(LONG* lType)	;
 //-------- Функции для работы со страницей --------------------------------------------------

ASCOfficePPTFile/PPTFormatLib/Reader/PPTFileDefines.h

@@ -401,48 +401,47 @@ static std::string GetRecordName(DWORD dwType)
 	case RECORD_TYPE_ROUNDTRIPNOTESMASTERTEXTSTYLES12				: { strName = ("RoundTripNotesMasterTextStyles12"); break; }
 	case RECORD_TYPE_ROUNDTRIPCUSTOMTABLESTYLES12					: { strName = ("RoundTripCustomTableStyles12"); break; }
 
-	//records greater then 0xF000 belong to with Microsoft Office Drawing format also known as Escher
-	case RECORD_TYPE_ESCHER_DGG_CONTAINER							: { strName = ("Escher_DrawingGroupContainer"); break; }
-	case RECORD_TYPE_ESCHER_DGG										: { strName = ("Escher_DrawingGroupRecord"); break; }
-	case RECORD_TYPE_ESCHER_CLSID									: { strName = ("Escher_CLSID_Record"); break; }
-	case RECORD_TYPE_ESCHER_OPT										: { strName = ("Escher_OPT"); break; }
-	case RECORD_TYPE_ESCHER_BSTORE_CONTAINER						: { strName = ("Escher_BlipStoreContainer"); break; }
-	case RECORD_TYPE_ESCHER_BSE										: { strName = ("Escher_BlipStoreEntry"); break; }
-	case RECORD_TYPE_ESCHER_BLIP_START								: { strName = ("Escher_BlipStart"); break; }
-	case RECORD_TYPE_ESCHER_BLIP_END								: { strName = ("Escher_BlipEnd"); break; }
-	case RECORD_TYPE_ESCHER_DG_CONTAINER							: { strName = ("Escher_DrawingContainer"); break; }
-	case RECORD_TYPE_ESCHER_DG										: { strName = ("Escher_DrawingRecord"); break; }
-	case RECORD_TYPE_ESCHER_REGROUPITEMS							: { strName = ("Escher_RegGroupItems"); break; }
-	case RECORD_TYPE_ESCHER_COLORSCHEME								: { strName = ("Escher_ColorSheme"); break; }
-	case RECORD_TYPE_ESCHER_SPGR_CONTAINER							: { strName = ("Escher_GroupShapeContainer"); break; }
-	case RECORD_TYPE_ESCHER_SP_CONTAINER							: { strName = ("Escher_ShapeContainer"); break; }
-	case RECORD_TYPE_ESCHER_SPGR									: { strName = ("Escher_GroupShapeRecord"); break; }
-	case RECORD_TYPE_ESCHER_SP										: { strName = ("Escher_ShapeRecord"); break; }
-	case RECORD_TYPE_ESCHER_TEXTBOX									: { strName = ("Escher_TextBox"); break; }
-	case RECORD_TYPE_ESCHER_CLIENTTEXTBOX							: { strName = ("Escher_ClientTextBox"); break; }
-	case RECORD_TYPE_ESCHER_ANCHOR									: { strName = ("Escher_Anchor"); break; }
-	case RECORD_TYPE_ESCHER_CHILDANCHOR								: { strName = ("Escher_ChildAnchor"); break; }
-	case RECORD_TYPE_ESCHER_CLIENTANCHOR							: { strName = ("Escher_ClientAnchor"); break; }
-	case RECORD_TYPE_ESCHER_CLIENTDATA								: { strName = ("Escher_ClientData"); break; }
-	case RECORD_TYPE_ESCHER_SOLVERCONTAINER							: { strName = ("Escher_SolverContainer"); break; }
-	case RECORD_TYPE_ESCHER_CONNECTORRULE							: { strName = ("Escher_ConnectorRule"); break; }
-	case RECORD_TYPE_ESCHER_ALIGNRULE								: { strName = ("Escher_AlignRule"); break; }
-	case RECORD_TYPE_ESCHER_ARCRULE									: { strName = ("Escher_ArcRule"); break; }
-	case RECORD_TYPE_ESCHER_CLIENTRULE								: { strName = ("Escher_ClientRule"); break; }
-	case RECORD_TYPE_ESCHER_CALLOUTRULE								: { strName = ("Escher_CallOutRule"); break; }
-	case RECORD_TYPE_ESCHER_SELECTION								: { strName = ("Escher_Selection"); break; }
-	case RECORD_TYPE_ESCHER_COLORMRU								: { strName = ("Escher_ColorMRU"); break; }
-	case RECORD_TYPE_ESCHER_DELETEDPSPL								: { strName = ("Escher_DeletedPSPL"); break; }
-	case RECORD_TYPE_ESCHER_SPLITMENUCOLORS							: { strName = ("Escher_SplitMenuColors"); break; }
-	case RECORD_TYPE_ESCHER_OLEOBJECT								: { strName = ("Escher_OleObject"); break; }
-	case RECORD_TYPE_ESCHER_SECONDARY_OPT							: { strName = ("Escher_SecondaryOPT"); break; }
-	case RECORD_TYPE_ESCHER_TETRIARY_OPT							: { strName = ("Escher_TetriaryOPT"); break; }
+	case RECORD_TYPE_ESCHER_DGG_CONTAINER							: { strName = ("DrawingGroupContainer"); break; }
+	case RECORD_TYPE_ESCHER_DGG										: { strName = ("DrawingGroupRecord"); break; }
+	case RECORD_TYPE_ESCHER_CLSID									: { strName = ("CLSID_Record"); break; }
+	case RECORD_TYPE_ESCHER_OPT										: { strName = ("OPT"); break; }
+	case RECORD_TYPE_ESCHER_BSTORE_CONTAINER						: { strName = ("BlipStoreContainer"); break; }
+	case RECORD_TYPE_ESCHER_BSE										: { strName = ("BlipStoreEntry"); break; }
+	case RECORD_TYPE_ESCHER_BLIP_START								: { strName = ("BlipStart"); break; }
+	case RECORD_TYPE_ESCHER_BLIP_END								: { strName = ("BlipEnd"); break; }
+	case RECORD_TYPE_ESCHER_DG_CONTAINER							: { strName = ("DrawingContainer"); break; }
+	case RECORD_TYPE_ESCHER_DG										: { strName = ("DrawingRecord"); break; }
+	case RECORD_TYPE_ESCHER_REGROUPITEMS							: { strName = ("RegGroupItems"); break; }
+	case RECORD_TYPE_ESCHER_COLORSCHEME								: { strName = ("ColorSheme"); break; }
+	case RECORD_TYPE_ESCHER_SPGR_CONTAINER							: { strName = ("GroupShapeContainer"); break; }
+	case RECORD_TYPE_ESCHER_SP_CONTAINER							: { strName = ("ShapeContainer"); break; }
+	case RECORD_TYPE_ESCHER_SPGR									: { strName = ("GroupShapeRecord"); break; }
+	case RECORD_TYPE_ESCHER_SP										: { strName = ("ShapeRecord"); break; }
+	case RECORD_TYPE_ESCHER_TEXTBOX									: { strName = ("TextBox"); break; }
+	case RECORD_TYPE_ESCHER_CLIENTTEXTBOX							: { strName = ("ClientTextBox"); break; }
+	case RECORD_TYPE_ESCHER_ANCHOR									: { strName = ("Anchor"); break; }
+	case RECORD_TYPE_ESCHER_CHILDANCHOR								: { strName = ("ChildAnchor"); break; }
+	case RECORD_TYPE_ESCHER_CLIENTANCHOR							: { strName = ("ClientAnchor"); break; }
+	case RECORD_TYPE_ESCHER_CLIENTDATA								: { strName = ("ClientData"); break; }
+	case RECORD_TYPE_ESCHER_SOLVERCONTAINER							: { strName = ("SolverContainer"); break; }
+	case RECORD_TYPE_ESCHER_CONNECTORRULE							: { strName = ("ConnectorRule"); break; }
+	case RECORD_TYPE_ESCHER_ALIGNRULE								: { strName = ("AlignRule"); break; }
+	case RECORD_TYPE_ESCHER_ARCRULE									: { strName = ("ArcRule"); break; }
+	case RECORD_TYPE_ESCHER_CLIENTRULE								: { strName = ("ClientRule"); break; }
+	case RECORD_TYPE_ESCHER_CALLOUTRULE								: { strName = ("CallOutRule"); break; }
+	case RECORD_TYPE_ESCHER_SELECTION								: { strName = ("Selection"); break; }
+	case RECORD_TYPE_ESCHER_COLORMRU								: { strName = ("ColorMRU"); break; }
+	case RECORD_TYPE_ESCHER_DELETEDPSPL								: { strName = ("DeletedPSPL"); break; }
+	case RECORD_TYPE_ESCHER_SPLITMENUCOLORS							: { strName = ("SplitMenuColors"); break; }
+	case RECORD_TYPE_ESCHER_OLEOBJECT								: { strName = ("OleObject"); break; }
+	case RECORD_TYPE_ESCHER_SECONDARY_OPT							: { strName = ("SecondaryOPT"); break; }
+	case RECORD_TYPE_ESCHER_TETRIARY_OPT							: { strName = ("TetriaryOPT"); break; }
 	default: break;
 	};
 
 	if ((dwType > RECORD_TYPE_ESCHER_BLIP_START) && (dwType < RECORD_TYPE_ESCHER_BLIP_END))
 	{
-		strName = ("Escher_Blip");
+		strName = ("Blip");
 	}
 
 	return strName;

ASCOfficePPTFile/PPTFormatLib/Records/Drawing/ShapeContainer.h

@@ -575,212 +575,134 @@ public:
 			}
 // line --------------------------------------------------------
 		case lineBoolean: //Line Style Boolean Properties
-			{
-				bool bNoLineDrawDash		= GETBIT(pProperty->m_lValue, 0);
-				bool bLineFillShape			= GETBIT(pProperty->m_lValue, 1);
-				bool bHitTestLine			= GETBIT(pProperty->m_lValue, 2);
-				bool bLine					= GETBIT(pProperty->m_lValue, 3);
-				bool bArrowheadsOK			= GETBIT(pProperty->m_lValue, 4);
-				bool bInsetPenOK			= GETBIT(pProperty->m_lValue, 5);
-				bool bInsetPen				= GETBIT(pProperty->m_lValue, 6);
-				bool bLineOpaqueBackColor	= GETBIT(pProperty->m_lValue, 9);
+		{
+			bool bNoLineDrawDash		= GETBIT(pProperty->m_lValue, 0);
+			bool bLineFillShape			= GETBIT(pProperty->m_lValue, 1);
+			bool bHitTestLine			= GETBIT(pProperty->m_lValue, 2);
+			bool bLine					= GETBIT(pProperty->m_lValue, 3);
+			bool bArrowheadsOK			= GETBIT(pProperty->m_lValue, 4);
+			bool bInsetPenOK			= GETBIT(pProperty->m_lValue, 5);
+			bool bInsetPen				= GETBIT(pProperty->m_lValue, 6);
+			bool bLineOpaqueBackColor	= GETBIT(pProperty->m_lValue, 9);
 
-				bool bUsefNoLineDrawDash	= GETBIT(pProperty->m_lValue, 16);
-				bool bUsefLineFillShape		= GETBIT(pProperty->m_lValue, 17);
-				bool bUsefHitTestLine		= GETBIT(pProperty->m_lValue, 18);
-				bool bUsefLine				= GETBIT(pProperty->m_lValue, 19);
-				bool bUsefArrowheadsOK		= GETBIT(pProperty->m_lValue, 20);
-				bool bUsefInsetPenOK		= GETBIT(pProperty->m_lValue, 21);
-				bool bUsefInsetPen			= GETBIT(pProperty->m_lValue, 22);
-				bool bUsefLineOpaqueBackColor = GETBIT(pProperty->m_lValue, 25);
+			bool bUsefNoLineDrawDash	= GETBIT(pProperty->m_lValue, 16);
+			bool bUsefLineFillShape		= GETBIT(pProperty->m_lValue, 17);
+			bool bUsefHitTestLine		= GETBIT(pProperty->m_lValue, 18);
+			bool bUsefLine				= GETBIT(pProperty->m_lValue, 19);
+			bool bUsefArrowheadsOK		= GETBIT(pProperty->m_lValue, 20);
+			bool bUsefInsetPenOK		= GETBIT(pProperty->m_lValue, 21);
+			bool bUsefInsetPen			= GETBIT(pProperty->m_lValue, 22);
+			bool bUsefLineOpaqueBackColor = GETBIT(pProperty->m_lValue, 25);
 
-				if (bUsefLine)
-					pElement->m_bLine = bLine;				
-			}break;
-		case lineStyle:
+			if (bUsefLine)
+				pElement->m_bLine = bLine;				
+		}break;
 		case lineDashStyle://from Complex
-			{
-				pElement->m_bLine = true;	
-			}break;
+		{
+			pElement->m_bLine = true;	
+		}break;
 		case lineColor:
-			{
-				SColorAtom oAtom;
-				oAtom.FromValue(pProperty->m_lValue);
-				
-				if (oAtom.bSysIndex)
-					pElement->m_oPen.Color = CorrectSysColor(pProperty->m_lValue, pElement, pTheme);
-				else
-					oAtom.ToColor(&pElement->m_oPen.Color);
-				break;
-			}
+		{
+			SColorAtom oAtom;
+			oAtom.FromValue(pProperty->m_lValue);
+			
+			if (oAtom.bSysIndex)
+				pElement->m_oPen.Color = CorrectSysColor(pProperty->m_lValue, pElement, pTheme);
+			else
+				oAtom.ToColor(&pElement->m_oPen.Color);			
+		}break;
 		case lineOpacity:
-			{
-                pElement->m_oPen.Alpha = (BYTE)(std::min)(255, (int)CDirectory::NormFixedPoint(pProperty->m_lValue, 255));
-				break;
-			}
+		{
+            pElement->m_oPen.Alpha = (BYTE)(std::min)(255, (int)CDirectory::NormFixedPoint(pProperty->m_lValue, 255));				
+		}break;
 		case lineBackColor:
-			{
-				SColorAtom oAtom;
-				oAtom.FromValue(pProperty->m_lValue);
-				
-				if (oAtom.bSysIndex)
-					pElement->m_oPen.Color2 = CorrectSysColor(pProperty->m_lValue, pElement, pTheme);
-				else 
-					oAtom.ToColor(&pElement->m_oPen.Color2);
+		{
+			SColorAtom oAtom;
+			oAtom.FromValue(pProperty->m_lValue);
+			
+			if (oAtom.bSysIndex)
+				pElement->m_oPen.Color2 = CorrectSysColor(pProperty->m_lValue, pElement, pTheme);
+			else 
+				oAtom.ToColor(&pElement->m_oPen.Color2);
 
-			}break;
+		}break;
 		case lineWidth:
-			{
-				pElement->m_oPen.Size	= (double)pProperty->m_lValue / EMU_MM;
-				pElement->m_bLine		= true;
-				break;
-			}
+		{
+			pElement->m_oPen.Size	= (double)pProperty->m_lValue / EMU_MM;
+			pElement->m_bLine		= true;				
+		}break;
+		case lineStyle:
+		{
+			pElement->m_bLine			= true;
+			pElement->m_oPen.LineStyle	= pProperty->m_lValue;				
+		}break;
 		case lineDashing:
-			{
-				BYTE nDashStyle = 0;
-				switch (pProperty->m_lValue)
-				{
-				case 0: 
-					{ 
-						nDashStyle = 0; // solid 						 
-					}break;
-				case 1: 
-				case 6:
-				case 7:
-					{ 
-						nDashStyle = 1; // dash 						
-					}break; 
-				case 2:
-				case 5:
-					{ 
-						nDashStyle = 2; // dot 						 
-					}break;
-				case 3:
-				case 8:
-				case 9:
-					{ 
-						nDashStyle = 3; // dashdot 						
-					}break; 
-				case 4:
-				case 10:
-					{ 
-						nDashStyle = 4;// dashdotdot 						
-					}break; 
-				default:
-						break; 
-				};
-				pElement->m_bLine				= true;
-				pElement->m_oPen.DashStyle	= nDashStyle;
-				break;
-			}
+		{
+			pElement->m_bLine			= true;
+			pElement->m_oPen.DashStyle	= pProperty->m_lValue;				
+		}break;
 		case lineJoinStyle:
-			{
-				BYTE nLineJoin = 2;
-				switch (pProperty->m_lValue)
-				{
-				case 0: 
-					{ 
-						nLineJoin = 1; // bevel 						 
-					}break;
-				case 1: 
-					{ 
-						nLineJoin = 1; // Miter 						 
-					}break;
-				case 2:
-					{ 
-						nLineJoin = 2; // round 						 
-					}break;	
-				default:
-						break; 
-				};
-
-				pElement->m_oPen.LineJoin = nLineJoin;
-				break;
-			}
+		{
+			pElement->m_oPen.LineJoin = pProperty->m_lValue;				
+		}break;
+		case lineStartArrowLength:
+		{
+			pElement->m_oPen.LineStartLength = pProperty->m_lValue;				
+		}break;
+		case lineEndArrowLength:
+		{
+			pElement->m_oPen.LineEndLength = pProperty->m_lValue;				
+		}break;
+		case lineStartArrowWidth:
+		{
+			pElement->m_oPen.LineStartWidth = pProperty->m_lValue;				
+		}break;
+		case lineEndArrowWidth:
+		{
+			pElement->m_oPen.LineEndWidth = pProperty->m_lValue;				
+		}break;
 		case lineStartArrowhead:
-			{
-				BYTE nStartCap = 0;
-				switch (pProperty->m_lValue)
-				{
-				case 1: 
-				case 2:
-				case 5:
-					{ 
-						nStartCap = 0x14; 
-					}break;
-				case 3:
-				case 4:
-
-					{ 
-						nStartCap = 2; 
-					}break; 
-				default:
-						break; 
-				};
-
-				pElement->m_oPen.LineStartCap = nStartCap;
-
-				break;
-			}
+		{
+			pElement->m_oPen.LineStartCap = pProperty->m_lValue;				
+		}break;
 		case lineEndArrowhead:
-			{
-				BYTE nEndCap = 0;
-				switch (pProperty->m_lValue)
-				{
-				case 1: 
-				case 2:
-				case 5:
-					{ 
-						nEndCap = 0x14; 						
-					}break; 
-				case 3:
-				case 4:
-
-					{ 
-						nEndCap = 2; 
-					}break; 
-				default:
-					break; 
-				};
-
-				pElement->m_oPen.LineEndCap = nEndCap;
-				break;
-			}
+		{
+			pElement->m_oPen.LineEndCap = pProperty->m_lValue;			
+		}break;
 		case shadowType:
-			{
-				pElement->m_oShadow.Type = pProperty->m_lValue;
-
-			}break;
+		{
+			pElement->m_oShadow.Type = pProperty->m_lValue;
+		}break;
 		case shadowOriginX://in emu, relative from center shape
-			{
-				pElement->m_oShadow.OriginX = FixedPointToDouble(pProperty->m_lValue);
-			}break;
+		{
+			pElement->m_oShadow.OriginX = FixedPointToDouble(pProperty->m_lValue);
+		}break;
 		case shadowOriginY:
-			{
-				pElement->m_oShadow.OriginY = FixedPointToDouble(pProperty->m_lValue);
-			}break;
+		{
+			pElement->m_oShadow.OriginY = FixedPointToDouble(pProperty->m_lValue);
+		}break;
 		case shadowColor:
-			{
-				SColorAtom oAtom;
-				oAtom.FromValue(pProperty->m_lValue);
+		{
+			SColorAtom oAtom;
+			oAtom.FromValue(pProperty->m_lValue);
 
-				if (oAtom.bSysIndex)
-					pElement->m_oShadow.Color = CorrectSysColor(pProperty->m_lValue, pElement, pTheme);
-				else
-					oAtom.ToColor(&pElement->m_oShadow.Color);
+			if (oAtom.bSysIndex)
+				pElement->m_oShadow.Color = CorrectSysColor(pProperty->m_lValue, pElement, pTheme);
+			else
+				oAtom.ToColor(&pElement->m_oShadow.Color);
 
-			}break;
+		}break;
 		case shadowWeight:
 			{
 			}break;
 		case shadowOpacity:
-			{
-                pElement->m_oShadow.Alpha = (BYTE)(std::min)(255, (int)CDirectory::NormFixedPoint(pProperty->m_lValue, 255));
-			}break;
+		{
+            pElement->m_oShadow.Alpha = (BYTE)(std::min)(255, (int)CDirectory::NormFixedPoint(pProperty->m_lValue, 255));
+		}break;
 		case shadowHighlight:
-			{
-				//оттенок двойной тени
-			}break;
+		{
+			//оттенок двойной тени
+		}break;
 		case shadowOffsetX:
 			{
 				pElement->m_oShadow.DistanceX = ((int)pProperty->m_lValue) / EMU_MM;
@@ -949,65 +871,80 @@ public:
 
 		switch (pProperty->m_ePID)
 		{
-			// здесь просто применяем проперти...
-			// geometry ----------------------------------------------------
-			// top, left, right, bottom logic
 		case NSOfficeDrawing::metroBlob:
-			{
-				//альтернатива в формате oox
-				//NSFile::CFileBinary f;
-				//f.CreateFileW(L"d:\\test.zip");
-				//f.WriteFile(pProperty->m_pOptions, pProperty->m_lValue);
-				//f.CloseFile();
-			}break;
+		{
+			//альтернатива в формате oox
+			//NSFile::CFileBinary f;
+			//f.CreateFileW(L"d:\\test.zip");
+			//f.WriteFile(pProperty->m_pOptions, pProperty->m_lValue);
+			//f.CloseFile();
+		}break;
 		case NSOfficeDrawing::geoRight:
-			{
-				if (0 < pProperty->m_lValue)
-					pParentShape->m_dWidthLogic = (double)(pProperty->m_lValue);				
-			}break;
+		{
+			if (0 < pProperty->m_lValue)
+				pParentShape->m_dWidthLogic = (double)(pProperty->m_lValue);				
+		}break;
 		case NSOfficeDrawing::geoBottom:
-			{
-				if (0 < pProperty->m_lValue)
-					pParentShape->m_dHeightLogic = (double)(pProperty->m_lValue);				
-			}break;
-			// shapePath
+		{
+			if (0 < pProperty->m_lValue)
+				pParentShape->m_dHeightLogic = (double)(pProperty->m_lValue);				
+		}break;
 		case NSOfficeDrawing::shapePath:
-			{
-				pShape->m_oCustomVML.SetPath((RulesType)pProperty->m_lValue);				
-				pShape->m_bCustomShape = true;
-			}break;
-			// segmentsInfo
+		{
+			pShape->m_oCustomVML.SetPath((RulesType)pProperty->m_lValue);				
+			pShape->m_bCustomShape = true;
+		}break;
 		case NSOfficeDrawing::pSegmentInfo:
+		{
+			if (pProperty->m_bComplex)
 			{
-				if (pProperty->m_bComplex)
-				{
-					pShape->m_oCustomVML.LoadSegments(pProperty);
-					pShape->m_bCustomShape = true;
-				}				
-			}break;
-			// verticesInfo
+				pShape->m_oCustomVML.LoadSegments(pProperty);
+				pShape->m_bCustomShape = true;
+			}				
+		}break;
 		case NSOfficeDrawing::pVertices:
+		{
+			if (pProperty->m_bComplex)
 			{
-				if (pProperty->m_bComplex)
-				{
-					pShape->m_oCustomVML.LoadVertices(pProperty);
-					pShape->m_bCustomShape = true;
-				}				
-			}break;
+				pShape->m_oCustomVML.LoadVertices(pProperty);
+				pShape->m_bCustomShape = true;
+			}				
+		}break;
+		case NSOfficeDrawing::pConnectionSites:
+		{
+			if (pProperty->m_bComplex)
+			{
+				pShape->m_oCustomVML.LoadConnectionSites(pProperty);
+			}				
+		}break;
+		case NSOfficeDrawing::pConnectionSitesDir:
+		{
+			if (pProperty->m_bComplex)
+			{
+				pShape->m_oCustomVML.LoadConnectionSitesDir(pProperty);
+			}				
+		}break;
 		case NSOfficeDrawing::pGuides:
+		{
+			if (pProperty->m_bComplex/* && pShape->m_eType != sptNotchedCircularArrow*/)
+			{//Тікбұрышты үшбұрыштарды.ppt - slide 25
+				pShape->m_oCustomVML.LoadGuides(pProperty);
+			}				
+		}break;
+		case NSOfficeDrawing::pInscribe:
+		{
+			if (pProperty->m_bComplex)
 			{
-				if (pProperty->m_bComplex && pShape->m_eType != sptNotchedCircularArrow)
-				{//Тікбұрышты үшбұрыштарды.ppt - slide 25
-					pShape->m_oCustomVML.LoadGuides(pProperty);
-				}				
-			}break;
+				pShape->m_oCustomVML.LoadInscribe(pProperty);
+			}
+		}break;
 		case NSOfficeDrawing::pAdjustHandles:
+		{
+			if (pProperty->m_bComplex)
 			{
-				if (pProperty->m_bComplex)
-				{
-					pShape->m_oCustomVML.LoadAHs(pProperty);
-				}				
-			}break;
+				pShape->m_oCustomVML.LoadAHs(pProperty);
+			}				
+		}break;
 		case NSOfficeDrawing::adjustValue:
 		case NSOfficeDrawing::adjust2Value:
 		case NSOfficeDrawing::adjust3Value:

ASCOfficePPTFile/PPTFormatLib/Win32/PPTFormatLib.vcproj

@@ -1026,6 +1026,26 @@
 				RelativePath="..\..\..\ASCOfficePPTXFile\Editor\Drawing\XmlWriter.h"
 				>
 			</File>
+			<Filter
+				Name="ppt shapes"
+				>
+				<File
+					RelativePath="..\..\..\ASCOfficePPTXFile\Editor\Drawing\Shapes\BaseShape\PPTShape\customgeomshape.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\ASCOfficePPTXFile\Editor\Drawing\Shapes\BaseShape\PPTShape\elementsettings.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\ASCOfficePPTXFile\Editor\Drawing\Shapes\BaseShape\PPTShape\formula.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\ASCOfficePPTXFile\Editor\Drawing\Shapes\BaseShape\PPTShape\PPTShape.h"
+					>
+				</File>
+			</Filter>
 		</Filter>
 		<Filter
 			Name="OOXWriter"

ASCOfficePPTXFile/Editor/Drawing/Attributes.h

@@ -478,10 +478,17 @@ namespace NSPresentationEditor
         long Alpha;
         double Size;
 
-        BYTE DashStyle;
-        BYTE LineStartCap;
-        BYTE LineEndCap;
-        BYTE LineJoin;
+		unsigned char DashStyle;
+		unsigned char LineStyle;
+		unsigned char LineJoin;
+		
+		unsigned char LineEndCap;
+		unsigned char LineEndLength;
+		unsigned char LineEndWidth;
+
+		unsigned char LineStartCap;
+		unsigned char LineStartLength;
+		unsigned char LineStartWidth;
 
         double* DashPattern;
         long Count;
@@ -492,9 +499,8 @@ namespace NSPresentationEditor
         double MiterLimit;
 
         CColor Color2;	//backLine
-    public:
 
-        void GetDashPattern(double* arrDashPattern, long& nCount) const
+		void GetDashPattern(double* arrDashPattern, long& nCount) const
         {
             if (nCount == Count)
             {
@@ -579,10 +585,16 @@ namespace NSPresentationEditor
             Alpha = 255;
             Size  = 0.26458;
 
-            DashStyle    = 0;
-            LineStartCap = 0;
-            LineEndCap   = 0;
-            LineJoin     = 0;
+			LineStyle	= 0; //single(Simple)
+			DashStyle	= 0; //Solid
+			LineJoin	= 2; //round
+
+			LineStartCap	= 0;
+			LineEndCap		= 0;
+			LineEndLength	= 1; //med
+			LineStartLength	= 1;
+			LineEndWidth	= 1;
+			LineStartWidth	= 1;
 
             DashPattern = NULL;
             Count       = 0;

ASCOfficePPTXFile/Editor/Drawing/Shapes/BaseShape/PPTShape/CustomGeomShape.h

@@ -488,6 +488,9 @@ namespace NSCustomVML
         std::vector<CSegment>			m_arSegments;
         std::vector<CGuide>				m_arGuides;
         std::vector<LONG>*				m_pAdjustValues;
+        std::vector<Aggplus::POINT>		m_arConnectionSites;
+		std::vector<Aggplus::RECT>		m_arInscribe;
+        std::vector<double>				m_arConnectionSitesDir;
 
         bool m_bIsVerticesPresent;
         bool m_bIsPathPresent;
@@ -496,7 +499,7 @@ namespace NSCustomVML
         CPen	m_oPen;
 
     public:
-        CCustomVML() : m_arVertices(), m_arSegments(), m_arGuides(), m_pAdjustValues(NULL)
+        CCustomVML() : m_pAdjustValues(NULL)
         {
             m_ePath = rtCurveTo/*rtLineTo*/;
 
@@ -579,6 +582,63 @@ namespace NSCustomVML
                 m_arVertices.push_back(oPoint);
             }
         }
+		void LoadConnectionSitesDir(CProperty* pProperty)
+        {
+            NSOfficeDrawing::CBinaryReader oReader(pProperty->m_pOptions, pProperty->m_lValue);
+            m_arConnectionSitesDir.clear();
+           
+			WORD lCount = (WORD)(pProperty->m_lValue / 4);
+            
+			for (WORD lIndex = 0; lIndex < lCount; ++lIndex)
+            {
+                DWORD v = oReader.ReadLONG();
+				double val = (double)((WORD)(v >> 16) + ((WORD)(v) / 65536.0));
+				m_arConnectionSitesDir.push_back(val);
+			}
+		}
+		void LoadConnectionSites(CProperty* pProperty)
+        {
+            NSOfficeDrawing::CBinaryReader oReader(pProperty->m_pOptions, pProperty->m_lValue);
+            m_arConnectionSites.clear();
+
+            WORD lCount = (WORD)(pProperty->m_lValue / 8);
+            if (pProperty->m_bIsTruncated)
+            {
+                lCount = (WORD)(pProperty->m_lValue / 4);
+            }
+
+            for (WORD lIndex = 0; lIndex < lCount; ++lIndex)
+            {
+                Aggplus::POINT oPoint;
+                if (pProperty->m_bIsTruncated)
+                {
+                    oPoint.x = (short)oReader.ReadWORD();
+                    oPoint.y = (short)oReader.ReadWORD();
+                }
+                else
+                {
+                    oPoint.x = oReader.ReadLONG();
+                    oPoint.y = oReader.ReadLONG();
+                }
+
+                LONG lMinF = (LONG)0x80000000;
+                LONG lMaxF = (LONG)0x8000007F;
+                if (lMinF <= oPoint.x)
+                {
+                    int nGuideIndex = (DWORD)oPoint.x - 0x80000000;
+
+                    bool b = false;
+                }
+                if (lMinF <= oPoint.y)
+                {
+                    int nGuideIndex = (DWORD)oPoint.y - 0x80000000;
+
+                    bool b = false;
+                }
+
+                m_arConnectionSites.push_back(oPoint);
+            }
+		}
         void LoadVertices(CProperty* pProperty)
         {
             NSOfficeDrawing::CBinaryReader oReader(pProperty->m_pOptions, pProperty->m_lValue);
@@ -704,8 +764,38 @@ namespace NSCustomVML
                 oInfo.Read(oReader);
                 m_arGuides.push_back(oInfo);
             }
-
         }
+		void LoadInscribe(CProperty* pProperty)
+		{
+            NSOfficeDrawing::CBinaryReader oReader(pProperty->m_pOptions, pProperty->m_lValue);
+            m_arInscribe.clear();
+
+            WORD lCount = (WORD)(pProperty->m_lValue / 16);
+            if (pProperty->m_bIsTruncated)
+            {
+                lCount = (WORD)(pProperty->m_lValue / 8);
+            }
+
+            for (WORD lIndex = 0; lIndex < lCount; ++lIndex)
+            {
+                Aggplus::RECT oRect;
+                if (pProperty->m_bIsTruncated)
+                {
+                    oRect.left		= (short)oReader.ReadWORD();
+                    oRect.right		= (short)oReader.ReadWORD();
+					oRect.top		= (short)oReader.ReadWORD();
+					oRect.bottom	= (short)oReader.ReadWORD();
+               }
+                else
+                {
+                    oRect.left		= (short)oReader.ReadLONG();
+                    oRect.right		= (short)oReader.ReadLONG();
+					oRect.top		= (short)oReader.ReadLONG();
+					oRect.bottom	= (short)oReader.ReadLONG();
+                }
+                m_arInscribe.push_back(oRect);
+            }
+		}
         void LoadAdjusts(LONG lIndex, LONG lValue)
         {
             if (NULL == m_pAdjustValues)

ASCOfficePPTXFile/Editor/Drawing/Shapes/BaseShape/PPTShape/PPTShape.cpp

@@ -47,10 +47,10 @@ CPPTShape* CPPTShape::CreateByType(PPTShapes::ShapeType type)
 	CPPTShape* pShape = NULL;
 	switch (type)
 	{
-// msosptNotchedCircularArrow           0x00000064 A value that SHOULD NOT be used.
+// msosptNotchedCircularArrow	0x00000064 A value that SHOULD NOT be used.
 // msosptHostControl			0x000000C9 A value that SHOULD NOT be used.
 
-	case sptNotchedCircularArrow:
+	//case sptNotchedCircularArrow:
 	case sptHostControl:		
 			{ pShape = new CPPTShape();  pShape->m_eType = type; break; }
 	case 0: { pShape = new CRectangleType(); break; }

ASCOfficeXlsFile2/source/XlsXlsxConverter/ShapeType.h

@@ -251,6 +251,19 @@ namespace oox
         case msosptRectangle : 					return L"rect";
         case msosptEllipse : 					return L"ellipse";
         case msosptLine : 						return L"line";
+        case msosptActionButtonBlank : 			return L"actionButtonBlank";
+        case msosptActionButtonHome : 			return L"actionButtonHome";
+        case msosptActionButtonHelp : 			return L"actionButtonHelp";
+        case msosptActionButtonInformation :	return L"actionButtonInformation";
+        case msosptActionButtonForwardNext :	return L"actionButtonForwardNext";
+        case msosptActionButtonBackPrevious :	return L"actionButtonBackPrevious";
+        case msosptActionButtonEnd : 			return L"actionButtonEnd";
+        case msosptActionButtonBeginning : 		return L"actionButtonBeginning";
+        case msosptActionButtonReturn : 		return L"actionButtonReturn";
+        case msosptActionButtonDocument : 		return L"actionButtonDocument";
+        case msosptActionButtonSound : 			return L"actionButtonSound";
+		case msosptActionButtonMovie : 			return L"actionButtonMovie";
+        case msosptLeftArrow : 					return L"leftArrow";
 		}
         return L"";
 	}

DesktopEditor/common/BigInteger.h

@@ -326,7 +326,7 @@ private:
         if (differenceInLength < 0)
             differenceInLength = -differenceInLength;
 
-        for (int i = number1.size() - 1; i >= 0; --i)
+        for (int i = (int)(number1.size()) - 1; i >= 0; --i)
         {
             add[i] = ((carry-'0')+(number1[i]-'0')+(number2[i]-'0')) + '0';
 
@@ -364,7 +364,7 @@ private:
         if (differenceInLength < 0)
             differenceInLength = -differenceInLength;
 
-        for (int i = number1.length() - 1; i >= 0; --i)
+        for (int i = (int)(number1.length()) - 1; i >= 0; --i)
         {
             if (number1[i] < number2[i])
             {
@@ -386,13 +386,13 @@ private:
             n1.swap(n2);
 
         std::string res = "0";
-        for (int i = n1.length() - 1; i >= 0; --i)
+        for (int i = (int)(n1.length()) - 1; i >= 0; --i)
         {
             std::string temp = n2;
             int currentDigit = n1[i] - '0';
             int carry = 0;
 
-            for (int j = temp.length() - 1; j >= 0; --j)
+            for (int j = (int)(temp.length()) - 1; j >= 0; --j)
             {
                 temp[j] = ((temp[j]-'0') * currentDigit) + carry;
 

DesktopEditor/xml/build/qt/libxml2.pro

@@ -11,6 +11,19 @@ TEMPLATE = lib
 CONFIG += staticlib
 QMAKE_CXXFLAGS += -Wall -g
 
+DEFINES += \
+    LIBXML_READER_ENABLED \
+    LIBXML_PUSH_ENABLED \
+    LIBXML_HTML_ENABLED \
+    LIBXML_XPATH_ENABLED \
+    LIBXML_OUTPUT_ENABLED \
+    LIBXML_C14N_ENABLED \
+    LIBXML_SAX1_ENABLED \
+    LIBXML_TREE_ENABLED \
+    LIBXML_XPTR_ENABLED \
+    IN_LIBXML \
+    LIBXML_STATIC
+
 CORE_ROOT_DIR = $$PWD/../../../..
 PWD_ROOT_DIR = $$PWD
 include(../../../../Common/base.pri)

DesktopEditor/xmlsec/src/OOXMLSigner.h

@@ -3,6 +3,7 @@
 
 #include "./XmlCanonicalizator.h"
 #include "./XmlSignerBase.h"
+#include "./XmlTransform.h"
 
 class COOXMLSigner
 {
@@ -23,167 +24,6 @@ public:
 
     std::wstring                            m_guid;
 
-public:
-    class COOXMLRelationship
-    {
-    public:
-        std::wstring rid;
-        std::wstring type;
-        std::wstring target;
-        std::wstring target_mode;
-
-    public:
-
-        COOXMLRelationship()
-        {
-        }
-
-        COOXMLRelationship(XmlUtils::CXmlNode& node)
-        {
-            rid = node.GetAttribute("Id");
-            type = node.GetAttribute("Type");
-            target = node.GetAttribute("Target");
-
-            CheckTargetMode();
-        }
-
-        std::wstring GetXml()
-        {
-            NSStringUtils::CStringBuilder builder;
-            builder.WriteString(L"<Relationship Id=\"");
-            builder.WriteEncodeXmlString(rid);
-            builder.WriteString(L"\" Type=\"");
-            builder.WriteEncodeXmlString(type);
-            builder.WriteString(L"\" Target=\"");
-            builder.WriteEncodeXmlString(target);
-            builder.WriteString(L"\" TargetMode=\"");
-            builder.WriteEncodeXmlString(target_mode);
-            builder.WriteString(L"\" />");
-            return builder.GetData();
-        }
-
-        static bool Compare(const COOXMLRelationship& i, const COOXMLRelationship& j)
-        {
-            return i.rid < j.rid;
-        }
-
-    protected:
-        void CheckTargetMode()
-        {
-            if (0 == target.find(L"http") || 0 == target.find(L"www") || 0 == target.find(L"ftp"))
-                target_mode = L"External";
-            else
-                target_mode = L"Internal";
-        }
-    };
-
-    class COOXMLRelationships
-    {
-    public:
-        std::vector<COOXMLRelationship> rels;
-
-    public:
-
-        COOXMLRelationships()
-        {
-        }
-
-        COOXMLRelationships(std::wstring& file)
-        {
-            XmlUtils::CXmlNode oNode;
-            if (!oNode.FromXmlFile(file))
-                return;
-
-            XmlUtils::CXmlNodes oNodes;
-            if (!oNode.GetNodes(L"Relationship", oNodes))
-                return;
-
-            int nCount = oNodes.GetCount();
-            for (int i = 0; i < nCount; ++i)
-            {
-                XmlUtils::CXmlNode oRel;
-                oNodes.GetAt(i, oRel);
-                rels.push_back(COOXMLRelationship(oRel));
-            }
-        }
-
-        std::wstring GetXml()
-        {
-            NSStringUtils::CStringBuilder builder;
-
-            builder.WriteString(L"<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
-
-            // sort by rId
-            std::sort(rels.begin(), rels.end(), COOXMLRelationship::Compare);
-
-            for (std::vector<COOXMLRelationship>::iterator i = rels.begin(); i != rels.end(); i++)
-                builder.WriteString(i->GetXml());
-
-            builder.WriteString(L"</Relationships>");
-
-            return builder.GetData();
-        }
-
-        std::wstring GetTransforms()
-        {
-            NSStringUtils::CStringBuilder builder;
-
-            builder.WriteString(L"<Transforms><Transform Algorithm=\"http://schemas.openxmlformats.org/package/2006/RelationshipTransform\">");
-
-            for (std::vector<COOXMLRelationship>::iterator i = rels.begin(); i != rels.end(); i++)
-            {
-                builder.WriteString(L"<mdssi:RelationshipReference xmlns:mdssi=\"http://schemas.openxmlformats.org/package/2006/digital-signature\" SourceId=\"");
-                builder.WriteEncodeXmlString(i->rid);
-                builder.WriteString(L"\" />");
-            }
-
-            builder.WriteString(L"</Transform><Transform Algorithm=\"http://www.w3.org/TR/2001/REC-xml-c14n-20010315\"/></Transforms>");
-
-            return builder.GetData();
-        }
-
-        void CheckOriginSigs(std::wstring& file)
-        {
-            int rId = 0;
-            std::vector<COOXMLRelationship>::iterator i = rels.begin();
-            while (i != rels.end())
-            {
-                if (0 == i->target.find(L"_xmlsignatures/"))
-                    return;
-
-                std::wstring rid = i->rid;
-                rid = rid.substr(3);
-
-                int nTemp = std::stoi(rid);
-
-                if (nTemp > rId)
-                    rId = nTemp;
-
-                i++;
-            }
-
-            std::string sXmlA;
-            NSFile::CFileBinary::ReadAllTextUtf8A(file, sXmlA);
-
-            std::string::size_type pos = sXmlA.rfind("</Relationships>");
-            if (pos == std::string::npos)
-                return;
-
-            rId++;
-            std::string sRet = sXmlA.substr(0, pos);
-            sRet += ("<Relationship Id=\"rId" + std::to_string(rId) + "\" \
-Type=\"http://schemas.openxmlformats.org/package/2006/relationships/digital-signature/origin\" Target=\"_xmlsignatures/origin.sigs\"/>\
-</Relationships>");
-
-            NSFile::CFileBinary::Remove(file);
-
-            NSFile::CFileBinary oFile;
-            oFile.CreateFileW(file);
-            oFile.WriteFile((BYTE*)sRet.c_str(), (DWORD)sRet.length());
-            oFile.CloseFile();
-        }
-    };
-
 public:
     COOXMLSigner(const std::wstring& sFolder, ICertificate* pContext)
     {
@@ -259,7 +99,7 @@ public:
 
     std::wstring GetRelsReference(const std::wstring& file)
     {
-        COOXMLRelationships oRels(m_sFolder + file);
+        COOXMLRelationships oRels(m_sFolder + file, true);
 
         if (L"/_rels/.rels" == file)
         {

DesktopEditor/xmlsec/src/OOXMLVerifier.h

@@ -0,0 +1,123 @@
+#ifndef _XML_OOXMLVERIFIER_H_
+#define _XML_OOXMLVERIFIER_H_
+
+#include "./XmlCanonicalizator.h"
+#include "./XmlSignerBase.h"
+#include "./XmlTransform.h"
+
+#define OOXML_SIGNATURE_VALID           0
+#define OOXML_SIGNATURE_INVALID         1
+#define OOXML_SIGNATURE_NOTSUPPORTED    2
+
+class COOXMLSignature
+{
+private:
+    int             m_valid;
+    std::string     m_guid;
+    ICertificate*   m_cert;
+
+    std::string     m_sImageValidBase64;
+    std::string     m_sImageInvalidBase64;
+
+private:
+   XmlUtils::CXmlNode   m_node; // signature file
+
+public:
+    COOXMLSignature()
+    {
+        m_valid = OOXML_SIGNATURE_INVALID;
+        m_guid = "";
+        m_cert = NULL;
+    }
+    ~COOXMLSignature()
+    {
+        RELEASEOBJECT(m_cert);
+    }
+
+public:
+    int GetValid()
+    {
+        return m_valid;
+    }
+    std::string GetGuid()
+    {
+        return m_guid;
+    }
+    ICertificate* GetCertificate()
+    {
+        return m_cert;
+    }
+    std::string GetImageValidBase64()
+    {
+        return m_sImageValidBase64;
+    }
+    std::string GetImageInvalidBase64()
+    {
+        return m_sImageInvalidBase64;
+    }
+
+public:
+    void Check()
+    {
+
+    }
+
+    friend class COOXMLVerifier;
+};
+
+class COOXMLVerifier
+{
+public:
+    std::wstring                            m_sFolder;
+    std::vector<COOXMLSignature*>           m_arSignatures;
+
+public:
+    COOXMLVerifier(const std::wstring& sFolder)
+    {
+        m_sFolder = sFolder;
+
+        if (!NSFile::CFileBinary::Exists(m_sFolder + L"/_xmlsignatures/origin.sigs"))
+            return;
+
+        XmlUtils::CXmlNode oContentTypes;
+        if (!oContentTypes.FromXmlFile(m_sFolder + L"/[Content_Types].xml"))
+            return;
+
+        XmlUtils::CXmlNodes oOverrides = oContentTypes.GetNodes(L"Override");
+        int nCount = oOverrides.GetCount();
+
+        for (int i = 0; i < nCount; i++)
+        {
+            XmlUtils::CXmlNode node;
+            oOverrides.GetAt(i, node);
+
+            if (node.GetAttributeA("ContentType") != "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml")
+                continue;
+
+            std::wstring sFile = m_sFolder + node.GetAttribute("PartName");
+            XmlUtils::CXmlNode nodeSig;
+            if (!nodeSig.FromXmlFile(sFile))
+                continue;
+
+            if (nodeSig.GetName() != L"Signature")
+                continue;
+
+            COOXMLSignature* pSignature = new COOXMLSignature();
+            pSignature->m_node = nodeSig;
+            pSignature->Check();
+
+            m_arSignatures.push_back(pSignature);
+        }
+    }
+    ~COOXMLVerifier()
+    {
+        for (std::vector<COOXMLSignature*>::iterator i = m_arSignatures.begin(); i != m_arSignatures.end(); i++)
+        {
+            COOXMLSignature* v = *i;
+            RELEASEOBJECT(v);
+        }
+        m_arSignatures.clear();
+    }
+};
+
+#endif //_XML_OOXMLVERIFIER_H_

DesktopEditor/xmlsec/src/XmlCanonicalizator.h

@@ -8,6 +8,10 @@
 #include "../../xml/include/xmlutils.h"
 #include "../../xml/libxml2/include/libxml/c14n.h"
 
+#ifndef XML_UNUSED
+#define XML_UNUSED( arg )  ( (arg) = (arg) )
+#endif
+
 class CXmlCanonicalizator
 {
 private:
@@ -33,11 +37,14 @@ private:
 
     static int buffer_xmlBufferIOClose(CXmlBuffer* buf)
     {
+        XML_UNUSED(buf);
         return 0;
     }
 
     static int buffer_xmlC14NIsVisibleCallback(void * user_data, xmlNodePtr node, xmlNodePtr parent)
     {
+        XML_UNUSED(user_data);
+        XML_UNUSED(parent);
         if (node->type == XML_TEXT_NODE)
         {
             const char* cur = (char*)node->content;
@@ -53,7 +60,7 @@ private:
     }
 
 public:
-    static std::string Execute(const std::string& sXml, int mode)
+    static std::string Execute(const std::string& sXml, int mode = XML_C14N_1_0, bool withComments = false)
     {
         xmlDocPtr xmlDoc = xmlParseMemory((char*)sXml.c_str(), (int)sXml.length());
 
@@ -63,21 +70,18 @@ public:
                                                              &bufferC14N,
                                                              NULL);
 
-        xmlC14NExecute(xmlDoc, buffer_xmlC14NIsVisibleCallback, NULL, mode, NULL, 0, _buffer);
+        xmlC14NExecute(xmlDoc, buffer_xmlC14NIsVisibleCallback, NULL, mode, NULL, withComments ? 1 : 0, _buffer);
 
         xmlOutputBufferClose(_buffer);
 
         return bufferC14N.builder.GetData();
     }
 
-    static std::string Execute(const std::wstring& sXmlFile, int mode)
+    static std::string Execute(const std::wstring& sXmlFile, int mode = XML_C14N_1_0, bool withComments = false)
     {
         std::string sXml;
         NSFile::CFileBinary::ReadAllTextUtf8A(sXmlFile, sXml);
-
-        xmlDocPtr xmlDoc = xmlParseMemory((char*)sXml.c_str(), (int)sXml.length());
-
-        return Execute(sXml, mode);
+        return Execute(sXml, mode, withComments);
     }
 };
 

DesktopEditor/xmlsec/src/XmlCertificate.h

@@ -0,0 +1,17 @@
+#ifndef _XMLSIGNER_CERTIFICATE_H_
+#define _XMLSIGNER_CERTIFICATE_H_
+
+#ifdef WIN32
+#include "XmlSigner_mscrypto.h"
+#define CCertificate CCertificate_mscrypto
+#endif
+
+#if defined(_LINUX) && !defined(_MAC)
+
+#endif
+
+#ifdef _MAC
+
+#endif
+
+#endif // _XMLSIGNER_CERTIFICATE_H_

DesktopEditor/xmlsec/src/XmlRels.h

@@ -0,0 +1,199 @@
+#ifndef _XML_RELS_H_
+#define _XML_RELS_H_
+
+#include "./XmlCanonicalizator.h"
+
+class COOXMLRelationship
+{
+public:
+    std::wstring rid;
+    std::wstring type;
+    std::wstring target;
+    std::wstring target_mode;
+
+public:
+
+    COOXMLRelationship()
+    {
+    }
+
+    COOXMLRelationship(XmlUtils::CXmlNode& node)
+    {
+        rid = node.GetAttribute("Id");
+        type = node.GetAttribute("Type");
+        target = node.GetAttribute("Target");
+
+        CheckTargetMode();
+    }
+
+    std::wstring GetXml()
+    {
+        NSStringUtils::CStringBuilder builder;
+        builder.WriteString(L"<Relationship Id=\"");
+        builder.WriteEncodeXmlString(rid);
+        builder.WriteString(L"\" Type=\"");
+        builder.WriteEncodeXmlString(type);
+        builder.WriteString(L"\" Target=\"");
+        builder.WriteEncodeXmlString(target);
+        builder.WriteString(L"\" TargetMode=\"");
+        builder.WriteEncodeXmlString(target_mode);
+        builder.WriteString(L"\" />");
+        return builder.GetData();
+    }
+
+    static bool Compare(const COOXMLRelationship& i, const COOXMLRelationship& j)
+    {
+        return i.rid < j.rid;
+    }
+
+protected:
+    void CheckTargetMode()
+    {
+        if (0 == target.find(L"http") || 0 == target.find(L"www") || 0 == target.find(L"ftp"))
+            target_mode = L"External";
+        else
+            target_mode = L"Internal";
+    }
+};
+
+class COOXMLRelationships
+{
+public:
+    std::vector<COOXMLRelationship> rels;
+
+public:
+
+    COOXMLRelationships()
+    {
+    }
+
+    COOXMLRelationships(const std::string& xml, std::map<std::wstring, bool>* check_need = NULL)
+    {
+        XmlUtils::CXmlNode oNode;
+        if (!oNode.FromXmlStringA(xml))
+            return;
+
+        FromXmlNode(oNode, check_need);
+    }
+
+    COOXMLRelationships(const std::wstring& xml, const bool& is_file, std::map<std::wstring, bool>* check_need = NULL)
+    {
+        XmlUtils::CXmlNode oNode;
+
+        if (!is_file)
+        {
+            if (!oNode.FromXmlString(xml))
+                return;
+        }
+        else
+        {
+            if (!oNode.FromXmlFile(xml))
+                return;
+        }
+
+        FromXmlNode(oNode, check_need);
+    }
+
+    void FromXmlNode(XmlUtils::CXmlNode& oNode, std::map<std::wstring, bool>* check_need = NULL)
+    {
+        XmlUtils::CXmlNodes oNodes;
+        if (!oNode.GetNodes(L"Relationship", oNodes))
+            return;
+
+        int nCount = oNodes.GetCount();
+        for (int i = 0; i < nCount; ++i)
+        {
+            XmlUtils::CXmlNode oRel;
+            oNodes.GetAt(i, oRel);
+
+            if (NULL == check_need)
+            {
+                rels.push_back(COOXMLRelationship(oRel));
+            }
+            else
+            {
+                std::wstring sRid = oRel.GetAttribute("Id");
+                if (check_need->find(sRid) != check_need->end())
+                    rels.push_back(COOXMLRelationship(oRel));
+            }
+        }
+    }
+
+    std::wstring GetXml()
+    {
+        NSStringUtils::CStringBuilder builder;
+
+        builder.WriteString(L"<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
+
+        // sort by rId
+        std::sort(rels.begin(), rels.end(), COOXMLRelationship::Compare);
+
+        for (std::vector<COOXMLRelationship>::iterator i = rels.begin(); i != rels.end(); i++)
+            builder.WriteString(i->GetXml());
+
+        builder.WriteString(L"</Relationships>");
+
+        return builder.GetData();
+    }
+
+    std::wstring GetTransforms()
+    {
+        NSStringUtils::CStringBuilder builder;
+
+        builder.WriteString(L"<Transforms><Transform Algorithm=\"http://schemas.openxmlformats.org/package/2006/RelationshipTransform\">");
+
+        for (std::vector<COOXMLRelationship>::iterator i = rels.begin(); i != rels.end(); i++)
+        {
+            builder.WriteString(L"<mdssi:RelationshipReference xmlns:mdssi=\"http://schemas.openxmlformats.org/package/2006/digital-signature\" SourceId=\"");
+            builder.WriteEncodeXmlString(i->rid);
+            builder.WriteString(L"\" />");
+        }
+
+        builder.WriteString(L"</Transform><Transform Algorithm=\"http://www.w3.org/TR/2001/REC-xml-c14n-20010315\"/></Transforms>");
+
+        return builder.GetData();
+    }
+
+    void CheckOriginSigs(std::wstring& file)
+    {
+        int rId = 0;
+        std::vector<COOXMLRelationship>::iterator i = rels.begin();
+        while (i != rels.end())
+        {
+            if (0 == i->target.find(L"_xmlsignatures/"))
+                return;
+
+            std::wstring rid = i->rid;
+            rid = rid.substr(3);
+
+            int nTemp = std::stoi(rid);
+
+            if (nTemp > rId)
+                rId = nTemp;
+
+            i++;
+        }
+
+        std::string sXmlA;
+        NSFile::CFileBinary::ReadAllTextUtf8A(file, sXmlA);
+
+        std::string::size_type pos = sXmlA.rfind("</Relationships>");
+        if (pos == std::string::npos)
+            return;
+
+        rId++;
+        std::string sRet = sXmlA.substr(0, pos);
+        sRet += ("<Relationship Id=\"rId" + std::to_string(rId) + "\" \
+Type=\"http://schemas.openxmlformats.org/package/2006/relationships/digital-signature/origin\" Target=\"_xmlsignatures/origin.sigs\"/>\
+</Relationships>");
+
+        NSFile::CFileBinary::Remove(file);
+
+        NSFile::CFileBinary oFile;
+        oFile.CreateFileW(file);
+        oFile.WriteFile((BYTE*)sRet.c_str(), (DWORD)sRet.length());
+        oFile.CloseFile();
+    }
+};
+
+#endif //_XML_RELS_H_

DesktopEditor/xmlsec/src/XmlSignerBase.h

@@ -33,6 +33,9 @@ public:
     virtual std::string GetHash(std::wstring& sXmlFile)                     = 0;
     virtual bool Verify(std::string& sXml, std::string& sXmlSignature)      = 0;
 
+    virtual bool LoadFromBase64Data(const std::string& data)                = 0;
+    virtual int ShowCertificate()                                           = 0;
+
 public:
     virtual bool ShowSelectDialog()             = 0;
 };

DesktopEditor/xmlsec/src/XmlSigner_mscrypto.h

@@ -14,27 +14,40 @@ public:
     HCERTSTORE     m_store;
     PCCERT_CONTEXT m_context;
 
+protected:
+    BYTE*           m_rawData;
+    int             m_rawDataLen;
+
 public:
     CCertificate_mscrypto() : ICertificate()
     {
         m_store = NULL;
         m_context = NULL;
+
+        m_rawData = NULL;
+        m_rawDataLen = 0;
     }
     CCertificate_mscrypto(PCCERT_CONTEXT ctx) : ICertificate()
     {
         m_store = NULL;
         m_context = ctx;
+
+        m_rawData = NULL;
+        m_rawDataLen = 0;
     }
 
     virtual ~CCertificate_mscrypto()
     {
-        if (m_store != NULL)
+        if (m_store != NULL || m_rawData != NULL)
         {
             if (NULL != m_context)
                 CertFreeCertificateContext(m_context);
 
-            CertCloseStore(m_store, 0);
+            RELEASEARRAYOBJECTS(m_rawData);
         }
+
+        if (m_store != NULL)
+            CertCloseStore(m_store, 0);
     }
 
 public:
@@ -286,6 +299,28 @@ public:
         return bResultRet && bResult;
     }
 
+    virtual bool LoadFromBase64Data(const std::string& data)
+    {
+        RELEASEARRAYOBJECTS(m_rawData);
+        if (!NSFile::CBase64Converter::Decode(data.c_str(), (int)data.length(), m_rawData, m_rawDataLen))
+            return false;
+
+        m_context = CertCreateCertificateContext(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, m_rawData, m_rawDataLen);
+        if (!m_context)
+        {
+            RELEASEARRAYOBJECTS(m_rawData);
+            m_rawDataLen = 0;
+            return false;
+        }
+
+        return true;
+    }
+
+    virtual int ShowCertificate()
+    {
+        return (int)CryptUIDlgViewContext(CERT_STORE_CERTIFICATE_CONTEXT, m_context, NULL, NULL, 0, NULL);
+    }
+
 public:
     virtual bool ShowSelectDialog()
     {

DesktopEditor/xmlsec/src/XmlTransform.h

@@ -0,0 +1,186 @@
+#ifndef _XML_TRANSFORM_H_
+#define _XML_TRANSFORM_H_
+
+#include "./XmlRels.h"
+
+class IXmlTransform
+{
+protected:
+    std::string m_algorithm;
+
+public:
+    IXmlTransform()
+    {
+        m_algorithm = "";
+    }
+    virtual ~IXmlTransform()
+    {
+    }
+
+public:
+    virtual std::string Transform(const std::string& sXml) = 0;
+    virtual void LoadFromXml(XmlUtils::CXmlNode& node) = 0;
+
+    static IXmlTransform* GetFromType(const std::string& alg);
+};
+
+class CXmlTransformRelationship : public IXmlTransform
+{
+protected:
+    std::map<std::wstring, bool> m_arIds;
+
+public:
+    CXmlTransformRelationship() : IXmlTransform()
+    {
+        m_algorithm = "http://schemas.openxmlformats.org/package/2006/RelationshipTransform";
+    }
+
+    virtual std::string Transform(const std::string& xml)
+    {
+        COOXMLRelationships _rels(xml, &m_arIds);
+        return U_TO_UTF8(_rels.GetXml());
+    }
+
+    virtual void LoadFromXml(XmlUtils::CXmlNode& node)
+    {
+        XmlUtils::CXmlNodes oNodesIds;
+        node.GetChilds(oNodesIds);
+
+        int nCount = oNodesIds.GetCount();
+        for (int i = 0; i < nCount; ++i)
+        {
+            XmlUtils::CXmlNode _node;
+            oNodesIds.GetAt(i, _node);
+
+            std::wstring sType = _node.GetAttribute("SourceId");
+            if (!sType.empty())
+                m_arIds.insert(std::pair<std::wstring, bool>(sType, true));
+        }
+    }
+};
+
+class CXmlTransformC14N : public IXmlTransform
+{
+protected:
+    int m_mode;
+    bool m_comments;
+
+public:
+    CXmlTransformC14N() : IXmlTransform()
+    {
+        m_mode = -1;
+        m_comments = false;
+    }
+
+    bool CheckC14NTransform(const std::string& alg)
+    {
+        m_mode = -1;
+        if ("http://www.w3.org/TR/2001/REC-xml-c14n-20010315" == alg)
+        {
+            m_mode = XML_C14N_1_0;
+            m_comments = false;
+        }
+        else if ("http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments" == alg)
+        {
+            m_mode = XML_C14N_1_0;
+            m_comments = true;
+        }
+        else if ("http://www.w3.org/2006/12/xml-c14n11" == alg)
+        {
+            m_mode = XML_C14N_1_1;
+            m_comments = false;
+        }
+        else if ("http://www.w3.org/2006/12/xml-c14n11#WithComments" == alg)
+        {
+            m_mode = XML_C14N_1_1;
+            m_comments = true;
+        }
+        else if ("http://www.w3.org/2001/10/xml-exc-c14n#" == alg)
+        {
+            m_mode = XML_C14N_EXCLUSIVE_1_0;
+            m_comments = false;
+        }
+        else if ("http://www.w3.org/2001/10/xml-exc-c14n#WithComments" == alg)
+        {
+            m_mode = XML_C14N_EXCLUSIVE_1_0;
+            m_comments = true;
+        }
+        return (-1 != m_mode) ? true : false;
+    }
+
+    virtual std::string Transform(const std::string& xml)
+    {
+        // TODO
+        return xml;
+    }
+
+    virtual void LoadFromXml(XmlUtils::CXmlNode& node)
+    {
+        // none
+        XML_UNUSED(node);
+    }
+};
+
+IXmlTransform* IXmlTransform::GetFromType(const std::string& alg)
+{
+    if (true)
+    {
+        CXmlTransformRelationship* transform = new CXmlTransformRelationship();
+        if (transform->m_algorithm == alg)
+            return transform;
+        RELEASEOBJECT(transform);
+    }
+    if (true)
+    {
+        CXmlTransformC14N* transform = new CXmlTransformC14N();
+        if (transform->CheckC14NTransform(alg))
+            return transform;
+        RELEASEOBJECT(transform);
+    }
+
+    return NULL;
+}
+
+class CXmlTransforms
+{
+protected:
+    std::vector<IXmlTransform*> m_transforms;
+    bool m_valid;
+
+public:
+    CXmlTransforms(XmlUtils::CXmlNode& node)
+    {
+        m_valid = true;
+
+        XmlUtils::CXmlNodes oNodes = node.GetNodes(L"Transform");
+        int nCount = oNodes.GetCount();
+        for (int i = 0; i < nCount; ++i)
+        {
+            XmlUtils::CXmlNode nodeTransform;
+            oNodes.GetAt(i, nodeTransform);
+
+            IXmlTransform* pTransform = IXmlTransform::GetFromType(nodeTransform.GetAttributeA("Algorithm"));
+            if (NULL == pTransform)
+            {
+                m_valid = false;
+                return;
+            }
+
+            pTransform->LoadFromXml(nodeTransform);
+            m_transforms.push_back(pTransform);
+        }
+    }
+
+    ~CXmlTransforms()
+    {
+        for (std::vector<IXmlTransform*>::iterator i = m_transforms.begin(); i != m_transforms.end(); i++)
+        {
+            IXmlTransform* t = *i;
+            RELEASEOBJECT(t);
+        }
+        m_transforms.clear();
+    }
+
+};
+
+#endif //_XML_TRANSFORM_H_

DesktopEditor/xmlsec/test/windows/test.pro

@@ -6,7 +6,9 @@ TEMPLATE = app
 CONFIG   += console
 CONFIG   -= app_bundle
 
-DEFINES += UNICODE
+DEFINES -= \
+    UNICODE \
+    _UNICODE
 
 CORE_ROOT_DIR = $$PWD/../../../..
 PWD_ROOT_DIR = $$PWD

DesktopEditor/xmlsec/test/windows_list_serts/main.cpp

@@ -1,6 +1,6 @@
-#include "../../src/XmlCanonicalizator.h"
-#include "../../src/XmlSigner_mscrypto.h"
+#include "../../src/XmlCertificate.h"
 #include "../../src/OOXMLSigner.h"
+#include "../../src/OOXMLVerifier.h"
 
 #pragma comment (lib, "crypt32.lib")
 #pragma comment (lib, "cryptui.lib")
@@ -12,17 +12,33 @@ void main(void)
     //std::wstring sSignId = L"{39B6B9C7-60AD-45A2-9F61-40C74A24042E}";
 
     std::wstring sFolderOOXML = L"D:\\555";
-    std::wstring sSignId = L"{9792D33F-AB37-4E5B-A465-481B9465818B}";
 
-    CCertificate_mscrypto oCertificate;
-    if (!oCertificate.ShowSelectDialog())
-        return;
+    if (false)
+    {
+        std::wstring sSignId = L"{9792D33F-AB37-4E5B-A465-481B9465818B}";
 
-    COOXMLSigner oOOXMLSigner(sFolderOOXML, &oCertificate);
+        CCertificate oCertificate;
+        if (!oCertificate.ShowSelectDialog())
+            return;
 
-    oOOXMLSigner.SetGuid(sSignId);
-    oOOXMLSigner.SetImageValid(NSFile::GetProcessDirectory() + L"/../../../resources/valid.png");
-    oOOXMLSigner.SetImageInvalid(NSFile::GetProcessDirectory() + L"/../../../resources/invalid.png");
+        COOXMLSigner oOOXMLSigner(sFolderOOXML, &oCertificate);
 
-    oOOXMLSigner.Sign();
+        oOOXMLSigner.SetGuid(sSignId);
+        oOOXMLSigner.SetImageValid(NSFile::GetProcessDirectory() + L"/../../../resources/valid.png");
+        oOOXMLSigner.SetImageInvalid(NSFile::GetProcessDirectory() + L"/../../../resources/invalid.png");
+
+        oOOXMLSigner.Sign();
+    }
+    else
+    {
+        COOXMLVerifier oVerifier(sFolderOOXML);
+
+        size_t nCount = oVerifier.m_arSignatures.size();
+        for (std::vector<COOXMLSignature*>::iterator i = oVerifier.m_arSignatures.begin(); i != oVerifier.m_arSignatures.end(); i++)
+        {
+            COOXMLSignature* pSign = *i;
+        }
+
+        XML_UNUSED(nCount);
+    }
 }