git-svn-id:...

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

.gitattributes

+ASCHTMLRenderer/Mac svnc_tsvn_003alogminsize=5
+ASCHTMLRenderer/Mac/ASCHTMLRendererLib svnc_tsvn_003alogminsize=5
+ASCHTMLRenderer/Mac/ASCHTMLRendererLib.xcodeproj svnc_tsvn_003alogminsize=5
+ASCHTMLRenderer/Mac/ASCHTMLRendererLib.xcodeproj/project.xcworkspace svnc_tsvn_003alogminsize=5
+ASCHTMLRenderer/Mac/ASCHTMLRendererLib.xcodeproj/project.xcworkspace/xcuserdata svnc_tsvn_003alogminsize=5
+ASCHTMLRenderer/Mac/ASCHTMLRendererLib.xcodeproj/project.xcworkspace/xcuserdata/alexey.musinov.xcuserdatad svnc_tsvn_003alogminsize=5
+ASCHTMLRenderer/Mac/ASCHTMLRendererLib.xcodeproj/project.xcworkspace/xcuserdata/alexey.musinov.xcuserdatad/UserInterfaceState.xcuserstate svn_mime_002dtype=application%2Foctet-stream
+ASCHTMLRenderer/Mac/ASCHTMLRendererLib.xcodeproj/xcuserdata svnc_tsvn_003alogminsize=5
+ASCHTMLRenderer/Mac/ASCHTMLRendererLib.xcodeproj/xcuserdata/alexey.musinov.xcuserdatad svnc_tsvn_003alogminsize=5
+ASCHTMLRenderer/Mac/ASCHTMLRendererLib.xcodeproj/xcuserdata/alexey.musinov.xcuserdatad/xcschemes svnc_tsvn_003alogminsize=5
+ASCHTMLRenderer/Resources/common.zip svn_mime_002dtype=application%2Foctet-stream
+ASCHTMLRenderer/Resources/imgtrackbar/b_bg_all.gif svn_mime_002dtype=application%2Foctet-stream
+ASCHTMLRenderer/Resources/imgtrackbar/b_bg_off.gif svn_mime_002dtype=application%2Foctet-stream
+ASCHTMLRenderer/Resources/imgtrackbar/b_bg_on.gif svn_mime_002dtype=application%2Foctet-stream
+ASCHTMLRenderer/Resources/imgtrackbar/b_l.gif svn_mime_002dtype=application%2Foctet-stream
+ASCHTMLRenderer/Resources/imgtrackbar/b_r.gif svn_mime_002dtype=application%2Foctet-stream
 ASCOfficeDjVuFile/Test/Test/bin/Debug/Interop.AVSOfficeDjVuFile.dll svn_mime_002dtype=application%2Foctet-stream
 ASCOfficeDjVuFile/Test/Test/bin/Debug/Test.exe svn_mime_002dtype=application%2Foctet-stream
 ASCOfficeDjVuFile/Test/Test/bin/Debug/Test.pdb svn_mime_002dtype=application%2Foctet-stream

ASCHTMLRenderer/ASCHTMLRenderer.cpp

+// ASCHTMLRenderer.cpp : Implementation of DLL Exports.
+
+
+#include "stdafx.h"
+#include "resource.h"
+
+#include "HTMLRenderer.h"
+#include "HTMLRenderer2.h"
+#include "HTMLRenderer3.h"
+#include "ASCSVGWriter.h"
+
+
+// The module attribute causes DllMain, DllRegisterServer and DllUnregisterServer to be automatically implemented for you
+[ module(dll, uuid = "{08DC1F03-6867-4585-B939-422C9078F5FD}", 
+		 name = "ASCHTMLRenderer", 
+		 helpstring = "ASCHTMLRenderer 1.0 Type Library",
+		 resource_name = "IDR_ASCHTMLRENDERER") ]
+class CASCHTMLRendererModule
+{
+public:
+// Override CAtlDllModuleT members
+};

ASCHTMLRenderer/ASCHTMLRenderer.rc

+// Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+#define COMPONENT_NAME "HTMLRenderer"
+#include "../Common/FileInfo.h"
+#include "version.h"
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "winres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// Russian resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_RUS)
+#ifdef _WIN32
+LANGUAGE LANG_RUSSIAN, SUBLANG_DEFAULT
+#pragma code_page(1251)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+3 TEXTINCLUDE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+#endif    // Russian resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+//#ifdef _DEBUG
+IDB_SCRIPT_CM		HTML2                     "Resources\\canvas_norm\\cachemanager.js"
+IDB_SCRIPT_IM		HTML2                     "Resources\\canvas_norm\\images.js"
+IDB_SCRIPT_MAIN		HTML2                     "Resources\\canvas_norm\\main.js"
+IDB_SCRIPT_PAGE		HTML2                     "Resources\\canvas_norm\\page.js"
+IDB_SCRIPT_GR		HTML2					  "Resources\\canvas_norm\\Graphics.js"
+IDB_SCRIPT_VIEW     HTML2                     "Resources\\canvas_norm\\Viewer.html"
+/*#else
+IDB_SCRIPT_CM		HTML2                     "Resources\\canvas\\cachemanager.js"
+IDB_SCRIPT_IM		HTML2                     "Resources\\canvas\\images.js"
+IDB_SCRIPT_MAIN		HTML2                     "Resources\\canvas\\main.js"
+IDB_SCRIPT_PAGE		HTML2                     "Resources\\canvas\\page.js"
+IDB_SCRIPT_GR		HTML2					  "Resources\\canvas\\Graphics.js"
+IDB_SCRIPT_VIEW     HTML2                     "Resources\\canvas\\Viewer.html"
+#endif*/
+
+IDB_COMMON_ZIP		HTML2                     	"Resources\\common.zip"
+
+IDB_FONT_SCRIPT_FT	HTML2						"Resources\\fonts\\freetype2.cc.js"
+IDB_FONT_SCRIPT_FM	HTML2						"Resources\\fonts\\FontManager.js"
+IDB_FONT_SCRIPT_1	HTML2						"Resources\\fonts\\FontFile.js"
+IDB_FONT_SCRIPT_E	HTML2						"Resources\\fonts\\FreeTypeFontEngine.js"
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE 
+BEGIN
+    "#include ""winres.h""\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION INTVER
+ PRODUCTVERSION INTVER
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "CompanyName", COMPANY_NAME
+            VALUE "FileDescription", FILE_DESCRIPTION_ACTIVEX
+            VALUE "FileVersion", STRVER
+            VALUE "InternalName", COMPONENT_FILE_NAME_DLL
+            VALUE "LegalCopyright", LEGAL_COPYRIGHT
+            VALUE "OriginalFilename", COMPONENT_FILE_NAME_DLL
+            VALUE "ProductName", FILE_DESCRIPTION_ACTIVEX
+            VALUE "ProductVersion", STRVER
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// REGISTRY
+//
+
+IDR_ASCHTMLRENDERER       REGISTRY                "ASCHTMLRenderer.rgs"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// String Table
+//
+
+STRINGTABLE 
+BEGIN
+    IDS_PROJNAME            "ASCHTMLRenderer"
+END
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+

ASCHTMLRenderer/ASCHTMLRenderer.rgs

+HKCR
+{
+	NoRemove AppID
+	{
+		'%APPID%' = s 'ASCHTMLRenderer'
+		'ASCHTMLRenderer.DLL'
+		{
+			val AppID = s '%APPID%'
+		}
+	}
+}

ASCHTMLRenderer/ASCHTMLRenderer.sln

+
+Microsoft Visual Studio Solution File, Format Version 9.00
+# Visual Studio 2005
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ASCHTMLRenderer", "ASCHTMLRenderer.vcproj", "{D02A88E6-5B2B-4A15-A4F6-C057F698FC53}"
+EndProject
+Global
+	GlobalSection(DPCodeReviewSolutionGUID) = preSolution
+		DPCodeReviewSolutionGUID = {00000000-0000-0000-0000-000000000000}
+	EndGlobalSection
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+		ReleaseASC|Win32 = ReleaseASC|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{D02A88E6-5B2B-4A15-A4F6-C057F698FC53}.Debug|Win32.ActiveCfg = Debug|Win32
+		{D02A88E6-5B2B-4A15-A4F6-C057F698FC53}.Debug|Win32.Build.0 = Debug|Win32
+		{D02A88E6-5B2B-4A15-A4F6-C057F698FC53}.Release|Win32.ActiveCfg = Release|Win32
+		{D02A88E6-5B2B-4A15-A4F6-C057F698FC53}.Release|Win32.Build.0 = Release|Win32
+		{D02A88E6-5B2B-4A15-A4F6-C057F698FC53}.ReleaseASC|Win32.ActiveCfg = ReleaseASC|Win32
+		{D02A88E6-5B2B-4A15-A4F6-C057F698FC53}.ReleaseASC|Win32.Build.0 = ReleaseASC|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

ASCHTMLRenderer/ASCSVGWriter.h

+#pragma once
+#include "../DesktopEditor/graphics/IRenderer.h"
+#include "IBaseMatrixUpdater.h"
+
+namespace Aggplus
+{
+	class CMatrix;
+	class CGraphicsPathSimpleConverter;
+}
+class CFontManager;
+namespace NSHtmlRenderer
+{
+	class CSVGGraphicsWriter;
+}
+namespace NSStructures
+{
+	class CPen;
+	class CBrush;
+	class CFont;
+}
+namespace NSHtmlRenderer
+{
+	class CASCSVGWriter : public IRenderer, public NSHtmlRenderer::IBaseMatrixUpdater
+	{
+	public:
+		CASCSVGWriter();
+		~CASCSVGWriter();
+
+	public:
+		// тип рендерера-----------------------------------------------------------------------------
+		HRESULT get_Type(LONG* lType);
+		//-------- Функции для работы со страницей --------------------------------------------------
+		HRESULT NewPage();
+		HRESULT get_Height(double* dHeight);
+		HRESULT put_Height(const double& dHeight);
+		HRESULT get_Width(double* dWidth);
+		HRESULT put_Width(const double& dWidth);
+		HRESULT get_DpiX(double* dDpiX);
+		HRESULT get_DpiY(double* dDpiY);
+
+		// pen --------------------------------------------------------------------------------------
+		HRESULT get_PenColor(LONG* lColor);
+		HRESULT put_PenColor(const LONG& lColor);
+		HRESULT get_PenAlpha(LONG* lAlpha);
+		HRESULT put_PenAlpha(const LONG& lAlpha);
+		HRESULT get_PenSize(double* dSize);
+		HRESULT put_PenSize(const double& dSize);
+		HRESULT get_PenDashStyle(BYTE* val);
+		HRESULT put_PenDashStyle(const BYTE& val);
+		HRESULT get_PenLineStartCap(BYTE* val);
+		HRESULT put_PenLineStartCap(const BYTE& val);
+		HRESULT get_PenLineEndCap(BYTE* val);
+		HRESULT put_PenLineEndCap(const BYTE& val);
+		HRESULT get_PenLineJoin(BYTE* val);
+		HRESULT put_PenLineJoin(const BYTE& val);
+		HRESULT get_PenDashOffset(double* dOffset);
+		HRESULT put_PenDashOffset(const double& dOffset);
+		HRESULT get_PenAlign(LONG* lAlign);
+		HRESULT put_PenAlign(const LONG& lAlign);
+		HRESULT get_PenMiterLimit(double* dOffset);
+		HRESULT put_PenMiterLimit(const double& dOffset);
+		HRESULT PenDashPattern(double* pPattern, LONG lCount);
+
+		// brush ------------------------------------------------------------------------------------
+		HRESULT get_BrushType(LONG* lType);
+		HRESULT put_BrushType(const LONG& lType);
+		HRESULT get_BrushColor1(LONG* lColor);
+		HRESULT put_BrushColor1(const LONG& lColor);
+		HRESULT get_BrushAlpha1(LONG* lAlpha);
+		HRESULT put_BrushAlpha1(const LONG& lAlpha);
+		HRESULT get_BrushColor2(LONG* lColor);
+		HRESULT put_BrushColor2(const LONG& lColor);
+		HRESULT get_BrushAlpha2(LONG* lAlpha);
+		HRESULT put_BrushAlpha2(const LONG& lAlpha);
+		HRESULT get_BrushTexturePath(std::wstring* bsPath);
+		HRESULT put_BrushTexturePath(const std::wstring& bsPath);
+		HRESULT get_BrushTextureMode(LONG* lMode);
+		HRESULT put_BrushTextureMode(const LONG& lMode);
+		HRESULT get_BrushTextureAlpha(LONG* lTxAlpha);
+		HRESULT put_BrushTextureAlpha(const LONG& lTxAlpha);
+		HRESULT get_BrushLinearAngle(double* dAngle);
+		HRESULT put_BrushLinearAngle(const double& dAngle);
+		HRESULT BrushRect(const INT& val, const double& left, const double& top, const double& width, const double& height);
+		HRESULT BrushBounds(const double& left, const double& top, const double& width, const double& height);
+
+		HRESULT put_BrushGradientColors(LONG* lColors, double* pPositions, LONG nCount);
+
+		// font -------------------------------------------------------------------------------------
+		HRESULT get_FontName(std::wstring* bsName);
+		HRESULT put_FontName(const std::wstring& bsName);
+		HRESULT get_FontPath(std::wstring* bsName);
+		HRESULT put_FontPath(const std::wstring& bsName);
+		HRESULT get_FontSize(double* dSize);
+		HRESULT put_FontSize(const double& dSize);
+		HRESULT get_FontStyle(LONG* lStyle)	;
+		HRESULT put_FontStyle(const LONG& lStyle);
+		HRESULT get_FontStringGID(INT* bGID);
+		HRESULT put_FontStringGID(const INT& bGID);
+		HRESULT get_FontCharSpace(double* dSpace);
+		HRESULT put_FontCharSpace(const double& dSpace);
+		HRESULT get_FontFaceIndex(int* lFaceIndex);
+		HRESULT put_FontFaceIndex(const int& lFaceIndex);
+
+		//-------- Функции для вывода текста --------------------------------------------------------
+		HRESULT CommandDrawTextCHAR(const LONG& c, const double& x, const double& y, const double& w, const double& h, const double& baselineOffset);
+		HRESULT CommandDrawText(const std::wstring& bsText, const double& x, const double& y, const double& w, const double& h, const double& baselineOffset);
+
+		HRESULT CommandDrawTextExCHAR(const LONG& c, const LONG& gid, const double& x, const double& y, const double& w, const double& h, const double& baselineOffset, const DWORD& lFlags);
+		HRESULT CommandDrawTextEx(const std::wstring& bsUnicodeText, const std::wstring& bsGidText, const double& x, const double& y, const double& w, const double& h, const double& baselineOffset, const DWORD& lFlags);
+
+		//-------- Маркеры для команд ---------------------------------------------------------------
+		HRESULT BeginCommand(const DWORD& lType);
+		HRESULT EndCommand(const DWORD& lType);
+
+		//-------- Функции для работы с Graphics Path -----------------------------------------------
+		HRESULT PathCommandMoveTo(const double& x, const double& y);
+		HRESULT PathCommandLineTo(const double& x, const double& y);
+		HRESULT PathCommandLinesTo(double* points, const int& count);
+		HRESULT PathCommandCurveTo(const double& x1, const double& y1, const double& x2, const double& y2, const double& x3, const double& y3);
+		HRESULT PathCommandCurvesTo(double* points, const int& count);
+		HRESULT PathCommandArcTo(const double& x, const double& y, const double& w, const double& h, const double& startAngle, const double& sweepAngle);
+		HRESULT PathCommandClose();
+		HRESULT PathCommandEnd();
+		HRESULT DrawPath(const LONG& nType);
+		HRESULT PathCommandStart();
+		HRESULT PathCommandGetCurrentPoint(double* x, double* y);
+
+		HRESULT PathCommandTextCHAR(const LONG& c, const double& x, const double& y, const double& w, const double& h, const double& baselineOffset);
+		HRESULT PathCommandText(const std::wstring& bsText, const double& x, const double& y, const double& w, const double& h, const double& baselineOffset);
+
+		HRESULT PathCommandTextExCHAR(const LONG& c, const LONG& gid, const double& x, const double& y, const double& w, const double& h, const double& baselineOffset, const DWORD& lFlags);
+		HRESULT PathCommandTextEx(const std::wstring& bsUnicodeText, const std::wstring& bsGidText, const double& x, const double& y, const double& w, const double& h, const double& baselineOffset, const DWORD& lFlags);
+
+		//-------- Функции для вывода изображений ---------------------------------------------------
+		HRESULT DrawImage(IGrObject* pImage, const double& x, const double& y, const double& w, const double& h);
+		HRESULT DrawImageFromFile(const std::wstring&, const double& x, const double& y, const double& w, const double& h, const BYTE& lAlpha);
+
+		// transform --------------------------------------------------------------------------------
+		HRESULT SetTransform(const double& m1, const double& m2, const double& m3, const double& m4, const double& m5, const double& m6);
+		HRESULT GetTransform(double *pdA, double *pdB, double *pdC, double *pdD, double *pdE, double *pdF);
+		HRESULT ResetTransform();
+
+		// -----------------------------------------------------------------------------------------
+		HRESULT get_ClipMode(LONG* plMode);
+		HRESULT put_ClipMode(const LONG& lMode);
+		// additiaonal params ----------------------------------------------------------------------
+		HRESULT SaveFile(const std::wstring& strFileSave);
+		HRESULT ReInit();
+		HRESULT IsRaster(bool* bVal);
+		// additiaonal params ----------------------------------------------------------------------
+		HRESULT CommandLong(const LONG& lType, const LONG& lCommand);
+		HRESULT CommandDouble(const LONG& lType, const double& dCommand);
+		HRESULT CommandString(const LONG& lType, const std::wstring& sCommand);
+	public:
+
+		void OnBaseMatrixUpdate(const double& dWidth, const double& dHeight);
+		void SetFontManager(CFontManager* pFontManager);
+
+	private:
+
+		NSHtmlRenderer::CSVGGraphicsWriter*			m_pVectorWriter;
+
+		Aggplus::CGraphicsPathSimpleConverter*	m_pSimpleGraphicsConverter;		// конвертер сложных гафических путей в простые
+		CFontManager*				m_pFontManager;					// менеджер шрифтов
+		bool						m_bDeleteFontManager;	
+
+		Aggplus::CMatrix*			m_pBaseTransform;	// матрица перерасчета координатных осей (здесь: миллиметры -> пикселы)
+		Aggplus::CMatrix*			m_pTransform;		// текущая матрица преобразований рендерера
+		Aggplus::CMatrix*			m_pFullTransform;	// полная матрица преобразований (m_oBaseTransform * m_oTransform)
+
+		double							m_dTransformAngle;
+
+		LONG							m_lCurrentCommandType;	// текущая команда
+
+		double							m_dDpiX;				
+		double							m_dDpiY;
+
+		double							m_dWidth;
+		double							m_dHeight;
+
+		LONG							m_lClipMode;
+
+		NSStructures::CPen*				m_pPen;				// настройки всей графики (скопирован ашник из AVSGraphics)
+		NSStructures::CBrush*			m_pBrush;
+		NSStructures::CFont*			m_pFont;
+
+		NSStructures::CFont*			m_pInstalledFont;
+
+		bool m_bIsRaster;
+		//todo
+		//IASCWinFonts*					m_pFonts;
+
+	protected:
+		void CalculateFullTransform();
+		inline void MoveTo(const double& dX, const double& dY);
+		inline void LineTo(const double& dX, const double& dY);
+		inline void CurveTo(const double& x1, const double& y1, const double& x2, const double& y2, const double& x3, const double& y3);
+		void Start();
+		void End();
+		void Close();
+		void _SetFont();
+	};
+}
\ No newline at end of file

ASCHTMLRenderer/CASCImage.h

+#ifndef C_IMAGE_RENDERER
+#define C_IMAGE_RENDERER
+
+#if defined(_WIN32) || defined (_WIN64)
+	#include <atlbase.h>
+	#include <atlstr.h>
+#else
+	#include "../Common/DocxFormat/Source/Base/ASCString.h"
+#endif
+
+#include "../DesktopEditor/graphics/IRenderer.h"
+
+const long c_lImageTypeUnknown  = 0x0000;
+const long c_lImageTypeMetafile = 0x1000;
+const long c_lImageTypeBitmap   = 0x2000;
+
+const long c_lMetaWmf = 0x01;
+const long c_lMetaEmf = 0x02;
+const long c_lMetaSVG = 0x04;
+
+
+const long c_ag_ImageTypeBitmap			= 0;
+const long c_ag_ImageTypeMetafile		= 1;
+
+class CFontManager;
+class CWmfFile;
+struct TWmfRectF;
+namespace Aggplus
+{
+	class CImage;
+}
+namespace NSHtmlRenderer
+{
+	class IASCImage
+	{
+	public:
+		virtual HRESULT get_Type(LONG* lType) = 0;
+
+		virtual HRESULT get_Width(LONG* lWidth) = 0;
+		virtual HRESULT put_Width(LONG lWidth) = 0;
+
+		virtual HRESULT get_Height(LONG* lHeight) = 0;
+		virtual HRESULT put_Height(LONG lHeight) = 0;
+
+		virtual HRESULT get_DpiX(double* dDpiX) = 0;
+		virtual HRESULT put_DpiX(double dDpiX) = 0;
+
+		virtual HRESULT get_DpiY(double* dDpiY) = 0;
+		virtual HRESULT put_DpiY(double dDpiY) = 0;
+
+		virtual CFontManager* get_FontManager() = 0;
+		virtual void put_FontManager(CFontManager* pManager) = 0;
+
+		virtual HRESULT LoadFromFile(const std::wstring& bsFilePath) = 0;
+		virtual HRESULT DrawOnRenderer(IRenderer* pRenderer, double dX, double dY, double dWidth, double dHeight) = 0;
+	};
+
+	// CAVSImage
+	class CASCImage : public IASCImage
+	{
+	private:
+
+		CWmfFile*			m_pWmfFile;
+
+		TWmfRectF* m_pRect;
+
+		CString  m_wsTempFilePath;
+
+		long      m_lImageType; // 0 - BMP, 1 - WMF, 2 - EFM
+
+		double   m_dDpiX;
+		double   m_dDpiY;
+
+		Aggplus::CImage* m_pMediaData;
+
+		BOOL      m_bLoadOnlyMeta; //   
+
+	public:
+
+		CASCImage();
+		~CASCImage();
+
+	private:
+
+		void Open(const std::wstring& bsFilePath);
+		void Close();
+	public:
+
+		HRESULT get_Type(LONG* lType);
+		HRESULT get_Width(LONG* lWidth);
+		HRESULT put_Width(LONG lWidth);
+		HRESULT get_Height(LONG* lHeight);
+		HRESULT put_Height(LONG lHeight);
+		HRESULT get_DpiX(double* dDpiX);
+		HRESULT put_DpiX(double dDpiX);
+		HRESULT get_DpiY(double* dDpiY);
+		HRESULT put_DpiY(double dDpiY);
+		HRESULT LoadFromFile(const std::wstring& bsFilePath);
+		HRESULT DrawOnRenderer(IRenderer* pRenderer, double dX, double dY, double dWidth, double dHeight);
+		HRESULT LoadOnlyMeta(bool bVal);
+		HRESULT LoadSVG(const std::wstring& sVal);
+		CFontManager* get_FontManager();
+		void put_FontManager(CFontManager* oManager);
+		Aggplus::CImage* get_BitmapImage();
+	};
+}
+#endif
\ No newline at end of file

ASCHTMLRenderer/CMetafile.cpp

+#include "CMetafile.h"
+#include "../DesktopEditor/common/File.h"
+#include "../DesktopEditor/graphics/Image.h"
+#include "../DesktopEditor/graphics/structures.h"
+#include "../DesktopEditor/fontengine/GlyphString.h"
+#include "CASCImage.h"
+
+namespace NSHtmlRenderer
+{
+	LONG CImageExt::GetImageType(const std::wstring& strFile)
+	{		
+		NSFile::CFileBinary oFile;
+		if (S_OK != oFile.OpenFile(strFile))
+		{
+			oFile.CloseFile();
+			return 0;
+		}
+
+		DWORD dwSize = (DWORD)oFile.GetFileSize();
+
+		if (44 > dwSize)
+		{
+			return 0;
+		}
+
+		DWORD dwKey = 0;
+		DWORD dwSizeRead;
+		oFile.ReadFile((BYTE*)(&dwKey), 4, dwSizeRead);
+
+		if (0x9AC6CDD7 == dwKey)
+		{
+			// placeable meta
+			oFile.CloseFile();
+			return 1;
+		}
+
+		if (0x00000001 == dwKey)
+		{
+			BYTE aTemp[40];
+			oFile.ReadFile((BYTE*)&aTemp, 40, dwSizeRead);
+			oFile.ReadFile((BYTE*)(&dwKey), 4, dwSizeRead);
+			oFile.CloseFile();
+
+			if (0x464D4520 == dwKey)
+			{
+				// EMF/EMF+
+				return 2;
+			}
+			else
+			{
+				// 
+				return 0;
+			}
+		}
+
+		oFile.CloseFile();
+
+		if (0x00090001 == dwKey)
+		{
+			return 1;
+		}
+
+		return 0;
+	}
+
+	void CImageExt::DrawOnRenderer(IRenderer* pRenderer, const std::wstring& strFile, const double& dX, const double& dY, const double& dW, const double& dH, const BOOL& bIsFromFileUse = TRUE)
+	{
+		if (NULL == pRenderer)
+			return;
+
+		LONG lRendType = 0;
+		pRenderer->get_Type(&lRendType);
+		if (c_nPDFWriter == lRendType)
+		{
+			//todo
+			//VARIANT var;
+			//var.vt = VT_BOOL;
+			//var.boolVal = VARIANT_TRUE;
+			//pRenderer->SetAdditionalParam(L"WhiteBackImage", var);
+		}
+
+		LONG lFileType = 0;
+
+		if (c_nEbookWriter != lRendType)
+			lFileType = GetImageType(strFile);
+
+		BOOL bIsGraphics = FALSE;
+
+		//todo
+		//IASCGraphicsRenderer* pGR = NULL;
+		//pRenderer->QueryInterface(__uuidof(IASCGraphicsRenderer), (void**)&pGR);
+
+		//if (NULL != pGR)
+		//{
+		//	bIsGraphics = TRUE;
+		//}
+
+		//RELEASEINTERFACE(pGR);
+
+		if (0 == lFileType)
+		{
+			// 
+			if (bIsGraphics)
+			{
+				pRenderer->DrawImageFromFile(strFile, dX, dY, dW, dH);
+			}
+			else
+			{
+				Aggplus::CImage oImage(strFile);
+				pRenderer->DrawImage(&oImage, dX, dY, dW, dH);
+			}
+		}
+		else if (1 == lFileType || 2 == lFileType)
+		{
+			//    Brush, Font, Pen, Shadow  ..
+			NSStructures::CBrush oBrush;
+			std::wstring bsBrushTexturePath;
+			pRenderer->get_BrushAlpha1( &oBrush.Alpha1 );
+			pRenderer->get_BrushAlpha2( &oBrush.Alpha2 );
+			pRenderer->get_BrushColor1( &oBrush.Color1 );
+			pRenderer->get_BrushColor2( &oBrush.Color2 );
+			pRenderer->get_BrushLinearAngle( &oBrush.LinearAngle );
+			pRenderer->get_BrushTextureMode( &oBrush.TextureMode );
+			pRenderer->get_BrushTextureAlpha( &oBrush.TextureAlpha );
+			pRenderer->get_BrushTexturePath( &bsBrushTexturePath );
+			pRenderer->get_BrushType( &oBrush.Type );
+
+			NSStructures::CFont oFont;
+			std::wstring bsFontPath, bsFontName;
+			pRenderer->get_FontName( &bsFontName );
+			pRenderer->get_FontPath( &bsFontPath );
+			pRenderer->get_FontSize( &oFont.Size );
+			LONG lStyle;
+			pRenderer->get_FontStyle( &lStyle );
+			oFont.Bold      = lStyle & FontConstants::FontStyleBold;
+			oFont.Italic    = lStyle & FontConstants::FontStyleItalic;
+			oFont.Strikeout = lStyle & FontConstants::FontStyleStrikeout;
+			oFont.Underline = lStyle & FontConstants::FontStyleUnderline;
+			pRenderer->get_FontStringGID( &oFont.StringGID );
+
+			NSStructures::CPen oPen;
+			pRenderer->get_PenAlign( &oPen.Align );
+			pRenderer->get_PenAlpha( &oPen.Alpha );
+			pRenderer->get_PenColor( &oPen.Color );
+
+
+			NSHtmlRenderer::CASCImage oImage;
+			//todo font manager
+			oImage.put_FontManager(NULL);
+
+			oImage.LoadFromFile( strFile );
+			oImage.DrawOnRenderer( pRenderer, dX, dY, dW, dH );
+
+			//  
+
+			pRenderer->put_BrushAlpha1( oBrush.Alpha1 );
+			pRenderer->put_BrushAlpha2( oBrush.Alpha2 );
+			pRenderer->put_BrushColor1( oBrush.Color1 );
+			pRenderer->put_BrushColor2( oBrush.Color2 );
+			pRenderer->put_BrushLinearAngle( oBrush.LinearAngle );
+			pRenderer->put_BrushTextureMode( oBrush.TextureMode );
+			pRenderer->put_BrushTextureAlpha( oBrush.TextureAlpha );
+			pRenderer->put_BrushTexturePath( bsBrushTexturePath );
+			pRenderer->put_BrushType( oBrush.Type );
+
+			pRenderer->put_FontName( bsFontName );
+			pRenderer->put_FontPath( bsFontPath );
+			pRenderer->put_FontSize( oFont.Size );
+			pRenderer->put_FontStyle( oFont.GetStyle() );
+			pRenderer->put_FontStringGID( oFont.StringGID );
+
+			pRenderer->put_PenAlign( oPen.Align );
+			pRenderer->put_PenAlpha( oPen.Alpha );
+			pRenderer->put_PenColor( oPen.Color );
+
+			//     path
+			pRenderer->PathCommandEnd();
+		}
+		//else if (2 == lFileType)
+		//{		
+		//	if (bIsGraphics)
+		//	{
+		//		pRenderer->DrawImageFromFile(strFile, dX, dY, dW, dH);
+		//		return;
+		//	}
+
+		//	NSDocumentViewer::CDIB oSection;
+
+		//	double dDpiX = 0;
+		//	double dDpiY = 0;
+		//	pRenderer->get_DpiX(&dDpiX);
+		//	pRenderer->get_DpiY(&dDpiY);
+
+		//	LONG lPixW = (LONG)dW * dDpiX / NSDocumentViewer::c_dInch_to_MM;
+		//	LONG lPixH = (LONG)dH * dDpiX / NSDocumentViewer::c_dInch_to_MM;
+
+		//	oSection.Create(lPixW, lPixH, dDpiX, dDpiY);
+
+		//	LONG lCount = lPixW * lPixH;
+		//	memset(oSection.m_pBits, 0xFF, 4 * lCount);
+
+		//	HDC hDC = GetDC(NULL);
+
+		//	HDC memDC = CreateCompatibleDC(hDC);
+		//	ReleaseDC(0, hDC);
+
+		//	HBITMAP hOldBitmap = (HBITMAP)SelectObject(memDC, oSection.m_hBitmap);
+
+		//	RECT oRectPlay;
+		//	oRectPlay.left		= 0;
+		//	oRectPlay.top		= 0;
+		//	oRectPlay.right		= lPixW;
+		//	oRectPlay.bottom	= lPixH;
+
+		//	HENHMETAFILE hMeta = GetEnhMetaFile(strFile);
+
+		//	PlayEnhMetaFile(memDC, hMeta, &oRectPlay);
+		//	DeleteEnhMetaFile(hMeta);
+
+		//	MediaCore::IAVSUncompressedVideoFrame* pMediaData = NULL;
+		//	CoCreateInstance(MediaCore::CLSID_CAVSUncompressedVideoFrame, NULL, CLSCTX_INPROC, MediaCore::IID_IAVSUncompressedVideoFrame, (void**)&pMediaData);
+
+		//	pMediaData->put_ColorSpace(CSP_VFLIP | CSP_BGRA);
+		//	pMediaData->put_Width(lPixW);
+		//	pMediaData->put_Height(lPixH);
+		//	pMediaData->SetDefaultStrides();
+		//	pMediaData->AllocateBuffer(-1);
+
+		//	BYTE* pPixels = NULL;
+		//	pMediaData->get_Buffer(&pPixels);
+		//	memcpy(pPixels, oSection.m_pBits, 4 * lPixW * lPixH);
+
+		//	DeleteObject(hOldBitmap);
+		//	DeleteDC(memDC);
+
+		//	IUnknown* punkImage = NULL;
+		//	pMediaData->QueryInterface(IID_IUnknown, (void**)&punkImage);
+
+		//	RELEASEINTERFACE(pMediaData);
+
+		//	pRenderer->DrawImage(punkImage, dX, dY, dW, dH);
+		//	RELEASEINTERFACE(punkImage);
+		//}
+	}
+}
\ No newline at end of file

ASCHTMLRenderer/CMetafile.h

+#ifndef C_METAFILE
+#define C_METAFILE
+
+#include "../DesktopEditor/graphics/IRenderer.h"
+namespace NSHtmlRenderer
+{
+	class CImageExt
+	{
+	public:
+		LONG GetImageType(const std::wstring& strFile);
+
+		void DrawOnRenderer(IRenderer* pRenderer, const std::wstring& strFile, const double& dX, const double& dY, const double& dW, const double& dH, const BOOL& bIsFromFileUse);
+	};
+}
+#endif
\ No newline at end of file

ASCHTMLRenderer/GraphicWriter.h

+#pragma once

ASCHTMLRenderer/Graphics/Matrix.h

+#pragma once
+
+#include "ap_AggPlusEnums.h"
+#include "ap_AggPlusTypes.h"
+#include "agg_trans_affine.h"
+
+namespace NSHtmlRenderer
+{
+	class CMatrix  
+	{
+	public:
+		CMatrix(double m11, double m12, double m21, double m22, double dx, double dy) : m_agg_mtx(m11, m12, m21, m22, dx, dy)
+		{
+		}
+
+		CMatrix() : m_agg_mtx() 
+		{
+		}
+		
+		~CMatrix()
+		{
+		}
+		
+		void Translate(double offsetX, double offsetY, Aggplus::MatrixOrder order = Aggplus::MatrixOrderPrepend)
+		{
+			if (order == Aggplus::MatrixOrderPrepend) 
+			{ 
+				m_agg_mtx.premultiply(agg::trans_affine_translation(offsetX, offsetY)); 
+			}
+			else                            
+			{ 
+				m_agg_mtx.multiply(agg::trans_affine_translation(offsetX, offsetY)); 
+			}
+		}
+
+		void Scale(double scaleX, double scaleY, Aggplus::MatrixOrder order = Aggplus::MatrixOrderPrepend)
+		{	
+			if (order == Aggplus::MatrixOrderPrepend) 
+			{ 
+				m_agg_mtx.premultiply(agg::trans_affine_scaling(scaleX, scaleY)); 
+			}
+			else                            
+			{ 
+				m_agg_mtx.multiply(agg::trans_affine_scaling(scaleX, scaleY)); 
+			}
+		}
+
+		void Shear(double shearX, double shearY, Aggplus::MatrixOrder order = Aggplus::MatrixOrderPrepend)
+		{
+			if (order == Aggplus::MatrixOrderPrepend) 
+			{ 
+				m_agg_mtx.premultiply(agg::trans_affine_skewing(shearX, shearY)); 
+			}
+			else                            
+			{ 
+				m_agg_mtx.multiply(agg::trans_affine_skewing(shearX, shearY)); 
+			}
+		}
+
+		void TransformPoint(double& x, double& y)
+		{
+			m_agg_mtx.transform(&x, &y);
+		}
+
+		void Rotate(double angle, Aggplus::MatrixOrder order = Aggplus::MatrixOrderPrepend)
+		{
+			if (order == Aggplus::MatrixOrderPrepend) 
+			{ 
+				m_agg_mtx.premultiply(agg::trans_affine_rotation(agg::deg2rad(angle))); 
+			}
+			else
+			{ 
+				m_agg_mtx.multiply(agg::trans_affine_rotation(agg::deg2rad(angle))); 
+			}
+		}
+
+		void RotateAt(double angle, double x, double y, Aggplus::MatrixOrder order = Aggplus::MatrixOrderPrepend)
+		{
+			Translate(-x, -y, order);
+			if (order == Aggplus::MatrixOrderPrepend) 
+			{ 
+				m_agg_mtx.premultiply(agg::trans_affine_rotation(agg::deg2rad(angle))); 
+			}
+			else                            
+			{ 
+				m_agg_mtx.multiply(agg::trans_affine_rotation(agg::deg2rad(angle))); 
+			}
+			Translate(x, y, order);
+		}
+
+		void Multiply(const CMatrix* matrix, Aggplus::MatrixOrder order = Aggplus::MatrixOrderPrepend)
+		{
+			if (order == Aggplus::MatrixOrderPrepend) 
+			{ 
+				m_agg_mtx.premultiply(matrix->m_agg_mtx); 
+			}
+			else
+			{ 
+				m_agg_mtx.multiply(matrix->m_agg_mtx); 
+			}
+		}
+
+		double OffsetX() const
+		{
+			double M[6]; m_agg_mtx.store_to(M);
+			return (M[4]);
+		}
+		double OffsetY() const
+		{
+			double M[6]; m_agg_mtx.store_to(M);
+			return (M[5]);
+		}
+		
+		bool GetElements(float* m) const
+		{
+			double M[6]; m_agg_mtx.store_to(M);
+			m[0]=(float)M[0];
+			m[1]=(float)M[1];
+			m[2]=(float)M[2];
+			m[3]=(float)M[3];
+			m[4]=(float)M[4];
+			m[5]=(float)M[5];
+			return true;
+		}
+
+		bool GetElements(double* m) const
+		{
+			m_agg_mtx.store_to(m);
+			return true;
+		}
+
+		void Reset()
+		{
+			m_agg_mtx.reset();
+		}
+
+		const CMatrix& operator=(const CMatrix& Src)
+		{
+			m_agg_mtx	= Src.m_agg_mtx;
+			return		*this;
+		}
+
+		AVSINLINE bool IsEqualMain(const CMatrix* pMatrix)
+		{
+			if (fabs(m_agg_mtx.sx - pMatrix->m_agg_mtx.sx) < 0.001 && 
+				fabs(m_agg_mtx.sy - pMatrix->m_agg_mtx.sy) < 0.001 &&
+				fabs(m_agg_mtx.shx - pMatrix->m_agg_mtx.shx) < 0.001 &&
+				fabs(m_agg_mtx.shy - pMatrix->m_agg_mtx.shy) < 0.001)
+				return true;
+			return false;
+		}
+
+		bool Invert()
+		{
+			double d = m_agg_mtx.determinant();
+			if (0.0001 >= abs(d))
+				return false;
+
+			m_agg_mtx.invert();
+			return true;
+		}
+
+		//Temp
+		//Used in X_BrushLinearGradient constructor
+		double z_Rotation() const 
+		{ 
+			return agg::rad2deg(m_agg_mtx.rotation()); 
+		}
+
+	public:
+		agg::trans_affine m_agg_mtx;
+	};
+}
\ No newline at end of file

ASCHTMLRenderer/Graphics/agg_trans_affine.cpp

+//
+// Affine transformations
+//
+//----------------------------------------------------------------------------
+#include "stdafx.h"
+#include "agg_trans_affine.h"
+
+
+namespace agg
+{
+
+    //------------------------------------------------------------------------
+    const trans_affine& trans_affine::parl_to_parl(const double* src, 
+                                                   const double* dst)
+    {
+        sx  = src[2] - src[0];
+        shy = src[3] - src[1];
+        shx = src[4] - src[0];
+        sy  = src[5] - src[1];
+        tx  = src[0];
+        ty  = src[1];
+        invert();
+        multiply(trans_affine(dst[2] - dst[0], dst[3] - dst[1], 
+                              dst[4] - dst[0], dst[5] - dst[1],
+                              dst[0], dst[1]));
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    const trans_affine& trans_affine::rect_to_parl(double x1, double y1, 
+                                                   double x2, double y2, 
+                                                   const double* parl)
+    {
+        double src[6];
+        src[0] = x1; src[1] = y1;
+        src[2] = x2; src[3] = y1;
+        src[4] = x2; src[5] = y2;
+        parl_to_parl(src, parl);
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    const trans_affine& trans_affine::parl_to_rect(const double* parl, 
+                                                   double x1, double y1, 
+                                                   double x2, double y2)
+    {
+        double dst[6];
+        dst[0] = x1; dst[1] = y1;
+        dst[2] = x2; dst[3] = y1;
+        dst[4] = x2; dst[5] = y2;
+        parl_to_parl(parl, dst);
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    const trans_affine& trans_affine::multiply(const trans_affine& m)
+    {
+        double t0 = sx  * m.sx + shy * m.shx;
+        double t2 = shx * m.sx + sy  * m.shx;
+        double t4 = tx  * m.sx + ty  * m.shx + m.tx;
+        shy = sx  * m.shy + shy * m.sy;
+        sy  = shx * m.shy + sy  * m.sy;
+        ty  = tx  * m.shy + ty  * m.sy + m.ty;
+        sx  = t0;
+        shx = t2;
+        tx  = t4;
+        return *this;
+    }
+
+
+    //------------------------------------------------------------------------
+    const trans_affine& trans_affine::invert()
+    {
+        double d  = determinant_reciprocal();
+
+        double t0  =  sy  * d;
+               sy  =  sx  * d;
+               shy = -shy * d;
+               shx = -shx * d;
+
+        double t4 = -tx * t0  - ty * shx;
+               ty = -tx * shy - ty * sy;
+
+        sx = t0;
+        tx = t4;
+        return *this;
+    }
+
+
+   //------------------------------------------------------------------------
+    const trans_affine& trans_affine::flip_x()
+    {
+        sx  = -sx;
+        shy = -shy;
+        tx  = -tx;
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    const trans_affine& trans_affine::flip_y()
+    {
+        shx = -shx;
+        sy  = -sy;
+        ty  = -ty;
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    const trans_affine& trans_affine::reset()
+    {
+        sx  = sy  = 1.0; 
+        shy = shx = tx = ty = 0.0;
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    bool trans_affine::is_identity(double epsilon) const
+    {
+        return is_equal_eps(sx,  1.0, epsilon) &&
+               is_equal_eps(shy, 0.0, epsilon) &&
+               is_equal_eps(shx, 0.0, epsilon) && 
+               is_equal_eps(sy,  1.0, epsilon) &&
+               is_equal_eps(tx,  0.0, epsilon) &&
+               is_equal_eps(ty,  0.0, epsilon);
+    }
+
+	bool trans_affine::is_identity_main(double epsilon) const
+    {
+        return is_equal_eps(sx,  1.0, epsilon) &&
+               is_equal_eps(shy, 0.0, epsilon) &&
+               is_equal_eps(shx, 0.0, epsilon) && 
+               is_equal_eps(sy,  1.0, epsilon);
+    }
+
+    //------------------------------------------------------------------------
+    bool trans_affine::is_valid(double epsilon) const
+    {
+        return fabs(sx) > epsilon && fabs(sy) > epsilon;
+    }
+
+    //------------------------------------------------------------------------
+    bool trans_affine::is_equal(const trans_affine& m, double epsilon) const
+    {
+        return is_equal_eps(sx,  m.sx,  epsilon) &&
+               is_equal_eps(shy, m.shy, epsilon) &&
+               is_equal_eps(shx, m.shx, epsilon) && 
+               is_equal_eps(sy,  m.sy,  epsilon) &&
+               is_equal_eps(tx,  m.tx,  epsilon) &&
+               is_equal_eps(ty,  m.ty,  epsilon);
+    }
+
+    //------------------------------------------------------------------------
+    double trans_affine::rotation() const
+    {
+        double x1 = 0.0;
+        double y1 = 0.0;
+        double x2 = 1.0;
+        double y2 = 0.0;
+        transform(&x1, &y1);
+        transform(&x2, &y2);
+        return atan2(y2-y1, x2-x1);
+    }
+
+    //------------------------------------------------------------------------
+    void trans_affine::translation(double* dx, double* dy) const
+    {
+        *dx = tx;
+        *dy = ty;
+    }
+
+    //------------------------------------------------------------------------
+    void trans_affine::scaling(double* x, double* y) const
+    {
+        double x1 = 0.0;
+        double y1 = 0.0;
+        double x2 = 1.0;
+        double y2 = 1.0;
+        trans_affine t(*this);
+        t *= trans_affine_rotation(-rotation());
+        t.transform(&x1, &y1);
+        t.transform(&x2, &y2);
+        *x = x2 - x1;
+        *y = y2 - y1;
+    }
+
+
+}
+

ASCHTMLRenderer/Graphics/ap_AggPlusTypes.h

+
+
+#ifndef _AGGPLUSTYPES_H
+#define _AGGPLUSTYPES_H
+
+#include "windows.h"
+
+namespace Aggplus
+{
+
+typedef float				REAL;
+typedef int                 INT;
+typedef unsigned int        *PUINT;
+typedef unsigned long		ARGB;
+
+ typedef INT PixelFormat;
+
+#define REAL_MAX            FLT_MAX
+#define REAL_MIN            FLT_MIN
+#define REAL_TOLERANCE     (FLT_MIN * 100)
+#define REAL_EPSILON        1.192092896e-07F        /* FLT_EPSILON */
+
+//--------------------------------------------------------------------------
+// Status return values from AGG+ methods
+//--------------------------------------------------------------------------
+
+enum Status
+{
+    Ok							= 0,
+    GenericError				= 1,
+    InvalidParameter			= 2,
+    OutOfMemory					= 3,
+    ObjectBusy					= 4,
+    InsufficientBuffer			= 5,
+    NotImplemented				= 6,
+    Win32Error					= 7,
+    WrongState					= 8,
+    Aborted						= 9,
+    FileNotFound				= 10,
+    ValueOverflow				= 11,
+    AccessDenied				= 12,
+    UnknownImageFormat			= 13,
+    FontFamilyNotFound			= 14,
+    FontStyleNotFound			= 15,
+    NotTrueTypeFont				= 16,
+    UnsupportedGdiplusVersion	= 17,
+    AggplusNotInitialized		= 18,
+    PropertyNotFound			= 19,
+    PropertyNotSupported		= 20
+};
+
+
+
+
+class SizeF
+{
+public:
+		SizeF() : Width(0.0f), Height(0.0f) { }
+		SizeF(const SizeF& size) : Width(size.Width), Height(size.Height) { }
+		SizeF(REAL width, REAL height) : Width(width), Height(height) { }
+
+		SizeF operator+(const SizeF& sz) const { return SizeF(Width+sz.Width, Height+sz.Height); }
+		SizeF operator-(const SizeF& sz) const { return SizeF(Width-sz.Width, Height-sz.Height); }
+		BOOL Equals(const SizeF& sz) const { return((Width == sz.Width) && (Height == sz.Height)); }
+		BOOL Empty() const { return(Width == 0.0f && Height == 0.0f); }
+
+public:
+		REAL Width, Height;
+};
+
+
+class PointF  
+{
+public:
+		PointF() : X(0.0f), Y(0.0f) { }
+		PointF(const PointF &point) : X(point.X), Y(point.Y)  { }
+		PointF(const SizeF &size) : X(size.Width), Y(size.Height)  { }
+		PointF(REAL x, REAL y) : X(x), Y(y) { }
+		//~PointF() { }
+		BOOL Equals(const PointF& point) const { return(X==point.X && Y==point.Y); }
+		PointF operator+(const PointF& point) const { return PointF(X + point.X, Y + point.Y); }
+		PointF operator-(const PointF& point) const { return PointF(X - point.X, Y - point.Y); }
+public:
+		REAL X, Y;
+};
+
+class RectF
+{
+public:
+		RectF() : X(0.0f), Y(0.0f), Width(0.0f), Height(0.0f) { }
+		RectF(REAL x, REAL y, REAL width, REAL height) : X(x), Y(y), Width(width), Height(height) { }
+		RectF(RECT rct)  
+		   { X = REAL(rct.left); Y = REAL(rct.top); Width = REAL(rct.right-rct.left); Height=REAL(rct.bottom-rct.top);}
+		RectF(const PointF& location, const SizeF& size) : X(location.X), Y(location.Y), Width(size.Width), Height(size.Height) { }
+
+		RectF* Clone() const { return new RectF(X, Y, Width, Height); }
+
+		void GetLocation(PointF* point) const { point->X = X; point->Y = Y; }
+		void GetSize(SizeF* size) const { size->Width = Width; size->Height = Height; }
+		void GetBounds(RectF* rect) const { rect->X = X; rect->Y = Y; rect->Width = Width; rect->Height = Height; }
+		REAL GetLeft() const { return X; }
+		REAL GetTop() const { return Y; }
+		REAL GetRight() const { return X+Width; }
+		REAL GetBottom() const { return Y+Height; }
+		BOOL IsEmptyArea() const { return (Width <= REAL_EPSILON) || (Height <= REAL_EPSILON); }
+		BOOL Equals(const RectF & rect) const
+		{
+			return X == rect.X && Y == rect.Y &&
+				Width == rect.Width && Height == rect.Height;
+		}
+		BOOL Contains(REAL x, REAL y) const
+		{
+			return x >= X && x < X+Width &&
+				y >= Y && y < Y+Height;
+		}
+		BOOL Contains(const PointF& pt) const { return Contains(pt.X, pt.Y); }
+		BOOL Contains(const RectF& rect) const
+		{
+			return (X <= rect.X) && (rect.GetRight() <= GetRight()) &&
+				(Y <= rect.Y) && (rect.GetBottom() <= GetBottom());
+		}
+
+		void Inflate(REAL dx, REAL dy) { X -= dx; Y -= dy; Width += 2*dx; Height += 2*dy; }
+		void Inflate(const PointF& point) { Inflate(point.X, point.Y); }
+
+		BOOL Intersect(const RectF& rect) { return Intersect(*this, *this, rect); }
+		static BOOL Intersect(RectF& c, const RectF& a, const RectF& b)
+		{
+				REAL right = min(a.GetRight(), b.GetRight());
+				REAL bottom = min(a.GetBottom(), b.GetBottom());
+				REAL left = max(a.GetLeft(), b.GetLeft());
+				REAL top = max(a.GetTop(), b.GetTop());
+
+				c.X = left;
+				c.Y = top;
+				c.Width = right - left;
+				c.Height = bottom - top;
+				return !c.IsEmptyArea();
+		}
+
+		BOOL IntersectsWith(const RectF& rect) const
+		{
+			return (GetLeft() < rect.GetRight() &&
+				GetTop() < rect.GetBottom() &&
+				GetRight() > rect.GetLeft() &&
+				GetBottom() > rect.GetTop());
+		}
+
+		static BOOL Union(RectF& c, const RectF& a, const RectF& b)
+		{
+				REAL right = max(a.GetRight(), b.GetRight());
+				REAL bottom = max(a.GetBottom(), b.GetBottom());
+				REAL left = min(a.GetLeft(), b.GetLeft());
+				REAL top = min(a.GetTop(), b.GetTop());
+
+				c.X = left;
+				c.Y = top;
+				c.Width = right - left;
+				c.Height = bottom - top;
+				return !c.IsEmptyArea();
+		}
+
+		void Offset(const PointF& point) { Offset(point.X, point.Y); }
+		void Offset(REAL dx, REAL dy) { X += dx; Y += dy; }
+
+public:
+		REAL X, Y, Width, Height;
+};
+
+
+} //namespace Aggplus
+
+#endif // _AGGPLUSTYPES_H
\ No newline at end of file