git-svn-id:...

git-svn-id: svn://fileserver/activex/AVS/Sources/TeamlabOffice/trunk/ServerComponents@62728 954022d7-b5bf-4e40-9824-e11837661b57

DesktopEditor/raster/BgraFrame.cpp

@@ -4,7 +4,6 @@
 
 #include "Jp2/J2kFile.h"
 #include "JBig2/source/JBig2File.h"
-#include "SvmFile/Source/SvmFile.h"
 
 bool CBgraFrame::OpenFile(const std::wstring& strFileName, unsigned int nFileType)
 {
@@ -13,11 +12,6 @@ bool CBgraFrame::OpenFile(const std::wstring& strFileName, unsigned int nFileTyp
         Jpeg2000::CJ2kFile oJ2;
         return oJ2.Open(this, strFileName, std::wstring(L""));
     }
-//    if (22/*CXIMAGE_FORMAT_SVM*/ == nFileType)
-//    {
-//        SvmFile::CSvmFile oSvm;
-//        return oSvm.Open(this, strFileName);
-//    }
 	else
 	{
 		NSFile::CFileBinary oFile;

DesktopEditor/raster/Metafile/Common/MetaFileObjects.h

@@ -28,12 +28,14 @@ namespace MetaFile
 		virtual ~IBrush(){}
 
 		virtual int          GetColor()			= 0;
+		virtual int          GetColor2()		= 0;
 		virtual unsigned int GetStyle()			= 0;
+		virtual unsigned int GetStyleEx()		= 0;
 		virtual unsigned int GetHatch()			= 0;
 		virtual unsigned int GetAlpha()			= 0;
 		virtual std::wstring GetDibPatterPath() = 0;
+		virtual void GetBounds(double& left, double& top, double& width, double& height) = 0;
 	};
-
 	class IPen
 	{
 	public:

DesktopEditor/raster/Metafile/Common/MetaFileRenderer.h

@@ -499,7 +499,6 @@ namespace MetaFile
 			oPoint.y = m_dScaleY * dY + m_dY;
 			return oPoint;
 		}
-
 		bool UpdateBrush()
 		{
 			IBrush* pBrush = m_pFile->GetBrush();
@@ -548,6 +547,25 @@ namespace MetaFile
 				m_pRenderer->put_BrushAlpha1(255);
 				m_pRenderer->put_BrushColor1(oFgColor.ToInt());
 			}
+			else if (	BS_LINEARGRADIENT	== unBrushStyle ||
+						BS_RADIALGRADIENT	== unBrushStyle ||
+						BS_AXIALGRADIENT	== unBrushStyle ||
+						BS_RECTGRADIENT		== unBrushStyle ||
+						BS_PATHGRADIENT		== unBrushStyle
+					)
+			{
+				m_pRenderer->put_BrushType(c_BrushTypeCenter);
+
+				m_pRenderer->put_BrushColor1(pBrush->GetColor());
+				m_pRenderer->put_BrushColor2(pBrush->GetColor2());
+				m_pRenderer->put_BrushAlpha1(pBrush->GetAlpha());
+
+				m_pRenderer->put_BrushLinearAngle(pBrush->GetStyleEx());
+				double l=0, t=0, w=0, h=0;
+				pBrush->GetBounds(l,t,w,h);
+				m_pRenderer->BrushBounds(l,t,w,h);
+
+			}
 			else //if (BS_SOLID == unBrushStyle)
 			{
 				m_pRenderer->put_BrushType(c_BrushTypeSolid);

DesktopEditor/raster/Metafile/Common/MetaFileTypes.h

@@ -86,6 +86,12 @@ typedef unsigned char BYTE;
 #define BS_PATTERN8X8       7
 #define BS_DIBPATTERN8X8    8
 #define BS_MONOPATTERN      9
+#define BS_LINEARGRADIENT	10
+#define BS_RADIALGRADIENT	11
+#define BS_AXIALGRADIENT	12
+#define BS_RECTGRADIENT		13
+#define BS_PATHGRADIENT		14
+//square? ellips ??
 
 /* Hatch Styles */
 #define HS_HORIZONTAL       0       /* ----- */

DesktopEditor/raster/Metafile/Common/MetaFileUtils.cpp

@@ -797,6 +797,9 @@ namespace MetaFile
 			if (DIB_RGB_COLORS == unColorUsage)
 			{
 				int lCalcLen = (((nWidth * ushPlanes * ushBitCount + 31) & ~31) / 8) * abs(nHeight);
+
+				if (unCompression == 0)
+				{
 					int nAvailableLen = (unBufferLen - unHeaderSize) - lCalcLen - unColorUsed * 4;
 					if (nAvailableLen < 0)
 						return;
@@ -805,6 +808,7 @@ namespace MetaFile
 						unColorUsed = 2;
 					else if (0 == unColorUsed && BI_BITCOUNT_3 == ushBitCount && nAvailableLen >= 1024)
 						unColorUsed = 256;
+				}
 
 				unHeaderSize += 4 * unColorUsed; // RGBQuad
 				ReadImageInfoHeader(pImageBuffer + 4, unHeaderSize - 4, pImageBuffer + unHeaderSize, unBufferLen - unHeaderSize, ppDstBuffer, punWidth, punHeight);

DesktopEditor/raster/Metafile/Emf/EmfObjects.h

@@ -42,10 +42,18 @@ namespace MetaFile
 
 		// IBrush
 		int          GetColor();
+		int          GetColor2()
+		{
+			return 0;
+		}
 		unsigned int GetStyle()
 		{
 			return BrushStyle;
 		}
+		unsigned int GetStyleEx()
+		{
+			return 0;
+		}
 		unsigned int GetHatch()
 		{
 			return BrushHatch;
@@ -58,6 +66,7 @@ namespace MetaFile
 		{
 			return DibPatternPath;
 		}
+		void GetBounds(double& left, double& top, double& width, double& height) {}
 
 	public:
 		unsigned int   BrushStyle;

DesktopEditor/raster/Metafile/Emf/EmfPlayer.cpp

@@ -12,6 +12,7 @@ namespace MetaFile
 			return;
 		}
 
+		m_pEmfFile = pFile;
 		m_pDC = pDC;
 		m_vDCStack.push_back(pDC);
 

DesktopEditor/raster/Metafile/MetaFile.cpp

@@ -121,6 +121,7 @@ namespace MetaFile
 	{
 		m_oWmfFile.Close();
 		m_oEmfFile.Close();
+		m_oSvmFile.Close();
 
 		m_lType  = 0;
 	};

DesktopEditor/raster/Metafile/StarView/SvmClip.cpp

+#include "SvmClip.h"
+
+namespace MetaFile
+{
+	CSvmClip::CSvmClip()
+	{
+	}
+	CSvmClip::~CSvmClip()
+	{
+		Clear();
+	}
+	void CSvmClip::operator=(CSvmClip& oClip)
+	{
+		Clear();
+		for (unsigned int ulIndex = 0; ulIndex < oClip.m_vCommands.size(); ulIndex++)
+		{
+			CSvmClipCommandBase* pCommand = oClip.m_vCommands.at(ulIndex);
+			CSvmClipCommandBase* pNewCommand = NULL;
+			switch (pCommand->GetType())
+			{
+				case SVM_CLIPCOMMAND_INTERSECT:
+				{
+					CSvmClipCommandIntersect* pI = (CSvmClipCommandIntersect*)pCommand;
+					pNewCommand = new CSvmClipCommandIntersect(pI->m_dL, pI->m_dT, pI->m_dR, pI->m_dB);
+					break;
+				}
+				case SVM_CLIPCOMMAND_EXCLUDE:
+				{
+					CSvmClipCommandExclude* pE = (CSvmClipCommandExclude*)pCommand;
+					pNewCommand = new CSvmClipCommandExclude(pE->m_dL, pE->m_dT, pE->m_dR, pE->m_dB, pE->m_dWindowL, pE->m_dWindowT, pE->m_dWindowR, pE->m_dWindowB);
+					break;
+				}
+			}
+
+			if (pNewCommand)
+				m_vCommands.push_back(pNewCommand);
+		}
+	}
+	void CSvmClip::Reset()
+	{
+		Clear();
+	}
+	bool CSvmClip::Intersect(double dL, double dT, double dR, double dB)
+	{
+		CSvmClipCommandBase* pCommand = new CSvmClipCommandIntersect(dL, dT, dR, dB);
+		if (!pCommand)
+			return false;
+
+		m_vCommands.push_back(pCommand);
+		return true;
+	}
+	bool CSvmClip::Exclude(double dL, double dT, double dR, double dB, double dWindowL, double dWindowT, double dWindowR, double dWindowB)
+	{
+		CSvmClipCommandBase* pCommand = new CSvmClipCommandExclude(dL, dT, dR, dB, dWindowL, dWindowT, dWindowR, dWindowB);
+		if (!pCommand)
+			return false;
+
+		m_vCommands.push_back(pCommand);
+		return true;
+	}
+	void CSvmClip::Clear()
+	{
+		for (unsigned int ulIndex = 0; ulIndex < m_vCommands.size(); ulIndex++)
+		{
+			CSvmClipCommandBase* pCommand = m_vCommands.at(ulIndex);
+			delete pCommand;
+		}
+		m_vCommands.clear();
+	}
+	void CSvmClip::ClipOnRenderer(IOutputDevice* pOutput)
+	{
+		if (pOutput)
+		{
+			pOutput->ResetClip();
+			for (unsigned int ulIndex = 0; ulIndex < m_vCommands.size(); ulIndex++)
+			{
+				CSvmClipCommandBase* pCommand = m_vCommands.at(ulIndex);
+
+				switch (pCommand->GetType())
+				{
+					case SVM_CLIPCOMMAND_INTERSECT:
+					{
+						CSvmClipCommandIntersect* pIntersect = (CSvmClipCommandIntersect*)pCommand;
+
+						pOutput->StartClipPath(RGN_AND, ALTERNATE);
+						pOutput->MoveTo(pIntersect->m_dL, pIntersect->m_dT);
+						pOutput->LineTo(pIntersect->m_dR, pIntersect->m_dT);
+						pOutput->LineTo(pIntersect->m_dR, pIntersect->m_dB);
+						pOutput->LineTo(pIntersect->m_dL, pIntersect->m_dB);
+						pOutput->ClosePath();
+						pOutput->EndClipPath(RGN_AND);
+
+						break;
+					}
+					case SVM_CLIPCOMMAND_EXCLUDE:
+					{
+						CSvmClipCommandExclude* pExclude = (CSvmClipCommandExclude*)pCommand;
+
+						pOutput->StartClipPath(RGN_AND, ALTERNATE);
+
+						pOutput->MoveTo(pExclude->m_dL, pExclude->m_dT);
+						pOutput->LineTo(pExclude->m_dR, pExclude->m_dT);
+						pOutput->LineTo(pExclude->m_dR, pExclude->m_dB);
+						pOutput->LineTo(pExclude->m_dL, pExclude->m_dB);
+						pOutput->ClosePath();
+
+						pOutput->MoveTo(pExclude->m_dWindowL, pExclude->m_dWindowT);
+						pOutput->LineTo(pExclude->m_dWindowR, pExclude->m_dWindowT);
+						pOutput->LineTo(pExclude->m_dWindowR, pExclude->m_dWindowB);
+						pOutput->LineTo(pExclude->m_dWindowL, pExclude->m_dWindowB);
+						pOutput->ClosePath();
+
+
+						pOutput->EndClipPath(RGN_AND);
+
+						break;
+					}
+				}
+			}
+		}
+	}
+}
\ No newline at end of file

DesktopEditor/raster/Metafile/StarView/SvmClip.h

+#ifndef _METAFILE_SVM_SVMCLIP_H
+#define _METAFILE_SVM_SVMCLIP_H
+
+#include "../Common/MetaFileClip.h"
+#include "../Common/IOutputDevice.h"
+#include "../Common/MetaFileTypes.h"
+
+#include <vector>
+
+namespace MetaFile
+{
+	typedef enum
+	{
+		SVM_CLIPCOMMAND_UNKNOWN   = 0x00,
+		SVM_CLIPCOMMAND_INTERSECT = 0x01,
+		SVM_CLIPCOMMAND_EXCLUDE   = 0x02
+	} ESvmClipCommandType;
+
+	class CSvmClipCommandBase
+	{
+	public:
+		CSvmClipCommandBase()
+		{
+		}
+		virtual ~CSvmClipCommandBase()
+		{
+		}
+		virtual ESvmClipCommandType GetType()
+		{
+			return SVM_CLIPCOMMAND_UNKNOWN;
+		}
+	};
+	class CSvmClipCommandIntersect : public CSvmClipCommandBase
+	{
+	public:
+		CSvmClipCommandIntersect(double dL, double dT, double dR, double dB)
+		{
+			m_dL = dL;
+			m_dT = dT;
+			m_dR = dR;
+			m_dB = dB;
+		}
+		~CSvmClipCommandIntersect()
+		{
+		}
+		ESvmClipCommandType GetType()
+		{
+			return SVM_CLIPCOMMAND_INTERSECT;
+		}
+
+	public:
+
+		double m_dL;
+		double m_dT;
+		double m_dR;
+		double m_dB;
+	};
+	class CSvmClipCommandExclude : public CSvmClipCommandBase
+	{
+	public:
+		CSvmClipCommandExclude(double dL, double dT, double dR, double dB, double dWindowL, double dWindowT, double dWindowR, double dWindowB)
+		{
+			m_dL = dL;
+			m_dT = dT;
+			m_dR = dR;
+			m_dB = dB;
+			m_dWindowL = dWindowL;
+			m_dWindowT = dWindowT;
+			m_dWindowR = dWindowR;
+			m_dWindowB = dWindowB;
+		}
+		~CSvmClipCommandExclude()
+		{
+		}
+		ESvmClipCommandType GetType()
+		{
+			return SVM_CLIPCOMMAND_EXCLUDE;
+		}
+
+	public:
+
+		double m_dL;
+		double m_dT;
+		double m_dR;
+		double m_dB;
+		double m_dWindowL;
+		double m_dWindowT;
+		double m_dWindowR;
+		double m_dWindowB;
+	};
+
+	class CSvmClip : public IClip
+	{
+	public:
+		CSvmClip();
+		~CSvmClip();
+
+		void operator=(CSvmClip& oClip);
+		void Reset();
+		bool Intersect(double dL, double dT, double dR, double dB);
+		bool Exclude(double dL, double dT, double dR, double dB, double dLbb, double dTbb, double dRbb, double dBbb);
+
+		// IClip
+		void ClipOnRenderer(IOutputDevice* pOutput);
+
+	private:
+
+		void Clear();
+
+	private:
+
+		std::vector<CSvmClipCommandBase*> m_vCommands;
+	};
+}
+
+#endif // _METAFILE_SVM_SVMCLIP_H
\ No newline at end of file

DesktopEditor/raster/Metafile/StarView/SvmFile.cpp

@@ -4,7 +4,7 @@
 #include <string>
 
 #include "../Common/MetaFileTypes.h"
-
+#include "../../../../ASCOfficeUtils/ASCOfficeUtilsLib/OfficeUtils.h"
 #ifdef _DEBUG
 	#include <iostream>
 #endif
@@ -83,119 +83,65 @@ static const struct ActionNames
 void CSvmFile::PlayMetaFile()
 {
 	m_oStream.SeekToStart();
-	BYTE* startPosBuffer = m_oStream.GetCurPtr();
 
     // Check the signature "VCLMTF"
 	std::string start = std::string((char*)m_oStream.GetCurPtr(), 6);
 
-    if (start != "VCLMTF")
-        return;
-
+    if (start != "VCLMTF")    return;
+	m_oStream.Skip(6);
 	
-    // Start reading from the stream: read past the signature and get the header.
-	soakBytes(m_oStream, 6);
 	Read_SVM_HEADER();
 
-    //kDebug(31000) << "================ SVM HEADER ================";
-    //kDebug(31000) << "version, length:" << header.versionCompat.version << header.versionCompat.length;
-    //kDebug(31000) << "compressionMode:" << header.compressionMode;
-    //kDebug(31000) << "mapMode:" << "Origin" << header.mapMode.origin
-                  //<< "scaleX"
-                  //<< header.mapMode.scaleX.numerator << header.mapMode.scaleX.numerator
-                  //<< (qreal(header.mapMode.scaleX.numerator) / header.mapMode.scaleX.numerator)
-                  //<< "scaleY"
-                  //<< header.mapMode.scaleY.numerator << header.mapMode.scaleY.numerator
-                  //<< (qreal(header.mapMode.scaleX.numerator) / header.mapMode.scaleX.numerator);
-    //kDebug(31000) << "size:" << header.width << header.height;
-    //kDebug(31000) << "actionCount:" << header.actionCount;
-    //kDebug(31000) << "================ SVM HEADER ================";  
-
 	if (m_pOutput)
 		m_pOutput->Begin();
 
-#if DEBUG_CSvmParser
-    {
-        QPolygon polygon;
-        polygon << QPoint(0, 0);
-        polygon << QPoint(header.width, header.height);
-        mBackend->polyLine(mContext, polygon);
-    }
-#endif
-
-    // Parse all actions and call the appropriate backend callback for
-    // the graphics drawing actions.  The context actions will
-    // manipulate the graphics context, which is maintained here.
 	for (unsigned int action = 0; action < m_oHeader.actionCount; ++action)
 	{
         unsigned short  actionType;
-        unsigned short  version;
-        unsigned int	totalSize;
 
 		m_oStream >> actionType;
 
-		m_oStream >> version;
-		m_oStream >> totalSize;
+		m_oStream >> m_currentActionVersion;
+		m_oStream >> m_unRecordSize;
 
-		m_ulRecordSize = totalSize;// - 8;
+        m_unRecordPos = m_oStream.Tell();
 
-        int start_node_pos = m_oStream.GetCurPtr() - startPosBuffer;
-        // Debug
-#if _DEBUG
-        {
-			std::wstring name;
-            if (actionType == 0)
-                name = actionNames[0].actionName;
-            else if (actionType == 512)
-                name = L"META_COMMENT_ACTION";            
-			else if (100 <= actionType && actionType <= META_LAST_ACTION)
-                name = actionNames[actionType - 99].actionName;
-            else
-                name = L"(out of bounds)";
-
-			std::wcout << name << L"\t(" << actionType << L") " << L"\tversion = " << version << L"\t; totalSize = " << totalSize << L"\n";
-        }			
-#endif
-
-        // Parse all actions.
         switch (actionType) 
 		{
 			case META_RECT_ACTION:			Read_META_RECTANGLE();		break;
-			case META_POLYLINE_ACTION:
-			case META_POLYGON_ACTION:
-				{
-					unsigned int size = Read_META_POLYGON();		
-					// FIXME: Version 2: Lineinfo, Version 3: polyflags
-					if (version > 1)
-						soakBytes(m_oStream, totalSize - 2 - 4 * 2 * size); //2 points * 4 byte * size polygon
+			case META_POLYLINE_ACTION:		Read_META_POLYLINE();       break;
+			case META_POLYGON_ACTION:		Read_META_POLYGON();        break;
+			case META_POLYPOLYGON_ACTION:	Read_META_POLYPOLYGON();	break;
 			
-				}break;
-			case META_POLYPOLYGON_ACTION:	Read_META_POLYPOLYGON(version); break;
+			case META_TEXT_ACTION:			Read_META_TEXT();			break;
+			case META_TEXTARRAY_ACTION:		Read_META_ARRAYTEXT();		break;
+			case META_MAPMODE_ACTION:		Read_META_SETMAPMODE();		break;
+			case META_FONT_ACTION:			Read_META_CREATEFONT();		break;
+			case META_BMPSCALE_ACTION:		Read_META_BMPSCALE();		break;
 
-			case META_TEXT_ACTION:
-			case META_TEXTARRAY_ACTION:		Read_META_TEXT_A();			break;
 			case META_LINECOLOR_ACTION:		Read_META_SETLINECOLOR();	break;
 			case META_FILLCOLOR_ACTION:		Read_META_SETFILLCOLOR();	break;
 			case META_TEXTCOLOR_ACTION:		Read_META_SETTEXTCOLOR();	break;
-			case META_MAPMODE_ACTION:		Read_META_SETMAPMODE();		break;
-			case META_FONT_ACTION:			Read_META_CREATEFONT();		break;
-			case META_PUSH_ACTION:
-				{
-					////kDebug(31000) << "Push action : " << totalSize;
-					unsigned short pushValue;
-					m_oStream >> pushValue;
-					////kDebug(31000) << "Push value : " << pushValue;
-				}break;
-			case META_POP_ACTION:
-				//{
-				//		//kDebug(31000) << "Pop action : " << totalSize;
-				//		/*unsigned short pushValue;
-				//		m_oStream >> pushValue;
-				//		//kDebug(31000) << "Push value : " << pushValue;*/
-				//}break;
+			case META_GRADIENT_ACTION:		Read_META_GRADIENT();		break;
+			case META_GRADIENTEX_ACTION:	Read_META_GRADIENTEX();		break;
+			case META_HATCH_ACTION:
+		
+			case META_RASTEROP_ACTION:		Read_META_RASTEROP();		break;			
+			case META_PUSH_ACTION:			Read_META_PUSH();			break;		
+			case META_POP_ACTION:			Read_META_POP();			break;		
+
+			case META_ROUNDRECT_ACTION:
+			case META_ELLIPSE_ACTION:
+			case META_ARC_ACTION:
+			case META_PIE_ACTION:
+			case META_CHORD_ACTION:
+			case META_PIXEL_ACTION:
+			case META_POINT_ACTION:
+			case META_LINE_ACTION:
+
 			case META_STRETCHTEXT_ACTION:
 			case META_TEXTRECT_ACTION:
 			case META_BMP_ACTION:
-			case META_BMPSCALE_ACTION:
 			case META_BMPSCALEPART_ACTION:
 			case META_BMPEX_ACTION:
 			case META_BMPEXSCALE_ACTION:
@@ -203,8 +149,6 @@ void CSvmFile::PlayMetaFile()
 			case META_MASK_ACTION:
 			case META_MASKSCALE_ACTION:
 			case META_MASKSCALEPART_ACTION:
-			case META_GRADIENT_ACTION:
-			case META_HATCH_ACTION:
 			case META_WALLPAPER_ACTION:
 			case META_CLIPREGION_ACTION:
 			case META_ISECTRECTCLIPREGION_ACTION:
@@ -212,34 +156,42 @@ void CSvmFile::PlayMetaFile()
 			case META_MOVECLIPREGION_ACTION:
 			case META_TEXTFILLCOLOR_ACTION:
 			case META_TEXTALIGN_ACTION:
-			case META_RASTEROP_ACTION:
 			case META_TRANSPARENT_ACTION:
 			case META_EPS_ACTION:
 			case META_REFPOINT_ACTION:
 			case META_TEXTLINECOLOR_ACTION:
 			case META_TEXTLINE_ACTION:
 			case META_FLOATTRANSPARENT_ACTION:
-			case META_GRADIENTEX_ACTION:
 			case META_LAYOUTMODE_ACTION:
 			case META_TEXTLANGUAGE_ACTION:
 			case META_OVERLINECOLOR_ACTION:
-			case META_RENDERGRAPHIC_ACTION:			//dumpAction(m_oStream, version, totalSize);				
+			case META_RENDERGRAPHIC_ACTION:				
 			case META_COMMENT_ACTION:
-			case META_ROUNDRECT_ACTION:
-			case META_ELLIPSE_ACTION:
-			case META_ARC_ACTION:
-			case META_PIE_ACTION:
-			case META_CHORD_ACTION:
+
 			case META_NULL_ACTION:
-			case META_PIXEL_ACTION:
-			case META_POINT_ACTION:
-			case META_LINE_ACTION:
 			default:
+#ifdef _DEBUG
+			if (actionType != 512 && m_unRecordSize > 0)
+			{
+				std::wstring name;
+				if (actionType == 0)
+					name = actionNames[0].actionName;
+				else if (actionType == 512)
+					name = L"META_COMMENT_ACTION";            
+				else if (100 <= actionType && actionType <= META_LAST_ACTION)
+					name = actionNames[actionType - 99].actionName;
+				else
+					name = L"(out of bounds)";
+
+				std::wcout << name << L"\t(" << actionType << L") " << L"\tversion = " << m_currentActionVersion << L"\t; totalSize = " << m_unRecordSize << L"\n";
+			}			
+#endif
 			break;
         }
 
-		int cur_pos = m_oStream.GetCurPtr() - startPosBuffer;
-		int need_skip = totalSize - (cur_pos - start_node_pos);
+		m_urrentActionType = actionType;
+
+		int need_skip = m_unRecordSize - (m_oStream.Tell() - m_unRecordPos);
 		m_oStream.Skip(need_skip);
     }
 	if (m_pOutput)
@@ -264,13 +216,34 @@ void CSvmFile::Read_SVM_HEADER()
 {
 	m_oStream >> m_oHeader;
 }
-unsigned int CSvmFile::Read_META_POLYGON()
+void CSvmFile::Read_META_POLYLINE()
 {
 	TSvmPolygon polygon;
-
 	m_oStream >> polygon;
 
-	if (polygon.count < 1) return 0;
+	if (m_currentActionVersion >= 2)
+	{
+		TSvmLineInfo line_info;
+		m_oStream >> line_info;
+
+		CSvmPen *last_pen = dynamic_cast<CSvmPen *>(m_oPlayer.GetLastObject(SVM_OBJECT_PEN));
+		if (last_pen)
+		{
+			last_pen->Width = line_info.width;
+
+			switch(line_info.style)
+			{
+				case LINE_SOLID:	last_pen->PenStyle = PS_SOLID ; break;
+				case LINE_DASH:		last_pen->PenStyle = PS_DASH ; break;
+			}
+		}
+	}
+
+	if (m_currentActionVersion >= 3)
+	{
+	}
+
+	if (polygon.count < 1) return;
 
 	MoveTo(polygon.points[0].x, polygon.points[0].y);
 
@@ -280,11 +253,27 @@ unsigned int CSvmFile::Read_META_POLYGON()
 	}
 	ClosePath();
 	DrawPath(true, true);
+}
+
+void CSvmFile::Read_META_POLYGON()
+{
+	TSvmPolygon polygon;
 
-	return polygon.count;
+	m_oStream >> polygon;
+
+	if (polygon.count < 1) return;
+
+	MoveTo(polygon.points[0].x, polygon.points[0].y);
+
+	for (int i = 1; i < polygon.count; i++)
+	{
+		LineTo(polygon.points[i].x, polygon.points[i].y);
+	}
+	ClosePath();
+	DrawPath(true, true);
 }
 
-void CSvmFile::Read_META_POLYPOLYGON(int version)
+void CSvmFile::Read_META_POLYPOLYGON()
 {
 	std::vector<TSvmPolygon> polygons;
 
@@ -300,10 +289,10 @@ void CSvmFile::Read_META_POLYPOLYGON(int version)
 		m_oStream >> poligon;
 		polygons.push_back(poligon);
 	}
-	//todooo ???    ???
 
 	std::vector<TSvmPolygon> complexPolygons;
-	if (version > 1)
+
+	if (m_currentActionVersion > 1)
 	{
 		unsigned short complexPolygonCount;
 		m_oStream >> complexPolygonCount;
@@ -361,39 +350,109 @@ void CSvmFile::Read_META_SETMAPMODE()
 
 	UpdateOutputDC();
 }
-void CSvmFile::Read_META_TEXT_A()
+void CSvmFile::Read_META_TEXT()
 {
 	std::wstring sText;
 	TSvmPoint   startPoint;
 
 	m_oStream >> startPoint;
-	parseString(m_oStream, sText);
 
+	parseString(m_oStream, sText, m_currentActionVersion, m_currentCharset);
+	
+	//unsigned short index, len;
+	//	
+	//m_oStream	>> index;
+	//m_oStream	>> len;
+
+	//if (m_currentActionVersion > 1)
+	//{
+	//	unsigned short nLen;
+	//	m_oStream >> nLen;
+	//	
+	//	std::wstring buf;
+	//	unsigned short nTemp;
+	//	while ( nLen-- )
+	//	{
+	//		m_oStream >> nTemp;
+	//		buf += (wchar_t)nTemp;
+	//	}
+	//	sText = buf;
+	//}
+	DrawText(sText, sText.length(), startPoint.x, startPoint.y);
+}
+void CSvmFile::Read_META_ARRAYTEXT()
+{
+	std::wstring sText;
+	TSvmPoint   startPoint;
+
+	m_oStream >> startPoint;
+
+	parseString(m_oStream, sText, m_currentActionVersion, m_currentCharset);
+	
+	unsigned short nIndex, nLen;
+	unsigned int nArrayLen;
+		
+	m_oStream >> nIndex;
+	m_oStream >> nLen;
+
+	m_oStream >> nArrayLen;
+
+	if( nArrayLen > 0 )
+	{
+        // #i9762#, #106172# Ensure that DX array is at least mnLen entries long
+		const unsigned int nIntAryLen = (std::max)(nArrayLen, (unsigned int)nLen) ;
+		int *mpDXAry = new int[ nIntAryLen ];
+        
+        int i=0;
+		for( i = 0; i < nArrayLen; i++ )
+			m_oStream >> mpDXAry[ i ];
+
+        // #106172# setup remainder
+		for( ; i < nIntAryLen; i++ )
+            mpDXAry[ i ] = 0;
+	}
+
+	if ( m_currentActionVersion >= 2 )							// Version 2
+	{
+		unsigned short nLen;
+		m_oStream >> nLen;
+
+		std::wstring tempBuffer;
+		unsigned short nTemp;
+		while ( nLen-- )
+		{
+			m_oStream >> nTemp;
+			tempBuffer += (wchar_t)nTemp;
+		}
+	}
 	DrawText(sText, sText.length(), startPoint.x, startPoint.y);
 }
 void CSvmFile::Read_META_SETTEXTCOLOR()
 {
-	TSvmColor oColor; //??? 3 byte????
+	TSvmColor oColor; 
 	m_oStream >> oColor;
 	m_pDC->SetTextColor(oColor);
 	UpdateOutputDC();
 }
 void CSvmFile::Read_META_SETFILLCOLOR()
 {
-	bool     doSet;
-	TSvmColor oColor; //??? 3 byte????
-	
-	m_oStream >> oColor;
-	m_oStream >> doSet;
+	if (m_urrentActionType == META_GRADIENT_ACTION ||
+		m_urrentActionType == META_GRADIENTEX_ACTION)
+	{
+		return;
+	}
 
 	CSvmBrush* pBrush = new CSvmBrush();
+	pBrush->BrushStyle = BS_NULL;
 	if (!pBrush)
 		return SetError();		
 	
-	pBrush->BrushStyle = BS_NULL;
+	bool doSet;
+	m_oStream >> pBrush->Color;
+	m_oStream >> doSet;
+
 	if (doSet)
 	{
-		pBrush->Color = oColor;
 		pBrush->BrushStyle = BS_SOLID; 
 	}
 	m_oPlayer.RegisterObject((CSvmObjectBase*)pBrush);
@@ -401,24 +460,108 @@ void CSvmFile::Read_META_SETFILLCOLOR()
 
 void CSvmFile::Read_META_SETLINECOLOR()
 {
-	TSvmColor  colorData;
-	bool     doSet;
-
-	m_oStream >> colorData;
-	m_oStream >> doSet;
-
 	CSvmPen* pPen = new CSvmPen();
 	if (!pPen)
 		return SetError();
-
 	pPen->PenStyle = PS_NULL;
+
+	bool     doSet;
+
+	m_oStream >> pPen->Color;
+	m_oStream >> doSet;
+	
 	if (doSet)
 	{
-		pPen->Color = colorData;
 		pPen->PenStyle = PS_COSMETIC | PS_SOLID;
 	}
 	m_oPlayer.RegisterObject((CSvmObjectBase*)pPen);
 }
+
+void CSvmFile::Read_META_GRADIENTEX()
+{
+	std::vector<TSvmPolygon> polygons;
+
+	unsigned short ushNumberOfPolygons;
+	m_oStream >> ushNumberOfPolygons;
+
+	for (unsigned short ushIndex = 0; ushIndex < ushNumberOfPolygons; ushIndex++)
+	{
+		TSvmPolygon poligon;
+
+		m_oStream >> poligon;
+		polygons.push_back(poligon);
+	}
+
+	std::vector<TSvmPolygon> complexPolygons;
+
+	if (m_currentActionVersion > 1)
+	{
+		unsigned short complexPolygonCount;
+		m_oStream >> complexPolygonCount;
+
+		complexPolygons.resize(complexPolygonCount);
+
+		for (unsigned short i = 0; i < complexPolygonCount; i++)
+		{
+			unsigned short complexPolygonIndex;
+			m_oStream >> complexPolygonIndex;
+
+			m_oStream >> complexPolygons[complexPolygonIndex];
+		}
+	}
+//////////////////////////////////////////////////////////////
+	CSvmBrush* pBrush = new CSvmBrush();
+	if (!pBrush)
+		return SetError();
+	pBrush->BrushStyle	= BS_PATHGRADIENT; 
+
+	unsigned short nTmp16;
+
+    m_oStream >> nTmp16; 
+	ESvmGradientStyle gradientStyle = (ESvmGradientStyle) nTmp16;
+
+	m_oStream >> pBrush->Color;
+	m_oStream >> pBrush->Color2;
+
+	m_oStream >> pBrush->BrushStyleEx;
+    m_oStream >> nTmp16; //Border 
+    m_oStream >> nTmp16; //OfsX 
+    m_oStream >> nTmp16; //OfsY 
+	m_oStream >> nTmp16; //IntensityStart 
+    m_oStream >> nTmp16; //IntensityEnd 
+    m_oStream >> nTmp16; //StepCount;	
+
+	m_oPlayer.RegisterObject((CSvmObjectBase*)pBrush);
+}
+
+void CSvmFile::Read_META_GRADIENT()
+{
+	CSvmBrush* pBrush = new CSvmBrush();
+	if (!pBrush)
+		return SetError();
+	pBrush->BrushStyle	= BS_LINEARGRADIENT; 
+
+	m_oStream >> pBrush->BrushBounds;
+	
+	unsigned short nTmp16;
+    m_oStream >> nTmp16; 
+	ESvmGradientStyle gradientStyle = (ESvmGradientStyle) nTmp16;
+
+	m_oStream >> pBrush->Color;
+	m_oStream >> pBrush->Color2;
+
+	m_oStream >> pBrush->BrushStyleEx;
+    m_oStream >> nTmp16; //Border 
+    m_oStream >> nTmp16; //OfsX 
+    m_oStream >> nTmp16; //OfsY 
+	m_oStream >> nTmp16; //IntensityStart 
+    m_oStream >> nTmp16; //IntensityEnd 
+    m_oStream >> nTmp16; //StepCount;	
+	
+	m_oPlayer.RegisterObject((CSvmObjectBase*)pBrush);
+
+}
+ 
 void CSvmFile::Read_META_CREATEFONT()
 {
 	CSvmFont* pFont = new CSvmFont();
@@ -426,19 +569,174 @@ void CSvmFile::Read_META_CREATEFONT()
 		return SetError();
 
 	m_oStream >> pFont;
+	m_currentCharset = pFont->CharSet;
 	m_oPlayer.RegisterObject((CSvmObjectBase*)pFont);
 }
+#define COMPRESS_OWN				('S'|('D'<<8))
+#define COMPRESS_NONE				( 0 )
+#define RLE_8						( 1 )
+#define RLE_4						( 2 )
+#define BITFIELDS					( 3 )
+#define ZCOMPRESS					( COMPRESS_OWN | 0x01000000 ) 
+
+inline USHORT discretizeBitcount( int nInputCount )
+{
+    return ( nInputCount <= 1 ) ? 1 :
+           ( nInputCount <= 4 ) ? 4 :
+           ( nInputCount <= 8 ) ? 8 : 24;
+}
+bool CSvmFile::ReadImage(unsigned short ushColorUsage, BYTE** ppBgraBuffer, unsigned int* pulWidth, unsigned int* pulHeight)
+{
+	unsigned int unRemainBytes = m_unRecordSize - ( m_oStream.Tell() - m_unRecordPos);
+	if (unRemainBytes <= 0)
+		return false;
+
+	BYTE* pBuffer = m_oStream.GetCurPtr();
+	MetaFile::ReadImage(pBuffer, unRemainBytes, ushColorUsage, ppBgraBuffer, pulWidth, pulHeight);
+	return true;
+}
+void CSvmFile::Read_META_POP()
+{
+	m_oPlayer.Pop();
+}
+void CSvmFile::Read_META_PUSH()
+{
+	unsigned short nFlags;
+	m_oStream >> nFlags; 
+	
+	m_oPlayer.Push(nFlags);
+}
+void CSvmFile::Read_META_RASTEROP()
+{
+	unsigned short tmp;
+	m_oStream >> tmp; 
+	
+	m_oPlayer.SetRasterOp(tmp);
+	
+}
 
-void CSvmFile::dumpAction(CDataStream &stream, unsigned short version, unsigned int totalSize)
+void CSvmFile::Read_META_BMPSCALE()
 {
-    //qDebug() << "Version: " << version;
-    for (unsigned int i = 0; i < totalSize; ++i) 
+	TSvmBitmapSize	size; 
+	TSvmBitmapPoint	point; 
+
+	m_oStream >> size;
+	m_oStream >> point;
+
+	unsigned int	rOffset = 0;
+	
+	unsigned int	nTmp32;
+	unsigned short	nTmp16 = 0;
+	bool			bRet = false;
+
+	m_oStream >> nTmp16;
+	m_oStream >> rOffset;
+
+	if ( ( 0x4D42 == nTmp16 ) || ( 0x4142 == nTmp16 ) )
+	{
+		if ( 0x4142 == nTmp16 )
 		{
-        unsigned char  temp;
-        stream >> temp;
-        //qDebug() << hex << i << temp << dec;
+			m_oStream.Skip( 12 );
+			m_oStream >> nTmp16;
+			m_oStream.Skip( 8 );
+			m_oStream >> nTmp32;
+			rOffset = nTmp32 - 28UL;;
+			bRet = ( 0x4D42 == nTmp16 );
 		}
-}
+		else
+		{
+			m_oStream.Skip( 8L );
+			m_oStream >> nTmp32;
+			rOffset = nTmp32 - 14UL;
+		}
+	}
+
+	TSvmBitmap bitmap_info;
+
+	m_oStream >> bitmap_info; //size = 40 
+	
+	unsigned short	nColors;
+	BYTE*			pData = NULL;
 	
+	int nBitCount = discretizeBitcount(bitmap_info.nBitCount);
+
+	if( nBitCount <= 8 )
+	{
+		if( bitmap_info.nColsUsed )
+			nColors = (USHORT) bitmap_info.nColsUsed;
+		else
+			nColors = ( 1 << bitmap_info.nBitCount );
+	}
+	else
+		nColors = 0;
+
+	if( ZCOMPRESS == bitmap_info.nCompression && m_pOutput )
+	{
+		COfficeUtils OfficeUtils(NULL);
+		
+		ULONG destSize, srcSize;
+		m_oStream >> srcSize >> destSize >> bitmap_info.nCompression;
+
+		BYTE*		srcBuf = m_oStream.GetCurPtr();
+		BYTE*		destBuf = new BYTE[destSize];
+
+		if (destSize > 0 && m_pOutput && destBuf )
+		{
+			if (OfficeUtils.Uncompress(destBuf, &destSize, srcBuf, srcSize) == S_OK)
+			{
+				//memcpy(destBuf,&bitmap_info,40);
+				//unsigned int ulWidth=0, ulHeight=0;
+				//BYTE*		bufBGRA = NULL;
+				//MetaFile::ReadImage(destBuf, destSize, 0, &bufBGRA, &ulWidth, &ulHeight);
+
+				int size_BGRA = bitmap_info.nWidth * bitmap_info.nHeight * 4;
+
+				BYTE*		bufBGRA = new BYTE [size_BGRA];
+				if (bufBGRA)
+				{
+					BYTE* bufBGRA1 = bufBGRA;
+					int  nCount = bitmap_info.nHeight;
+					for( int j = bitmap_info.nHeight-1; j>=0; j--)
+					{
+						for( long i=0; i < bitmap_info.nWidth; i+=3 )
+						{
+							*bufBGRA1 = destBuf[j * bitmap_info.nWidth + i + 0];	bufBGRA1++;
+							*bufBGRA1 = destBuf[j * bitmap_info.nWidth + i + 1];	bufBGRA1++;
+							*bufBGRA1 = destBuf[j * bitmap_info.nWidth + i + 2];	bufBGRA1++;
+							*bufBGRA1 = 0xff;										bufBGRA1++;
+						}
+					}
+					//for ( int i=0, j=0 ; i < destSize, j < size_BGRA; i+=3, j+=4)
+					//{
+					//	bufBGRA[j+0] = destBuf[i+0];
+					//	bufBGRA[j+1] = destBuf[i+1];
+					//	bufBGRA[j+2] = destBuf[i+2];
+					//	bufBGRA[j+3] = 0xff;
+					//}
+					double dX, dY, dX1, dY1;
+					TranslatePoint(point.x, point.y, dX, dY);
+					TranslatePoint(point.x + size.cx, point.y + size.cy, dX1, dY1);
+
+					dX1 = dX1-dX;
+					dY1 = dY1-dY;
+
+					MapMode aMapMode;
+					aMapMode.unit = MAP_PIXEL;//MAP_MM;
+									  //Fraction( 1000, aHeader.nXPelsPerMeter )
+									  //Fraction( 1000, aHeader.nYPelsPerMeter ) 
+
+					m_pDC->SetMapMode(aMapMode);
+					UpdateOutputDC();
+
+					m_pOutput->DrawBitmap(dX, dY, dX1, dY1, bufBGRA, bitmap_info.nWidth, bitmap_info.nHeight);
+					//m_pOutput->DrawBitmap(dX, dY, dX1, dY1, bufBGRA, ulWidth, ulHeight);
+					delete []bufBGRA;
+				}
+			}
+			delete []destBuf;
+		}
+	}
+	UpdateOutputDC();
+}
 } // namespace MetaFile
 

DesktopEditor/raster/Metafile/StarView/SvmFile.h

@@ -14,6 +14,9 @@ class CSvmFile : virtual public IMetaFileBase
 	 CSvmFile() : m_oPlayer(this)
 	 {
 		 m_pDC					= m_oPlayer.GetDC();
+		 m_currentActionVersion = 0;
+		 m_currentCharset		= 0;
+		 m_urrentActionType	= 0;
 	 };
 
 	 ~CSvmFile()
@@ -27,6 +30,9 @@ class CSvmFile : virtual public IMetaFileBase
 	{
 		m_oPlayer.Clear();
 		m_pDC = m_oPlayer.GetDC();
+
+		m_currentActionVersion	= 0;
+		m_currentCharset		= 0;
 	}
 	TRect*   GetBounds()
 	{
@@ -47,7 +53,7 @@ class CSvmFile : virtual public IMetaFileBase
 	int GetTextColor()
 	{
 		TSvmColor& oColor = m_pDC->GetTextColor();
-		return METAFILE_RGBA(oColor.r, oColor.g, oColor.b);
+		return oColor.color; //METAFILE_RGBA(oColor.r, oColor.g, oColor.b);
 	}
 	IFont*       GetFont()
 	{
@@ -84,7 +90,7 @@ class CSvmFile : virtual public IMetaFileBase
 	int          GetTextBgColor()
 	{
 		TSvmColor& oColor = m_pDC->GetBgColor();
-		return METAFILE_RGBA(oColor.r, oColor.g, oColor.b);
+		return oColor.color; //METAFILE_RGBA(oColor.r, oColor.g, oColor.b);
 	}
 	unsigned int GetFillMode()
 	{
@@ -115,39 +121,77 @@ class CSvmFile : virtual public IMetaFileBase
 	}
 	IClip*       GetClip()
 	{
+		CSvmClip* pClip = m_pDC->GetClip();			
+		if (!pClip)
 			return NULL;
+
+		return (IClip*)pClip;
 	}
 	int          GetCharSpace()
 	{
 		return 0;
 	}
- private:
-    void dumpAction(CDataStream &stream, unsigned short version, unsigned int totalSize);
-
 
  private:
 	BYTE*				m_pBufferData;
 	CSvmDC*				m_pDC;
 	CSvmPlayer          m_oPlayer;
 	SvmHeader			m_oHeader;
-	unsigned int		m_ulRecordSize;
+
+	unsigned short		m_currentActionVersion;
+	unsigned short		m_currentCharset;
+	unsigned short		m_urrentActionType;
+
+	unsigned int		m_unRecordSize;
+	unsigned int		m_unRecordPos;
+	
+	bool				m_bFirstPoint;
+	TRect				m_oBoundingBox;
 
 	friend class CSvmPlayer;
 
 	void Read_META_RECTANGLE();
 	void Read_SVM_HEADER();
-	unsigned int Read_META_POLYGON();
-	void Read_META_POLYPOLYGON(int version);
-	void Read_META_TEXT_A();
+	void Read_META_POLYGON();
+	void Read_META_POLYLINE();
+	void Read_META_POLYPOLYGON();
+	void Read_META_TEXT();
+	void Read_META_ARRAYTEXT();
 	void Read_META_SETMAPMODE();
 	void Read_META_SETTEXTCOLOR();
 	void Read_META_SETFILLCOLOR();
 	void Read_META_SETLINECOLOR();
 	void Read_META_CREATEFONT();
-	void Read_META_UNKNOWN()
+	void Read_META_BMPSCALE();
+	void Read_META_RASTEROP();
+	void Read_META_PUSH();
+	void Read_META_POP();
+	void Read_META_GRADIENT();
+	void Read_META_GRADIENTEX();
+
+	
+	void RegisterPoint(short shX, short shY)
 	{
-		//      
-		m_oStream.Skip(m_ulRecordSize);
+		if (m_bFirstPoint)
+		{
+			m_oBoundingBox.nLeft   = shX;
+			m_oBoundingBox.nRight  = shX;
+			m_oBoundingBox.nTop    = shY;
+			m_oBoundingBox.nBottom = shY;
+			m_bFirstPoint = false;
+		}
+		else
+		{
+			if (shX < m_oBoundingBox.nLeft)
+				m_oBoundingBox.nLeft = shX;
+			else if (shX > m_oBoundingBox.nRight)
+				m_oBoundingBox.nRight = shX;
+
+			if (shY < m_oBoundingBox.nTop)
+				m_oBoundingBox.nTop = shY;
+			else if (shY > m_oBoundingBox.nBottom)
+				m_oBoundingBox.nBottom = shY;
+		}
 	}
 	void TranslatePoint(TEmfPointL& oPoint, double& dX, double& dY)
 	{
@@ -175,6 +219,7 @@ class CSvmFile : virtual public IMetaFileBase
 		pInverse->Apply(dX, dY);
 	}
 
+	bool ReadImage(unsigned short ushColorUsage, BYTE** ppBgraBuffer, unsigned int* pulWidth, unsigned int* pulHeight);
 	bool ReadImage(unsigned int offBmi, unsigned int cbBmi, unsigned int offBits, unsigned int cbBits, unsigned int ulSkip, BYTE** ppBgraBuffer, unsigned int* pulWidth, unsigned int* pulHeight)
 	{
 		int lHeaderOffset = offBmi - ulSkip;
@@ -218,6 +263,36 @@ class CSvmFile : virtual public IMetaFileBase
 			m_pOutput->DrawBitmap(dX, dY, dR - dX, dB - dY, pImageBuffer, unImageW, unImageH);
 		}
 	}
+	void DrawImage(int nX, int nY, int nW, int nH, unsigned int unColorUsage)
+	{
+		if (m_pOutput)
+		{
+			BYTE* pBgra = NULL;
+			unsigned int unWidth, unHeight;
+			if (ReadImage(unColorUsage, &pBgra, &unWidth, &unHeight))
+			{
+				//ProcessRasterOperation(unRasterOperation, &pBgra, unWidth, unHeight);
+
+				double dX, dY, dX1, dY1;
+				TranslatePoint(nX, nY, dX, dY);
+				TranslatePoint(nX + nW, nY + nH, dX1, dY1);
+
+				m_pOutput->DrawBitmap(dX, dY, abs(dX1 - dX), abs(dY1 - dY), pBgra, unWidth, unHeight);
+			}
+
+			if (pBgra)
+				delete[] pBgra;
+
+			//int nRemainingBytes = GetRecordRemainingBytesCount();
+			//if (nRemainingBytes < 0)
+			//	return SetError();
+		}
+		else
+		{
+			RegisterPoint(nX, nY);
+			RegisterPoint(nX + nW, nY + nH);
+		}
+	}
 	void MoveTo(TEmfPointL& oPoint)
 	{
 		MoveTo(oPoint.x, oPoint.y);
@@ -385,115 +460,115 @@ class CSvmFile : virtual public IMetaFileBase
 				delete[] pdDx;
 		}
 	}
-	void DrawTextA(TEmfEmrText& oText)
-	{
-		if (!oText.OutputString)
-			return SetError();
-
-		IFont* pFont = GetFont();
-		NSString::CConverter::ESingleByteEncoding eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_DEFAULT;
-		if (pFont)
-		{
-			//  Charset -> Codepage: http://support.microsoft.com/kb/165478
-			// http://msdn.microsoft.com/en-us/library/cc194829.aspx
-			//  Charset Name       Charset Value(hex)  Codepage number
-			//  ------------------------------------------------------
-			//
-			//  DEFAULT_CHARSET           1 (x01)
-			//  SYMBOL_CHARSET            2 (x02)
-			//  OEM_CHARSET             255 (xFF)
-			//  ANSI_CHARSET              0 (x00)            1252
-			//  RUSSIAN_CHARSET         204 (xCC)            1251
-			//  EASTEUROPE_CHARSET      238 (xEE)            1250
-			//  GREEK_CHARSET           161 (xA1)            1253
-			//  TURKISH_CHARSET         162 (xA2)            1254
-			//  BALTIC_CHARSET          186 (xBA)            1257
-			//  HEBREW_CHARSET          177 (xB1)            1255
-			//  ARABIC _CHARSET         178 (xB2)            1256
-			//  SHIFTJIS_CHARSET        128 (x80)             932
-			//  HANGEUL_CHARSET         129 (x81)             949
-			//  GB2313_CHARSET          134 (x86)             936
-			//  CHINESEBIG5_CHARSET     136 (x88)             950
-			//  THAI_CHARSET            222 (xDE)             874	
-			//  JOHAB_CHARSET	        130 (x82)            1361
-			//  VIETNAMESE_CHARSET      163 (xA3)            1258
-
-			switch (pFont->GetCharSet())
-			{
-			default:
-			case DEFAULT_CHARSET:       eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_DEFAULT; break;
-			case SYMBOL_CHARSET:        eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_DEFAULT; break;
-			case ANSI_CHARSET:          eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1252; break;
-			case RUSSIAN_CHARSET:       eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1251; break;
-			case EASTEUROPE_CHARSET:    eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1250; break;
-			case GREEK_CHARSET:         eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1253; break;
-			case TURKISH_CHARSET:       eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1254; break;
-			case BALTIC_CHARSET:        eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1257; break;
-			case HEBREW_CHARSET:        eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1255; break;
-			case ARABIC_CHARSET:        eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1256; break;
-			case SHIFTJIS_CHARSET:      eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP932; break;
-			case HANGEUL_CHARSET:       eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP949; break;
-			case 134/*GB2313_CHARSET*/: eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP936; break;
-			case CHINESEBIG5_CHARSET:   eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP950; break;
-			case THAI_CHARSET:          eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP874; break;
-			case JOHAB_CHARSET:         eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1361; break;
-			case VIETNAMESE_CHARSET:    eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1258; break;
-			}
-		}
-
-		std::wstring wsText = NSString::CConverter::GetUnicodeFromSingleByteString((unsigned char*)oText.OutputString, oText.Chars, eCharSet);
-
-		int* pDx = NULL;
-		if (oText.OutputDx)
-		{
-			pDx = new int[oText.Chars];
-			if (pDx)
-			{
-				for (unsigned int unIndex = 0; unIndex < oText.Chars; unIndex++)
-				{
-					pDx[unIndex] = oText.OutputDx[unIndex];
-
-					//    Y   
-					if (oText.Options & ETO_PDY)
-						unIndex++;
-				}
-			}
-		}
-
-		DrawText(wsText, oText.Chars, oText.Reference.x, oText.Reference.y, pDx);
-
-		if (pDx)
-			delete[] pDx;
-	}
-	void DrawTextW(TEmfEmrText& oText)
-	{
-		if (!oText.OutputString)
-			return SetError();
-
-		std::wstring wsText = NSString::CConverter::GetUnicodeFromUTF16((unsigned short*)oText.OutputString, oText.Chars);
-
-		int* pDx = NULL;
-		if (oText.OutputDx)
-		{
-			pDx = new int[oText.Chars];
-			if (pDx)
-			{
-				for (unsigned int unIndex = 0; unIndex < oText.Chars; unIndex++)
-				{
-					pDx[unIndex] = oText.OutputDx[unIndex];
-
-					//    Y   
-					if (oText.Options & ETO_PDY)
-						unIndex++;
-				}
-			}
-		}
+	//void DrawTextA(TEmfEmrText& oText)
+	//{
+	//	if (!oText.OutputString)
+	//		return SetError();
 
-		DrawText(wsText, oText.Chars, oText.Reference.x, oText.Reference.y, pDx);
+	//	IFont* pFont = GetFont();
+	//	NSString::CConverter::ESingleByteEncoding eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_DEFAULT;
+	//	if (pFont)
+	//	{
+	//		//  Charset -> Codepage: http://support.microsoft.com/kb/165478
+	//		// http://msdn.microsoft.com/en-us/library/cc194829.aspx
+	//		//  Charset Name       Charset Value(hex)  Codepage number
+	//		//  ------------------------------------------------------
+	//		//
+	//		//  DEFAULT_CHARSET           1 (x01)
+	//		//  SYMBOL_CHARSET            2 (x02)
+	//		//  OEM_CHARSET             255 (xFF)
+	//		//  ANSI_CHARSET              0 (x00)            1252
+	//		//  RUSSIAN_CHARSET         204 (xCC)            1251
+	//		//  EASTEUROPE_CHARSET      238 (xEE)            1250
+	//		//  GREEK_CHARSET           161 (xA1)            1253
+	//		//  TURKISH_CHARSET         162 (xA2)            1254
+	//		//  BALTIC_CHARSET          186 (xBA)            1257
+	//		//  HEBREW_CHARSET          177 (xB1)            1255
+	//		//  ARABIC _CHARSET         178 (xB2)            1256
+	//		//  SHIFTJIS_CHARSET        128 (x80)             932
+	//		//  HANGEUL_CHARSET         129 (x81)             949
+	//		//  GB2313_CHARSET          134 (x86)             936
+	//		//  CHINESEBIG5_CHARSET     136 (x88)             950
+	//		//  THAI_CHARSET            222 (xDE)             874	
+	//		//  JOHAB_CHARSET	        130 (x82)            1361
+	//		//  VIETNAMESE_CHARSET      163 (xA3)            1258
+
+	//		switch (pFont->GetCharSet())
+	//		{
+	//		default:
+	//		case DEFAULT_CHARSET:       eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_DEFAULT; break;
+	//		case SYMBOL_CHARSET:        eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_DEFAULT; break;
+	//		case ANSI_CHARSET:          eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1252; break;
+	//		case RUSSIAN_CHARSET:       eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1251; break;
+	//		case EASTEUROPE_CHARSET:    eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1250; break;
+	//		case GREEK_CHARSET:         eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1253; break;
+	//		case TURKISH_CHARSET:       eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1254; break;
+	//		case BALTIC_CHARSET:        eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1257; break;
+	//		case HEBREW_CHARSET:        eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1255; break;
+	//		case ARABIC_CHARSET:        eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1256; break;
+	//		case SHIFTJIS_CHARSET:      eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP932; break;
+	//		case HANGEUL_CHARSET:       eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP949; break;
+	//		case 134/*GB2313_CHARSET*/: eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP936; break;
+	//		case CHINESEBIG5_CHARSET:   eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP950; break;
+	//		case THAI_CHARSET:          eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP874; break;
+	//		case JOHAB_CHARSET:         eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1361; break;
+	//		case VIETNAMESE_CHARSET:    eCharSet = NSString::CConverter::ESingleByteEncoding::SINGLE_BYTE_ENCODING_CP1258; break;
+	//		}
+	//	}
+
+	//	std::wstring wsText = NSString::CConverter::GetUnicodeFromSingleByteString((unsigned char*)oText.OutputString, oText.Chars, eCharSet);
+
+	//	int* pDx = NULL;
+	//	if (oText.OutputDx)
+	//	{
+	//		pDx = new int[oText.Chars];
+	//		if (pDx)
+	//		{
+	//			for (unsigned int unIndex = 0; unIndex < oText.Chars; unIndex++)
+	//			{
+	//				pDx[unIndex] = oText.OutputDx[unIndex];
+
+	//				//    Y   
+	//				if (oText.Options & ETO_PDY)
+	//					unIndex++;
+	//			}
+	//		}
+	//	}
+
+	//	DrawText(wsText, oText.Chars, oText.Reference.x, oText.Reference.y, pDx);
+
+	//	if (pDx)
+	//		delete[] pDx;
+	//}
+	//void DrawTextW(TEmfEmrText& oText)
+	//{
+	//	if (!oText.OutputString)
+	//		return SetError();
 
-		if (pDx)
-			delete[] pDx;
-	}
+	//	std::wstring wsText = NSString::CConverter::GetUnicodeFromUTF16((unsigned short*)oText.OutputString, oText.Chars);
+
+	//	int* pDx = NULL;
+	//	if (oText.OutputDx)
+	//	{
+	//		pDx = new int[oText.Chars];
+	//		if (pDx)
+	//		{
+	//			for (unsigned int unIndex = 0; unIndex < oText.Chars; unIndex++)
+	//			{
+	//				pDx[unIndex] = oText.OutputDx[unIndex];
+
+	//				//    Y   
+	//				if (oText.Options & ETO_PDY)
+	//					unIndex++;
+	//			}
+	//		}
+	//	}
+
+	//	DrawText(wsText, oText.Chars, oText.Reference.x, oText.Reference.y, pDx);
+
+	//	if (pDx)
+	//		delete[] pDx;
+	//}
 };
 
 

DesktopEditor/raster/Metafile/StarView/SvmObjects.cpp

 
 #include "SvmObjects.h"
+#include "../../../common/String.h"
 
 
 namespace MetaFile
 {
-	void soakBytes(CDataStream &stream, int numBytes)
+	void parseString(CDataStream &stream, std::wstring &string, unsigned short version, unsigned short charset)
 	{
-		unsigned char scratch;
-		for (int i = 0; i < numBytes; ++i) 
+
+		if (charset == 0xffff)//RTL_UNICODE
 		{
-			stream >> scratch;
-		}
+			unsigned int length;
+			stream >> length;
+			
+			string = NSString::CConverter::GetUnicodeFromUTF16((unsigned short*)stream.GetCurPtr(), length);
+	
+			stream.Skip(length*2);
 		}
-	void parseString(CDataStream &stream, std::wstring &string)
+		else
 		{
 			unsigned short  length;
-
 			stream >> length;
-		for (unsigned int i = 0; i < length; ++i)
+		
+			if (charset < 1)
 			{
-			unsigned char  ch;
-			stream >> ch;
-			string += char(ch);
+				std::string ansiString = std::string((char*)stream.GetCurPtr(),length);
+				string = std::wstring(ansiString.begin(), ansiString.end());
+			}else
+				string = NSString::CConverter::GetUnicodeFromSingleByteString((unsigned char*)stream.GetCurPtr(), length,
+																			(NSString::CConverter::ESingleByteEncoding)charset);
+			stream.Skip(length);
 		}
 	}
 
@@ -119,7 +127,7 @@ CDataStream& operator>>(CDataStream &stream, SvmHeader &header)
 	stream >> header.actionCount;
 
 	if (header.versionCompat.version > 1)
-		soakBytes(stream, 1);
+		stream.Skip(1);
 
 	return stream;
 }
@@ -133,6 +141,13 @@ TSvmRect::TSvmRect()
 {
 	l = t = r = b = 0;
 }
+CDataStream& operator>>(CDataStream &stream, TSvmBitmapSize &s)
+{
+	stream >> s.cx;
+	stream >> s.cy;
+
+	return stream;
+}
 CDataStream& operator>>(CDataStream &stream, TSvmPoint &p)
 {
 	stream >> p.x;
@@ -140,6 +155,13 @@ CDataStream& operator>>(CDataStream &stream, TSvmPoint &p)
 
 	return stream;
 }
+CDataStream& operator>>(CDataStream &stream, TSvmBitmapPoint &p)
+{
+	stream >> p.x;
+	stream >> p.y;
+
+	return stream;
+}
 CSvmBrush::CSvmBrush() : Color(255, 255, 255)
 {
 	BrushStyle = BS_SOLID;
@@ -154,7 +176,15 @@ CSvmBrush::CSvmBrush(CSvmBrush& oBrush)
 
 int CSvmBrush::GetColor()
 {
-	return METAFILE_RGBA(Color.r, Color.g, Color.b);
+	return Color.color;//METAFILE_RGBA(Color.r, Color.g, Color.b);
+}
+int CSvmBrush::GetColor2()
+{
+	return Color2.color;//METAFILE_RGBA(Color2.r, Color2.g, Color2.b);
+}
+unsigned int CSvmBrush::GetStyleEx()
+{
+	return BrushStyleEx;
 }
 unsigned int CSvmBrush::GetStyle()
 {
@@ -166,11 +196,18 @@ unsigned int CSvmBrush::GetHatch()
 }
 unsigned int CSvmBrush::GetAlpha()
 {
-	return 255;
+	return 0xff-Color.a;
+}
+void CSvmBrush::GetBounds(double& left, double& top, double& width, double& height)
+{
+	left	= BrushBounds.l;
+	top		= BrushBounds.t;
+	width	= BrushBounds.r - BrushBounds.l;
+	height	= BrushBounds.b - BrushBounds.t;
 }
 int CSvmPen::GetColor()
 {
-	return METAFILE_RGBA(Color.r, Color.g, Color.b);
+	return Color.color;//METAFILE_RGBA(Color.r, Color.g, Color.b);
 }
 TSvmRect::TSvmRect(CDataStream &stream)
 {
@@ -179,8 +216,8 @@ TSvmRect::TSvmRect(CDataStream &stream)
 CDataStream& operator>>(CDataStream &stream, TSvmRect &p)
 {
 	stream >> p.l;
-	stream >> p.r;
 	stream >> p.t;
+	stream >> p.r;
 	stream >> p.b;
 
 	return stream;
@@ -201,18 +238,53 @@ CDataStream& operator>>(CDataStream &stream, TSvmPolygon &p)
 	}
 	return stream;
 }
+#define METAFILE_RGBA(r, g, b, a) ((unsigned int)( ( (unsigned char)(r) )| ( ( (unsigned char)(g) ) << 8 ) | ( ( (unsigned char)(b) ) << 16 ) | ( (unsigned char)(a) << 24 ) ) )
+
+
 CDataStream& operator>>(CDataStream &stream, TSvmColor &c)
 {
+	char s;
+    unsigned short  a, r, g, b, p;
+    
+	//stream >> s;
+ //   stream >> a;
+ //   stream >> r;
+ //   stream >> g;
+ //   stream >> b;
+ //   stream >> p;
+
     stream >> c.b;
     stream >> c.g;
     stream >> c.r;
     stream >> c.a;
 
-	return stream;
+	//c.a = a;
+	//c.r = r;
+	//c.b = b;
+	//c.g = g;
 
+	c.color = METAFILE_RGBA(c.r, c.g, c.b, c.a);
+
+	return stream;
 }
-CDataStream& operator>>(CDataStream &stream, CSvmBrush *b)
+CDataStream& operator>>(CDataStream &stream, TSvmLineInfo &i)
 {
+	VersionCompat version;
+
+	stream >> version;
+
+	unsigned short style;
+	stream >> style;
+	
+	i.style = (ESvmLineStyle) style;
+	stream >> i.width;
+
+	if (version.version >=2)
+	{
+		//counts  dot & dashes, size, distance
+		stream.Skip(2 + 4 + 2 + 4 + 4);
+	}
+
 	return stream;
 }
 CDataStream& operator>>(CDataStream &stream, CSvmFont *font)
@@ -220,57 +292,34 @@ CDataStream& operator>>(CDataStream &stream, CSvmFont *font)
 	unsigned short  version;
 	unsigned int	totalSize;
 
-	// the VersionCompat struct
 	stream >> version;
 	stream >> totalSize;
 
-	// Name and style
-	std::wstring  family;
-	std::wstring  style;
+	parseString(stream, font->sFamilyName, version);
+	parseString(stream, font->sStyle, version);
 
-	parseString(stream, family);
-	parseString(stream, style);
+	stream >> font->SizeWidth;
+	stream >> font->SizeHeight;
 	
-	font->sFacename = family;
-
-	// Font size
-	unsigned int  width;
-	unsigned int  height;
-	stream >> width;
-	stream >> height;
+	stream >> font->CharSet;    
+	stream >> font->Family;
+	stream >> font->Pitch;
+	stream >> font->Weight;    
+	stream >> font->Underline;  
+	stream >> font->StrikeOut; 
+	stream >> font->Italic; 
+	stream >> font->Language;
+	stream >> font->Width;
 
-	font->Width = width;
-	font->Height = height;
+	stream >> font->Orientation;
+	stream >> font->bWordline;   
+	stream >> font->bOutline;
+	stream >> font->bShadow;
+	stream >> font->Kerning;
 
 	char   temp8;
 	bool    tempbool;
 	unsigned short tempu16;
-	stream >> tempu16;          // charset
-	stream >> tempu16;          // family
-	stream >> tempu16;          // pitch
-	stream >> tempu16;          // weight
-	if (tempu16 > 0)
-		font->Weight = tempu16;
-	stream >> tempu16;          // underline
-	if (tempu16 > 0)
-		font->Underline= 1;
-	stream >> tempu16;          // strikeout
-	if (tempu16 > 0)
-		font->StrikeOut = 1;
-	stream >> tempu16;          // italic
-	if (tempu16 > 0)
-		font->Italic = 1;
-	stream >> tempu16;          // language
-	stream >> tempu16;          // width
-
-	if (tempu16 > 0)
-		font->Width = tempu16; //??? todo
-
-	stream >> tempu16;          // orientation
-	stream >> tempbool;         // wordline
-	stream >> tempbool;         // outline
-	stream >> tempbool;         // shadow
-	stream >> temp8;            // kerning
 
 	if (version > 1) 
 	{
@@ -286,9 +335,106 @@ CDataStream& operator>>(CDataStream &stream, CSvmFont *font)
 	{
 		stream >> tempu16;      // overline
 	}
-	// FIXME: Read away the rest of font here to allow for higher versions than 3.
 	return stream;
 }
+#define DIBCOREHEADERSIZE			12 
+
+CDataStream& operator>>(CDataStream &stream, TSvmBitmap &b)
+{
+	// BITMAPINFOHEADER or BITMAPCOREHEADER
+	stream >> b.nSize;
+
+	// BITMAPCOREHEADER
+	if ( b.nSize == DIBCOREHEADERSIZE )
+	{
+		short nTmp16;
+
+		stream >> nTmp16;	b.nWidth = nTmp16;
+		stream >> nTmp16;	b.nHeight = nTmp16;
+		stream >> b.nPlanes;
+		stream >> b.nBitCount;
+	}
+	else
+	{
+		// unknown Header
+		if( b.nSize < sizeof( TSvmBitmap ) )
+		{
+			unsigned int nUnknownSize = sizeof( b.nSize );
+
+			stream >> b.nWidth;		nUnknownSize += sizeof( b.nWidth );
+			stream >> b.nHeight;	nUnknownSize += sizeof( b.nHeight );
+			stream >> b.nPlanes;	nUnknownSize += sizeof( b.nPlanes );
+			stream >> b.nBitCount;	nUnknownSize += sizeof( b.nBitCount );
+
+			if( nUnknownSize < b.nSize )
+			{
+				stream >> b.nCompression;
+				nUnknownSize += sizeof( b.nCompression );
+
+				if( nUnknownSize < b.nSize )
+				{
+					stream >> b.nSizeImage;
+					nUnknownSize += sizeof( b.nSizeImage );
+
+					if( nUnknownSize < b.nSize )
+					{
+						stream >> b.nXPelsPerMeter;
+						nUnknownSize += sizeof( b.nXPelsPerMeter );
+
+						if( nUnknownSize < b.nSize )
+						{
+							stream >> b.nYPelsPerMeter;
+							nUnknownSize += sizeof( b.nYPelsPerMeter );
+						}
+
+						if( nUnknownSize < b.nSize )
+						{
+							stream >> b.nColsUsed;
+							nUnknownSize += sizeof( b.nColsUsed );
 
+							if( nUnknownSize < b.nSize )
+							{
+								stream >> b.nColsImportant;
+								nUnknownSize += sizeof( b.nColsImportant );
+							}
+						}
+					}
+				}
+			}
+		}
+		else
+		{
+			stream >> b.nWidth;
+			stream >> b.nHeight;
+			stream >> b.nPlanes;
+			stream >> b.nBitCount;
+			stream >> b.nCompression;
+			stream >> b.nSizeImage;
+			stream >> b.nXPelsPerMeter;
+			stream >> b.nYPelsPerMeter;
+			stream >> b.nColsUsed;
+			stream >> b.nColsImportant;
+		}
+
+		// Eventuell bis zur Palette ueberlesen
+		if ( b.nSize > sizeof( TSvmBitmap ) ) // ???
+			stream.Skip( b.nSize - sizeof( TSvmBitmap ) );
+	}
+	bool bTopDown;
+	if ( b.nHeight < 0 )
+	{
+		bTopDown = true;
+		b.nHeight *= -1;
+	}
+	else
+		bTopDown = false;
+
+   
+    // #144105# protect a little against damaged files
+    if( b.nSizeImage > ( 16 * static_cast< unsigned int >( b.nWidth * b.nHeight ) ) )
+        b.nSizeImage = 0;
+	
+	return stream;
+}
 }
 

DesktopEditor/raster/Metafile/StarView/SvmObjects.h

 #pragma once
 
-//#include <qglobal.h>
 #include "../Common/MetaFileTypes.h"
 #include "../Common/MetaFileObjects.h"
 
@@ -15,8 +14,7 @@ namespace MetaFile
 		SVM_OBJECT_UNKNOWN			= 0x00,
 		SVM_OBJECT_BRUSH			= 0x01,
 		SVM_OBJECT_FONT				= 0x02,
-		SVM_OBJECT_PEN = 0x03//,
-		//EMF_OBJECT_PALETTE = 0x04
+		SVM_OBJECT_PEN				= 0x03
 	} ESvmObjectType;
 
 	class CSvmObjectBase
@@ -36,7 +34,7 @@ struct VersionCompat
     VersionCompat(CDataStream &stream);
 
     unsigned short  version;
-    unsigned int  length;//32
+    unsigned int	length;
 };
 
 struct Fraction 
@@ -68,7 +66,16 @@ struct TSvmSize
 	unsigned int cx;
 	unsigned int cy;
 };
-
+struct TSvmBitmapSize
+{
+	unsigned short cx;
+	unsigned short cy;
+};
+struct TSvmBitmapPoint
+{
+	unsigned short x;
+	unsigned short y;
+};
 enum ESvmMapUnit
 {
 MAP_100TH_MM, MAP_10TH_MM, MAP_MM, MAP_CM,
@@ -77,6 +84,25 @@ MAP_100TH_MM, MAP_10TH_MM, MAP_MM, MAP_CM,
 			   MAP_RELATIVE, /*MAP_REALAPPFONT,*/ MAP_LASTENUMDUMMY
 };
 
+enum ESvnRasterOp
+{
+	ROP_OVERPAINT, ROP_XOR, ROP_0, ROP_1, ROP_INVERT 
+};
+enum ESvmGradientStyle
+{
+	GRADIENT_LINEAR		= 0,
+	GRADIENT_AXIAL		= 1,
+	GRADIENT_RADIAL		= 2,
+	GRADIENT_ELLIPTICAL = 3,
+	GRADIENT_SQUARE		= 4,
+	GRADIENT_RECT		= 5
+};
+enum ESvmLineStyle
+{
+	LINE_NONE = 0,
+	LINE_SOLID = 1,
+	LINE_DASH = 2
+};
 struct MapMode 
 {
     MapMode();
@@ -121,12 +147,15 @@ struct TSvmPolygon
 	std::vector<TSvmPoint>	points;
 	unsigned short			count;
 };
+
 struct TSvmColor
 {
 	unsigned char r;
 	unsigned char g;
 	unsigned char b;
-	unsigned char a; //Reserved Must be 0x00
+	unsigned char a; 
+
+	unsigned int color;
 
 	TSvmColor()
 	{
@@ -146,14 +175,21 @@ struct TSvmColor
 	}
 	void Copy(const TSvmColor& oOther)
 	{
-		r = oOther.r;		g = oOther.g;		b = oOther.b;		a = oOther.a;
+		r = oOther.r;		g = oOther.g;		b = oOther.b;		a = oOther.a; color = oOther.color;
 	}
 	TSvmColor& operator=(const TSvmColor& oColor)
 	{
-		r = oColor.r;		g = oColor.g;		b = oColor.b;		a = oColor.a;
+		r = oColor.r;		g = oColor.g;		b = oColor.b;		a = oColor.a; color = oColor.color;
 		return *this;
 	}
 };
+
+struct TSvmLineInfo
+{
+	ESvmLineStyle	style;
+	int				width;
+};
+
 struct TSvmWindow
 {
 	int lX;
@@ -190,18 +226,38 @@ public:
 	}
 	// IBrush
 	int          GetColor();
+	int          GetColor2();
+	unsigned int GetStyleEx();
 	unsigned int GetStyle();
 	unsigned int GetHatch();
 	unsigned int GetAlpha();
 	std::wstring GetDibPatterPath(){ return L""; }
+	void GetBounds(double& left, double& top, double& width, double& height);
 
 public:
-
+	unsigned short	BrushStyleEx;  //angle, or ....
 	unsigned short	BrushStyle;
 	TSvmColor		Color;
+	TSvmColor		Color2;
 	unsigned short	BrushHatch;
+
+	TSvmRect		BrushBounds;
 };
 
+struct TSvmBitmap
+{
+	unsigned int	nSize;
+	unsigned int	nWidth;
+	unsigned int	nHeight;
+	unsigned short	nPlanes;
+	unsigned short	nBitCount;
+	unsigned int	nCompression;
+	unsigned int	nSizeImage;
+	int				nXPelsPerMeter;
+	int				nYPelsPerMeter;
+	unsigned int	nColsUsed;
+	unsigned int	nColsImportant;
+};
 class CSvmFont : public CSvmObjectBase, public IFont
 {
 public:
@@ -221,11 +277,11 @@ public:
 	// IFont
 	int          GetHeight()
 	{
-		return (int)Height;
+		return (int)SizeHeight;
 	}
 	std::wstring GetFaceName()
 	{
-		return sFacename;
+		return sFamilyName;
 	}
 	int          GetWeight()
 	{
@@ -245,7 +301,7 @@ public:
 	}
 	int          GetEscapement()
 	{
-		return (int)Escapement;
+		return 0;//(int)Escapement;
 	}
 	int          GetCharSet()
 	{
@@ -254,20 +310,27 @@ public:
 
 public:
 
-	short         Height;
-	short         Width;
-	short         Escapement;
-	short         Orientation;
-	short         Weight;
-	unsigned char Italic;
-	unsigned char Underline;
-	unsigned char StrikeOut;
-	unsigned char CharSet;
-	unsigned char OutPrecision;
-	unsigned char ClipPrecision;
-	unsigned char Quality;
-	unsigned char PitchAndFamily;
-	std::wstring  sFacename; 
+	unsigned int	SizeHeight;
+	unsigned int	SizeWidth;
+	
+	unsigned short	Width;
+	unsigned short	Orientation;
+	unsigned short	Weight;
+	unsigned short	Italic;
+	unsigned short	Underline;
+	unsigned short	StrikeOut;
+	unsigned short	CharSet;
+	unsigned short	Language;
+	unsigned short	Pitch;
+	unsigned short	Family;
+	
+	bool bWordline;
+	bool bOutline;
+	bool bShadow;
+	char Kerning;
+
+	std::wstring  sFamilyName;
+	std::wstring  sStyle;
 	//        32       
 };
 
@@ -276,7 +339,6 @@ class CSvmPen : public CSvmObjectBase, public IPen
 public:
 	CSvmPen()
 	{
-		Width.x = 1;
 	}
 	~CSvmPen()
 	{
@@ -295,28 +357,30 @@ public:
 	}
 	unsigned int GetWidth()
 	{
-		return (unsigned int)Width.x;
+		return (unsigned int)Width;
 	}
 
 public:
 	unsigned short	PenStyle;
-	TSvmPoint      Width;
+	int				Width;
 	TSvmColor		Color;
 };
 
-void soakBytes(CDataStream &stream, int numBytes);
-void parseString(CDataStream &stream, std::wstring &string);
+void parseString(CDataStream &stream, std::wstring &string, unsigned short version = 0, unsigned short charset = 0);
 
 CDataStream& operator>>(CDataStream &stream, VersionCompat &compat);
 CDataStream& operator>>(CDataStream &stream, Fraction &fract);
 CDataStream& operator>>(CDataStream &stream, MapMode &mm);
 CDataStream& operator>>(CDataStream &stream, SvmHeader &header);
+CDataStream& operator>>(CDataStream &stream, TSvmBitmapSize &s);
+CDataStream& operator>>(CDataStream &stream, TSvmBitmapPoint &s);
 CDataStream& operator>>(CDataStream &stream, TSvmPoint &p);
 CDataStream& operator>>(CDataStream &stream, TSvmRect &p);
 CDataStream& operator>>(CDataStream &stream, TSvmPolygon &p);
 CDataStream& operator>>(CDataStream &stream, TSvmColor &c);
-CDataStream& operator>>(CDataStream &stream, CSvmBrush *b);
+CDataStream& operator>>(CDataStream &stream, TSvmBitmap &b);
 CDataStream& operator>>(CDataStream &stream, CSvmFont *f);
+CDataStream& operator>>(CDataStream &stream, TSvmLineInfo &l);
 
 }
 

DesktopEditor/raster/Metafile/StarView/SvmPlayer.cpp

@@ -2,22 +2,36 @@
 #include "SvmPlayer.h"
 #include "SvmFile.h"
 
-
 // MetaFile
 #include "SvmEnums.h"
 #include "SvmObjects.h"
 
 #define DEBUG_SVMPAINT 0
 
+// Flags for Push
+#define PUSH_LINECOLOR                  ((USHORT)0x0001)
+#define PUSH_FILLCOLOR                  ((USHORT)0x0002)
+#define PUSH_FONT                       ((USHORT)0x0004)
+#define PUSH_TEXTCOLOR                  ((USHORT)0x0008)
+#define PUSH_MAPMODE                    ((USHORT)0x0010)
+#define PUSH_CLIPREGION                 ((USHORT)0x0020)
+#define PUSH_RASTEROP                   ((USHORT)0x0040)
+#define PUSH_TEXTFILLCOLOR              ((USHORT)0x0080)
+#define PUSH_TEXTALIGN                  ((USHORT)0x0100)
+#define PUSH_REFPOINT                   ((USHORT)0x0200)
+#define PUSH_TEXTLINECOLOR              ((USHORT)0x0400)
+#define PUSH_TEXTLAYOUTMODE             ((USHORT)0x0800)
+#define PUSH_TEXTLANGUAGE               ((USHORT)0x1000)
+#define PUSH_OVERLINECOLOR              ((USHORT)0x2000)
+#define PUSH_ALLTEXT                    (PUSH_TEXTCOLOR | PUSH_TEXTFILLCOLOR | PUSH_TEXTLINECOLOR | PUSH_OVERLINECOLOR | PUSH_TEXTALIGN | PUSH_TEXTLAYOUTMODE | PUSH_TEXTLANGUAGE)
+#define PUSH_ALLFONT                    (PUSH_ALLTEXT | PUSH_FONT)
+#define PUSH_ALL                        ((USHORT)0xFFFF)
 
-/**
-   Namespace for StarView Metafile (SVM) classes
-*/
 namespace MetaFile
 {
 
-	CSvmPlayer::CSvmPlayer(CSvmFile* pFile)
-	{
+CSvmPlayer::CSvmPlayer(CSvmFile* pFile)
+{
 	CSvmDC* pDC = new CSvmDC();
 	if (!pDC)
 	{
@@ -25,12 +39,16 @@ namespace MetaFile
 		return;
 	}
 
+	m_pFile = pFile;
 	m_pDC = pDC;
 	m_vDCStack.push_back(pDC);
+
+	m_nFlags = 0;
+	m_eRasterOp = ROP_OVERPAINT;
 	m_ushIndex = 0;
 
 	InitStockObjects();
-	}
+}
 
 CSvmPlayer::~CSvmPlayer()
 {
@@ -68,13 +86,15 @@ void    CSvmPlayer::Clear()
 	CSvmDC* pDC = new CSvmDC();
 	if (!pDC)
 	{
-		m_pSvmFile->SetError();
+		m_pFile->SetError();
 		return;
 	}
+	m_nFlags = 0;
+	m_eRasterOp = ROP_OVERPAINT;
+	m_ushIndex = 0;
 
 	m_pDC = pDC;
 	m_vDCStack.push_back(pDC);
-	m_ushIndex = 0;
 	m_vAvailableIndexes.clear();
 
 	InitStockObjects();
@@ -95,18 +115,31 @@ void CSvmPlayer::SelectObject(unsigned short ushIndex)
 		}
 	}
 }
+CSvmObjectBase *CSvmPlayer::GetLastObject (ESvmObjectType type)
+{
+	CSvmObjectMap::iterator oIterator = m_mObjects.end();
+	oIterator--;
+	for (; oIterator != m_mObjects.begin(); oIterator--)
+	{
+		if (oIterator->second->GetType() == type)
+		{
+			return oIterator->second;
+		}
+	}
+	return NULL;
+}
 CSvmDC* CSvmPlayer::SaveDC()
 {
 	if (!m_pDC)
 	{
-		m_pSvmFile->SetError();
+		m_pFile->SetError();
 		return NULL;
 	}
 
 	CSvmDC* pNewDC = m_pDC->Copy();
 	if (!pNewDC)
 	{
-		m_pSvmFile->SetError();
+		m_pFile->SetError();
 		return NULL;
 	}
 
@@ -118,7 +151,7 @@ CSvmDC* CSvmPlayer::RestoreDC()
 {
 	if (m_vDCStack.size() <= 1)
 	{
-		m_pSvmFile->SetError();
+		m_pFile->SetError();
 		return m_pDC;
 	}
 
@@ -170,11 +203,157 @@ void CSvmPlayer::RegisterObject(CSvmObjectBase* pObject)
 
 	SelectObject(m_ushIndex-1);
 }
+void CSvmPlayer::SetRasterOp(int op)
+{
+	m_eRasterOp = (ESvnRasterOp)op;
+}
 void CSvmPlayer::InitStockObjects()
 {
 	InitStockBrush(false, 79, 129, 189); //default OnlyOffice
 	InitStockPen(false, 0x00, 0x00, 0x00);
 }
+void CSvmPlayer::Pop()
+{
+	//if ( m_nFlags & PUSH_LINECOLOR )
+	//{
+	//	if ( m_nFlags->mpLineColor )
+	//		SetLineColor( *m_nFlags->mpLineColor );
+	//	else
+	//		SetLineColor();
+	//}
+	//if ( m_nFlags & PUSH_FILLCOLOR )
+	//{
+	//	if ( m_nFlags->mpFillColor )
+	//		SetFillColor( *m_nFlags->mpFillColor );
+	//	else
+	//		SetFillColor();
+	//}
+	//if ( m_nFlags & PUSH_FONT )
+	//	SetFont( *pData->mpFont );
+	//if ( m_nFlags & PUSH_TEXTCOLOR )
+	//	SetTextColor( *pData->mpTextColor );
+	//if ( m_nFlags & PUSH_TEXTFILLCOLOR )
+	//{
+	//	if ( pData->mpTextFillColor )
+	//		SetTextFillColor( *pData->mpTextFillColor );
+	//	else
+	//		SetTextFillColor();
+	//}
+	//if ( m_nFlags & PUSH_TEXTLINECOLOR )
+	//{
+	//	if ( pData->mpTextLineColor )
+	//		SetTextLineColor( *pData->mpTextLineColor );
+	//	else
+	//		SetTextLineColor();
+	//}
+	//if ( m_nFlags & PUSH_OVERLINECOLOR )
+	//{
+	//	if ( pData->mpOverlineColor )
+	//		SetOverlineColor( *pData->mpOverlineColor );
+	//	else
+	//		SetOverlineColor();
+	//}
+	//if ( m_nFlags & PUSH_TEXTALIGN )
+	//	SetTextAlign( pData->meTextAlign );
+	//if( m_nFlags & PUSH_TEXTLAYOUTMODE )
+	//	SetLayoutMode( pData->mnTextLayoutMode );
+	//if( m_nFlags & PUSH_TEXTLANGUAGE )
+	//	SetDigitLanguage( pData->meTextLanguage );
+	//if ( m_nFlags & PUSH_RASTEROP )
+	//	SetRasterOp( m_eRasterOp );
+	//if ( m_nFlags & PUSH_MAPMODE )
+	//{
+	//	if ( pData->mpMapMode )
+	//		SetMapMode( *pData->mpMapMode );
+	//	else
+	//		SetMapMode();
+	//}
+	if ( m_nFlags & PUSH_CLIPREGION )
+	{
+		GetDC()->GetClip()->ClipOnRenderer(m_pFile->m_pOutput);
+		GetDC()->GetClip()->Reset();
+	}
+
+	m_nFlags = 0;
+	//if ( m_nFlags & PUSH_REFPOINT )
+	//{
+	//	if ( pData->mpRefPoint )
+	//		SetRefPoint( *pData->mpRefPoint );
+	//	else
+	//		SetRefPoint();
+	//}
+}
+
+void CSvmPlayer::Push(int nFlags) //     
+{
+	m_nFlags = nFlags;
+	//if ( nFlags & PUSH_LINECOLOR )
+	//{
+	//	if ( mbLineColor )
+	//		pData->mpLineColor = new Color( maLineColor );
+	//	else
+	//		pData->mpLineColor = NULL;
+	//}
+	//if ( nFlags & PUSH_FILLCOLOR )
+	//{
+	//	if ( mbFillColor )
+	//		pData->mpFillColor = new Color( maFillColor );
+	//	else
+	//		pData->mpFillColor = NULL;
+	//}
+	//if ( nFlags & PUSH_FONT )
+	//	pData->mpFont = new Font( maFont );
+	//if ( nFlags & PUSH_TEXTCOLOR )
+	//	pData->mpTextColor = new Color( GetTextColor() );
+	//if ( nFlags & PUSH_TEXTFILLCOLOR )
+	//{
+	//	if ( IsTextFillColor() )
+	//		pData->mpTextFillColor = new Color( GetTextFillColor() );
+	//	else
+	//		pData->mpTextFillColor = NULL;
+	//}
+	//if ( nFlags & PUSH_TEXTLINECOLOR )
+	//{
+	//	if ( IsTextLineColor() )
+	//		pData->mpTextLineColor = new Color( GetTextLineColor() );
+	//	else
+	//		pData->mpTextLineColor = NULL;
+	//}
+	//if ( nFlags & PUSH_OVERLINECOLOR )
+	//{
+	//	if ( IsOverlineColor() )
+	//		pData->mpOverlineColor = new Color( GetOverlineColor() );
+	//	else
+	//		pData->mpOverlineColor = NULL;
+	//}
+	//if ( nFlags & PUSH_TEXTALIGN )
+	//	pData->meTextAlign = GetTextAlign();
+	//if( nFlags & PUSH_TEXTLAYOUTMODE )
+	//	pData->mnTextLayoutMode = GetLayoutMode();
+	//if( nFlags & PUSH_TEXTLANGUAGE )
+	//	pData->meTextLanguage = GetDigitLanguage();
+	//if ( nFlags & PUSH_RASTEROP )
+	//	pData->meRasterOp = GetRasterOp();
+	//if ( nFlags & PUSH_MAPMODE )
+	//{
+	//	if ( mbMap )
+	//		pData->mpMapMode = new MapMode( maMapMode );
+	//	else
+	//		pData->mpMapMode = NULL;
+	//}
+	if ( nFlags & PUSH_CLIPREGION )
+	{
+		GetDC()->GetClip()->Reset();
+		//new region
+	}
+	//if ( nFlags & PUSH_REFPOINT )
+	//{
+	//	if ( mbRefPoint )
+	//		pData->mpRefPoint = new Point( maRefPoint );
+	//	else
+	//		pData->mpRefPoint = NULL;
+	//}
+}
 void  CSvmPlayer::InitStockBrush(bool bNull, unsigned char r, unsigned char g, unsigned char b)
 {
 	CSvmBrush* pBrush = new CSvmBrush();
@@ -261,7 +440,7 @@ CSvmDC*         CSvmDC::Copy()
 	pNewDC->m_oWindow.Copy(&m_oWindow);
 	pNewDC->m_oViewport.Copy(&m_oViewport);
 	pNewDC->m_oCurPos = m_oCurPos;
-	//pNewDC->m_oClip = m_oClip;
+	pNewDC->m_oClip = m_oClip;
 	pNewDC->m_unArcDirection = m_unArcDirection;
 
 	return pNewDC;
@@ -426,6 +605,10 @@ CSvmPen* CSvmDC::GetPen()
 {
 	return m_pPen;
 }
+CSvmClip* CSvmDC::GetClip()
+{
+	return &m_oClip;
+}
 void CSvmDC::SetStretchMode(unsigned int& oMode)
 {
 	m_ulStretchMode = oMode;
@@ -543,10 +726,6 @@ TSvmPoint & CSvmDC::GetCurPos()
 {
 	return m_oCurPos;
 }
-//CSvmClip* CSvmDC::GetClip()
-//{
-//	return &m_oClip;
-//}
 //void CSvmDC::ClipToPath(CSvmPath* pPath, unsigned int unMode)
 //{
 //	m_oClip.SetPath(pPath, unMode);

DesktopEditor/raster/Metafile/StarView/SvmPlayer.h

@@ -2,6 +2,7 @@
 
 #include "SvmEnums.h"
 #include "SvmObjects.h"
+#include "SvmClip.h"
 
 #include <map>
 #include <vector>
@@ -17,30 +18,41 @@ public:
 	CSvmPlayer(CSvmFile *file);
     virtual ~CSvmPlayer();
 	void	Clear();
+	
 	CSvmDC* SaveDC();
 	CSvmDC* RestoreDC();
 	CSvmDC* GetDC();
 
-	void RegisterObject(CSvmObjectBase* pObject);
-	void SelectObject(unsigned short ushIndex);
-	void SelectPalette(unsigned short ushIndex);
-	void DeleteObject(unsigned short ushIndex);
+	void RegisterObject	(CSvmObjectBase* pObject);
+	void SelectObject	(unsigned short ushIndex);
+	void DeleteObject	(unsigned short ushIndex);
+	
+	CSvmObjectBase *GetLastObject (ESvmObjectType type);
+
+	void Pop();
+	void Push(int Flags);
+
+	void SetRasterOp(int op);
+
 private:
 	void InitStockObjects();
-	void InitStockBrush(bool bNull, unsigned char r, unsigned char g, unsigned char b);
-	void InitStockPen(bool bNull, unsigned char r, unsigned char g, unsigned char b);
+	void InitStockBrush	(bool bNull, unsigned char r, unsigned char g, unsigned char b);
+	void InitStockPen	(bool bNull, unsigned char r, unsigned char g, unsigned char b);
 
 	typedef std::map < unsigned int, CSvmObjectBase* > CSvmObjectMap;
 
 	CSvmDC*					m_pDC;
 	std::vector<CSvmDC*>	m_vDCStack;
-	CSvmFile*            m_pSvmFile;
+	CSvmFile*				m_pFile;
 	CSvmObjectMap			m_mObjects;
+	int						m_nFlags;
+	ESvnRasterOp			m_eRasterOp;
 
 	typedef std::map <unsigned int, CWmfObjectBase*> CWmfObjectMap;
 
 	unsigned short              m_ushIndex;
 	std::vector<unsigned short> m_vAvailableIndexes;
+
 };
 
 class CSvmDC
@@ -95,7 +107,7 @@ public:
 	void            SetCurPos(TSvmPoint& oPoint);
 	void            SetCurPos(int lX, int lY);
 	TSvmPoint&      GetCurPos();
-	//CSvmClip*       GetClip();
+	CSvmClip*       GetClip();
 	//void            ClipToPath(CSvmPath* pPath, unsigned int unMode);
 	void            SetArcDirection(unsigned int unDirection);
 	unsigned int    GetArcDirection();
@@ -128,7 +140,7 @@ private:
 	TSvmWindow      m_oWindow;
 	TSvmWindow      m_oViewport;
 	TSvmPoint		m_oCurPos;
-//	CSvmClip        m_oClip;
+	CSvmClip        m_oClip;
 	unsigned int    m_unArcDirection;
 };
 

DesktopEditor/raster/Metafile/Wmf/WmfObjects.h

@@ -44,10 +44,19 @@ namespace MetaFile
 
 		// IBrush
 		int          GetColor();
+		int          GetColor2()
+		{
+			return 0;
+		}
 		unsigned int GetStyle();
+		unsigned int GetStyleEx()
+		{
+			return 0;
+		}
 		unsigned int GetHatch();
 		unsigned int GetAlpha();
 		std::wstring GetDibPatterPath();
+		void GetBounds(double& left, double& top, double& width, double& height) {}
 
 	public:
 

DesktopEditor/raster/raster_vs2005.vcproj

@@ -785,6 +785,38 @@
 					>
 				</File>
 			</Filter>
+			<Filter
+				Name="StarView"
+				>
+				<File
+					RelativePath=".\Metafile\StarView\SvmEnums.h"
+					>
+				</File>
+				<File
+					RelativePath=".\Metafile\StarView\SvmFile.cpp"
+					>
+				</File>
+				<File
+					RelativePath=".\Metafile\StarView\SvmFile.h"
+					>
+				</File>
+				<File
+					RelativePath=".\Metafile\StarView\SvmObjects.cpp"
+					>
+				</File>
+				<File
+					RelativePath=".\Metafile\StarView\SvmObjects.h"
+					>
+				</File>
+				<File
+					RelativePath=".\Metafile\StarView\SvmPlayer.cpp"
+					>
+				</File>
+				<File
+					RelativePath=".\Metafile\StarView\SvmPlayer.h"
+					>
+				</File>
+			</Filter>
 		</Filter>
 		<Filter
 			Name="Jp2"