Wmf перенесен из ImageStudio. Исходники wmf сделаны кроссплатформенными (убран...

Wmf перенесен из ImageStudio. Исходники wmf сделаны кроссплатформенными (убран CString и заменены функции винды). Исправлены некоторые баги в wmf. Написан внешний класс CMetaFile для работы и с Emf и с Wmf. Написаны заготовочные классы для чтениния Emf, чтение уже происходит нормально, но почти все пока не поддерживается. В Emf реализована поддержка картинок.

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

.gitattributes

@@ -2959,6 +2959,9 @@ DesktopEditor/mac_build/raster/raster.xcodeproj/project.xcworkspace/xcuserdata/a
 DesktopEditor/mac_build/raster/raster.xcodeproj/xcuserdata svnc_tsvn_003alogminsize=5
 DesktopEditor/mac_build/raster/raster.xcodeproj/xcuserdata/alexey.musinov.xcuserdatad svnc_tsvn_003alogminsize=5
 DesktopEditor/mac_build/raster/raster.xcodeproj/xcuserdata/alexey.musinov.xcuserdatad/xcschemes svnc_tsvn_003alogminsize=5
+DesktopEditor/raster/Metafile svnc_tsvn_003alogminsize=5
+DesktopEditor/raster/Metafile/Emf svnc_tsvn_003alogminsize=5
+DesktopEditor/raster/Metafile/Wmf svnc_tsvn_003alogminsize=5
 DoctRenderer/COMMON/Dlls/AVSGraphics.dll svn_mime_002dtype=application%2Foctet-stream
 DoctRenderer/COMMON/Dlls/AVSOfficeFOFile.dll svn_mime_002dtype=application%2Foctet-stream
 DoctRenderer/COMMON/Joiner/bin/Debug/Joiner.exe svn_mime_002dtype=application%2Foctet-stream

DesktopEditor/raster/Metafile/Common.h

+#ifndef _METAFILE_WMF_EMF_COMMON_H
+#define _METAFILE_WMF_EMF_COMMON_H
+
+#ifndef BYTE
+typedef unsigned char BYTE;
+#endif
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#include <algorithm>
+
+#include "Emf/EmfTypes.h"
+#include "Wmf/WmfTypes.h"
+#include "Wmf/WmfUtils.h"
+#include "Emf/EmfObjects.h"
+
+namespace Metafile
+{
+	class CDataStream
+	{
+	public:
+
+		CDataStream() : pBuffer(NULL)
+		{
+		}
+
+		~CDataStream()
+		{
+		}
+
+		void SetStream(BYTE* pBuf, unsigned long unSize)
+		{
+			pBuffer = pBuf;
+			pCur    = pBuf;
+			pEnd    = pBuf + unSize + 1;
+		};
+
+		unsigned char  ReadUChar()
+		{
+			if (pCur + 1 >= pEnd)
+				return 0;
+
+			unsigned char unResult = pCur[0];
+			pCur++;
+			return unResult;
+		};
+		unsigned short ReadUShort()
+		{
+			if (pCur + 2 >= pEnd)
+				return 0;
+
+			unsigned short ushResult = (pCur[0]) | ((pCur[1]) << 8);
+			pCur += 2;
+			return ushResult;
+		};
+		unsigned long  ReadULong()
+		{
+			if (pCur + 4 >= pEnd)
+				return 0;
+
+			unsigned long unResult = (unsigned long)((pCur[0] << 0) | ((pCur[1]) << 8) | ((pCur[2]) << 16) | ((pCur[3]) << 24));
+			pCur += 4;
+			return unResult;
+		};
+		double         ReadDouble()
+		{
+			if (pCur + 4 >= pEnd)
+				return 0;
+
+			long lIntValue  = (long)((pCur[0] << 16) | ((pCur[1]) << 8) | ((pCur[2]) << 0));
+			long lFracValue = (long)(pCur[3]);
+			pCur += 4;
+			return (double)(lIntValue + (lFracValue / 16.0));
+		};
+		char           ReadChar()
+		{
+			return (char)ReadUChar();
+		};
+		short          ReadShort()
+		{
+			return (short)ReadUShort();
+		};
+		long           ReadLong()
+		{
+			return (long)ReadULong();
+		};
+		void           ReadBytes(BYTE* pBuffer, unsigned long ulSize)
+		{
+			size_t ulRemainSize = (pEnd - pCur);
+			size_t ulFinalSize  = (ulRemainSize > ulSize ? ulSize : ulRemainSize);
+
+			for (size_t ulIndex = 0; ulIndex < ulFinalSize; ulIndex++)
+			{
+				pBuffer[ulIndex] = ReadChar();
+			}
+		};
+
+		CDataStream& operator>>(unsigned char&  nValue)
+		{
+			nValue = ReadUChar();
+			return *this;
+		}
+		CDataStream& operator>>(unsigned short& nValue)
+		{
+			nValue = ReadUShort();
+			return *this;
+		}
+		CDataStream& operator>>(unsigned long&  nValue)
+		{
+			nValue = ReadULong();
+			return *this;
+		}
+		CDataStream& operator>>(unsigned int&   nValue)
+		{
+			nValue = ReadULong();
+			return *this;
+		}
+		CDataStream& operator>>(double&         dValue)
+		{
+			dValue = ReadDouble();
+			return *this;
+		}
+		CDataStream& operator>>(char&  nValue)
+		{
+			nValue = ReadChar();
+			return *this;
+		}
+		CDataStream& operator>>(short& nValue)
+		{
+			nValue = ReadShort();
+			return *this;
+		}
+		CDataStream& operator>>(long&  nValue)
+		{
+			nValue = ReadLong();
+			return *this;
+		}
+		CDataStream& operator>>(int&   nValue)
+		{
+			nValue = ReadLong();
+			return *this;
+		}
+		CDataStream& operator>>(TEmfRect& oRect)
+		{
+			*this >> oRect.shLeft;
+			*this >> oRect.shTop;
+			*this >> oRect.shRight;
+			*this >> oRect.shBottom;
+
+			return *this;
+		}
+		CDataStream& operator>>(TEmfRectL& oRect)
+		{
+			*this >> oRect.lLeft;
+			*this >> oRect.lTop;
+			*this >> oRect.lRight;
+			*this >> oRect.lBottom;
+
+			return *this;
+		}
+		CDataStream& operator>>(TEmfSizeL& oSize)
+		{
+			*this >> oSize.ulX;
+			*this >> oSize.ulY;
+
+			return *this;
+		}
+		CDataStream& operator>>(TEmfColor& oColor)
+		{
+			*this >> oColor.r;
+			*this >> oColor.g;
+			*this >> oColor.b;
+			*this >> oColor.a;
+
+			return *this;
+		}
+		CDataStream& operator>>(CEmfLogBrushEx& oBrush)
+		{
+			*this >> oBrush.BrushStyle;
+			*this >> oBrush.Color;
+			*this >> oBrush.BrushHatch;
+
+			return *this;
+		}
+
+		bool IsValid() const
+		{
+			if (NULL == pBuffer)
+				return false;
+
+			return true;
+		}
+
+		bool IsEof() const
+		{
+			if (pCur >= pEnd)
+				return true;
+
+			return false;
+		}
+
+		unsigned long Tell()
+		{
+			return (unsigned long)(pCur - pBuffer);
+		}
+
+		void Skip(unsigned long ulSkip)
+		{
+			pCur += ulSkip;
+		}
+
+		void SeekBack(unsigned long ulSkipBack)
+		{
+			pCur -= ulSkipBack;
+		}
+
+	private:
+
+		BYTE *pBuffer;
+		BYTE *pCur;
+		BYTE *pEnd;
+	};
+
+	void ReadImage(BYTE* pHeaderBuffer, unsigned long ulHeaderBufferLen, BYTE* pImageBuffer, unsigned long ulImageBufferLen, BYTE** ppDstBuffer, unsigned long* pulWidth, unsigned long* pulHeight);
+};
+
+#endif //_METAFILE_WMF_EMF_COMMON_H
\ No newline at end of file

DesktopEditor/raster/Metafile/Emf/EmfFile.h

+#ifndef _EMF_FILE_H
+#define _EMF_FILE_H
+
+#include "../Wmf/WmfUtils.h"
+#include "../Wmf/WmfTypes.h"
+
+#include "../Common.h"
+
+#include "EmfTypes.h"
+#include "EmfOutputDevice.h"
+#include "EmfPlayer.h"
+
+#include "../../../fontengine/FontManager.h"
+
+namespace Metafile
+{
+	class CEmfFile
+	{
+	public:
+
+		CEmfFile() : m_oPlayer(this)
+		{
+			m_pBufferData = NULL;
+			m_bError      = false;
+			m_pOutput     = NULL;
+
+			m_oStream.SetStream(NULL, 0);
+
+			m_pDC = m_oPlayer.GetDC();
+		};
+
+		~CEmfFile()
+		{
+
+		};
+
+		bool OpenFromFile(const wchar_t* wsFilePath)
+		{
+			if (m_pBufferData)
+				delete m_pBufferData;
+
+			NSFile::CFileBinary oFile;
+			oFile.OpenFile(wsFilePath);
+			long lFileSize = oFile.GetFileSize();
+
+			m_pBufferData = new BYTE[lFileSize];
+			if (!m_pBufferData)
+				return false;
+
+			DWORD lReadedSize;
+			oFile.ReadFile(m_pBufferData, lFileSize, lReadedSize);
+
+			m_oStream.SetStream(m_pBufferData, lFileSize);
+
+			return true;
+		}
+		void Close()
+		{
+			if (m_pBufferData)
+				delete m_pBufferData;
+
+			m_pOutput = NULL;
+			m_oStream.SetStream(NULL, 0);
+			m_bError = false;
+
+			m_oPlayer.Clear();
+			m_pDC = m_oPlayer.GetDC();
+		}
+		TEmfRectL GetBounds()
+		{
+			return m_oHeader.oFrame;
+		}
+		void SetOutputDevice(CEmfOutputDevice* pOutput)
+		{
+			m_pOutput = pOutput;
+		}
+		void Scan()
+		{
+			Read_EMR_HEADER();
+		}
+
+		bool CheckError()
+		{
+			return m_bError;
+		}
+
+		void SetFontManager(CFontManager* pManager)
+		{
+			m_pFontManager = pManager;
+		}
+
+		void PlayMetaFile()
+		{
+			unsigned long ulSize, ulType;
+			unsigned long ulNumber = 0;
+
+			bool bEof = false;
+
+			do
+			{
+				m_oStream >> ulType;
+				m_oStream >> ulSize;
+
+				m_ulRecordSize = ulSize - 8;
+
+				switch (ulType)
+				{
+					case EMR_STRETCHDIBITS:
+					{
+						Read_EMR_STRETCHDIBITS();
+						break;
+					}
+					//-----------------------------------------------------------
+					// 2.3.5 Drawing
+					//-----------------------------------------------------------
+					case EMR_EXTTEXTOUTW:
+					{
+						Read_EMR_EXTTEXTOUTW();
+						break;
+					}
+					//-----------------------------------------------------------
+					// 2.3.7 Object Creation
+					//-----------------------------------------------------------
+					case EMR_CREATEBRUSHINDIRECT:
+					{
+						Read_EMR_CREATEBRUSHINDIRECT();
+						break;
+					}
+					//-----------------------------------------------------------
+					// 2.3.11 State
+					//-----------------------------------------------------------
+					case EMR_SAVEDC:
+					{
+						Read_EMR_SAVEDC();
+						break;
+					}
+					case EMR_RESTOREDC:
+					{
+						Read_EMR_RESTOREDC();
+						break;
+					}
+					case EMR_SETTEXTCOLOR:
+					{
+						Read_EMR_SETTEXTCOLOR();
+						break;
+					}
+					//-----------------------------------------------------------
+					// 2.3.12 Transform
+					//-----------------------------------------------------------
+					case EMR_SETWORLDTRANSFORM:
+					{
+						Read_EMR_SETWORLDTRANSFORM();
+						break;
+					}
+					case EMR_MODIFYWORLDTRANSFORM:
+					{
+						Read_EMR_MODIFYWORLDTRANSFORM();
+						break;
+					}
+
+
+					case EMR_EOF:
+					{
+						Read_EMR_EOF();
+						bEof = true;
+						break;
+					}
+					case EMR_SETICMMODE:
+					default:
+					{						
+						Read_EMR_UNKNOWN();
+						break;
+					}
+				}
+
+				if (bEof)
+					break;
+
+				if (!m_oStream.IsValid())
+					SetError();
+
+			} while (!CheckError());
+		
+		}
+
+	private:
+
+		void SetError()
+		{
+			m_bError = true;
+		}
+
+		void Read_EMR_HEADER()
+		{
+			unsigned long ulType, ulSize;
+
+			m_oStream >> ulType;
+			m_oStream >> ulSize;
+
+			if (EMR_HEADER != ulType)
+				return SetError();
+
+			m_oStream >> m_oHeader.oBounds;
+			m_oStream >> m_oHeader.oFrame;
+			m_oStream >> m_oHeader.ulSignature;
+			m_oStream >> m_oHeader.ulVersion;
+			m_oStream >> m_oHeader.ulSize;
+			m_oStream >> m_oHeader.ulRecords;
+			m_oStream >> m_oHeader.ushObjects;
+			m_oStream >> m_oHeader.ushReserved;
+			m_oStream >> m_oHeader.ulSizeDescription;
+			m_oStream >> m_oHeader.ulOffsetDescription;
+			m_oStream >> m_oHeader.ulPalEntries;
+			m_oStream >> m_oHeader.oDevice;
+			m_oStream >> m_oHeader.oMillimeters;
+
+			if (ENHMETA_SIGNATURE != m_oHeader.ulSignature || 0x00010000 != m_oHeader.ulVersion)
+				return SetError();
+
+			//    , ..     
+			unsigned long ulRemaining = ulSize - 88; // 8 + sizeof(TEmfHeader)
+			m_oStream.Skip(ulRemaining);
+		}
+		void Read_EMR_STRETCHDIBITS()
+		{
+			TEmfStretchDIBITS oBitmap;
+
+			m_oStream >> oBitmap.Bounds;
+			m_oStream >> oBitmap.xDest;
+			m_oStream >> oBitmap.yDest;
+			m_oStream >> oBitmap.xSrc;
+			m_oStream >> oBitmap.ySrc;
+			m_oStream >> oBitmap.cxSrc;
+			m_oStream >> oBitmap.cySrc;
+			m_oStream >> oBitmap.offBmiSrc;
+			m_oStream >> oBitmap.cbBmiSrc;
+			m_oStream >> oBitmap.offBitsSrc;
+			m_oStream >> oBitmap.cbBitsSrc;
+			m_oStream >> oBitmap.UsageSrc;
+			m_oStream >> oBitmap.BitBltRasterOperation;
+			m_oStream >> oBitmap.cxDest;
+			m_oStream >> oBitmap.cyDest;
+
+			unsigned long ulHeaderOffset = oBitmap.offBmiSrc - sizeof(TEmfStretchDIBITS) - 8;
+			unsigned long ulHeaderSize   = oBitmap.cbBmiSrc;
+			m_oStream.Skip(ulHeaderOffset);
+
+			BYTE* pHeaderBuffer = new BYTE[ulHeaderSize];
+			if (!pHeaderBuffer)
+				return SetError();
+
+			m_oStream.ReadBytes(pHeaderBuffer, ulHeaderSize);
+
+			unsigned long ulBitsOffset = oBitmap.offBitsSrc - oBitmap.offBmiSrc - oBitmap.cbBmiSrc;
+			unsigned long ulBitsSize   = oBitmap.cbBitsSrc;
+			m_oStream.Skip(ulBitsOffset);
+			BYTE* pBitsBuffer = new BYTE[ulBitsSize];
+			if (!pBitsBuffer)
+			{
+				delete[] pHeaderBuffer;
+				return SetError();
+			}
+			m_oStream.ReadBytes(pBitsBuffer, ulBitsSize);
+
+			BYTE* pBgraBuffer;
+			unsigned long ulWidth, ulHeight;
+			ReadImage(pHeaderBuffer, ulHeaderSize, pBitsBuffer, ulBitsSize, &pBgraBuffer, &ulWidth, &ulHeight);
+
+			if (m_pOutput)
+				m_pOutput->Draw_Bitmap(oBitmap.xDest, oBitmap.yDest, oBitmap.cxDest, oBitmap.cyDest, pBgraBuffer, ulWidth, ulHeight);
+
+			if (pBgraBuffer)
+				delete[] pBgraBuffer;
+
+			delete[] pBitsBuffer;
+			delete[] pHeaderBuffer;
+		}
+		void Read_EMR_EOF()
+		{
+			unsigned long ulCount, ulOffset, ulSizeLast;
+
+			m_oStream >> ulCount;
+			m_oStream >> ulOffset;
+
+			m_oStream.Skip(m_ulRecordSize - 8 - 4);
+
+			m_oStream >> ulSizeLast;
+		}
+		void Read_EMR_UNKNOWN()
+		{
+			//      
+			m_oStream.Skip(m_ulRecordSize);
+		}
+		void Read_EMR_SAVEDC()
+		{
+			m_pDC = m_oPlayer.SaveDC();
+		}
+		void Read_EMR_RESTOREDC()
+		{
+			long lSavedDC;
+			m_oStream >> lSavedDC;
+
+			if (lSavedDC >= 0)
+			{
+				SetError();
+				return;
+			}
+
+			long lCount = -lSavedDC;
+			for (long lIndex = 0; lIndex < lCount; lIndex++)
+				m_oPlayer.RestoreDC();
+
+			m_pDC = m_oPlayer.GetDC();
+		}
+		void Read_EMR_MODIFYWORLDTRANSFORM()
+		{
+			TEmfXForm oXForm;
+
+			m_oStream >> oXForm.M11;
+			m_oStream >> oXForm.M12;
+			m_oStream >> oXForm.M21;
+			m_oStream >> oXForm.M22;
+			m_oStream >> oXForm.Dx;
+			m_oStream >> oXForm.Dy;
+
+			unsigned long ulMode;
+			m_oStream >> ulMode;
+
+			TEmfXForm* pCurTransform = m_pDC->GetTransform();
+			pCurTransform->Multiply(oXForm, ulMode);
+		}
+		void Read_EMR_SETWORLDTRANSFORM()
+		{
+			TEmfXForm oXForm;
+
+			m_oStream >> oXForm.M11;
+			m_oStream >> oXForm.M12;
+			m_oStream >> oXForm.M21;
+			m_oStream >> oXForm.M22;
+			m_oStream >> oXForm.Dx;
+			m_oStream >> oXForm.Dy;
+
+			TEmfXForm* pCurTransform = m_pDC->GetTransform();
+			pCurTransform->Multiply(oXForm, MWT_SET);
+		}
+		void Read_EMR_CREATEBRUSHINDIRECT()
+		{
+			unsigned long ulBrushIndex;
+			CEmfLogBrushEx* pBrush = new CEmfLogBrushEx();
+
+			m_oStream >> ulBrushIndex;
+			m_oStream >> *pBrush;
+
+			m_oPlayer.RegisterObject(ulBrushIndex, (CEmfObjectBase*)pBrush);
+		}
+		void Read_EMR_SETTEXTCOLOR()
+		{
+			TEmfColor oColor;
+			m_oStream >> oColor;
+
+			m_pDC->SetTextColor(oColor);
+		}
+		void Read_EMR_EXTTEXTOUTW()
+		{
+			TEmfRectL oBounds;
+			m_oStream >> oBounds;
+
+			unsigned long ulGrMode;
+			double dExScale, dEyScale;
+
+			m_oStream >> ulGrMode;
+			m_oStream >> dExScale;
+			m_oStream >> dEyScale;
+
+			// EmrText
+			
+		}
+
+	private:
+
+		CDataStream       m_oStream;
+		BYTE*             m_pBufferData;
+		bool              m_bError;
+		CFontManager*     m_pFontManager;
+		TEmfHeader        m_oHeader;
+
+		unsigned long     m_ulRecordSize;
+		CEmfOutputDevice* m_pOutput;
+
+		CEmfDC*           m_pDC;
+		CEmfPlayer        m_oPlayer;
+
+		friend class CEmfRendererOutput;
+		friend class CEmfPlayer;
+	};
+}
+
+#endif // _EMF_FILE_H
\ No newline at end of file

DesktopEditor/raster/Metafile/Emf/EmfObjects.h

+#ifndef _EMF_OBJECTS_H
+#define _EMF_OBJECTS_H
+
+#include "EmfTypes.h"
+#include "../Wmf/WmfTypes.h"
+
+namespace Metafile
+{
+	class CEmfObjectBase
+	{
+	public:
+		CEmfObjectBase(){}
+		virtual ~CEmfObjectBase(){}
+	};
+
+	class CEmfLogBrushEx : public CEmfObjectBase
+	{
+	public:
+
+		CEmfLogBrushEx()
+		{
+			BrushStyle = BS_SOLID;
+			BrushHatch = HS_HORIZONTAL;
+		}
+		virtual ~CEmfLogBrushEx()
+		{
+		}
+
+	public:
+		unsigned long BrushStyle;
+		TEmfColor     Color;
+		unsigned long BrushHatch;
+	};
+}
+
+#endif // _EMF_OBJECTS_H
\ No newline at end of file

DesktopEditor/raster/Metafile/Emf/EmfOutputDevice.h

+#ifndef _EMF_OUTPUT_DEVICE_H
+#define _EMF_OUTPUT_DEVICE_H
+
+#include "../Wmf/WmfTypes.h"
+
+namespace Metafile
+{
+
+	class CEmfOutputDevice
+	{
+	public:
+
+		CEmfOutputDevice() {}
+		virtual ~CEmfOutputDevice() {}
+
+		//     
+		virtual void Begin() = 0;
+		virtual void End() = 0;
+
+		// pBuffer - BGRA   ulWidth, ulHeight,      
+		virtual void Draw_Bitmap(long lX, long lY, long lW, long lH, BYTE* pBuffer, unsigned long ulWidth, unsigned long ulHeight) = 0;
+	};
+
+}
+
+#endif //_EMF_OUTPUT_DEVICE_H
\ No newline at end of file

DesktopEditor/raster/Metafile/Emf/EmfPlayer.cpp

+#include "EmfPlayer.h"
+#include "EmfFile.h"
+
+namespace Metafile
+{
+	CEmfPlayer::CEmfPlayer(CEmfFile* pFile)
+	{
+		CEmfDC* pDC = new CEmfDC();
+		if (!pDC)
+		{
+			pFile->SetError();
+			return;
+		}
+
+		m_pDC = pDC;
+		m_vDCStack.push_back(pDC);
+	};
+	CEmfPlayer::~CEmfPlayer()
+	{
+		for (int nIndex = 0; nIndex < m_vDCStack.size(); nIndex++)
+		{
+			CEmfDC* pDC = m_vDCStack.at(nIndex);
+			delete pDC;
+		}
+
+		for (CEmfObjectMap::iterator oIterator = m_mObjects.begin(); oIterator != m_mObjects.end(); oIterator++)
+		{
+			CEmfObjectBase* pOldObject = oIterator->second;
+			delete pOldObject;
+		}
+		m_mObjects.clear();
+	}
+	void CEmfPlayer::Clear()
+	{
+		for (int nIndex = 0; nIndex < m_vDCStack.size(); nIndex++)
+		{
+			CEmfDC* pDC = m_vDCStack.at(nIndex);
+			delete pDC;
+		}
+
+		for (CEmfObjectMap::iterator oIterator = m_mObjects.begin(); oIterator != m_mObjects.end(); oIterator++)
+		{
+			CEmfObjectBase* pOldObject = oIterator->second;
+			delete pOldObject;
+		}
+		m_mObjects.clear();
+
+		CEmfDC* pDC = new CEmfDC();
+		if (!pDC)
+		{
+			m_pEmfFile->SetError();
+			return;
+		}
+
+		m_pDC = pDC;
+		m_vDCStack.push_back(pDC);
+	}
+	CEmfDC* CEmfPlayer::SaveDC()
+	{
+		if (!m_pDC)
+		{
+			m_pEmfFile->SetError();
+			return NULL;
+		}
+
+		CEmfDC* pNewDC = m_pDC->Copy();
+		if (!pNewDC)
+		{
+			m_pEmfFile->SetError();
+			return NULL;
+		}
+
+		m_vDCStack.push_back(pNewDC);
+		m_pDC = pNewDC;
+		return pNewDC;
+	}
+	CEmfDC* CEmfPlayer::RestoreDC()
+	{
+		if (m_vDCStack.size() <= 1)
+		{
+			m_pEmfFile->SetError();
+			return m_pDC;
+		}
+
+		CEmfDC* pDC = m_vDCStack.at(m_vDCStack.size() - 1);
+		m_vDCStack.pop_back();
+		delete pDC;
+
+		pDC = m_vDCStack.at(m_vDCStack.size() - 1);
+		m_pDC = pDC;
+		return m_pDC;
+	}
+	CEmfDC* CEmfPlayer::GetDC()
+	{
+		return m_pDC;
+	}
+	void CEmfPlayer::RegisterObject(unsigned long ulIndex, CEmfObjectBase* pObject)
+	{
+		CEmfObjectMap::const_iterator oPos = m_mObjects.find(ulIndex);
+		if (m_mObjects.end() != oPos)
+		{ 
+			CEmfObjectBase* pOldObject = oPos->second;
+			delete pOldObject;
+		}
+
+		m_mObjects.insert(std::pair<unsigned long, CEmfObjectBase*>(ulIndex, pObject));
+	}
+
+	CEmfDC::CEmfDC()
+	{
+		m_oTransform.Init();
+		m_oTextColor.Init();
+	}
+	CEmfDC::~CEmfDC()
+	{
+	}
+	CEmfDC* CEmfDC::Copy()
+	{
+		CEmfDC* pNewDC = new CEmfDC();
+		if (!pNewDC)
+			return NULL;
+
+		pNewDC->m_oTransform.Copy(&m_oTransform);
+		pNewDC->m_oTextColor.Copy(&m_oTextColor);
+
+		return pNewDC;
+	}
+	TEmfXForm* CEmfDC::GetTransform()
+	{
+		return &m_oTransform;
+	}
+	void CEmfDC::SetTextColor(TEmfColor& oColor)
+	{
+		m_oTextColor.Copy(&oColor);
+	}
+}
\ No newline at end of file

DesktopEditor/raster/Metafile/Emf/EmfPlayer.h

+#ifndef _EMF_PLAYER_H
+#define _EMF_PLAYER_H
+
+#include <vector>
+#include <map>
+#include "EmfTypes.h"
+#include "EmfObjects.h"
+
+namespace Metafile
+{
+	class CEmfFile;
+	class CEmfDC;
+
+	class CEmfPlayer
+	{
+	public:
+
+		CEmfPlayer(CEmfFile* pFile);
+		~CEmfPlayer();
+		void Clear();
+		CEmfDC* SaveDC();
+		CEmfDC* RestoreDC();
+		CEmfDC* GetDC();
+		void RegisterObject(unsigned long ulIndex, CEmfObjectBase* pObject);
+
+	private:
+
+		typedef std::map < unsigned long, CEmfObjectBase* > CEmfObjectMap;
+
+		CEmfDC*              m_pDC;
+		std::vector<CEmfDC*> m_vDCStack;
+		CEmfFile*            m_pEmfFile;		
+		CEmfObjectMap        m_mObjects;
+	};
+
+	class CEmfDC
+	{
+	public:
+
+		CEmfDC();
+		~CEmfDC();
+		CEmfDC* Copy();
+		TEmfXForm* GetTransform();
+		void SetTextColor(TEmfColor& oColor);
+
+	private:
+
+		TEmfXForm m_oTransform;
+		TEmfColor m_oTextColor;
+	};
+}
+
+#endif //_EMF_PLAYER_H
\ No newline at end of file

DesktopEditor/raster/Metafile/Emf/EmfTypes.h

+#ifndef _EMF_TYPES_H
+#define _EMF_TYPES_H
+
+namespace Metafile
+{
+	struct TEmfColor
+	{
+		unsigned char r;
+		unsigned char g;
+		unsigned char b;
+		unsigned char a; //Reserved Must be 0x00
+
+		void Init()
+		{
+			r = 0;
+			g = 0;
+			b = 0;
+			a = 0;
+		}
+
+		void Copy(TEmfColor* pOther)
+		{
+			r = pOther->r;
+			g = pOther->g;
+			b = pOther->b;
+			a = pOther->a;
+		}
+	};
+
+	struct TEmfRect
+	{
+		short shLeft;
+		short shTop;
+		short shRight;
+		short shBottom;
+	};
+
+	struct TEmfRectL
+	{
+		long lLeft;
+		long lTop;
+		long lRight;
+		long lBottom;
+	};
+
+	struct TEmfSizeL
+	{
+		unsigned long ulX;
+		unsigned long ulY;
+	};
+
+	struct TEmfPointL
+	{
+		long x;
+		long y;
+	};
+
+	struct TEmfHeader
+	{
+		TEmfRectL      oBounds;
+		TEmfRectL      oFrame;
+		unsigned long  ulSignature;
+		unsigned long  ulVersion;
+		unsigned long  ulSize;
+		unsigned long  ulRecords;
+		unsigned short ushObjects;
+		unsigned short ushReserved;
+		unsigned long  ulSizeDescription;
+		unsigned long  ulOffsetDescription;
+		unsigned long  ulPalEntries;
+		TEmfSizeL      oDevice;
+		TEmfSizeL      oMillimeters;
+	};
+
+	struct TEmfStretchDIBITS
+	{
+		TEmfRectL     Bounds;
+		long          xDest;
+		long          yDest;
+		long          xSrc;
+		long          ySrc;
+		long          cxSrc;
+		long          cySrc;
+		unsigned long offBmiSrc;
+		unsigned long cbBmiSrc;
+		unsigned long offBitsSrc;
+		unsigned long cbBitsSrc;
+		unsigned long UsageSrc;
+		unsigned long BitBltRasterOperation;
+		long          cxDest;
+		long          cyDest;
+	};
+
+#define MWT_IDENTITY	  0x01
+#define MWT_LEFTMULTIPLY  0x02
+#define MWT_RIGHTMULTIPLY 0x03
+#define MWT_SET           0x04
+
+	struct TEmfXForm
+	{
+		double M11;
+		double M12;
+		double M21;
+		double M22;
+		double Dx;
+		double Dy;
+
+		void Init()
+		{
+			M11 = 1;
+			M12 = 0;
+			M21 = 0;
+			M22 = 1;
+			Dx  = 0;
+			Dy  = 0;
+		}
+
+		void Copy(TEmfXForm* pOther)
+		{
+			M11 = pOther->M11;
+			M12	= pOther->M12;
+			M21	= pOther->M21;
+			M22	= pOther->M22;
+			Dx	= pOther->Dx;
+			Dy	= pOther->Dy;
+		}
+
+		void Multiply(TEmfXForm &oOther, unsigned long ulMode)
+		{
+			if (MWT_IDENTITY == ulMode)
+				Init();
+			else if (MWT_LEFTMULTIPLY == ulMode)
+			{
+				// oOther ,   
+				double dM11 = oOther.M11 * M11 + oOther.M12 * M21;
+				double dM12 = oOther.M11 * M21 + oOther.M12 * M22;
+				double dM21 = oOther.M21 * M11 + oOther.M22 * M21;
+				double dM22 = oOther.M21 * M21 + oOther.M22 * M22;
+
+				double dDx = oOther.Dx * M11 + oOther.Dy * M21 + Dx;
+				double dDy = oOther.Dx * M21 + oOther.Dy * M22 + Dy;
+
+				M11 = dM11;
+				M12	= dM12;
+				M21	= dM21;
+				M22	= dM22;
+				Dx	= dDx;
+				Dy	= dDy;
+			}
+			else if (MWT_RIGHTMULTIPLY == ulMode)
+			{
+				// oOther ,   
+				double dM11 = M11 * oOther.M11 + M12 * oOther.M21;
+				double dM12 = M11 * oOther.M21 + M12 * oOther.M22;
+				double dM21 = M21 * oOther.M11 + M22 * oOther.M21;
+				double dM22 = M21 * oOther.M21 + M22 * oOther.M22;
+
+				double dDx = Dx * oOther.M11 + Dy * oOther.M21 + oOther.Dx;
+				double dDy = Dx * oOther.M21 + Dy * oOther.M22 + oOther.Dy;
+
+				M11 = dM11;
+				M12	= dM12;
+				M21	= dM21;
+				M22	= dM22;
+				Dx	= dDx;
+				Dy	= dDy;
+			}
+			else //if (MWT_SET == ulMode)
+			{
+				Copy(&oOther);
+			}
+		}
+	};
+};
+#endif //_EMF_TYPES_H
\ No newline at end of file

DesktopEditor/raster/Metafile/Emf/RendererOutput.h

+#ifndef _RENDERER_OUPUT_EMF_H
+#define _RENDERER_OUPUT_EMF_H
+
+
+#include "../../../graphics/IRenderer.h"
+#include "../../../graphics/structures.h"
+#include "../../../graphics/Image.h"
+#include "../../../raster/ImageFileFormatChecker.h"
+#include "../../../raster/BgraFrame.h"
+
+#include "EmfOutputDevice.h"
+#include "EmfFile.h"
+
+namespace Metafile
+{
+	class CEmfRendererOutput : public CEmfOutputDevice
+	{
+
+	public:
+		CEmfRendererOutput(CEmfFile *pFile, IRenderer *pRenderer, double dX, double dY, double dWidth, double dHeight)
+		{
+			m_pEmfFile = pFile;
+
+			m_dX = dX;
+			m_dY = dY;
+			m_dW = dWidth;
+			m_dH = dHeight;
+
+			m_pRenderer = NULL;
+
+			if (!pRenderer)
+				return;
+
+			m_pRenderer = pRenderer;
+		}
+		~CEmfRendererOutput()
+		{
+		}
+
+		void Begin()
+		{
+		}
+		void End()
+		{
+		}
+
+		void Draw_Bitmap(long lX, long lY, long lW, long lH, BYTE* pBuffer, unsigned long ulWidth, unsigned long ulHeight)
+		{
+			Aggplus::CImage oImage;
+			BYTE* pBufferPtr = new BYTE[4 * ulWidth * ulHeight];
+			oImage.Create(pBufferPtr, ulWidth, ulHeight, 4 * ulWidth);
+
+			for (int nIndex = 0, nSize = 4 * ulWidth * ulHeight; nIndex < nSize; nIndex += 4)
+			{
+				pBufferPtr[0] = (unsigned char)pBuffer[nIndex + 0];
+				pBufferPtr[1] = (unsigned char)pBuffer[nIndex + 1];
+				pBufferPtr[2] = (unsigned char)pBuffer[nIndex + 2];
+				pBufferPtr[3] = (unsigned char)pBuffer[nIndex + 3];
+				pBufferPtr += 4;
+			}
+
+			double dX = TransX(lX);
+			double dY = TransX(lY);
+
+			double dX1 = TransX(lX + lW);
+			double dY1 = TransY(lY + lH);
+
+			m_pRenderer->DrawImage(&oImage, dX, dY, dX1 - dX, dY1 - dY);
+		}
+
+	private:
+
+		double TransX(long lX)
+		{
+			long lL = m_pEmfFile->m_oHeader.oBounds.lLeft;
+			long lR = m_pEmfFile->m_oHeader.oBounds.lRight;
+
+			if (lR - lL <= 0)
+				return 0;
+
+			return m_dW * (double)(lX - lL) / (double)(lR - lL);
+		}
+
+		double TransY(long lY)
+		{
+			long lT = m_pEmfFile->m_oHeader.oBounds.lTop;
+			long lB = m_pEmfFile->m_oHeader.oBounds.lBottom;
+
+			if (lB - lT <= 0)
+				return 0;
+
+			return m_dH * (double)(lY - lT) / (double)(lB - lT);
+		}
+
+	private:
+
+		IRenderer*              m_pRenderer;
+		NSStructures::CPen      m_oPen;
+		NSStructures::CBrush    m_oBrush;
+		NSStructures::CFont     m_oFont;
+
+		double                  m_dDpiX;
+		double                  m_dDpiY;
+
+		double                  m_dX;        //    
+		double                  m_dY;        //
+		double                  m_dW;   //  /,  
+		double                  m_dH;   //     .
+		CEmfFile*               m_pEmfFile;
+	};
+}
+#endif // _RENDERER_OUPUT_EMF_H
\ No newline at end of file

DesktopEditor/raster/Metafile/MetaFile.cpp

+#include "MetaFile.h"
+
+#include "../../graphics/GraphicsRenderer.h"
+#include "../../raster/BgraFrame.h"
+
+#include "Emf/RendererOutput.h"
+
+namespace Metafile
+{
+	CMetaFile::CMetaFile(CApplicationFonts *pAppFonts)
+	{
+		m_pAppFonts = pAppFonts;
+
+		//      
+		m_pFontManager = pAppFonts->GenerateFontManager();
+		CFontsCache* pMeasurerCache = new CFontsCache();
+		pMeasurerCache->SetStreams(pAppFonts->GetStreams());
+		m_pFontManager->SetOwnerCache(pMeasurerCache);
+		m_oWmfFile.SetFontManager(m_pFontManager);
+		m_oEmfFile.SetFontManager(m_pFontManager);
+	}
+	CMetaFile::~CMetaFile()
+	{
+		Close();
+		RELEASEINTERFACE(m_pFontManager);
+	}
+	bool CMetaFile::LoadFromFile(const wchar_t *wsFilePath)
+	{
+		//      Wmf
+		m_oWmfFile.OpenFromFile(wsFilePath);
+		m_oWmfFile.Scan(&m_oWmfRect);
+
+		if (!m_oWmfFile.CheckError())
+		{
+			m_lType = c_lMetaWmf;
+			return true;
+		}
+
+		//   Wmf,     Emf
+		m_oWmfFile.Close();
+
+		m_oEmfFile.OpenFromFile(wsFilePath);
+		m_oEmfFile.Scan();
+
+		if (!m_oEmfFile.CheckError())
+		{
+			m_lType = c_lMetaEmf;
+			return true;
+		}
+
+		//   Emf
+		m_oEmfFile.Close();
+
+		return false;
+	};
+	bool CMetaFile::DrawOnRenderer(IRenderer* pRenderer, double dX, double dY, double dWidth, double dHeight)
+	{
+		if (NULL == pRenderer)
+			return false;
+
+		pRenderer->BeginCommand(c_nImageType);
+
+		if (c_lMetaWmf == m_lType)
+		{
+			double dRendererDpix, dRendererDpiY;
+			pRenderer->get_DpiX(&dRendererDpix);
+			pRenderer->get_DpiY(&dRendererDpiY);
+
+			CRendererOutput oWmfOut(&m_oWmfFile, pRenderer, dX, dY, dWidth, dHeight);
+
+			double fSrcWidth, fSrcHeight;
+
+			float fW, fH;
+			m_oWmfFile.GetSize(&fW, &fH);
+			m_oWmfFile.GetDisplaySize(&fSrcWidth, &fSrcHeight, dRendererDpix, dRendererDpiY);
+
+			//m_oWmfFile.GetDisplaySize( &fSrcWidth, &fSrcHeight, 25.4, 25.4 );
+			TWmfRectF oRectB = m_oWmfFile.GetBounds();
+
+			//double dW = m_oRect.oBR.fX - m_oRect.oTL.fX;
+			//double dH = m_oRect.oBR.fY - m_oRect.oTL.fY;
+			double dW = oRectB.oBR.fX - oRectB.oTL.fX;
+			double dH = oRectB.oBR.fY - oRectB.oTL.fY;
+
+			double dScaleX = dWidth / dW;//fSrcWidth;
+			double dScaleY = dHeight / dH;//fSrcHeight;
+			//double dScaleX = dWidth  / fSrcWidth;
+			//double dScaleY = dHeight / fSrcHeight;
+
+			double dSrcDpiX, dSrcDpiY;
+			m_oWmfFile.GetDpi(&dSrcDpiX, &dSrcDpiY);
+
+			double dDpiKoefX = dRendererDpix / dSrcDpiX;
+			double dDpiKoefY = dRendererDpiY / dSrcDpiY;
+
+			double dDpi = dSrcDpiY * fSrcHeight / fH;
+			oWmfOut.SetDpi(dRendererDpix, dDpi);
+			oWmfOut.SetWmfRect(oRectB);
+			oWmfOut.SetScales(dScaleX, dScaleY);
+
+			m_oWmfFile.SetOutputDevice(&oWmfOut);
+
+			TWmfRectF oRect;
+			m_oWmfFile.Play(&oRect);
+		}
+		else if (c_lMetaEmf == m_lType)
+		{
+			CEmfRendererOutput oEmfOut(&m_oEmfFile, pRenderer, dX, dY, dWidth, dHeight);
+			m_oEmfFile.SetOutputDevice(&oEmfOut);
+			m_oEmfFile.PlayMetaFile();
+		}
+
+		pRenderer->EndCommand(c_nImageType);
+		return true;
+	};
+	void CMetaFile::Close()
+	{
+		m_oWmfFile.Close();
+	};
+	void CMetaFile::GetBounds(double* pdX, double* pdY, double* pdW, double* pdH)
+	{
+		if (c_lMetaWmf == m_lType)
+		{
+			*pdX = m_oWmfRect.oTL.fX;
+			*pdY = m_oWmfRect.oTL.fY;
+			*pdW = m_oWmfRect.oBR.fX - m_oWmfRect.oTL.fX;
+			*pdH = m_oWmfRect.oBR.fY - m_oWmfRect.oTL.fY;
+		}
+		else if (c_lMetaEmf == m_lType)
+		{
+			TEmfRectL oRect = m_oEmfFile.GetBounds();
+			*pdX = oRect.lLeft;
+			*pdY = oRect.lTop;
+			*pdW = oRect.lRight - oRect.lLeft;
+			*pdH = oRect.lBottom - oRect.lTop;
+		}
+		else
+		{
+			*pdX = 0;
+			*pdY = 0;
+			*pdW = 0;
+			*pdH = 0;
+		}
+	};
+	void CMetaFile::ConvertToRaster(const wchar_t* wsOutFilePath, unsigned int unFileType, int nWidth, int nHeight)
+	{
+		CFontManager *pFontManager = m_pAppFonts->GenerateFontManager();
+		CImageFilesCache oCache;
+
+		CGraphicsRenderer oRenderer;
+		oRenderer.SetFontManager(pFontManager);
+		oRenderer.SetImageCache(&oCache);
+
+		if (-1 == nHeight)
+		{
+			double dX, dY, dW, dH;
+			GetBounds(&dX, &dY, &dW, &dH);
+			nHeight = (int)((double)nWidth * dH / dW);
+		}
+
+		double dDpiX, dDpiY;
+		oRenderer.get_DpiX(&dDpiX);
+		oRenderer.get_DpiX(&dDpiY);
+
+		double dWidth  = nWidth * 72 / 25.4 / dDpiX;
+		double dHeight = nHeight * 72 / 25.4 / dDpiY;
+
+		BYTE* pBgraData = new BYTE[nWidth * nHeight * 4];
+		CBgraFrame oFrame;
+		oFrame.put_Data(pBgraData);
+		oFrame.put_Width(nWidth);
+		oFrame.put_Height(nHeight);
+		oFrame.put_Stride(-4 * nWidth);
+
+		oRenderer.CreateFromBgraFrame(&oFrame);
+		oRenderer.put_Width(dWidth);
+		oRenderer.put_Height(dHeight);
+
+		DrawOnRenderer(&oRenderer, 0, 0, dWidth, dHeight);
+
+		oFrame.SaveFile(wsOutFilePath, unFileType);
+		RELEASEINTERFACE(pFontManager);
+	}
+}

DesktopEditor/raster/Metafile/MetaFile.h

+#ifndef _METAFILE_H
+#define _METAFILE_H
+
+#include "../../fontengine/ApplicationFonts.h"
+
+#include "Wmf/WmfFile.h"
+#include "Wmf/RendererOutput.h"
+#include "Emf/EmfFile.h"
+
+namespace Metafile
+{
+	const long c_lMetaWmf = 0x01;
+	const long c_lMetaEmf = 0x02;
+	const long c_lMetaSvg = 0x04;
+
+	class CMetaFile
+	{
+	public:
+		CMetaFile(CApplicationFonts *pAppFonts);
+		~CMetaFile();
+
+		bool LoadFromFile(const wchar_t* wsFilePath);
+		bool DrawOnRenderer(IRenderer* pRenderer, double dX, double dY, double dWidth, double dHeight);
+		void Close();
+		void GetBounds(double* pdX, double* pdY, double* pdW, double* pdH);
+		void ConvertToRaster(const wchar_t* wsOutFilePath, unsigned int unFileType, int nWidth, int nHeight = -1);
+
+	private:
+
+		CApplicationFonts* m_pAppFonts;
+		CFontManager*      m_pFontManager;
+		CWmfFile           m_oWmfFile;
+		TWmfRectF          m_oWmfRect;
+		CEmfFile           m_oEmfFile;
+		long               m_lType;
+	};
+}
+
+#endif //_METAFILE_H
\ No newline at end of file

DesktopEditor/raster/Metafile/Wmf/WmfMemory.h

+#ifndef _WMF_MEMORY_H
+#define _WMF_MEMORY_H
+
+#include <stdio.h>
+
+
+#ifdef _DEBUG
+//#define DebugCheckMemory
+//#include <vector>
+//#include <iterator>
+#endif
+
+class CWmfMemoryManager
+{
+
+public:
+
+	CWmfMemoryManager()
+	{
+#ifdef DebugCheckMemory
+		m_arrDescription.clear();
+		m_arrMemoryList.clear();
+#endif
+
+	}
+	~CWmfMemoryManager()
+	{
+#ifdef DebugCheckMemory
+		m_arrDescription.clear();
+		m_arrMemoryList.clear();
+#endif
+	}
+
+	void *Malloc(size_t unSize, std::wstring sDescription)
+	{
+		void *pAddress = malloc(unSize);
+		if (NULL == pAddress)
+			return NULL;
+
+#ifdef DebugCheckMemory
+		Add(pAddress, sDescription);
+#endif
+
+		return pAddress;
+	}
+	void *Realloc(void *pMemory, size_t unSize)
+	{
+#ifdef DebugCheckMemory
+		std::wstring sDescription = Remove(pMemory);
+#endif
+
+		void *pAddress = realloc(pMemory, unSize);
+		if (NULL == pAddress)
+			return NULL;
+
+#ifdef DebugCheckMemory
+		Add(pAddress, sDescription);
+#endif
+
+		return pAddress;
+	}
+	void Free(void *pMemory)
+	{
+		if (pMemory)
+		{
+			free(pMemory);
+		}
+
+#ifdef DebugCheckMemory
+		Remove(pMemory);
+#endif
+	}
+
+private:
+
+#ifdef DebugCheckMemory
+	void Add(void *pAddress, std::wstring sDescription)
+	{
+		m_arrDescription.push_back(sDescription);
+		m_arrMemoryList.push_back(pAddress);
+	}
+	std::wstring Remove(void *pAddress)
+	{
+		int nIndex = 0;
+		for (nIndex = 0; nIndex < m_arrMemoryList.size(); nIndex++)
+		{
+			if (pAddress == m_arrMemoryList.at(nIndex))
+				break;
+		}
+
+		if (nIndex >= m_arrMemoryList.size())
+			return L"";
+		
+		m_arrMemoryList.erase(m_arrMemoryList.begin() + nIndex);
+		std::wstring sResult = m_arrDescription.at(nIndex);
+		m_arrDescription.erase(m_arrDescription.begin() + nIndex);
+		return sResult;
+	}
+
+#endif
+
+private:
+
+#ifdef DebugCheckMemory
+	std::vector<void *>       m_arrMemoryList;
+	std::vector<std::wstring> m_arrDescription;
+#endif
+};
+
+#endif /* _WMF_MEMORY_H */
\ No newline at end of file

DesktopEditor/raster/Metafile/Wmf/WmfOutputDevice.h

+#ifndef _WMF_OUTPUT_DEVICE_H
+#define _WMF_OUTPUT_DEVICE_H
+
+#include "WmfTypes.h"
+
+class CWmfOutputDevice
+{
+public:
+
+	CWmfOutputDevice() {}
+	virtual ~CWmfOutputDevice() {}
+
+	virtual bool IsSupportPolypolygon() { return false; }
+
+	//     
+	virtual void Begin() = 0;
+	virtual void End  () = 0;
+
+	virtual void Flood_Interior(TWmfFlood*) = 0;
+	virtual void Flood_Exterior(TWmfFlood*) = 0;
+
+	virtual void Draw_Pixel      (TWmfDrawPixel*)     = 0;
+	virtual void Draw_Pie        (TWmfDrawArc*)       = 0;
+	virtual void Draw_Chord      (TWmfDrawArc*)       = 0;
+	virtual void Draw_Arc        (TWmfDrawArc*)       = 0;
+	virtual void Draw_Ellipse    (TWmfDrawArc*)       = 0;
+	virtual void Draw_Line       (TWmfDrawLine*)      = 0;
+	virtual void Poly_Line       (TWmfPolyLine*)      = 0;
+	virtual void Draw_Polygon    (TWmfPolyLine*)      = 0;
+	virtual void Draw_Polypolygon(TWmfPolyPoly*)      = 0;
+	virtual void Draw_Rectangle  (TWmfDrawRectangle*) = 0;
+
+	virtual void Rop_Draw(TWmfROPDraw*) = 0;
+	virtual void Bmp_Draw(TWmfBMPDraw*) = 0;
+	virtual void Bmp_Read(TWmfBMPRead*) = 0;
+	virtual void Bmp_Free(TWmfBMP*)     = 0;
+
+	virtual void Draw_Text(TWmfDrawText*) = 0;
+
+	virtual void Region_Frame(TWmfPolyRectangle*) = 0;
+	virtual void Region_Paint(TWmfPolyRectangle*) = 0;
+	virtual void Region_Clip (TWmfPolyRectangle*) = 0;
+private:
+
+};
+
+#endif /* _WMF_OUTPUT_DEVICE_H */
\ No newline at end of file

DesktopEditor/raster/Metafile/Wmf/WmfUtils.h

+#ifndef _WMF_UTILS_H
+#define _WMF_UTILS_H
+
+#include "WmfTypes.h"
+#include <stdio.h>
+#include <time.h>
+
+#ifndef _USE_MATH_DEFINES
+#define _USE_MATH_DEFINES
+#endif
+
+#include <math.h>
+
+#include "../../../common/File.h"
+#define UTF8_TO_U(val) NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)val, strlen(val))
+#define U_TO_UTF8(val) NSFile::CUtf8Converter::GetUtf8StringFromUnicode2(val, wcslen(val))
+static std::wstring ascii_to_unicode(const char *src)
+{
+	size_t nSize = mbstowcs(0, src, 0);
+	wchar_t* pBuffer = new wchar_t[nSize];
+	nSize = mbstowcs(pBuffer, src, nSize);
+	std::wstring sRes;
+	if (nSize != (size_t)-1)
+		sRes = std::wstring(pBuffer, nSize);
+	delete[] pBuffer;
+	return sRes;
+}
+static std::string unicode_to_ascii(const wchar_t *src)
+{
+	size_t nSize = wcstombs(0, src, 0);
+	char* pBuffer = new char[nSize];
+	nSize = wcstombs(pBuffer, src, nSize);
+	std::string sRes;
+	if (nSize != (size_t)-1)
+		sRes = std::string(pBuffer, nSize);
+	delete[] pBuffer;
+	return sRes;
+}
+
+static char *WmfStrDup(const char *sString)
+{
+	if ( NULL == sString )
+		return NULL;
+
+	char *sCopy = (char*)malloc( strlen(sString) + 1 );
+	if ( NULL == sCopy )
+		return NULL;
+
+	strcpy( sCopy, sString );
+
+	return sCopy;
+}
+static TWmfCoord WmfCoord(unsigned short ushX, unsigned short ushY)
+{	
+	TWmfCoord oPoint;
+
+	oPoint.unX = UShort_2_Long( ushX );
+	oPoint.unY = UShort_2_Long( ushY );
+
+	return oPoint;
+}
+
+static void PolyPoly_To_PolyLine(TWmfPolyPoly *pPolyPoly, TWmfPolyLine *pPolyLine, unsigned short ushPolyIndex)
+{	
+	unsigned short ushCount = pPolyPoly->pCount[ushPolyIndex];
+
+	if ( NULL == pPolyPoly->ppPoints ) 
+		return;
+
+	if ( ( NULL == pPolyPoly->ppPoints[ushPolyIndex] ) || ( pPolyPoly->pCount[ushPolyIndex] < 3 ) ) 
+		return;
+
+	// Избавляемся от лишних точек
+	while ( ( pPolyPoly->ppPoints[ushPolyIndex][0].fX == pPolyPoly->ppPoints[ushPolyIndex][ushCount - 1].fX ) && ( pPolyPoly->ppPoints[ushPolyIndex][0].fY == pPolyPoly->ppPoints[ushPolyIndex][ushCount - 1].fY ) )
+	{
+		ushCount--;
+		if ( ushCount < 3 ) 
+			break;
+	}
+	if ( ushCount < 3 ) 
+		return;
+
+	// Определяем последний ли полигон
+	bool bLast = false;
+	if ( ushPolyIndex < ( pPolyPoly->ushPolyCount - 1 ) )
+	{	
+		if ( ( NULL == pPolyPoly->ppPoints[ushPolyIndex + 1] == 0 ) || ( pPolyPoly->pCount[ushPolyIndex + 1] < 3 ) )
+		{	
+			bLast = 1;
+		}
+	}
+	else
+	{	
+		bLast = 1;
+	}
+
+	if ( bLast )
+	{	
+		for ( unsigned short ushPointIndex = 0; ushPointIndex < ushCount; ushPointIndex++ )
+		{	
+			pPolyLine->pPoints[pPolyLine->ushCount].fX = pPolyPoly->ppPoints[ushPolyIndex][ushPointIndex].fX;
+			pPolyLine->pPoints[pPolyLine->ushCount].fY = pPolyPoly->ppPoints[ushPolyIndex][ushPointIndex].fY;
+			pPolyLine->ushCount++;
+		}
+		pPolyLine->pPoints[pPolyLine->ushCount].fX = pPolyPoly->ppPoints[ushPolyIndex][0].fX;
+		pPolyLine->pPoints[pPolyLine->ushCount].fY = pPolyPoly->ppPoints[ushPolyIndex][0].fY;
+		pPolyLine->ushCount++;
+
+		return;
+	}
+
+	// Ищем в данном полигоне точку ближающую к нулевой точке следующего полигона (т.к. этот полигон не последний, то все впорядке)
+	unsigned short ushMinIndex = 0;
+	double dMinR2;
+	for ( unsigned short ushPointIndex = 0; ushPointIndex < ushCount; ushPointIndex++ )
+	{	
+		double dX2 = (double) pPolyPoly->ppPoints[ushPolyIndex][ushPointIndex].fX - (double) pPolyPoly->ppPoints[ushPolyIndex+1][0].fX;
+		dX2 *= dX2;
+		double dY2 = (double) pPolyPoly->ppPoints[ushPolyIndex][ushPointIndex].fY - (double) pPolyPoly->ppPoints[ushPolyIndex+1][0].fY;
+		dY2 *= dY2;
+		double dR2 = dX2 + dY2;
+		if ( 0 == ushPointIndex )
+		{	
+			dMinR2 = dR2;
+		}
+		else if ( dR2 < dMinR2 )
+		{	
+			dMinR2 = dR2;
+			ushMinIndex = ushPointIndex;
+		}
+	}
+
+	for ( unsigned short ushPointIndex = 0; ushPointIndex <= ushMinIndex; ushPointIndex++ )
+	{	
+		pPolyLine->pPoints[pPolyLine->ushCount].fX = pPolyPoly->ppPoints[ushPolyIndex][ushPointIndex].fX;
+		pPolyLine->pPoints[pPolyLine->ushCount].fY = pPolyPoly->ppPoints[ushPolyIndex][ushPointIndex].fY;
+		pPolyLine->ushCount++;
+	}
+
+	PolyPoly_To_PolyLine( pPolyPoly, pPolyLine, (unsigned short)(ushPolyIndex + 1) );
+
+	for ( unsigned short ushPointIndex = ushMinIndex; ushPointIndex < ushCount; ushPointIndex++ )
+	{	
+		pPolyLine->pPoints[pPolyLine->ushCount].fX = pPolyPoly->ppPoints[ushPolyIndex][ushPointIndex].fX;
+		pPolyLine->pPoints[pPolyLine->ushCount].fY = pPolyPoly->ppPoints[ushPolyIndex][ushPointIndex].fY;
+		pPolyLine->ushCount++;
+	}
+	pPolyLine->pPoints[pPolyLine->ushCount].fX = pPolyPoly->ppPoints[ushPolyIndex][0].fX;
+	pPolyLine->pPoints[pPolyLine->ushCount].fY = pPolyPoly->ppPoints[ushPolyIndex][0].fY;
+	pPolyLine->ushCount++;
+}
+
+static BOOL WmfOpenTempFile(std::wstring *pwsName, FILE **ppFile, wchar_t *wsMode, wchar_t *wsExt, wchar_t *wsFolder)
+{
+	std::wstring wsTemp, wsFileName;
+	FILE *pTempFile;
+#ifdef _WIN32
+	wchar_t *wsTempDir;
+	if ((wsTempDir = _wgetenv(L"TEMP")) && (wsFolder == NULL))
+	{
+		wsTemp = std::wstring(wsTempDir);
+#else
+	char *wsTempDirA;
+	if ( ( wsTempDirA = getenv( "TEMP" ) ) && ( wsFolder == NULL ) )
+	{
+		std::wstring wsTempDir = UTF8_TO_U( wsTempDirA );
+		wsTemp = wsTempDir.c_str();
+#endif
+		wsTemp.append(L"/");
+	}
+	else if (wsFolder != NULL)
+	{
+		wsTemp = std::wstring(wsFolder);
+		wsTemp.append(L"/");
+	}
+	else
+	{
+		wsTemp = L"";
+	}
+	wsTemp.append(L"x");
+	int nTime = (int)time(NULL);
+	for (int nIndex = 0; nIndex < 1000; ++nIndex)
+	{
+		wsFileName = wsTemp;
+		wsFileName.append(std::to_wstring(nTime + nIndex));
+
+		if (wsExt)
+		{
+			wsFileName.append(wsExt);
+		}
+#ifdef _WIN32
+		if (!(pTempFile = _wfopen(wsFileName.c_str(), L"r")))
+		{
+			if (!(pTempFile = _wfopen(wsFileName.c_str(), wsMode)))
+#else
+		std::string sFileName = U_TO_UTF8(wsFileName);
+		if ( !( pTempFile = fopen( sFileName.c_str(), "r" ) ) )
+		{
+			std::string sMode = U_TO_UTF8(wsMode);
+			if ( !( pTempFile = fopen( sFileName.c_str(), sMode.c_str() ) ) )
+#endif
+			{
+				return FALSE;
+			}
+			*pwsName = wsFileName;
+			*ppFile = pTempFile;
+			return TRUE;
+		}
+
+		fclose(pTempFile);
+	}
+
+	return FALSE;
+}
+
+
+#endif /* _WMF_UTILS_H */