Fix indents and move operator for CImage

DesktopEditor/fontengine/FontManager.cpp

@@ -351,11 +351,17 @@ CFontManager::~CFontManager()
 	RELEASEINTERFACE(m_pFont);
 	RELEASEOBJECT(m_pOwnerCache);
 }
+
 void CFontManager::SetOwnerCache(NSFonts::IFontsCache* pCache)
 {
 	m_pOwnerCache = (CFontsCache*)pCache;
 }
 
+void CFontManager::ClearOwnerCache()
+{
+	m_pOwnerCache->Clear();
+}
+
 NSFonts::IFontsCache* CFontManager::GetCache() { return m_pOwnerCache; }
 NSFonts::IApplicationFonts* CFontManager::GetApplication() { return m_pApplication; }
 NSFonts::IFontFile* CFontManager::GetFile() { return m_pFont; }

DesktopEditor/fontengine/FontManager.h

@@ -132,6 +132,7 @@ public:
 
 	virtual void Initialize();
 	virtual void SetOwnerCache(NSFonts::IFontsCache* pCache);
+	virtual void ClearOwnerCache();
 
 	virtual NSFonts::IFontsCache* GetCache();
 	virtual NSFonts::IApplicationFonts* GetApplication();

DesktopEditor/graphics/Brush.cpp

@@ -33,479 +33,647 @@
 
 namespace Aggplus
 {
-	////////////////////////////////////////////////////////////////////////////////
-
-	CBrush::CBrush(BrushType bType) : m_bType(bType)
+	CBrush::CBrush()
 	{
 	}
-	 
+
+	CBrush::CBrush(const BrushType& type)
+		: m_bType(type)
+	{
+	}
+
 	CBrush::~CBrush()
 	{
 	}
 
-	BrushType CBrush::GetType() const 
-	{ 
-		return m_bType; 
+	BrushType CBrush::GetType() const
+	{
+		return m_bType;
 	}
 
-	////////////////////////////////////////////////////////////////////////////////
-
-	CBrushSolid::CBrushSolid(CColor dwColor) : CBrush(BrushTypeSolidColor), m_dwColor(dwColor)		
+	CBrushSolid::CBrushSolid() : CBrush()
 	{
 	}
-	CBrushSolid::~CBrushSolid()																
+
+	CBrushSolid::CBrushSolid(CColor color)
+		: CBrush(),
+		m_dwColor(color)
 	{
 	}
-	CBrush* CBrushSolid::Clone() const 
-	{ 
-		return new CBrushSolid(m_dwColor);
+
+	CBrushSolid::CBrushSolid(const CBrushSolid& other) : CBrush()
+	{
+		*this = other;
 	}
 
-	void CBrushSolid::GetColor(CColor* color) const { *color = m_dwColor; }
-	void CBrushSolid::SetColor(const CColor &color) { m_dwColor = color; }
-
-	////////////////////////////////////////////////////////////////////////////////
-
-	CBrushHatch::CBrushHatch() : CBrush(BrushTypeHatchFill)
+	CBrushSolid::~CBrushSolid()
 	{
 	}
-	CBrushHatch::~CBrushHatch()																
+
+	void CBrushSolid::GetColor(CColor* color) const
+	{
+		*color = m_dwColor;
+	}
+
+	void CBrushSolid::SetColor(const CColor &color)
+	{
+		m_dwColor = color;
+	}
+
+	CBrushSolid& CBrushSolid::operator=(const CBrushSolid& other)
+	{
+		if (this == &other)
+			return *this;
+
+		m_dwColor = other.m_dwColor;
+		return *this;
+	}
+
+	CBrushHatch::CBrushHatch()
+		: CBrush(BrushTypeHatchFill)
 	{
 	}
-	CBrush* CBrushHatch::Clone() const 
-	{ 
-		CBrushHatch* clone = new CBrushHatch();
-		clone->m_name		= m_name;
-		clone->m_dwColor1	= m_dwColor1;
-		clone->m_dwColor2	= m_dwColor2;
-		return clone;
-	}
-	
-	////////////////////////////////////////////////////////////////////////////////
 
-	CBrushLinearGradient::CBrushLinearGradient( const PointF& p1, const PointF& p2, const CColor& c1, const CColor& c2 ) 
+	CBrushHatch::CBrushHatch(const CBrushHatch& other)
+		: CBrush(BrushTypeHatchFill)
+	{
+		*this = other;
+	}
+
+	CBrushHatch::CBrushHatch(CBrushHatch&& other) noexcept
+		: CBrush(BrushTypeHatchFill)
+	{
+		*this = std::move(other);
+	}
+
+	CBrushHatch::~CBrushHatch()
+	{
+	}
+
+	void CBrushHatch::SetName(const std::wstring& name)
+	{
+		m_wsName = name;
+	}
+
+	std::wstring CBrushHatch::GetName() const
+	{
+		return m_wsName;
+	}
+
+	void CBrushHatch::SetColor1(const CColor& color)
+	{
+		m_dwColor1 = color;
+	}
+
+	CColor CBrushHatch::GetColor1() const
+	{
+		return m_dwColor1;
+	}
+
+	void CBrushHatch::SetColor2(const CColor& color)
+	{
+		m_dwColor2 = color;
+	}
+
+	CColor CBrushHatch::GetColor2() const
+	{
+		return m_dwColor2;
+	}
+
+	void CBrushHatch::SetBounds(const CDoubleRect& rect)
+	{
+		m_oBounds = rect;
+	}
+
+	CDoubleRect& CBrushHatch::GetBounds()
+	{
+		return m_oBounds;
+	}
+
+	CBrushHatch& CBrushHatch::operator=(const CBrushHatch& other)
+	{
+		if (this == &other)
+			return *this;
+
+		m_wsName = other.m_wsName;
+		m_dwColor1 = other.m_dwColor1;
+		m_dwColor2 = other.m_dwColor2;
+		return *this;
+	}
+
+	CBrushHatch& CBrushHatch::operator=(CBrushHatch&& other) noexcept
+	{
+		if (this == &other)
+			return *this;
+
+		m_wsName = std::move(other.m_wsName);
+		m_dwColor1 = other.m_dwColor1;
+		m_dwColor2 = other.m_dwColor2;
+		return *this;
+	}
+
+	CBrushLinearGradient::CBrushLinearGradient()
 		: CBrush(BrushTypeLinearGradient)
 	{
-		m_points[0] = p1;
-		m_points[1] = p2;
-
-		m_colors[0] = c1;
-		m_colors[1] = c2;
-
-		m_angle = 0;
-		m_wrap = Aggplus::WrapModeTile;
-
-		m_bAngleScalable = FALSE;
-		m_bRectable = FALSE;
-		m_bRelativeCoords = FALSE;
 	}
 
-	CBrushLinearGradient::CBrushLinearGradient( const Point& p1, const Point& p2, const CColor& c1, const CColor& c2 ) 
+	CBrushLinearGradient::CBrushLinearGradient(const PointF& p1, const PointF& p2, const CColor& c1, const CColor& c2)
 		: CBrush(BrushTypeLinearGradient)
 	{
-		m_points[0].X = (float)p1.X;
-		m_points[0].Y = (float)p1.Y;
-		m_points[1].X = (float)p2.X;
-		m_points[1].Y = (float)p2.Y;
+		m_arPoints[0] = p1;
+		m_arPoints[1] = p2;
 
-		m_colors[0] = c1;
-		m_colors[1] = c2;
-
-		m_angle = 0;
-		
-		m_wrap = Aggplus::WrapModeTile;
-
-		m_bAngleScalable = FALSE;
-		m_bRectable = FALSE;
-		m_bRelativeCoords = FALSE;
+		m_arColors[0] = c1;
+		m_arColors[1] = c2;
 	}
 
-	CBrushLinearGradient::CBrushLinearGradient( const RectF& rect, const CColor& c1, const CColor& c2, float angle, INT isAngleScalable ) 
+	CBrushLinearGradient::CBrushLinearGradient(const Point& p1, const Point& p2, const CColor& c1, const CColor& c2)
 		: CBrush(BrushTypeLinearGradient)
 	{
-		m_points[0].X = rect.GetLeft();
-		m_points[0].Y = rect.GetTop();
-		m_points[1].X = rect.GetRight();
-		m_points[1].Y = rect.GetBottom();
+		m_arPoints[0].X = static_cast<float>(p1.X);
+		m_arPoints[0].Y = static_cast<float>(p1.Y);
+		m_arPoints[1].X = static_cast<float>(p2.X);
+		m_arPoints[1].Y = static_cast<float>(p2.Y);
 
-		m_colors[0] = c1;
-		m_colors[1] = c2;
+		m_arColors[0] = c1;
+		m_arColors[1] = c2;
+	}
 
-		m_angle = angle;
-		
-		m_wrap = Aggplus::WrapModeTile;
+	CBrushLinearGradient::CBrushLinearGradient(const RectF& rect, const CColor& c1, const CColor& c2, float angle, bool isAngleScalable)
+		: CBrush(BrushTypeLinearGradient)
+	{
+		m_arPoints[0].X = rect.GetLeft();
+		m_arPoints[0].Y = rect.GetTop();
+		m_arPoints[1].X = rect.GetRight();
+		m_arPoints[1].Y = rect.GetBottom();
+
+		m_arColors[0] = c1;
+		m_arColors[1] = c2;
+
+		m_fAngle = angle;
 
 		m_bAngleScalable = isAngleScalable;
-		m_bRectable = TRUE;
-		m_bRelativeCoords = FALSE;
+		m_bRectable = true;
 	}
 
-	CBrushLinearGradient::CBrushLinearGradient( const Rect& rect, const CColor& c1, const CColor& c2, float angle, INT isAngleScalable ) 
+	CBrushLinearGradient::CBrushLinearGradient(const Rect& rect, const CColor& c1, const CColor& c2, float angle, bool isAngleScalable)
 		: CBrush(BrushTypeLinearGradient)
 	{
-		m_points[0].X = (float)rect.GetLeft();
-		m_points[0].Y = (float)rect.GetTop();
-		m_points[1].X = (float)rect.GetRight();
-		m_points[1].Y = (float)rect.GetBottom();
+		m_arPoints[0].X = static_cast<float>(rect.GetLeft());
+		m_arPoints[0].Y = static_cast<float>(rect.GetTop());
+		m_arPoints[1].X = static_cast<float>(rect.GetRight());
+		m_arPoints[1].Y = static_cast<float>(rect.GetBottom());
 
-		m_colors[0] = c1;
-		m_colors[1] = c2;
+		m_arColors[0] = c1;
+		m_arColors[1] = c2;
 
-		m_angle = angle;
-		
-		m_wrap = Aggplus::WrapModeTile;
+		m_fAngle = angle;
 
 		m_bAngleScalable = isAngleScalable;
-		m_bRectable = TRUE;
-		m_bRelativeCoords = FALSE;
+		m_bRectable = true;
 	}
 
-	CBrushLinearGradient::CBrushLinearGradient( const RectF& rect, const CColor& c1, const CColor& c2, Aggplus::LinearGradientMode mode ) 
+	CBrushLinearGradient::CBrushLinearGradient(const RectF& rect, const CColor& c1, const CColor& c2, Aggplus::LinearGradientMode mode)
 		: CBrush(BrushTypeLinearGradient)
 	{
-		m_points[0].X = rect.GetLeft();
-		m_points[0].Y = rect.GetTop();
-		m_points[1].X = rect.GetRight();
-		m_points[1].Y = rect.GetBottom();
+		m_arPoints[0].X = rect.GetLeft();
+		m_arPoints[0].Y = rect.GetTop();
+		m_arPoints[1].X = rect.GetRight();
+		m_arPoints[1].Y = rect.GetBottom();
 
 		switch( mode )
 		{
 		case LinearGradientModeHorizontal:
-			m_angle = 0;
+			m_fAngle = 0;
 			break;
-
 		case LinearGradientModeVertical:
-			m_angle = 90;
+			m_fAngle = 90;
 			break;
-
 		case LinearGradientModeForwardDiagonal:
-			m_angle = 45;
+			m_fAngle = 45;
 			break;
-
 		default:
-			m_angle = 315;
+			m_fAngle = 315;
 		}
 
-		m_colors[0] = c1;
-		m_colors[1] = c2;
+		m_arColors[0] = c1;
+		m_arColors[1] = c2;
 
-		m_wrap = Aggplus::WrapModeTile;
-
-		m_bAngleScalable = TRUE;
-		m_bRectable = TRUE;
-		m_bRelativeCoords = FALSE;
+		m_bAngleScalable = true;
+		m_bRectable = true;
 	}
 
-	CBrushLinearGradient::CBrushLinearGradient( const Rect& rect, const CColor& c1, const CColor& c2, Aggplus::LinearGradientMode mode ) 
+	CBrushLinearGradient::CBrushLinearGradient(const Rect& rect, const CColor& c1, const CColor& c2, Aggplus::LinearGradientMode mode)
 		: CBrush(BrushTypeLinearGradient)
 	{
-		m_points[0].X = (REAL)rect.GetLeft();
-		m_points[0].Y = (REAL)rect.GetTop();
-		m_points[1].X = (REAL)rect.GetRight();
-		m_points[1].Y = (REAL)rect.GetBottom();
+		m_arPoints[0].X = static_cast<float>(rect.GetLeft());
+		m_arPoints[0].Y = static_cast<float>(rect.GetTop());
+		m_arPoints[1].X = static_cast<float>(rect.GetRight());
+		m_arPoints[1].Y = static_cast<float>(rect.GetBottom());
 
 		switch( mode )
 		{
 		case LinearGradientModeHorizontal:
-			m_angle = 0;
+			m_fAngle = 0;
 			break;
-
 		case LinearGradientModeVertical:
-			m_angle = 90;
+			m_fAngle = 90;
 			break;
-
 		case LinearGradientModeForwardDiagonal:
-			m_angle = 45;
+			m_fAngle = 45;
 			break;
-
 		default:
-			m_angle = 315;
+			m_fAngle = 315;
 		}
 
-		m_colors[0] = c1;
-		m_colors[1] = c2;
+		m_arColors[0] = c1;
+		m_arColors[1] = c2;
 
-		m_wrap = Aggplus::WrapModeTile;
-
-		m_bAngleScalable = TRUE;
-		m_bRectable = TRUE;
-		m_bRelativeCoords = FALSE;
+		m_bAngleScalable = true;
+		m_bRectable = true;
 	}
 
-
-	CBrushLinearGradient::CBrushLinearGradient( const CBrushLinearGradient& out )
-		: CBrush(out.m_bType)
+	CBrushLinearGradient::CBrushLinearGradient(const CBrushLinearGradient& other)
+		: CBrush(other.m_bType)
 	{
-		m_colors[0] = out.m_colors[0];
-		m_colors[1] = out.m_colors[1];
-		m_points[0] = out.m_points[0];
-		m_points[1] = out.m_points[1];
-
-		m_subcolors = out.m_subcolors;
-
-		m_matrix = out.m_matrix;
-		m_angle = out.m_angle;
-
-		m_wrap = out.m_wrap;
-		m_bAngleScalable = out.m_bAngleScalable;
-		m_bRectable = out.m_bRectable;
-		m_bRelativeCoords = out.m_bRelativeCoords;
+		*this = other;
 	}
 
-	Status CBrushLinearGradient::GetLinearColors( CColor* colors ) const
+	CBrushLinearGradient::CBrushLinearGradient(CBrushLinearGradient&& other) noexcept
 	{
-		if( !colors )
+		*this = std::move(other);
+	}
+
+	CBrushLinearGradient::~CBrushLinearGradient()
+	{
+	}
+
+	Status CBrushLinearGradient::GetLinearColors(CColor* colors) const
+	{
+		if(!colors)
 			return InvalidParameter;
 
-		colors[0] = m_colors[0];
-		colors[1] = m_colors[1];
+		colors[0] = m_arColors[0];
+		colors[1] = m_arColors[1];
 
 		return Ok;
 	}
 
-	Status CBrushLinearGradient::GetRectangle( Rect *rect ) const
+	Status CBrushLinearGradient::GetRectangle(Rect *rect) const
 	{
-		if( !rect )
+		if(!rect)
 			return InvalidParameter;
 
-		rect->X = (int)( m_points[0].X );
-		rect->Y = (int)( m_points[0].Y );
-		rect->Width = (int)( m_points[1].X ) - rect->X;
-		rect->Height = (int)( m_points[1].Y ) - rect->Y;
+		rect->X		 = static_cast<int>((m_arPoints[0].X));
+		rect->Y 	 = static_cast<int>((m_arPoints[0].Y));
+		rect->Width  = static_cast<int>((m_arPoints[1].X) - rect->X);
+		rect->Height = static_cast<int>((m_arPoints[1].Y) - rect->Y);
+		return Ok;
+	}
+
+	Status CBrushLinearGradient::GetRectangle(RectF *rect) const
+	{
+		if(!rect)
+			return InvalidParameter;
+
+		rect->X 	 = m_arPoints[0].X;
+		rect->Y 	 = m_arPoints[0].Y;
+		rect->Width  = m_arPoints[1].X - rect->X;
+		rect->Height = m_arPoints[1].Y - rect->Y;
 
 		return Ok;
 	}
 
-	Status CBrushLinearGradient::GetRectangle( RectF *rect ) const
+	Status CBrushLinearGradient::GetTransform(CMatrix* matrix) const
 	{
-		if( !rect )
+		if(!matrix)
 			return InvalidParameter;
 
-		rect->X = m_points[0].X;
-		rect->Y = m_points[0].Y;
-		rect->Width = m_points[1].X - rect->X;
-		rect->Height = m_points[1].Y - rect->Y;
+		*matrix = m_Matrix;
 
 		return Ok;
 	}
 
-	Status CBrushLinearGradient::GetTransform( CMatrix* matrix ) const
+	Status CBrushLinearGradient::MultiplyTransform(const CMatrix *matrix, MatrixOrder order)
 	{
 		if( !matrix )
 			return InvalidParameter;
 
-		*matrix = m_matrix;
-
-		return Ok;
-	}
-
-	Status CBrushLinearGradient::MultiplyTransform( const CMatrix *matrix, MatrixOrder order)
-	{
-		if( !matrix )
-			return InvalidParameter;
-
-		m_matrix.Multiply( matrix, order );
+		m_Matrix.Multiply(matrix, order);
 
 		return Ok;
 	}
 
 	Status CBrushLinearGradient::ResetTransform()
 	{
-		m_matrix.Reset();
+		m_Matrix.Reset();
 
 		return Ok;
 	}
 
-	Status CBrushLinearGradient::RotateTransform( REAL angle, MatrixOrder order )
+	Status CBrushLinearGradient::RotateTransform(float angle, MatrixOrder order)
 	{
-		m_matrix.Rotate( angle, order );
+		m_Matrix.Rotate(angle, order);
 
 		return Ok;
 	}
 
-	Status CBrushLinearGradient::ScaleTransform( REAL sx, REAL sy, MatrixOrder order )
+	Status CBrushLinearGradient::ScaleTransform(float sx, float sy, MatrixOrder order)
 	{
-		m_matrix.Scale( sx, sy, order );
+		m_Matrix.Scale(sx, sy, order);
 
 		return Ok;
 	}
 
-	void CBrushLinearGradient::SetWrapMode( WrapMode mode )
+	void CBrushLinearGradient::SetWrapMode(WrapMode mode)
 	{
-		m_wrap = mode;
+		m_eWrap = mode;
 	}
 
 	WrapMode CBrushLinearGradient::GetWrapMode() const
 	{
-		return m_wrap;
+		return m_eWrap;
 	}
 
-	CBrush* CBrushLinearGradient::Clone() const
+	Status CBrushLinearGradient::SetInterpolationColors(const CColor *presetColors, const float *blendPositions, int count)
 	{
-		return new CBrushLinearGradient( *this ); 
-	}
+		m_arSubColors.clear();
 
-	Status CBrushLinearGradient::SetInterpolationColors( const CColor *presetColors, const REAL *blendPositions, INT count )
-	{
-        m_subcolors.clear();
-
-		if( count > 0 && presetColors && blendPositions )
+		if(count > 0 && presetColors && blendPositions)
 		{
-            m_subcolors.resize( count );
+			m_arSubColors.resize(count);
 
-			for( int i = 0; i < count; i++ )
+			for(int i = 0; i < count; i++)
 			{
-				m_subcolors[i].color = presetColors[i];
-				m_subcolors[i].position = blendPositions[i];
+				m_arSubColors[i].color = presetColors[i];
+				m_arSubColors[i].position = blendPositions[i];
 			}
 		}
 
 		return Ok;
 	}
 
-	Status CBrushLinearGradient::GetInterpolationColors( CColor *presetColors, REAL *blendPositions, INT count ) const
+	Status CBrushLinearGradient::GetInterpolationColors(CColor *presetColors, float *blendPositions, int count) const
 	{
-        if( count > 0 && count <= (INT)m_subcolors.size() && presetColors && blendPositions )
+		if( count > 0 && count <= (int)m_arSubColors.size() && presetColors && blendPositions )
 		{
 			for( int i = 0; i < count; i++ )
 			{
-				presetColors[i] = m_subcolors[i].color;
-				blendPositions[i] = m_subcolors[i].position;
+				presetColors[i] = m_arSubColors[i].color;
+				blendPositions[i] = m_arSubColors[i].position;
 			}
 		}
 
 		return Ok;
 	}
 
-	INT CBrushLinearGradient::GetInterpolationColorsCount() const
+	int CBrushLinearGradient::GetInterpolationColorsCount() const
 	{
-        return (INT)m_subcolors.size();
+		return static_cast<int>(m_arSubColors.size());
 	}
 
-	// additional methods
-	void CBrushLinearGradient::GetSubColor( int nIndex, CColor* pColor, float* pPosition ) const
+	void CBrushLinearGradient::GetSubColor(int index, CColor* color, float* position) const
 	{
-		*pColor = m_subcolors[nIndex].color;
-		*pPosition = m_subcolors[nIndex].position;
+		*color = m_arSubColors[index].color;
+		*position = m_arSubColors[index].position;
 	}
-	
-	void CBrushLinearGradient::SetRelativeCoords( INT bRelative )
+
+	void CBrushLinearGradient::SetRelativeCoords(bool relative)
 	{
-		m_bRelativeCoords = bRelative;
+		m_bRelativeCoords = relative;
 	}
-	INT CBrushLinearGradient::IsRelativeCoords() const
+
+	bool CBrushLinearGradient::IsRelativeCoords() const
 	{
 		return m_bRelativeCoords;
 	}
 
-	INT CBrushLinearGradient::IsAngleScalable() const
+	bool CBrushLinearGradient::IsAngleScalable() const
 	{
 		return m_bAngleScalable;
 	}
-	INT CBrushLinearGradient::IsRectable() const
+
+	bool CBrushLinearGradient::IsRectable() const
 	{
 		return m_bRectable;
 	}
+
 	float CBrushLinearGradient::GetAngle() const
 	{
-		return m_angle;
+		return m_fAngle;
 	}
 
-	////////////////////////////////////////////////////////////////////////////////
-
-	CBrushTexture::CBrushTexture() : CBrush(BrushTypeTextureFill)											
+	void CBrushLinearGradient::SetBounds(const CDoubleRect& rect)
 	{
-		m_pImage = NULL;
-		m_bReleaseImage = FALSE;
-		Alpha = 255;
-        m_bUseBounds = false;
+		m_oBounds = rect;
 	}
 
-	CBrushTexture::CBrushTexture(const std::wstring& strName, WrapMode wrapMode) : CBrush(BrushTypeTextureFill), m_wrapMode(wrapMode)
+	CDoubleRect& CBrushLinearGradient::GetBounds()
 	{
-		m_pImage = new CImage(strName);
-		m_bReleaseImage = TRUE;
-		Alpha = 255;
-        m_bUseBounds = false;
+		return m_oBounds;
 	}
 
-	CBrushTexture::CBrushTexture(CImage *pImage, WrapMode wrapMode) : CBrush(BrushTypeTextureFill), m_wrapMode(wrapMode)
+	CBrushLinearGradient& CBrushLinearGradient::operator=(const CBrushLinearGradient& other)
 	{
-		m_pImage = pImage;
-		m_bReleaseImage = FALSE;
-		Alpha = 255;
-        m_bUseBounds = false;
+		if (this == &other)
+			return *this;
+
+		m_arColors[0] = other.m_arColors[0];
+		m_arColors[1] = other.m_arColors[1];
+		m_arPoints[0] = other.m_arPoints[0];
+		m_arPoints[1] = other.m_arPoints[1];
+
+		m_arSubColors = other.m_arSubColors;
+
+		m_Matrix = other.m_Matrix;
+		m_fAngle = other.m_fAngle;
+
+		m_eWrap = other.m_eWrap;
+
+		m_bAngleScalable = other.m_bAngleScalable;
+		m_bRectable = other.m_bRectable;
+		m_bRelativeCoords = other.m_bRelativeCoords;
+
+		return *this;
 	}
-	
-	CBrushTexture::~CBrushTexture() 
+
+	CBrushLinearGradient& CBrushLinearGradient::operator=(CBrushLinearGradient&& other) noexcept
+	{
+		if (this == &other)
+			return *this;
+
+		m_arColors[0] = other.m_arColors[0];
+		m_arColors[1] = other.m_arColors[1];
+		m_arPoints[0] = other.m_arPoints[0];
+		m_arPoints[1] = other.m_arPoints[1];
+
+		m_arSubColors = other.m_arSubColors;
+
+		m_Matrix = std::move(other.m_Matrix);
+
+		m_eWrap = other.m_eWrap;
+
+		m_bAngleScalable = other.m_bAngleScalable;
+		m_bRectable = other.m_bRectable;
+		m_bRelativeCoords = other.m_bRelativeCoords;
+
+		return *this;
+	}
+
+	CBrushTexture::CBrushTexture()
+		: CBrush(BrushTypeTextureFill)
+	{
+	}
+
+	CBrushTexture::CBrushTexture(const std::wstring& name, WrapMode mode)
+		: CBrush(BrushTypeTextureFill),
+		m_eWrapMode(mode)
+	{
+		m_pImage = new CImage(name);
+		m_bReleaseImage = true;
+	}
+
+	CBrushTexture::CBrushTexture(CImage *image, WrapMode mode)
+		: CBrush(BrushTypeTextureFill),
+		m_eWrapMode(mode)
+	{
+		m_pImage = image;
+	}
+
+	CBrushTexture::CBrushTexture(const CBrushTexture& other)
+	{
+		*this = other;
+	}
+
+	CBrushTexture::CBrushTexture(CBrushTexture&& other)
+	{
+		*this = std::move(other);
+	}
+
+	CBrushTexture::~CBrushTexture()
 	{
 		if (m_bReleaseImage)
-		{
 			RELEASEOBJECT(m_pImage);
-		}
 	}
-	
-	CBrush* CBrushTexture::Clone() const
+
+	void CBrushTexture::TranslateTransform(double x, double y, MatrixOrder order)
 	{
-		CBrushTexture *pRet = new CBrushTexture(m_pImage, m_wrapMode);
-		if( pRet )
-		{
-			pRet->m_mtx = m_mtx;
-		}
-
-		return pRet;
+		m_Matrix.Translate(x, y, order);
 	}
 
-	void CBrushTexture::TranslateTransform(double dX, double dY, MatrixOrder order) 
-	{ 
-		m_mtx.Translate(dX, dY, order); 
-	}
-	void CBrushTexture::ScaleTransform(double dX, double dY, MatrixOrder order) 
-	{ 
-		m_mtx.Scale(dX, dY, order); 
-	}
-	void CBrushTexture::RotateTransform(double angle, MatrixOrder order) 
-	{ 
-		m_mtx.Rotate(angle, order); 
-	}
-	void CBrushTexture::GetTransform(CMatrix* matrix) const 
-	{ 
-		*matrix = m_mtx; 
-	}
-	void CBrushTexture::SetTransform(const CMatrix* matrix) 
-	{ 
-		m_mtx = *matrix;
+	void CBrushTexture::ScaleTransform(double x, double y, MatrixOrder order)
+	{
+		m_Matrix.Scale(x, y, order);
 	}
 
-	void CBrushTexture::SetWrapMode(WrapMode wMode) 
-	{ 
-		m_wrapMode = wMode; 
+	void CBrushTexture::RotateTransform(double angle, MatrixOrder order)
+	{
+		m_Matrix.Rotate(angle, order);
 	}
-	WrapMode CBrushTexture::GetWrapMode() const 
-	{ 
-		return(m_wrapMode); 
+
+	void CBrushTexture::GetTransform(CMatrix* matrix) const
+	{
+		*matrix = m_Matrix;
+	}
+
+	void CBrushTexture::SetTransform(const CMatrix* matrix)
+	{
+		m_Matrix = *matrix;
+	}
+
+	void CBrushTexture::SetWrapMode(WrapMode mode)
+	{
+		m_eWrapMode = mode;
+	}
+
+	WrapMode CBrushTexture::GetWrapMode() const
+	{
+		return m_eWrapMode;
+	}
+
+	void CBrushTexture::SetBounds(const CDoubleRect& rect)
+	{
+		m_bUseBounds = true;
+		m_oBounds = rect;
+	}
+
+	CDoubleRect& CBrushTexture::GetBounds()
+	{
+		return m_oBounds;
+	}
+
+	void CBrushTexture::SetReleaseImage(bool isReleaseImage)
+	{
+		m_bReleaseImage = isReleaseImage;
+	}
+
+	bool CBrushTexture::IsReleaseImage() const
+	{
+		return m_bReleaseImage;
+	}
+
+	void CBrushTexture::SetAlpha(BYTE alpha)
+	{
+		m_Alpha = alpha;
+	}
+
+	BYTE CBrushTexture::GetAlpha() const
+	{
+		return m_Alpha;
 	}
 
 	void* CBrushTexture::GetData()
 	{
 		return m_pImage->m_pImgData;
 	}
+
 	void* CBrushTexture::PatternFinalize()
-	{	
+	{
 		if (m_pImage->m_nStride < 0)
 			return m_pImage->m_pImgData - ((m_pImage->m_dwHeight - 1) * m_pImage->m_nStride);
 		return m_pImage->m_pImgData;
 	}
+
 	DWORD CBrushTexture::PatternGetWidth()
-	{	
+	{
 		return m_pImage->m_dwWidth;
 	}
+
 	DWORD CBrushTexture::PatternGetHeight()
-	{	
+	{
 		return m_pImage->m_dwHeight;
 	}
+
 	int CBrushTexture::PatternGetStride()
-	{	
+	{
 		return m_pImage->m_nStride;
 	}
+
+	CBrushTexture& CBrushTexture::operator=(const CBrushTexture& other)
+	{
+		if (this == &other)
+			return *this;
+
+		m_pImage = new CImage(*other.m_pImage);
+
+		m_Matrix = other.m_Matrix;
+
+		m_eWrapMode = other.m_eWrapMode;
+
+		return *this;
+	}
+
+	CBrushTexture& CBrushTexture::operator=(CBrushTexture&& other)
+	{
+		if (this == &other)
+			return *this;
+
+		m_pImage = std::move(other.m_pImage);
+
+		m_Matrix = std::move(other.m_Matrix);
+
+		m_eWrapMode = other.m_eWrapMode;
+
+		return *this;
+	}
 }

DesktopEditor/graphics/Brush.h

@@ -43,170 +43,256 @@
 
 namespace Aggplus
 {
-class CBrush
-{
-	friend class CGraphics;
-
-protected:
-
-	CBrush(BrushType bType);
-	 
-public:
-	virtual ~CBrush();
-
-	virtual CBrush* Clone() const = 0;
-	BrushType GetType() const;
-
-public:
-	BrushType m_bType;
-};
-
-class CBrushSolid : public CBrush
-{
-public:
-	CBrushSolid(CColor dwColor);
-	virtual ~CBrushSolid();
-	virtual CBrush *Clone() const;
-
-	void GetColor(CColor* color) const;
-	void SetColor(const CColor &color);
-	
-protected:
-	CColor m_dwColor;
-};
-
-class CBrushHatch : public CBrush
-{
-public:
-	CBrushHatch();
-	virtual ~CBrushHatch();
-	virtual CBrush *Clone() const;
-
-	inline CDoubleRect& GetBounds() { return Bounds; }
-
-		
-public:
-	std::wstring	m_name;
-	CColor			m_dwColor1;
-	CColor			m_dwColor2;
-
-	CDoubleRect		Bounds;
-};
-
-
-class CBrushLinearGradient : public CBrush
-{
-	friend class CGraphics;
-
-public:
-	CBrushLinearGradient( const PointF& p1, const PointF& p2, const CColor& c1, const CColor& c2 );
-	CBrushLinearGradient( const Point& p1, const Point& p2, const CColor& c1, const CColor& c2 );
-	CBrushLinearGradient( const RectF& rect, const CColor& c1, const CColor& c2, float angle, INT isAngleScalable );
-	CBrushLinearGradient( const Rect& rect, const CColor& c1, const CColor& c2, float angle, INT isAngleScalable );
-	CBrushLinearGradient( const RectF& rect, const CColor& c1, const CColor& c2, Aggplus::LinearGradientMode mode );
-	CBrushLinearGradient( const Rect& rect, const CColor& c1, const CColor& c2, Aggplus::LinearGradientMode mode );
-	CBrushLinearGradient( const CBrushLinearGradient& out );
-
-	Status GetLinearColors( CColor* colors ) const;
-	Status GetRectangle( Rect *rect ) const;
-	Status GetRectangle( RectF *rect ) const;
-
-	Status GetTransform( CMatrix* matrix ) const;
-	Status MultiplyTransform( const CMatrix *matrix, MatrixOrder order = MatrixOrderPrepend);
-	Status ResetTransform();
-	Status RotateTransform( REAL angle, MatrixOrder order = MatrixOrderPrepend );
-	Status ScaleTransform( REAL sx, REAL sy, MatrixOrder order = MatrixOrderPrepend );
-
-	void SetWrapMode( WrapMode mode );
-	WrapMode GetWrapMode() const;
-
-	virtual CBrush *Clone() const;
-
-	Status SetInterpolationColors( const CColor *presetColors, const REAL *blendPositions, INT count );
-	Status GetInterpolationColors( CColor *presetColors, REAL *blendPositions, INT count ) const;
-	INT GetInterpolationColorsCount() const;
-
-	// additional methods
-	void GetSubColor( int nIndex, CColor* pColor, float* pPosition ) const;
-	
-	void SetRelativeCoords( INT bRelative );
-	INT IsRelativeCoords() const;
-	INT IsAngleScalable() const;
-	INT IsRectable() const;
-	float GetAngle() const;
-	inline void SetBounds(const CDoubleRect& oRect) { Bounds = oRect; }
-	inline CDoubleRect& GetBounds() { return Bounds; }
-
-    // info about gradient
-    NSStructures::GradientInfo m_oGradientInfo; // used in 60xx grad types
-protected:
-	CColor m_colors[2];
-	PointF m_points[2];
-
-	struct TSubColor
+	/**
+	 * @abstract CBrush
+	 *
+	 * Base class for brushes (by default a solid brush
+	 * is created).
+	 */
+	class CBrush
 	{
-		CColor color;
-		float position;
+		friend class CGraphics;
+
+	protected:
+		CBrush();
+		CBrush(const BrushType& type);
+
+	public:
+		virtual ~CBrush();
+
+		BrushType GetType() const;
+
+	public:
+		BrushType m_bType = BrushTypeSolidColor;
 	};
-	
-    std::vector<TSubColor> m_subcolors;
 
-	CMatrix m_matrix;
-	float m_angle; // угол поворота в градусах базовой линии p1 -> p2
+	/**
+	 * @class CBrushSolid
+	 *
+	 * A single-color brush used to draw text, graphic paths,
+	 * and fills with a single color.
+	 */
+	class CBrushSolid : public CBrush
+	{
+	public:
+		CBrushSolid();
+		CBrushSolid(CColor color);
+		virtual ~CBrushSolid();
+		CBrushSolid(const CBrushSolid& other);
 
-	CDoubleRect Bounds;
+		void GetColor(CColor* color) const;
+		void SetColor(const CColor &color);
 
-	Aggplus::WrapMode m_wrap;
+		CBrushSolid& operator=(const CBrushSolid& other);
+	protected:
+		CColor m_dwColor{};
+	};
 
-	INT m_bAngleScalable; // масштабировать угол поворота относительно заданных точек b = arctan( width / height * tan(angle) );
-	INT m_bRectable; // в качестве направляющей используется диагональ прямоугольника
-	INT m_bRelativeCoords; // координаты точек считаются относительно рисуемого примитива
-};
+	/**
+	 * @class CBrushHatch
+	 *
+	 * A two-color brush used to fill graphic paths using
+	 * one of the hatch patterns
+	 */
+	class CBrushHatch : public CBrush
+	{
+	public:
+		CBrushHatch();
+		CBrushHatch(const CBrushHatch& other);
+		CBrushHatch(CBrushHatch&& other) noexcept;
+		virtual ~CBrushHatch();
 
-class CBrushTexture : public CBrush
-{
-	friend class CGraphics;
-	
-protected:
-	CBrushTexture();
+		void SetName(const std::wstring& name);
+		std::wstring GetName() const;
 
-public:
-	CBrushTexture(const std::wstring& strName, WrapMode wrapMode = WrapModeTile);
-	CBrushTexture(CImage *pImage, WrapMode wrapMode = WrapModeTile);
-	virtual ~CBrushTexture();
-	virtual CBrush* Clone() const;
+		void SetColor1(const CColor& color);
+		CColor GetColor1() const;
+		void SetColor2(const CColor& color);
+		CColor GetColor2() const;
 
-	void TranslateTransform(double dX, double dY, MatrixOrder order = MatrixOrderPrepend);
-	void ScaleTransform(double dX, double dY, MatrixOrder order = MatrixOrderPrepend);
-	void RotateTransform(double angle, MatrixOrder order = MatrixOrderPrepend);
-	void GetTransform(CMatrix* matrix) const;
-	void SetTransform(const CMatrix* matrix);
+		void SetBounds(const CDoubleRect& rect);
+		CDoubleRect& GetBounds();
 
-	void SetWrapMode(WrapMode wMode);
-	WrapMode GetWrapMode() const;
-	 
-public:
+		CBrushHatch& operator=(const CBrushHatch& other);
+		CBrushHatch& operator=(CBrushHatch&& other) noexcept;
+	protected:
+		/**
+		 * @brief m_wsName - hatch brush pattern name
+		 *   (as default - cross)
+		 *
+		 * See all patterns in agg_span_hatch.h, array -
+		 * c_resource_hatches_names.
+		 */
+		std::wstring	m_wsName;
+		CColor			m_dwColor1{};
+		CColor			m_dwColor2{};
 
-	void* GetData();
-	void* PatternFinalize();
-	DWORD PatternGetWidth();
-	DWORD PatternGetHeight();
-	int PatternGetStride();
-		
-public:
-	CImage* m_pImage;
-	INT m_bReleaseImage;
-	
-	WrapMode m_wrapMode;
-	CMatrix m_mtx;
+		CDoubleRect		m_oBounds{};
+	};
 
-	CColor m_colors[2];
+	/**
+	 * @class CBrushLinearGradient
+	 *
+	 * brush for drawing gradients, stores information about the gradient.
+	 * According to the pdf documentation, it stores the start and end point
+	 * and color, as well as the linear interpolation of the colors.
+	 */
+	class CBrushLinearGradient : public CBrush
+	{
+		friend class CGraphics;
 
-	bool m_bUseBounds;
-	CDoubleRect m_oBounds;
+	public:
+		CBrushLinearGradient();
+		CBrushLinearGradient(const PointF& p1, const PointF& p2, const CColor& c1, const CColor& c2);
+		CBrushLinearGradient(const Point& p1, const Point& p2, const CColor& c1, const CColor& c2);
+		CBrushLinearGradient(const RectF& rect, const CColor& c1, const CColor& c2, float angle, bool isAngleScalable);
+		CBrushLinearGradient(const Rect& rect, const CColor& c1, const CColor& c2, float angle, bool isAngleScalable);
+		CBrushLinearGradient(const RectF& rect, const CColor& c1, const CColor& c2, Aggplus::LinearGradientMode mode);
+		CBrushLinearGradient(const Rect& rect, const CColor& c1, const CColor& c2, Aggplus::LinearGradientMode mode);
+		CBrushLinearGradient(const CBrushLinearGradient& other);
+		CBrushLinearGradient(CBrushLinearGradient&& other) noexcept;
+		virtual ~CBrushLinearGradient();
 
-	BYTE Alpha;
-};
+		Status GetLinearColors(CColor* colors) const;
+		Status GetRectangle(Rect *rect) const;
+		Status GetRectangle(RectF *rect) const;
+
+		Status GetTransform(CMatrix* matrix) const;
+		Status MultiplyTransform(const CMatrix *matrix, MatrixOrder order = MatrixOrderPrepend);
+		Status ResetTransform();
+		Status RotateTransform(float angle, MatrixOrder order = MatrixOrderPrepend );
+		Status ScaleTransform(float sx, float sy, MatrixOrder order = MatrixOrderPrepend );
+
+		void SetWrapMode(WrapMode mode);
+		WrapMode GetWrapMode() const;
+
+		Status SetInterpolationColors(const CColor *presetColors, const float *blendPositions, int count);
+		Status GetInterpolationColors(CColor *presetColors, float *blendPositions, int count) const;
+		int GetInterpolationColorsCount() const;
+
+		void GetSubColor(int index, CColor* color, float* position) const;
+
+		void SetRelativeCoords(bool relative);
+		bool IsRelativeCoords() const;
+		bool IsAngleScalable() const;
+		bool IsRectable() const;
+		float GetAngle() const;
+
+		void SetBounds(const CDoubleRect& rect);
+		CDoubleRect& GetBounds();
+
+		CBrushLinearGradient& operator=(const CBrushLinearGradient& other);
+		CBrushLinearGradient& operator=(CBrushLinearGradient&& other) noexcept;
+
+		NSStructures::GradientInfo m_oGradientInfo{};
+	protected:
+		CColor m_arColors[2];
+		PointF m_arPoints[2];
+
+		struct TSubColor
+		{
+			CColor color{};
+			float position = 0;
+		};
+
+		std::vector<TSubColor> m_arSubColors;
+
+		CMatrix m_Matrix{};
+
+		/**
+		 * @brief m_angle - rotation angle of line p1 - p2 (measured in degrees)
+		 */
+		float m_fAngle = 0;
+
+		CDoubleRect m_oBounds{};
+
+		/**
+		 * @brief m_eWrapMode - Used to determine the rotation of the image tiles
+		 *   (by default, we do not change the position).
+		 */
+		WrapMode m_eWrap = Aggplus::WrapModeTile;
+
+		/**
+		 * @brief m_bAngleScalable - whether to scale the rotation angle relative
+		 *   to the given points
+		 *
+		 * calculated like this b = arctan(width / height * tan(angle));
+		 */
+		bool m_bAngleScalable = false;
+
+		/**
+		 * @brief m_bRectable - is the diagonal of a rectangle a guide
+		 */
+		bool m_bRectable = false;
+
+		/**
+		 * @brief m_bRelativeCoords - are the coordinates of the points calculated
+		 *   relative to the resulting primitive
+		 */
+		bool m_bRelativeCoords = false;
+	};
+
+	/**
+	 * @class CBrushTexture
+	 *
+	 * A texture brush that is used to draw images on the renderer.
+	 */
+	class CBrushTexture : public CBrush
+	{
+		friend class CGraphics;
+
+	public:
+		CBrushTexture();
+		CBrushTexture(const std::wstring& name, WrapMode mode = WrapModeTile);
+		CBrushTexture(CImage *image, WrapMode mode = WrapModeTile);
+		CBrushTexture(const CBrushTexture& other);
+		CBrushTexture(CBrushTexture&& other);
+		virtual ~CBrushTexture();
+
+		void TranslateTransform(double x, double y, MatrixOrder order = MatrixOrderPrepend);
+		void ScaleTransform(double x, double y, MatrixOrder order = MatrixOrderPrepend);
+		void RotateTransform(double angle, MatrixOrder order = MatrixOrderPrepend);
+		void GetTransform(CMatrix* matrix) const;
+		void SetTransform(const CMatrix* matrix);
+
+		void SetWrapMode(WrapMode mode);
+		WrapMode GetWrapMode() const;
+
+		void SetBounds(const CDoubleRect& rect);
+		CDoubleRect& GetBounds();
+
+		void SetReleaseImage(bool isReleaseImage);
+		bool IsReleaseImage() const;
+
+		void SetAlpha(BYTE alpha);
+		BYTE GetAlpha() const;
+
+		void* GetData();
+		void* PatternFinalize();
+		DWORD PatternGetWidth();
+		DWORD PatternGetHeight();
+		int PatternGetStride();
+
+		CBrushTexture& operator=(const CBrushTexture& other);
+		CBrushTexture& operator=(CBrushTexture&& other);
+
+	protected:
+		CImage* m_pImage{nullptr};
+		bool m_bReleaseImage = false;
+
+		/**
+		 * @brief m_eWrapMode - Used to determine the rotation of the image tiles
+		 *   (by default, we do not change the position).
+		 */
+		WrapMode m_eWrapMode = WrapModeTile;
+
+		CMatrix m_Matrix{};
+
+		bool m_bUseBounds = false;
+		CDoubleRect m_oBounds{};
+
+		BYTE m_Alpha = 255;
+	};
 }
 
 #endif // _BUILD_BRUSH_H_

DesktopEditor/graphics/Graphics.cpp

@@ -832,7 +832,8 @@ namespace Aggplus
 				b = ptxBrush->m_oBounds.bottom;
 			}
 
-			CMatrix brushMatrix(ptxBrush->m_mtx);
+			CMatrix brushMatrix;
+			ptxBrush->GetTransform(&brushMatrix);
 			if (ptxBrush->GetWrapMode() == Aggplus::WrapModeClamp)
 			{
 				double dScaleX = (r - x) / dwPatternWidth;
@@ -1652,11 +1653,11 @@ namespace Aggplus
 			m_rasterizer.gamma(1.0);
 		}
 #else
-		agg::rgba8 c1 = agg::rgba8(pBrush->m_dwColor1.GetR(), pBrush->m_dwColor1.GetG(), pBrush->m_dwColor1.GetB(), pBrush->m_dwColor1.GetA());
-		agg::rgba8 c2 = agg::rgba8(pBrush->m_dwColor2.GetR(), pBrush->m_dwColor2.GetG(), pBrush->m_dwColor2.GetB(), pBrush->m_dwColor2.GetA());
+		agg::rgba8 c1 = agg::rgba8(pBrush->GetColor1().GetR(), pBrush->GetColor1().GetG(), pBrush->GetColor1().GetB(), pBrush->GetColor1().GetA());
+		agg::rgba8 c2 = agg::rgba8(pBrush->GetColor2().GetR(), pBrush->GetColor2().GetG(), pBrush->GetColor2().GetB(), pBrush->GetColor2().GetA());
 
 		BYTE* pPattern = new BYTE[HATCH_TX_SIZE * HATCH_TX_SIZE * 4];
-		agg::GetHatchPattern(pBrush->m_name, (agg::rgba8*)pPattern, c1, c2);
+		agg::GetHatchPattern(pBrush->GetName(), (agg::rgba8*)pPattern, c1, c2);
 
 		agg::trans_affine mtx_Work(m_oTransform.m_internal->m_agg_mtx);
 		if (m_dDpiTile > 1)
@@ -2049,22 +2050,22 @@ namespace Aggplus
 
 				if(pImgBuff && dwImgWidth && dwImgHeight)
 				{
-					Aggplus::WrapMode wrapmode = ptxBrush->m_wrapMode;
-					Aggplus::CMatrix matrix = ptxBrush->m_mtx;
+					Aggplus::WrapMode wrapmode = ptxBrush->m_eWrapMode;
+					Aggplus::CMatrix matrix = ptxBrush->m_Matrix;
 
 					if(wrapmode == WrapModeClamp)
 					{
-						DoFillPathTextureClampSz2( matrix, pImgBuff, dwImgWidth, dwImgHeight, nImgStride, ptxBrush->Alpha);
+						DoFillPathTextureClampSz2( matrix, pImgBuff, dwImgWidth, dwImgHeight, nImgStride, ptxBrush->m_Alpha);
 					}
 					else
 					{
 						if (!m_bSwapRGB)
 						{
-							DoFillPathTextureClampSz3<agg::pixfmt_bgra32>(matrix, pImgBuff, dwImgWidth, dwImgHeight, nImgStride, wrapmode, ptxBrush->Alpha);
+							DoFillPathTextureClampSz3<agg::pixfmt_bgra32>(matrix, pImgBuff, dwImgWidth, dwImgHeight, nImgStride, wrapmode, ptxBrush->m_Alpha);
 						}
 						else
 						{
-							DoFillPathTextureClampSz3<agg::pixfmt_rgba32>(matrix, pImgBuff, dwImgWidth, dwImgHeight, nImgStride, wrapmode, ptxBrush->Alpha);
+							DoFillPathTextureClampSz3<agg::pixfmt_rgba32>(matrix, pImgBuff, dwImgWidth, dwImgHeight, nImgStride, wrapmode, ptxBrush->m_Alpha);
 						}
 					}
 				}

DesktopEditor/graphics/GraphicsPath.cpp

@@ -48,7 +48,7 @@ namespace Aggplus
 
 	CGraphicsPath::CGraphicsPath(CGraphicsPath&& other) noexcept
 	{
-		*this = other;
+		*this = std::move(other);
 	}
 
 	CGraphicsPath::CGraphicsPath(const std::vector<CGraphicsPath>& paths) noexcept : CGraphicsPath()

DesktopEditor/graphics/GraphicsRenderer.cpp

@@ -94,7 +94,7 @@ Aggplus::CBrush* CGraphicsRenderer::CreateBrush(NSStructures::CBrush* pBrush)
         Aggplus::CColor o1((BYTE)(pBrush->Alpha1 * m_dGlobalAlpha), pBrush->Color1, bIsSwappedRGB);
         Aggplus::CColor o2((BYTE)(pBrush->Alpha2 * m_dGlobalAlpha), pBrush->Color2, bIsSwappedRGB);
 
-		Aggplus::CBrushLinearGradient* pNew = new Aggplus::CBrushLinearGradient( Aggplus::RectF(0.0f, 0.0f, 1.0f, 1.0f), o1, o2, (float)pBrush->LinearAngle, TRUE );
+		Aggplus::CBrushLinearGradient* pNew = new Aggplus::CBrushLinearGradient(Aggplus::RectF(0.0f, 0.0f, 1.0f, 1.0f), o1, o2, (float)pBrush->LinearAngle, true);
 		if( pNew )
 		{
 			pNew->SetRelativeCoords( TRUE );
@@ -180,11 +180,11 @@ Aggplus::CBrush* CGraphicsRenderer::CreateBrush(NSStructures::CBrush* pBrush)
         Aggplus::CColor o2((BYTE)(pBrush->Alpha2 * m_dGlobalAlpha), pBrush->Color2, bIsSwappedRGB);
 
 		Aggplus::CBrushHatch* pNew = new Aggplus::CBrushHatch();
-		pNew->m_dwColor1	= o1;
-		pNew->m_dwColor2	= o2;
-		pNew->m_name		= pBrush->TexturePath;
+		pNew->SetColor1(o1);
+		pNew->SetColor2(o2);
+		pNew->SetName(pBrush->TexturePath);
 
-		pNew->Bounds		= pBrush->Bounds;
+		pNew->SetBounds(pBrush->Bounds);
 
 		return pNew;
 	}
@@ -996,7 +996,7 @@ HRESULT CGraphicsRenderer::DrawPath(const LONG& nType)
 						pImage->Create(oFrame.get_Data(), oFrame.get_Width(), oFrame.get_Height(), oFrame.get_Stride());
 						oFrame.ClearNoAttack();
 						pTextureBrush = new Aggplus::CBrushTexture(pImage, oMode);
-						pTextureBrush->m_bReleaseImage = TRUE;
+						pTextureBrush->SetReleaseImage(true);
 					}
 					else
 						RELEASEARRAYOBJECTS(pImageData);
@@ -1018,15 +1018,14 @@ HRESULT CGraphicsRenderer::DrawPath(const LONG& nType)
 				{
 					pTextureBrush->SetTransform(&m_oBrush.Transform);
 
-					pTextureBrush->Alpha = (BYTE)m_oBrush.TextureAlpha;
+					pTextureBrush->SetAlpha(static_cast<BYTE>(m_oBrush.TextureAlpha));
 
                     if (m_oBrush.Rectable == 1)
                     {
-                        pTextureBrush->m_bUseBounds = true;
-                        pTextureBrush->m_oBounds.left = m_oBrush.Rect.X;
-                        pTextureBrush->m_oBounds.top = m_oBrush.Rect.Y;
-                        pTextureBrush->m_oBounds.right = pTextureBrush->m_oBounds.left + m_oBrush.Rect.Width;
-                        pTextureBrush->m_oBounds.bottom = pTextureBrush->m_oBounds.top + m_oBrush.Rect.Height;
+						pTextureBrush->SetBounds({m_oBrush.Rect.X,
+												  m_oBrush.Rect.Y,
+												  m_oBrush.Rect.X + m_oBrush.Rect.Width,
+												  m_oBrush.Rect.Y + m_oBrush.Rect.Height});
                     }
 				}
 

DesktopEditor/graphics/Image.cpp

@@ -51,6 +51,16 @@ namespace Aggplus
 		Create(filename);		
 	}
 
+	CImage::CImage(const CImage& other)
+	{
+		*this = other;
+	}
+
+	CImage::CImage(CImage&& other)
+	{
+		*this = std::move(other);
+	}
+
 	CImage::~CImage()
 	{
 		Destroy();
@@ -136,6 +146,46 @@ namespace Aggplus
 		m_bExternalBuffer = false;
 	}
 
+	CImage& CImage::operator=(const CImage& other)
+	{
+		if (this == &other)
+			return *this;
+
+		m_Status = other.m_Status;
+
+		m_dwHeight = other.m_dwHeight;
+		m_dwWidth = other.m_dwWidth;
+		m_nStride = other.m_nStride;
+
+		m_bExternalBuffer = other.m_bExternalBuffer;
+
+		size_t size_of_data = m_dwHeight * m_nStride > 0 ? m_nStride : -m_nStride;
+		m_pImgData = new BYTE[size_of_data];
+
+		memcpy(m_pImgData, other.m_pImgData, size_of_data);
+
+		return *this;
+	}
+
+	CImage& CImage::operator=(CImage&& other)
+	{
+		if (this == &other)
+			return *this;
+
+		m_Status = other.m_Status;
+
+		m_dwHeight = other.m_dwHeight;
+		m_dwWidth = other.m_dwWidth;
+		m_nStride = other.m_nStride;
+
+		m_bExternalBuffer = other.m_bExternalBuffer;
+
+		m_pImgData = other.m_pImgData;
+		other.m_pImgData = nullptr;
+
+		return *this;
+	}
+
 	DWORD CImage::GetWidth() const { return(m_dwWidth); }
 	DWORD CImage::GetHeight() const { return(m_dwHeight); }
 	long CImage::GetStride() const { return(m_nStride); }
@@ -146,10 +196,10 @@ namespace Aggplus
 	////////////////////////////////////////////////////////////////////////////////////////
 	CBitmap::CBitmap(LONG width, LONG height, PixelFormat format) : CImage()
 	{
-		if(width <= 0 || height <= 0) 
-		{ 
-			m_Status=InvalidParameter; 
-			return; 
+		if(width <= 0 || height <= 0)
+		{
+			m_Status=InvalidParameter;
+			return;
 		}
 
 		LONG lSize = 4 * width * height;
@@ -168,15 +218,15 @@ namespace Aggplus
 	CBitmap::CBitmap(LONG width, LONG height, LONG stride, PixelFormat format, BYTE* scan0) : CImage()
 	{
 		//Warning! This is not Gdiplus behavior; it returns Ok!
-		if(width <= 0 || height <= 0 || stride == 0) 
-		{ 
-			m_Status = InvalidParameter; 
-			return; 
+		if(width <= 0 || height <= 0 || stride == 0)
+		{
+			m_Status = InvalidParameter;
+			return;
 		}
 
 		m_bExternalBuffer = true;
 
-		if (stride > 0) 
+		if (stride > 0)
 		{
 			m_pImgData = scan0;
 		}
@@ -184,7 +234,7 @@ namespace Aggplus
 		{
 			m_pImgData = scan0 + (height - 1) * (-stride);
 		}
-		
+
 		m_dwWidth	= width;
 		m_dwHeight	= height;
 		m_nStride	= stride;

DesktopEditor/graphics/Image.h

@@ -49,6 +49,8 @@ public:
 public:
 	CImage();
 	CImage(const std::wstring& filename);
+	CImage(const CImage& other);
+	CImage(CImage&& other);
 	virtual ~CImage();
 
 	DWORD GetWidth() const;
@@ -64,6 +66,9 @@ public:
 	bool SaveFile(const std::wstring& strFileName, UINT nFileType);
 	void Destroy();
 
+	CImage& operator=(const CImage& other);
+	CImage& operator=(CImage&& other);
+
 protected:
 	Status m_Status;
 	

DesktopEditor/graphics/Matrix.cpp

@@ -30,127 +30,133 @@
  *
  */
 #include "Matrix_private.h"
+#include <utility>
 
 namespace Aggplus
 {
-    CMatrix::CMatrix(double m11, double m12, double m21, double m22, double dx, double dy)
+	CMatrix::CMatrix(double m11, double m12, double m21, double m22, double dx, double dy)
 	{
-        m_internal = new CMatrix_private();
-        m_internal->m_agg_mtx.sx = m11;
-        m_internal->m_agg_mtx.shy = m12;
-        m_internal->m_agg_mtx.shx = m21;
-        m_internal->m_agg_mtx.sy = m22;
-        m_internal->m_agg_mtx.tx = dx;
-        m_internal->m_agg_mtx.ty = dy;
+		m_internal = new CMatrix_private();
+		m_internal->m_agg_mtx.sx = m11;
+		m_internal->m_agg_mtx.shy = m12;
+		m_internal->m_agg_mtx.shx = m21;
+		m_internal->m_agg_mtx.sy = m22;
+		m_internal->m_agg_mtx.tx = dx;
+		m_internal->m_agg_mtx.ty = dy;
 	}
 
-    CMatrix::CMatrix(const CMatrix& oSrc)
-    {
-        m_internal = new CMatrix_private();
-        m_internal->m_agg_mtx = oSrc.m_internal->m_agg_mtx;
-    }
-
-    CMatrix::CMatrix()
+	CMatrix::CMatrix()
 	{
-        m_internal = new CMatrix_private();
+		m_internal = new CMatrix_private();
 	}
-	
+
+	CMatrix::CMatrix(const CMatrix& other)
+	{
+		*this = other;
+	}
+
+	CMatrix::CMatrix(CMatrix&& other)
+	{
+		*this = std::move(other);
+	}
+
 	CMatrix::~CMatrix()
 	{
-        RELEASEOBJECT(m_internal);
+		RELEASEOBJECT(m_internal);
 	}
-	
+
 	void CMatrix::Translate(double offsetX, double offsetY, MatrixOrder order)
 	{
-		if (order == MatrixOrderPrepend) 
-		{ 
-            m_internal->m_agg_mtx.premultiply(agg::trans_affine_translation(offsetX, offsetY));
-		}
-		else                            
-		{ 
-            m_internal->m_agg_mtx.multiply(agg::trans_affine_translation(offsetX, offsetY));
-		}
+		if (order == MatrixOrderPrepend)
+			m_internal->m_agg_mtx.premultiply(agg::trans_affine_translation(offsetX, offsetY));
+		else
+			m_internal->m_agg_mtx.multiply(agg::trans_affine_translation(offsetX, offsetY));
 	}
 
 	void CMatrix::Scale(double scaleX, double scaleY, MatrixOrder order)
-	{	
-		if (order == MatrixOrderPrepend) 
-		{ 
-            m_internal->m_agg_mtx.premultiply(agg::trans_affine_scaling(scaleX, scaleY));
-		}
-		else                            
-		{ 
-            m_internal->m_agg_mtx.multiply(agg::trans_affine_scaling(scaleX, scaleY));
-		}
+	{
+		if (order == MatrixOrderPrepend)
+			m_internal->m_agg_mtx.premultiply(agg::trans_affine_scaling(scaleX, scaleY));
+		else
+			m_internal->m_agg_mtx.multiply(agg::trans_affine_scaling(scaleX, scaleY));
 	}
 
 	void CMatrix::Shear(double shearX, double shearY, MatrixOrder order)
 	{
-		if (order == MatrixOrderPrepend) 
-		{ 
-            m_internal->m_agg_mtx.premultiply(agg::trans_affine_skewing(shearX, shearY));
-		}
-		else                            
-		{ 
-            m_internal->m_agg_mtx.multiply(agg::trans_affine_skewing(shearX, shearY));
-		}
+		if (order == MatrixOrderPrepend)
+			m_internal->m_agg_mtx.premultiply(agg::trans_affine_skewing(shearX, shearY));
+		else
+			m_internal->m_agg_mtx.multiply(agg::trans_affine_skewing(shearX, shearY));
+	}
+
+	double CMatrix::Determinant() const
+	{
+		return m_internal->m_agg_mtx.determinant();
 	}
 
 	void CMatrix::TransformVectors(PointF* pts, int count) const
 	{
 		// Store matrix to an array [6] of double
-        double M[6]; m_internal->m_agg_mtx.store_to(M);
+		double M[6];
+		m_internal->m_agg_mtx.store_to(M);
 
-        for (int i = 0; i < count; ++i)
+		for (int i = 0; i < count; ++i)
 		{
-            double x = pts[i].X;
-            double y = pts[i].Y;
-            m_internal->m_agg_mtx.transform(&x, &y);
-            pts[i].X = (float)(x-M[4]);
-            pts[i].Y = (float)(y-M[5]);
+			double x = pts[i].X;
+			double y = pts[i].Y;
+			m_internal->m_agg_mtx.transform(&x, &y);
+			pts[i].X = static_cast<float>(x-M[4]);
+			pts[i].Y = static_cast<float>(y-M[5]);
 		}
 	}
 
 	void CMatrix::TransformPoints(PointF* pts, int count) const
 	{
-        for (int i = 0; i < count; ++i)
+		for (int i = 0; i < count; ++i)
 		{
 			double x = pts[i].X;
 			double y = pts[i].Y;
-            m_internal->m_agg_mtx.transform(&x, &y);
-			pts[i].X = (float)x;
-			pts[i].Y = (float)y;
+			m_internal->m_agg_mtx.transform(&x, &y);
+			pts[i].X = static_cast<float>(x);
+			pts[i].Y = static_cast<float>(y);
 		}
 	}
 
 	void CMatrix::TransformPoint(double& x, double& y) const
 	{
-        m_internal->m_agg_mtx.transform(&x, &y);
+		m_internal->m_agg_mtx.transform(&x, &y);
+	}
+
+	void CMatrix::TransformPoints(PointF* dst, const PointF* src, int count) const
+	{
+		agg::trans_affine& m = m_internal->m_agg_mtx;
+		for(int i = 0; i < count; ++i)
+		{
+			double x = src[i].X * m.sx + src[i].Y * m.shx + m.tx;
+			double y = src[i].Y * m.sy + src[i].X * m.shy + m.ty;
+
+			dst[i].X = static_cast<float>(x);
+			dst[i].Y = static_cast<float>(y);
+		}
 	}
 
 	void CMatrix::Rotate(double angle, MatrixOrder order)
 	{
-		if (order == MatrixOrderPrepend) 
-		{ 
-            m_internal->m_agg_mtx.premultiply(agg::trans_affine_rotation(agg::deg2rad(angle)));
-		}
+		if (order == MatrixOrderPrepend)
+			m_internal->m_agg_mtx.premultiply(agg::trans_affine_rotation(agg::deg2rad(angle)));
 		else
-		{ 
-            m_internal->m_agg_mtx.multiply(agg::trans_affine_rotation(agg::deg2rad(angle)));
-		}
+			m_internal->m_agg_mtx.multiply(agg::trans_affine_rotation(agg::deg2rad(angle)));
 	}
 
 	void CMatrix::RotateAt(double angle, const PointF &center, MatrixOrder order)
 	{
 		Translate(-center.X, -center.Y, order);
-		if(order == MatrixOrderPrepend) 
-		{ 
-            m_internal->m_agg_mtx.premultiply(agg::trans_affine_rotation(agg::deg2rad(angle)));
-		}
-		else                            
-		{ 
-            m_internal->m_agg_mtx.multiply(agg::trans_affine_rotation(agg::deg2rad(angle)));
-		}
+
+		if(order == MatrixOrderPrepend)
+			m_internal->m_agg_mtx.premultiply(agg::trans_affine_rotation(agg::deg2rad(angle)));
+		else
+			m_internal->m_agg_mtx.multiply(agg::trans_affine_rotation(agg::deg2rad(angle)));
+
 		Translate(center.X, center.Y, order);
 		return;
 	}
@@ -158,168 +164,169 @@ namespace Aggplus
 	void CMatrix::RotateAt(double angle, double x, double y, MatrixOrder order)
 	{
 		Translate(-x, -y, order);
-		if (order == MatrixOrderPrepend) 
-		{ 
-            m_internal->m_agg_mtx.premultiply(agg::trans_affine_rotation(agg::deg2rad(angle)));
-		}
-		else                            
-		{ 
-            m_internal->m_agg_mtx.multiply(agg::trans_affine_rotation(agg::deg2rad(angle)));
-		}
+
+		if (order == MatrixOrderPrepend)
+			m_internal->m_agg_mtx.premultiply(agg::trans_affine_rotation(agg::deg2rad(angle)));
+		else
+			m_internal->m_agg_mtx.multiply(agg::trans_affine_rotation(agg::deg2rad(angle)));
+
 		Translate(x, y, order);
 	}
 
 	void CMatrix::Multiply(const CMatrix* matrix, MatrixOrder order)
 	{
-		if (order == MatrixOrderPrepend) 
-		{ 
-            m_internal->m_agg_mtx.premultiply(matrix->m_internal->m_agg_mtx);
-		}
+		if (order == MatrixOrderPrepend)
+			m_internal->m_agg_mtx.premultiply(matrix->m_internal->m_agg_mtx);
 		else
-		{ 
-            m_internal->m_agg_mtx.multiply(matrix->m_internal->m_agg_mtx);
-		}
+			m_internal->m_agg_mtx.multiply(matrix->m_internal->m_agg_mtx);
 	}
 
 	double CMatrix::OffsetX() const
 	{
-        return m_internal->m_agg_mtx.tx;
+		return m_internal->m_agg_mtx.tx;
 	}
+
 	double CMatrix::OffsetY() const
 	{
-        return m_internal->m_agg_mtx.ty;
+		return m_internal->m_agg_mtx.ty;
 	}
 
-    double CMatrix::sx() const
-    {
-        return m_internal->m_agg_mtx.sx;
-    }
-    double CMatrix::sy() const
-    {
-        return m_internal->m_agg_mtx.sy;
-    }
-    double CMatrix::shx() const
-    {
-        return m_internal->m_agg_mtx.shx;
-    }
-    double CMatrix::shy() const
-    {
-        return m_internal->m_agg_mtx.shy;
-    }
-    double CMatrix::tx() const
-    {
-        return m_internal->m_agg_mtx.tx;
-    }
-    double CMatrix::ty() const
-    {
-        return m_internal->m_agg_mtx.ty;
-    }        
-    double CMatrix::rotation()
-    {
-        return m_internal->m_agg_mtx.rotation();
-    }
-
-
-    void CMatrix::SetElements(const double& sx, const double& shy, const double& shx, const double& sy, const double& tx, const double& ty)
-    {
-        m_internal->m_agg_mtx.sx = sx;
-        m_internal->m_agg_mtx.shy = shy;
-        m_internal->m_agg_mtx.shx = shx;
-        m_internal->m_agg_mtx.sy = sy;
-        m_internal->m_agg_mtx.tx = tx;
-        m_internal->m_agg_mtx.ty = ty;
-    }
-	
-	Status CMatrix::GetElements(REAL* m) const
+	double CMatrix::sx() const
 	{
-        double M[6]; m_internal->m_agg_mtx.store_to(M);
-		m[0]=(REAL)M[0];
-		m[1]=(REAL)M[1];
-		m[2]=(REAL)M[2];
-		m[3]=(REAL)M[3];
-		m[4]=(REAL)M[4];
-		m[5]=(REAL)M[5];
+		return m_internal->m_agg_mtx.sx;
+	}
+
+	double CMatrix::sy() const
+	{
+		return m_internal->m_agg_mtx.sy;
+	}
+
+	double CMatrix::shx() const
+	{
+		return m_internal->m_agg_mtx.shx;
+	}
+
+	double CMatrix::shy() const
+	{
+		return m_internal->m_agg_mtx.shy;
+	}
+
+	double CMatrix::tx() const
+	{
+		return m_internal->m_agg_mtx.tx;
+	}
+
+	double CMatrix::ty() const
+	{
+		return m_internal->m_agg_mtx.ty;
+	}
+
+	double CMatrix::rotation()
+	{
+		return m_internal->m_agg_mtx.rotation();
+	}
+
+	void CMatrix::SetElements(const double& sx, const double& shy, const double& shx,
+							  const double& sy, const double& tx, const double& ty)
+	{
+		m_internal->m_agg_mtx.sx = sx;
+		m_internal->m_agg_mtx.shy = shy;
+		m_internal->m_agg_mtx.shx = shx;
+		m_internal->m_agg_mtx.sy = sy;
+		m_internal->m_agg_mtx.tx = tx;
+		m_internal->m_agg_mtx.ty = ty;
+	}
+
+	Status CMatrix::GetElements(float* m) const
+	{
+		double M[6];
+		m_internal->m_agg_mtx.store_to(M);
+
+		m[0] = static_cast<float>(M[0]);
+		m[1] = static_cast<float>(M[1]);
+		m[2] = static_cast<float>(M[2]);
+		m[3] = static_cast<float>(M[3]);
+		m[4] = static_cast<float>(M[4]);
+		m[5] = static_cast<float>(M[5]);
+
 		return Ok;
 	}
 
 	Status CMatrix::GetElements(double* m) const
 	{
-        m_internal->m_agg_mtx.store_to(m);
+		m_internal->m_agg_mtx.store_to(m);
 		return Ok;
 	}
 
 	void CMatrix::Reset()
 	{
-        m_internal->m_agg_mtx.reset();
+		m_internal->m_agg_mtx.reset();
 	}
 
-	double CMatrix::Determinant() const
+	bool CMatrix::IsIdentity(const double& eps) const
 	{
-        return m_internal->m_agg_mtx.determinant();
-    }
+		return m_internal->m_agg_mtx.is_identity(eps);
+	}
 
-	const CMatrix& CMatrix::operator=(const CMatrix& Src)
+	bool CMatrix::IsIdentity2(const double& eps) const
 	{
-        m_internal->m_agg_mtx = Src.m_internal->m_agg_mtx;
-        return *this;
+		agg::trans_affine& m = m_internal->m_agg_mtx;
+		return agg::is_equal_eps(m.sx,  1.0, eps) &&
+			   agg::is_equal_eps(m.shy, 0.0, eps) &&
+			   agg::is_equal_eps(m.shx, 0.0, eps) &&
+			   agg::is_equal_eps(m.sy,  1.0, eps);
+	}
+
+	bool CMatrix::IsEqual(const CMatrix* mm1, const CMatrix* mm2, const double& eps, bool bIsOnlyMain)
+	{
+		agg::trans_affine& m1 = mm1->m_internal->m_agg_mtx;
+		agg::trans_affine& m2 = mm2->m_internal->m_agg_mtx;
+
+		bool bMain = fabs(m1.sx  - m2.sx)  < eps &&
+					 fabs(m1.sy  - m2.sy)  < eps &&
+					 fabs(m1.shx - m2.shx) < eps &&
+					 fabs(m1.shy - m2.shy) < eps;
+
+		if (!bMain || bIsOnlyMain)
+			return bMain;
+
+		return fabs(m1.tx - m2.tx) < eps && fabs(m1.ty - m2.ty) < eps;
 	}
 
 	Status CMatrix::Invert()
 	{
-        double d = m_internal->m_agg_mtx.determinant();
-        if (0.0001 >= fabs(d))
+		double d = m_internal->m_agg_mtx.determinant();
+		if (0.0001 >= fabs(d))
 			return InvalidParameter;
 
-        m_internal->m_agg_mtx.invert();
+		m_internal->m_agg_mtx.invert();
 		return Ok;
 	}
 
 	//Temp
 	//Used in X_BrushLinearGradient constructor
-	double CMatrix::z_Rotation() const 
-	{ 
-        return agg::rad2deg(m_internal->m_agg_mtx.rotation());
-	}
-
-    void CMatrix::TransformPoints( PointF* dst, const PointF* src, int count ) const
+	double CMatrix::z_Rotation() const
 	{
-        agg::trans_affine& m = m_internal->m_agg_mtx;
-		for(int i = 0; i < count; ++i)
-		{
-            double x = src[i].X * m.sx + src[i].Y * m.shx + m.tx;
-            double y = src[i].Y * m.sy + src[i].X * m.shy + m.ty;
-			
-			dst[i].X = (float)x;
-			dst[i].Y = (float)y;
-		}
+		return agg::rad2deg(m_internal->m_agg_mtx.rotation());
 	}
 
-    bool CMatrix::IsIdentity(const double& eps) const
+	const CMatrix& CMatrix::operator=(const CMatrix& other)
 	{
-        return m_internal->m_agg_mtx.is_identity(eps);
+		if (this == &other)
+			return *this;
+
+		m_internal = new CMatrix_private();
+		m_internal->m_agg_mtx = other.m_internal->m_agg_mtx;
+		return *this;
 	}
-    bool CMatrix::IsIdentity2(const double& eps) const
+
+	CMatrix& CMatrix::operator=(CMatrix&& other)
 	{
-        agg::trans_affine& m = m_internal->m_agg_mtx;
-        return agg::is_equal_eps(m.sx,  1.0, eps) &&
-               agg::is_equal_eps(m.shy, 0.0, eps) &&
-               agg::is_equal_eps(m.shx, 0.0, eps) &&
-               agg::is_equal_eps(m.sy,  1.0, eps);
+		if (this == &other)
+			return *this;
+
+		m_internal = other.m_internal;
+		other.m_internal = nullptr;
+		return *this;
 	}
-
-    bool CMatrix::IsEqual(const CMatrix* mm1, const CMatrix* mm2, const double& eps, bool bIsOnlyMain)
-    {
-        agg::trans_affine& m1 = mm1->m_internal->m_agg_mtx;
-        agg::trans_affine& m2 = mm2->m_internal->m_agg_mtx;
-
-        bool bMain = fabs(m1.sx  - m2.sx)  < eps &&
-                     fabs(m1.sy  - m2.sy)  < eps &&
-                     fabs(m1.shx - m2.shx) < eps &&
-                     fabs(m1.shy - m2.shy) < eps;
-
-        if (!bMain || bIsOnlyMain)
-            return bMain;
-
-        return fabs(m1.tx - m2.tx) < eps && fabs(m1.ty - m2.ty) < eps;
-    }
 }

DesktopEditor/graphics/Matrix.h

@@ -37,62 +37,62 @@
 
 namespace Aggplus
 {
-    class CMatrix_private;
-    class GRAPHICS_DECL CMatrix
-    {
-    public:
-        CMatrix(double m11, double m12, double m21, double m22, double dx, double dy);
-        CMatrix();
-        CMatrix(const CMatrix& oSrc);
+	class CMatrix_private;
+	class GRAPHICS_DECL CMatrix
+	{
+	public:
+		CMatrix();
+		CMatrix(double m11, double m12, double m21, double m22, double dx, double dy);
+		CMatrix(const CMatrix& other);
+		CMatrix(CMatrix&& other);
+		~CMatrix();
 
-        ~CMatrix();
+		void Translate(double offsetX, double offsetY, MatrixOrder order = MatrixOrderPrepend);
+		void Scale(double scaleX, double scaleY, MatrixOrder order = MatrixOrderPrepend);
+		void Shear(double shearX, double shearY, MatrixOrder order = MatrixOrderPrepend);
+		double Determinant() const;
 
-        void Translate(double offsetX, double offsetY, MatrixOrder order = MatrixOrderPrepend);
-        void Scale(double scaleX, double scaleY, MatrixOrder order = MatrixOrderPrepend);
-        void Shear(double shearX, double shearY, MatrixOrder order = MatrixOrderPrepend);
-        double Determinant() const;
+		void TransformVectors(PointF* pts, int count) const;
+		void TransformPoints(PointF* pts, int count) const;
+		void TransformPoint(double& x, double& y) const;
+		void TransformPoints(PointF* dst, const PointF* src, int count) const;
 
-        void TransformVectors(PointF* pts, int count) const;
-        void TransformPoints(PointF* pts, int count) const;
-        void TransformPoint(double& x, double& y) const;
-        void TransformPoints(PointF* dst, const PointF* src, int count) const;
+		void Rotate(double angle, MatrixOrder order = MatrixOrderPrepend);
+		void RotateAt(double angle, const PointF &center, MatrixOrder order = MatrixOrderPrepend);
+		void RotateAt(double angle, double x, double y, MatrixOrder order = MatrixOrderPrepend);
 
-        void Rotate(double angle, MatrixOrder order = MatrixOrderPrepend);
-        void RotateAt(double angle, const PointF &center, MatrixOrder order = MatrixOrderPrepend);
-        void RotateAt(double angle, double x, double y, MatrixOrder order = MatrixOrderPrepend);
+		void Multiply(const CMatrix* matrix, MatrixOrder order = MatrixOrderPrepend);
 
-        void Multiply(const CMatrix* matrix, MatrixOrder order = MatrixOrderPrepend);
+		double OffsetX() const;
+		double OffsetY() const;
 
-        double OffsetX() const;
-        double OffsetY() const;
+		double sx() const;
+		double sy() const;
+		double shx() const;
+		double shy() const;
+		double tx() const;
+		double ty() const;
+		double rotation();
 
-        double sx() const;
-        double sy() const;
-        double shx() const;
-        double shy() const;
-        double tx() const;
-        double ty() const;
-        double rotation();
-        void SetElements(const double& sx, const double& shy, const double& shx, const double& sy, const double& tx = 0, const double& ty = 0);
+		void SetElements(const double& sx, const double& shy, const double& shx, const double& sy, const double& tx = 0, const double& ty = 0);
+		Status GetElements(float* m) const;
+		Status GetElements(double* m) const;
 
-        Status GetElements(float* m) const;
-        Status GetElements(double* m) const;
+		void Reset();
+		bool IsIdentity(const double& eps = 0.00001) const;
+		bool IsIdentity2(const double& eps = 0.00001) const;
 
-        void Reset();
-        bool IsIdentity(const double& eps = 0.00001) const;
-        bool IsIdentity2(const double& eps = 0.00001) const;
+		static bool IsEqual(const CMatrix* m1, const CMatrix* m2, const double& eps = 0.001, bool bIsOnlyMain = false);
 
-        static bool IsEqual(const CMatrix* m1, const CMatrix* m2, const double& eps = 0.001, bool bIsOnlyMain = false);
+		Status Invert();
 
-        const CMatrix& operator=(const CMatrix& Src);
+		double z_Rotation() const;
 
-        Status Invert();
+		const CMatrix& operator=(const CMatrix& other);
+		CMatrix& operator=(CMatrix&& other);
 
-        double z_Rotation() const;
-
-    public:
-        CMatrix_private* m_internal;
-    };
+	public:
+		CMatrix_private* m_internal;
+	};
 }
-
 #endif // _BUILD_MATRIX_H_

DesktopEditor/graphics/pro/Fonts.h

@@ -701,6 +701,7 @@ namespace NSFonts
 		virtual void Initialize() = 0;
 		virtual void SetOwnerCache(IFontsCache* pCache) = 0;
 		virtual void CreateOwnerCache(const int& nCacheSize = -1);
+		virtual void ClearOwnerCache() = 0;
 
 		virtual void AfterLoad() = 0;
 

DesktopEditor/graphics/pro/Image.h

@@ -110,11 +110,20 @@ namespace NSImages
 #ifndef GRAPHICS_DISABLE_METAFILE
 namespace MetaFile
 {
-	const int c_lMetaWmf = 0x01;
-	const int c_lMetaEmf = 0x02;
-	const int c_lMetaSvg = 0x04;
-	const int c_lMetaSvm = 0x05;
+	/**
+	 * @brief Meta file extension constants
+	 */
+	const long c_lMetaWmf = 0x0001;
+	const long c_lMetaEmf = 0x0002;
+	const long c_lMetaSvg = 0x0004;
+	const long c_lMetaSvm = 0x0005;
 
+	/**
+	 * @interface IMetaFile
+	 *
+	 * The interface provides various options for loading a metafile and saving it
+	 * in another format.
+	 */
 	class GRAPHICS_DECL IMetaFile : public NSBase::CBaseRefCounter
 	{
 	public:
@@ -124,23 +133,20 @@ namespace MetaFile
 		virtual bool LoadFromFile(const wchar_t* wsFilePath) = 0;
 		virtual bool LoadFromBuffer(BYTE* pBuffer, unsigned int unSize) = 0;
 		virtual bool LoadFromString(const std::wstring& data) = 0;
-		virtual bool DrawOnRenderer(IRenderer* pRenderer, double dX, double dY, double dWidth, double dHeight) = 0;
+		virtual bool DrawOnRenderer(IRenderer* pRenderer, double dX, double dY,
+									double dWidth, double dHeight, const wchar_t* wsXmlFilePath = NULL) = 0;
 		virtual void Close() = 0;
 		virtual void GetBounds(double* pdX, double* pdY, double* pdW, double* pdH) = 0;
 		virtual int GetType() = 0;
-		virtual void ConvertToRaster(const wchar_t* wsOutFilePath, unsigned int unFileType, int nWidth, int nHeight = -1) = 0;
+		virtual void ConvertToRaster(const wchar_t* wsOutFilePath, unsigned int unFileType, int nWidth, int nHeight = -1, const wchar_t* wsXmlOutFile = NULL) = 0;
 		virtual NSFonts::IFontManager* get_FontManager() = 0;
 
 		virtual std::wstring ConvertToSvg(unsigned int unWidth = 0, unsigned int unHeight = 0) = 0;
 		virtual void SetTempDirectory(const std::wstring& dir) = 0;
 
-		//Для тестов
-	#ifdef METAFILE_SUPPORT_WMF_EMF
-		virtual void ConvertToXml(const wchar_t *wsFilePath) = 0;
-		virtual void ConvertToXmlAndRaster(const wchar_t *wsXmlFilePath, const wchar_t* wsOutFilePath, unsigned int unFileType, int nWidth, int nHeight = -1) = 0;
 		virtual bool LoadFromXmlFile(const wchar_t* wsFilePath) = 0;
+		virtual void ConvertToXml(const wchar_t *wsFilePath) = 0;
 		virtual void ConvertToEmf(const wchar_t *wsFilePath) = 0;
-	#endif
 	};
 
 	GRAPHICS_DECL IMetaFile* Create(NSFonts::IApplicationFonts *pAppFonts);

DesktopEditor/graphics/tests/TestPICT/main.cpp

@@ -1,11 +0,0 @@
-#include <codecvt>
-
-#include "../../pro/Graphics.h"
-
-int main(int argc, char *argv[])
-{
-    Aggplus::CImage Cimg(std::wstring_convert<std::codecvt_utf8<wchar_t>>().from_bytes(argv[1]));
-    Cimg.SaveFile(std::wstring_convert<std::codecvt_utf8<wchar_t>>().from_bytes(argv[2]), 1);
-
-    return 0;
-}

DesktopEditor/graphics/tests/hatchBrush/main.cpp

@@ -0,0 +1,11 @@
+#include "mainwindow.h"
+
+#include <QApplication>
+
+int main(int argc, char *argv[])
+{
+	QApplication a(argc, argv);
+	MainWindow w;
+	w.show();
+	return a.exec();
+}

DesktopEditor/graphics/tests/hatchBrush/mainwindow.cpp

@@ -0,0 +1,182 @@
+#include "mainwindow.h"
+#include "ui_mainwindow.h"
+
+#include <QImage>
+#include <QPixmap>
+#include <QSpinBox>
+#include <QComboBox>
+#include <QStringList>
+
+#include "../../pro/Graphics.h"
+
+static constexpr double rectangle[4] = {
+	10.0, 10.0, 80.0, 80.0,
+};
+
+static const QStringList patterns = {
+	"cross",
+	"dashDnDiag",
+	"dashHorz",
+	"dashUpDiag",
+	"dashVert",
+	"diagBrick",
+	"diagCross",
+	"divot",
+	"dkDnDiag",
+	"dkHorz",
+	"dkUpDiag",
+	"dkVert",
+	"dnDiag",
+	"dotDmnd",
+	"dotGrid",
+	"horz",
+	"horzBrick",
+	"lgCheck",
+	"lgConfetti",
+	"lgGrid",
+	"ltDnDiag",
+	"ltHorz",
+	"ltUpDiag",
+	"ltVert",
+	"narHorz",
+	"narVert",
+	"openDmnd",
+	"pct10",
+	"pct20",
+	"pct25",
+	"pct30",
+	"pct40",
+	"pct5",
+	"pct50",
+	"pct60",
+	"pct70",
+	"pct75",
+	"pct80",
+	"pct90",
+	"plaid",
+	"shingle",
+	"smCheck",
+	"smConfetti",
+	"smGrid",
+	"solidDmnd",
+	"sphere",
+	"trellis",
+	"upDiag",
+	"vert",
+	"wave",
+	"wdDnDiag",
+	"wdUpDiag",
+	"weave",
+	"zigZag"
+};
+
+MainWindow::MainWindow(QWidget *parent)
+	: QMainWindow(parent)
+	, ui(new Ui::MainWindow)
+{
+	ui->setupUi(this);
+	ui->pushButton->SetColor(Qt::red);
+	ui->pushButton_2->SetColor(Qt::blue);
+
+	ui->comboBox->addItems(patterns);
+
+	connect(ui->pushButton,		&CColorButton::ColorChanged,	this, &MainWindow::Draw);
+	connect(ui->pushButton_2,	&CColorButton::ColorChanged,	this, &MainWindow::Draw);
+	connect(ui->spinBox,		&QSpinBox::valueChanged,		this, &MainWindow::Draw);
+	connect(ui->spinBox_2,		&QSpinBox::valueChanged,		this, &MainWindow::Draw);
+	connect(ui->comboBox,		&QComboBox::currentTextChanged, this, &MainWindow::Draw);
+	connect(ui->radioButton,	&QRadioButton::clicked,			this, &MainWindow::Draw);
+	connect(ui->radioButton_2,	&QRadioButton::clicked,			this, &MainWindow::Draw);
+
+	m_oPathRectangle.StartFigure();
+	m_oPathRectangle.MoveTo(rectangle[0], rectangle[1]);
+	m_oPathRectangle.LineTo(rectangle[0] + rectangle[2], rectangle[1]);
+	m_oPathRectangle.LineTo(rectangle[0] + rectangle[2], rectangle[1] + rectangle[3]);
+	m_oPathRectangle.LineTo(rectangle[0], rectangle[1] + rectangle[3]);
+	m_oPathRectangle.LineTo(rectangle[0], rectangle[1]);
+	m_oPathRectangle.CloseFigure();
+
+	m_oPathEllisps.StartFigure();
+	m_oPathEllisps.AddEllipse(rectangle[0], rectangle[1], rectangle[2], rectangle[3]);
+	m_oPathEllisps.CloseFigure();
+
+	Draw();
+}
+
+MainWindow::~MainWindow()
+{
+	delete ui;
+}
+
+void MainWindow::Draw()
+{
+	NSGraphics::IGraphicsRenderer *renderer = NSGraphics::Create();
+
+	int width = ui->label->width(),
+		height = ui->label->height();
+
+	BYTE* data = new  BYTE[4 * width * height];
+
+	CBgraFrame frame;
+	frame.put_Data(data);
+	frame.put_Width(width);
+	frame.put_Height(height);
+	frame.put_Stride(4 * width);
+
+	renderer->put_Width(100);
+	renderer->put_Height(100);
+
+	renderer->CreateFromBgraFrame(&frame);
+	renderer->SetSwapRGB(false);
+
+	renderer->put_BrushType(c_BrushTypeHatch1);
+	renderer->put_BrushTexturePath(ui->comboBox->currentText().toStdWString());
+	renderer->put_BrushColor1(ui->pushButton->GetColor().rgb());
+	renderer->put_BrushAlpha1(ui->spinBox->value());
+	renderer->put_BrushColor2(ui->pushButton_2->GetColor().rgb());
+	renderer->put_BrushAlpha2(ui->spinBox->value());
+
+	std::vector<Aggplus::PointD> points;
+	unsigned length;
+	bool is_rectangle = ui->radioButton->isChecked();
+	if (is_rectangle)
+	{
+		length = m_oPathRectangle.GetPointCount();
+		points = m_oPathRectangle.GetPoints(0, length);
+	}
+	else
+	{
+		length = m_oPathEllisps.GetPointCount();
+		points = m_oPathEllisps.GetPoints(0, length);
+	}
+
+	renderer->BeginCommand(c_nPathType);
+	renderer->PathCommandStart();
+
+	for (unsigned i = 0; i < length; i++)
+	{
+		if (is_rectangle ? m_oPathRectangle.IsCurvePoint(i) : m_oPathEllisps.IsCurvePoint(i))
+		{
+			renderer->PathCommandCurveTo(points[i].X, points[i].Y,
+										 points[i + 1].X, points[i + 1].Y,
+										 points[i + 2].X, points[i + 2].Y);
+			i += 2;
+		}
+		else if (is_rectangle ? m_oPathRectangle.IsMovePoint(i) : m_oPathEllisps.IsMovePoint(i))
+			renderer->PathCommandMoveTo(points[i].X, points[i].Y);
+		else if (is_rectangle ? m_oPathRectangle.IsLinePoint(i) : m_oPathEllisps.IsLinePoint(i))
+			renderer->PathCommandLineTo(points[i].X, points[i].Y);
+	}
+
+	renderer->PathCommandClose();
+	renderer->Fill();
+	renderer->EndCommand(c_nPathType);
+	renderer->PathCommandEnd();
+
+	auto img = QImage(data, width, height, QImage::Format_RGBA8888, [](void *data){
+		delete[] (BYTE*)data;
+	});
+	ui->label->setPixmap(QPixmap::fromImage(img));
+
+	RELEASEOBJECT(renderer);
+}

DesktopEditor/graphics/tests/hatchBrush/mainwindow.h

@@ -0,0 +1,81 @@
+#ifndef MAINWINDOW_H
+#define MAINWINDOW_H
+
+#include <QMainWindow>
+#include <QPushButton>
+#include <QColor>
+#include <QColorDialog>
+#include <QPalette>
+
+#include "../../GraphicsPath.h"
+
+class CColorButton final : public QPushButton
+{
+	Q_OBJECT
+public:
+	CColorButton(QWidget *parent = nullptr) : QPushButton(parent)
+	{
+		connect(this, &QPushButton::clicked, this, &CColorButton::onClicked);
+	}
+
+	~CColorButton() {}
+
+	QColor GetColor() const
+	{
+		return m_oColor;
+	}
+
+	void SetColor(const QColor& color)
+	{
+		if (color == m_oColor)
+			return;
+
+		m_oColor = color;
+		setStyleSheet("QPushButton { background-color : " + m_oColor.name()
+					  + "; border: 1px solid black; padding 10px;}");
+
+		emit ColorChanged();
+	}
+
+signals:
+	void ColorChanged();
+
+public slots:
+	void onClicked()
+	{
+		QColorDialog color_dialog;
+		auto color = color_dialog.getColor();
+
+		if (color.isValid())
+			SetColor(color);
+	}
+
+private:
+	QColor m_oColor;
+};
+
+
+QT_BEGIN_NAMESPACE
+namespace Ui {
+class MainWindow;
+}
+QT_END_NAMESPACE
+
+class MainWindow : public QMainWindow
+{
+	Q_OBJECT
+
+public:
+	MainWindow(QWidget *parent = nullptr);
+	~MainWindow();
+
+public slots:
+	void Draw();
+
+private:
+	Aggplus::CGraphicsPath m_oPathRectangle;
+	Aggplus::CGraphicsPath m_oPathEllisps;
+
+	Ui::MainWindow *ui;
+};
+#endif // MAINWINDOW_H

DesktopEditor/graphics/tests/hatchBrush/mainwindow.ui

@@ -0,0 +1,253 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>368</width>
+    <height>538</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>MainWindow</string>
+  </property>
+  <widget class="QWidget" name="centralwidget">
+   <widget class="QLabel" name="label">
+    <property name="geometry">
+     <rect>
+      <x>30</x>
+      <y>190</y>
+      <width>300</width>
+      <height>300</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string/>
+    </property>
+   </widget>
+   <widget class="QGroupBox" name="groupBox">
+    <property name="geometry">
+     <rect>
+      <x>20</x>
+      <y>10</y>
+      <width>321</width>
+      <height>151</height>
+     </rect>
+    </property>
+    <property name="title">
+     <string>Hatch brush parametrs</string>
+    </property>
+    <widget class="CColorButton" name="pushButton">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>40</y>
+       <width>31</width>
+       <height>24</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string/>
+     </property>
+    </widget>
+    <widget class="CColorButton" name="pushButton_2">
+     <property name="geometry">
+      <rect>
+       <x>110</x>
+       <y>40</y>
+       <width>31</width>
+       <height>24</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string/>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_2">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>20</y>
+       <width>61</width>
+       <height>16</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>First color:</string>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_4">
+     <property name="geometry">
+      <rect>
+       <x>110</x>
+       <y>20</y>
+       <width>81</width>
+       <height>16</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Second color:</string>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_5">
+     <property name="geometry">
+      <rect>
+       <x>110</x>
+       <y>70</y>
+       <width>81</width>
+       <height>16</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Second alpha:</string>
+     </property>
+    </widget>
+    <widget class="QSpinBox" name="spinBox">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>90</y>
+       <width>42</width>
+       <height>25</height>
+      </rect>
+     </property>
+     <property name="maximum">
+      <number>255</number>
+     </property>
+     <property name="value">
+      <number>255</number>
+     </property>
+    </widget>
+    <widget class="QSpinBox" name="spinBox_2">
+     <property name="geometry">
+      <rect>
+       <x>110</x>
+       <y>90</y>
+       <width>42</width>
+       <height>25</height>
+      </rect>
+     </property>
+     <property name="maximum">
+      <number>255</number>
+     </property>
+     <property name="value">
+      <number>255</number>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_6">
+     <property name="geometry">
+      <rect>
+       <x>200</x>
+       <y>20</y>
+       <width>81</width>
+       <height>16</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Type:</string>
+     </property>
+    </widget>
+    <widget class="QComboBox" name="comboBox">
+     <property name="geometry">
+      <rect>
+       <x>200</x>
+       <y>40</y>
+       <width>110</width>
+       <height>24</height>
+      </rect>
+     </property>
+    </widget>
+    <widget class="QGroupBox" name="groupBox_2">
+     <property name="geometry">
+      <rect>
+       <x>200</x>
+       <y>70</y>
+       <width>110</width>
+       <height>70</height>
+      </rect>
+     </property>
+     <property name="title">
+      <string>Path:</string>
+     </property>
+     <widget class="QRadioButton" name="radioButton">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>20</y>
+        <width>91</width>
+        <height>22</height>
+       </rect>
+      </property>
+      <property name="text">
+       <string>Rectangle</string>
+      </property>
+      <property name="checked">
+       <bool>true</bool>
+      </property>
+     </widget>
+     <widget class="QRadioButton" name="radioButton_2">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>40</y>
+        <width>91</width>
+        <height>22</height>
+       </rect>
+      </property>
+      <property name="text">
+       <string>Circle</string>
+      </property>
+     </widget>
+    </widget>
+    <widget class="QLabel" name="label_7">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>70</y>
+       <width>61</width>
+       <height>16</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>First alpha:</string>
+     </property>
+    </widget>
+   </widget>
+   <widget class="QLabel" name="label_3">
+    <property name="geometry">
+     <rect>
+      <x>20</x>
+      <y>160</y>
+      <width>61</width>
+      <height>16</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Output:</string>
+    </property>
+   </widget>
+  </widget>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>368</width>
+     <height>21</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QStatusBar" name="statusbar"/>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>CColorButton</class>
+   <extends>QPushButton</extends>
+   <header>mainwindow.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

DesktopEditor/graphics/tests/hatchBrush/test.pro

@@ -0,0 +1,20 @@
+QT += core gui widgets
+
+QMAKE_CXXFLAGS += /permissive-
+
+SOURCES += \
+	main.cpp \
+	mainwindow.cpp
+
+HEADERS += \
+	mainwindow.h
+
+FORMS += \
+	mainwindow.ui
+
+PWD_ROOT_DIR = $$PWD
+CORE_ROOT_DIR = $$PWD/../../../../../core
+include($$CORE_ROOT_DIR/Common/base.pri)
+
+ADD_DEPENDENCY(kernel, graphics, UnicodeConverter)
+include($$CORE_ROOT_DIR/Common/3dParty/icu/icu.pri)

DesktopEditor/graphics/tests/images/main.cpp

@@ -0,0 +1,11 @@
+#include "mainwindow.h"
+
+#include <QApplication>
+
+int main(int argc, char *argv[])
+{
+	QApplication a(argc, argv);
+	MainWindow w;
+	w.show();
+	return a.exec();
+}

DesktopEditor/graphics/tests/images/mainwindow.cpp

@@ -0,0 +1,62 @@
+#include "mainwindow.h"
+#include "ui_mainwindow.h"
+
+#include <QFileDialog>
+#include <QLabel>
+#include <QSizePolicy>
+#include <QDir>
+
+#include "../../../../UnicodeConverter/UnicodeConverter.h"
+#include "../../pro/Graphics.h"
+
+MainWindow::MainWindow(QWidget *parent)
+	: QMainWindow(parent)
+	, ui(new Ui::MainWindow)
+{
+	ui->setupUi(this);
+	ui->label->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+	ui->label->setFixedWidth(310);
+	ui->comboBox->addItems(m_arExtensions);
+}
+
+MainWindow::~MainWindow()
+{
+	delete ui;
+}
+
+void MainWindow::on_pushButton_clicked()
+{
+	m_arFileNames = QFileDialog::getOpenFileNames(this,
+												  "Select one or more images",
+												  "",
+												  "*.bmp *.gif *.jpg *.png *.ico "
+												  "*.tif *.tga *.pcx *.wbmp *.jp2 "
+												  "*.jpc *.pgx *.pnm *.ras *.jbg "
+												  "*.mng *.ska *.raw *.psd *.pic");
+
+	if (!m_arFileNames.empty())
+		ui->label->setText("File:" + m_arFileNames[0]);
+}
+
+void MainWindow::on_pushButton_2_clicked()
+{
+	auto save_dir = QFileDialog::getExistingDirectory(this,
+													  "Open Directory",
+													  "",
+													  QFileDialog::ShowDirsOnly |
+													  QFileDialog::DontResolveSymlinks);
+
+	auto ext = ui->comboBox->currentText();
+
+	NSUnicodeConverter::CUnicodeConverter converter;
+	for (const auto& f : m_arFileNames)
+	{
+		ui->label->setText("File:" + f);
+		Aggplus::CImage img(converter.toUnicode(f.toStdString(), 1));
+		img.SaveFile(converter.toUnicode(QDir(save_dir).filePath("res." + ext).toStdString(), 1),
+					 m_mapExtensionCodes.value(ext));
+	}
+}
+
+
+

DesktopEditor/graphics/tests/images/mainwindow.h

@@ -0,0 +1,75 @@
+#ifndef MAINWINDOW_H
+#define MAINWINDOW_H
+
+#include <QMainWindow>
+#include <QString>
+#include <QStringList>
+#include <QMap>
+
+namespace Ui {
+class MainWindow;
+}
+
+class MainWindow : public QMainWindow
+{
+	Q_OBJECT
+
+public:
+	explicit MainWindow(QWidget *parent = nullptr);
+	~MainWindow();
+
+private slots:
+	void on_pushButton_clicked();
+
+	void on_pushButton_2_clicked();
+
+private:
+	Ui::MainWindow *ui;
+
+	QStringList		m_arFileNames;
+
+	QStringList m_arExtensions = {
+		"bmp",
+		"gif",
+		"jpg",
+		"png",
+		"ico",
+		"tif",
+		"tga",
+		"pcx",
+		"wbmp",
+		"jp2",
+		"jpc",
+		"pgx",
+		"pnm",
+		"ras",
+		"mng",
+		"ska",
+		"raw",
+		"psd",
+		"pic",
+	};
+	QMap<QString, int> m_mapExtensionCodes = {
+		{"bmp", 1},
+		{"gif", 2},
+		{"jpg", 3},
+		{"png", 4},
+		{"ico", 5},
+		{"tif", 6},
+		{"tga", 7},
+		{"pcx", 8},
+		{"wbmp", 9},
+		{"jp2", 11},
+		{"jpc", 12},
+		{"pgx", 13},
+		{"pnm", 14},
+		{"ras", 15},
+		{"mng", 17},
+		{"ska", 18},
+		{"raw", 19},
+		{"psd", 20},
+		{"pic", 25},
+	};
+};
+
+#endif // MAINWINDOW_H

DesktopEditor/graphics/tests/images/mainwindow.ui

@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>385</width>
+    <height>196</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>MainWindow</string>
+  </property>
+  <widget class="QWidget" name="centralwidget">
+   <widget class="QPushButton" name="pushButton">
+    <property name="geometry">
+     <rect>
+      <x>40</x>
+      <y>20</y>
+      <width>121</width>
+      <height>24</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Choose img file</string>
+    </property>
+   </widget>
+   <widget class="QLabel" name="label">
+    <property name="geometry">
+     <rect>
+      <x>40</x>
+      <y>50</y>
+      <width>310</width>
+      <height>91</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>File:</string>
+    </property>
+    <property name="wordWrap">
+     <bool>true</bool>
+    </property>
+   </widget>
+   <widget class="QPushButton" name="pushButton_2">
+    <property name="geometry">
+     <rect>
+      <x>270</x>
+      <y>20</y>
+      <width>80</width>
+      <height>24</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Convert</string>
+    </property>
+   </widget>
+   <widget class="QComboBox" name="comboBox">
+    <property name="geometry">
+     <rect>
+      <x>180</x>
+      <y>20</y>
+      <width>72</width>
+      <height>24</height>
+     </rect>
+    </property>
+   </widget>
+  </widget>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>385</width>
+     <height>21</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QStatusBar" name="statusbar"/>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

DesktopEditor/graphics/tests/images/test.pro

@@ -1,13 +1,8 @@
-#CONFIG += c++11 cmdline
+CONFIG += c++11
 
-#SOURCES += \
-QT       -= core
+QMAKE_CXXFLAGS += /permissive-
 
-QT       -= gui
-
-TARGET = test
-CONFIG   += console
-TEMPLATE = app
+QT += core gui widgets
 
 CORE_ROOT_DIR = $$PWD/../../../..
 PWD_ROOT_DIR = $$PWD
@@ -21,6 +16,13 @@ GRAPHICS_AGG_PATH = $$PWD/../../../agg-2.4
 INCLUDEPATH += \
     $$GRAPHICS_AGG_PATH/include
 
-SOURCES += main.cpp
+SOURCES += main.cpp \
+	mainwindow.cpp
 
 DESTDIR = $$PWD_ROOT_DIR/build/$$CORE_BUILDS_PLATFORM_PREFIX/$$CORE_BUILDS_CONFIGURATION_PREFIX
+
+FORMS += \
+	mainwindow.ui
+
+HEADERS += \
+	mainwindow.h

DesktopEditor/graphics/tests/metaFiles/main.cpp

@@ -0,0 +1,11 @@
+#include "mainwindow.h"
+
+#include <QApplication>
+
+int main(int argc, char *argv[])
+{
+	QApplication a(argc, argv);
+	MainWindow w;
+	w.show();
+	return a.exec();
+}

DesktopEditor/graphics/tests/metaFiles/mainwindow.cpp

@@ -0,0 +1,76 @@
+#include "mainwindow.h"
+#include "ui_mainwindow.h"
+
+#include <QFileDialog>
+#include <QLabel>
+#include <QSizePolicy>
+#include <QDir>
+
+#include "../../../../UnicodeConverter/UnicodeConverter.h"
+#include "../../pro/Graphics.h"
+
+MainWindow::MainWindow(QWidget *parent)
+	: QMainWindow(parent)
+	, ui(new Ui::MainWindow)
+{
+	ui->setupUi(this);
+	ui->label->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+	ui->label->setFixedWidth(160);
+}
+
+MainWindow::~MainWindow()
+{
+	delete ui;
+}
+
+void MainWindow::on_pushButton_clicked()
+{
+	m_arFileNames = QFileDialog::getOpenFileNames(this,
+												  "Select one or more metafiles to convert",
+												  "",
+												  "*.emf *.wmf *.svm *.svg");
+	if (!m_arFileNames.empty())
+		ui->label->setText("File:" + m_arFileNames[0]);
+}
+
+
+void MainWindow::on_pushButton_2_clicked()
+{
+	auto save_dir = QFileDialog::getExistingDirectory(this,
+													  "Open Directory",
+													  "",
+													  QFileDialog::ShowDirsOnly |
+													  QFileDialog::DontResolveSymlinks);
+
+	NSUnicodeConverter::CUnicodeConverter converter;
+	for (const auto& f : m_arFileNames)
+	{
+		ui->label->setText("File:" + f);
+		NSFonts::IApplicationFonts* app_fonts = NSFonts::NSApplication::Create();
+		app_fonts->Initialize();
+		MetaFile::IMetaFile* meta_file = MetaFile::Create(app_fonts);
+		if (!meta_file->LoadFromFile(converter.toUnicode(f.toStdString(), 1).c_str()))
+			return;
+
+		double x, y, w, h;
+		meta_file->GetBounds(&x, &y, &w, &h);
+
+		if (ui->radioButton->isChecked())
+			meta_file->ConvertToRaster(converter.toUnicode(QDir(save_dir).filePath("res.bmp").toStdString(), 1).c_str(), 1,
+									   static_cast<int>(w) + 1, static_cast<int>(h) + 1);
+		else if (ui->radioButton_2->isChecked())
+			meta_file->ConvertToXml(converter.toUnicode(QDir(save_dir).filePath("res.xml").toStdString(), 1).c_str());
+		else if (ui->radioButton_3->isChecked())
+			meta_file->ConvertToRaster(converter.toUnicode(QDir(save_dir).filePath("res.bmp").toStdString(), 1).c_str(), 1,
+									   static_cast<int>(w) + 1, static_cast<int>(h) + 1,
+									   converter.toUnicode(QDir(save_dir).filePath("res.xml").toStdString(), 1).c_str());
+		else if (ui->radioButton_4->isChecked())
+			meta_file->ConvertToSvg(static_cast<int>(w) + 1, static_cast<int>(h) + 1);
+		else if (ui->radioButton_5->isChecked())
+			meta_file->ConvertToEmf(converter.toUnicode(QDir(save_dir).filePath("res.emf").toStdString(), 1).c_str());
+
+		RELEASEOBJECT(app_fonts);
+		RELEASEOBJECT(meta_file);
+	}
+}
+

DesktopEditor/graphics/tests/metaFiles/mainwindow.h

@@ -0,0 +1,32 @@
+#ifndef MAINWINDOW_H
+#define MAINWINDOW_H
+
+#include <QMainWindow>
+#include <QString>
+#include <QStringList>
+
+
+namespace Ui {
+class MainWindow;
+}
+
+class MainWindow : public QMainWindow
+{
+	Q_OBJECT
+
+public:
+	explicit MainWindow(QWidget *parent = nullptr);
+	~MainWindow();
+
+private slots:
+	void on_pushButton_clicked();
+
+	void on_pushButton_2_clicked();
+
+private:
+	Ui::MainWindow *ui;
+
+	QStringList		m_arFileNames;
+};
+
+#endif // MAINWINDOW_H

DesktopEditor/graphics/tests/metaFiles/mainwindow.ui

@@ -0,0 +1,161 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>540</width>
+    <height>211</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>MainWindow</string>
+  </property>
+  <widget class="QWidget" name="centralwidget">
+   <widget class="QPushButton" name="pushButton">
+    <property name="geometry">
+     <rect>
+      <x>50</x>
+      <y>60</y>
+      <width>161</width>
+      <height>24</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Choose Metafile</string>
+    </property>
+   </widget>
+   <widget class="QGroupBox" name="groupBox">
+    <property name="geometry">
+     <rect>
+      <x>250</x>
+      <y>0</y>
+      <width>151</width>
+      <height>131</height>
+     </rect>
+    </property>
+    <property name="title">
+     <string>Choose to convert</string>
+    </property>
+    <widget class="QRadioButton" name="radioButton">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>30</y>
+       <width>91</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Raster(.bmp)</string>
+     </property>
+    </widget>
+    <widget class="QRadioButton" name="radioButton_2">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>50</y>
+       <width>91</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Xml</string>
+     </property>
+    </widget>
+    <widget class="QRadioButton" name="radioButton_3">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>70</y>
+       <width>131</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Raster(.bmp) + Xml</string>
+     </property>
+    </widget>
+    <widget class="QRadioButton" name="radioButton_4">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>90</y>
+       <width>91</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Svg</string>
+     </property>
+    </widget>
+    <widget class="QRadioButton" name="radioButton_5">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>110</y>
+       <width>91</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Emf</string>
+     </property>
+    </widget>
+   </widget>
+   <widget class="QPushButton" name="pushButton_2">
+    <property name="geometry">
+     <rect>
+      <x>450</x>
+      <y>60</y>
+      <width>80</width>
+      <height>24</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Convert</string>
+    </property>
+   </widget>
+   <widget class="QLabel" name="label">
+    <property name="geometry">
+     <rect>
+      <x>60</x>
+      <y>90</y>
+      <width>151</width>
+      <height>71</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>File: </string>
+    </property>
+    <property name="scaledContents">
+     <bool>false</bool>
+    </property>
+    <property name="wordWrap">
+     <bool>true</bool>
+    </property>
+    <property name="margin">
+     <number>0</number>
+    </property>
+    <property name="openExternalLinks">
+     <bool>false</bool>
+    </property>
+   </widget>
+  </widget>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>540</width>
+     <height>21</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QStatusBar" name="statusbar"/>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

DesktopEditor/graphics/tests/metaFiles/test.pro

@@ -0,0 +1,23 @@
+CONFIG += c++11
+
+QMAKE_CXXFLAGS += /permissive-
+
+QT       += core gui widgets
+
+SOURCES += \
+	main.cpp\
+	mainwindow.cpp
+
+FORMS += \
+	mainwindow.ui
+
+HEADERS += \
+	mainwindow.h
+
+PWD_ROOT_DIR = $$PWD
+CORE_ROOT_DIR = $$PWD/../../../../../core
+include($$CORE_ROOT_DIR/Common/base.pri)
+
+ADD_DEPENDENCY(kernel, graphics, UnicodeConverter)
+include($$CORE_ROOT_DIR/Common/3dParty/icu/icu.pri)
+

DesktopEditor/graphics/tests/text/main.cpp

@@ -0,0 +1,11 @@
+#include "mainwindow.h"
+
+#include <QApplication>
+
+int main(int argc, char *argv[])
+{
+	QApplication a(argc, argv);
+	MainWindow w;
+	w.show();
+	return a.exec();
+}

DesktopEditor/graphics/tests/text/mainwindow.cpp

@@ -0,0 +1,97 @@
+#include "mainwindow.h"
+#include "ui_mainwindow.h"
+
+#include <iterator>
+
+#include <QImage>
+#include <QPixmap>
+#include <QString>
+
+MainWindow::MainWindow(QWidget *parent)
+	: QMainWindow(parent)
+	, ui(new Ui::MainWindow)
+{
+	ui->setupUi(this);
+	ui->pushButton->SetColor(Qt::black);
+
+	m_oAppFonts = NSFonts::NSApplication::Create();
+	m_oAppFonts->Initialize();
+
+	m_oFontManager = m_oAppFonts->GenerateFontManager();
+	NSFonts::IFontsCache* fonts_cache = NSFonts::NSFontCache::Create();
+	fonts_cache->SetStreams(m_oAppFonts->GetStreams());
+	m_oFontManager->SetOwnerCache(fonts_cache);
+
+	for (auto it = m_oAppFonts->GetList()->GetFonts()->cbegin(); it != m_oAppFonts->GetList()->GetFonts()->cend(); it++)
+		ui->comboBox->addItem(QString::fromWCharArray((*it)->m_wsFontName.c_str()));
+
+	connect(ui->textEdit,	&QTextEdit::textChanged,		this, &MainWindow::Draw);
+	connect(ui->spinBox,	&QSpinBox::valueChanged,		this, &MainWindow::Draw);
+	connect(ui->comboBox,	&QComboBox::currentTextChanged, this, &MainWindow::Draw);
+	connect(ui->checkBox,	&QCheckBox::stateChanged,		this, &MainWindow::Draw);
+	connect(ui->checkBox_2, &QCheckBox::stateChanged,		this, &MainWindow::Draw);
+	connect(ui->pushButton, &CColorButton::ColorChanged,	this, &MainWindow::Draw);
+}
+
+MainWindow::~MainWindow()
+{
+	RELEASEOBJECT(m_oAppFonts);
+	RELEASEOBJECT(m_oFontManager);
+	delete ui;
+}
+
+
+void MainWindow::Draw()
+{
+	NSGraphics::IGraphicsRenderer* renderer = NSGraphics::Create();
+	renderer->SetFontManager(m_oFontManager);
+
+	int width = ui->label->width(),
+		height = ui->label->height();
+
+	BYTE* data = new BYTE[4 * width * height];
+
+	CBgraFrame frame;
+	frame.put_Data(data);
+	frame.put_Width(width);
+	frame.put_Height(height);
+	frame.put_Stride(4 * width);
+
+	renderer->put_Width(100);
+	renderer->put_Height(100);
+
+	renderer->CreateFromBgraFrame(&frame);
+	renderer->SetSwapRGB(false);
+
+	renderer->put_FontName(ui->comboBox->currentText().toStdWString());
+	renderer->put_FontSize(ui->spinBox->value());
+
+	long font_style = 0;
+	if (ui->checkBox->isChecked())
+		font_style |= 0x01;
+	if (ui->checkBox_2->isChecked())
+		font_style |= 0x02;
+	renderer->put_FontStyle(font_style);
+
+	renderer->put_BrushColor1(ui->pushButton->GetColor().rgb());
+
+	auto lines = ui->textEdit->toPlainText().split('\n');
+	double x = 1.0;
+	double y =  (ui->spinBox->value() * 25.4 / 96.0) + 3.0;
+	double scale_y = y;
+
+	renderer->BeginCommand(c_nTextGraphicType);
+	for (auto it = lines.cbegin(); it != lines.cend(); it++)
+	{
+		renderer->CommandDrawText((*it).toStdWString(), x, y, 0.0, 0.0);
+		y += scale_y;
+	}
+	renderer->EndCommand(c_nTextGraphicType);
+
+	QImage img = QImage(data, width, height, QImage::Format_RGBA8888, [](void *data){
+		delete[] (BYTE*)data;
+	});
+	ui->label->setPixmap(QPixmap::fromImage(img));
+
+	RELEASEOBJECT(renderer);
+}

DesktopEditor/graphics/tests/text/mainwindow.h

@@ -0,0 +1,80 @@
+#ifndef MAINWINDOW_H
+#define MAINWINDOW_H
+
+#include "../../pro/Graphics.h"
+
+#include <QMainWindow>
+#include <QPushButton>
+#include <QColor>
+#include <QColorDialog>
+#include <QPalette>
+
+class CColorButton final : public QPushButton
+{
+	Q_OBJECT
+public:
+	CColorButton(QWidget *parent = nullptr) : QPushButton(parent)
+	{
+		connect(this, &QPushButton::clicked, this, &CColorButton::onClicked);
+	}
+
+	~CColorButton() {}
+
+	QColor GetColor() const
+	{
+		return m_oColor;
+	}
+
+	void SetColor(const QColor& color)
+	{
+		if (color == m_oColor)
+			return;
+
+		m_oColor = color;
+		setStyleSheet("QPushButton { background-color : " + m_oColor.name()
+					  + "; border: 1px solid black; padding 10px;}");
+
+		emit ColorChanged();
+	}
+
+signals:
+	void ColorChanged();
+
+public slots:
+	void onClicked()
+	{
+		QColorDialog color_dialog;
+		auto color = color_dialog.getColor();
+
+		if (color.isValid())
+			SetColor(color);
+	}
+
+private:
+	QColor m_oColor;
+};
+
+QT_BEGIN_NAMESPACE
+namespace Ui {
+class MainWindow;
+}
+QT_END_NAMESPACE
+
+class MainWindow : public QMainWindow
+{
+	Q_OBJECT
+
+public:
+	MainWindow(QWidget *parent = nullptr);
+	~MainWindow();
+
+public slots:
+	void Draw();
+
+private:
+	Ui::MainWindow *ui;
+
+	NSFonts::IApplicationFonts* m_oAppFonts;
+	NSFonts::IFontManager*		m_oFontManager;
+};
+#endif // MAINWINDOW_H

DesktopEditor/graphics/tests/text/mainwindow.ui

@@ -0,0 +1,214 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>471</width>
+    <height>390</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>MainWindow</string>
+  </property>
+  <widget class="QWidget" name="centralwidget">
+   <widget class="QLabel" name="label">
+    <property name="geometry">
+     <rect>
+      <x>10</x>
+      <y>130</y>
+      <width>450</width>
+      <height>200</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string/>
+    </property>
+   </widget>
+   <widget class="QTextEdit" name="textEdit">
+    <property name="geometry">
+     <rect>
+      <x>10</x>
+      <y>20</y>
+      <width>180</width>
+      <height>70</height>
+     </rect>
+    </property>
+    <property name="placeholderText">
+     <string>Hello</string>
+    </property>
+   </widget>
+   <widget class="QLabel" name="label_2">
+    <property name="geometry">
+     <rect>
+      <x>10</x>
+      <y>0</y>
+      <width>61</width>
+      <height>16</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Text input:</string>
+    </property>
+   </widget>
+   <widget class="QGroupBox" name="groupBox">
+    <property name="geometry">
+     <rect>
+      <x>200</x>
+      <y>0</y>
+      <width>261</width>
+      <height>91</height>
+     </rect>
+    </property>
+    <property name="title">
+     <string>Brush</string>
+    </property>
+    <widget class="QSpinBox" name="spinBox">
+     <property name="geometry">
+      <rect>
+       <x>140</x>
+       <y>40</y>
+       <width>42</width>
+       <height>25</height>
+      </rect>
+     </property>
+     <property name="value">
+      <number>30</number>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_3">
+     <property name="geometry">
+      <rect>
+       <x>140</x>
+       <y>20</y>
+       <width>49</width>
+       <height>16</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Font size:</string>
+     </property>
+    </widget>
+    <widget class="QCheckBox" name="checkBox">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>70</y>
+       <width>51</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Bold</string>
+     </property>
+    </widget>
+    <widget class="QCheckBox" name="checkBox_2">
+     <property name="geometry">
+      <rect>
+       <x>60</x>
+       <y>70</y>
+       <width>51</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Italic</string>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_5">
+     <property name="geometry">
+      <rect>
+       <x>200</x>
+       <y>20</y>
+       <width>41</width>
+       <height>16</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Color:</string>
+     </property>
+    </widget>
+    <widget class="CColorButton" name="pushButton">
+     <property name="geometry">
+      <rect>
+       <x>200</x>
+       <y>40</y>
+       <width>31</width>
+       <height>24</height>
+      </rect>
+     </property>
+     <property name="autoFillBackground">
+      <bool>false</bool>
+     </property>
+     <property name="styleSheet">
+      <string notr="true"/>
+     </property>
+     <property name="text">
+      <string/>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_6">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>20</y>
+       <width>31</width>
+       <height>16</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Font:</string>
+     </property>
+    </widget>
+    <widget class="QComboBox" name="comboBox">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>40</y>
+       <width>121</width>
+       <height>24</height>
+      </rect>
+     </property>
+     <property name="duplicatesEnabled">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </widget>
+   <widget class="QLabel" name="label_4">
+    <property name="geometry">
+     <rect>
+      <x>10</x>
+      <y>100</y>
+      <width>71</width>
+      <height>16</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Text output:</string>
+    </property>
+   </widget>
+  </widget>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>471</width>
+     <height>21</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QStatusBar" name="statusbar"/>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>CColorButton</class>
+   <extends>QPushButton</extends>
+   <header>mainwindow.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

DesktopEditor/graphics/tests/text/test.pro

@@ -0,0 +1,20 @@
+QT += core gui widgets
+
+QMAKE_CXXFLAGS += /permissive-
+
+SOURCES += \
+	main.cpp \
+	mainwindow.cpp
+
+HEADERS += \
+	mainwindow.h
+
+FORMS += \
+	mainwindow.ui
+
+PWD_ROOT_DIR = $$PWD
+CORE_ROOT_DIR = $$PWD/../../../../../core
+include($$CORE_ROOT_DIR/Common/base.pri)
+
+ADD_DEPENDENCY(kernel, graphics, UnicodeConverter)
+include($$CORE_ROOT_DIR/Common/3dParty/icu/icu.pri)

DesktopEditor/raster/Metafile/MetaFile.cpp

@@ -47,11 +47,18 @@ namespace MetaFile
 		return new CMetaFile(pAppFonts);
 	}
 
+	/**
+	 * @brief CMetaFile Constructor
+	 * @param pAppFonts
+	 *
+	 * Create a font manager accordingly Applications Fonts for the
+	 * appropriate metafile.
+	 */
 	CMetaFile::CMetaFile(NSFonts::IApplicationFonts *pAppFonts) : MetaFile::IMetaFile(pAppFonts)
 	{
 		m_pFontManager = NULL;
 		m_pAppFonts = pAppFonts;
-		// Создаем менеджер шрифтов с собственным кэшем
+
 		if (pAppFonts)
 		{
 			m_pFontManager = pAppFonts->GenerateFontManager();
@@ -60,28 +67,35 @@ namespace MetaFile
 			m_pFontManager->SetOwnerCache(pMeasurerCache);
 		}
 
-	#ifdef METAFILE_SUPPORT_WMF_EMF
-		m_oWmfFile.SetFontManager(m_pFontManager);
-		m_oEmfFile.SetFontManager(m_pFontManager);
-	#endif
-
-	#ifdef METAFILE_SUPPORT_SVM
-		m_oSvmFile.SetFontManager(m_pFontManager);
-	#endif
 		m_lType  = 0;
 	}
 
+	/**
+	 * @brief CMetaFile::get_FontManager
+	 * @return Pointer of current Font Manager
+	 */
 	NSFonts::IFontManager* CMetaFile::get_FontManager()
 	{
 		return m_pFontManager;
 	}
 
+	/**
+	 * @brief CMetaFile Destructor
+	 *
+	 * Close metafile and release memory, allocated for Font Manager
+	 */
 	CMetaFile::~CMetaFile()
 	{
 		Close();
 		RELEASEINTERFACE(m_pFontManager);
 	}
 
+	/**
+	 * @brief CMetaFile::ConvertToSvg
+	 * @param unWidth - width of picture from metafile (0 - default)
+	 * @param unHeight - height of picture from metafile (0 - default)
+	 * @return string containing svg content
+	 */
 	std::wstring CMetaFile::ConvertToSvg(unsigned int unWidth, unsigned int unHeight)
 	{
 
@@ -102,7 +116,16 @@ namespace MetaFile
 		return L"";
 	}
 
+	/**
+	 * @brief Methods for conversation in test examples
+	 */
 #ifdef METAFILE_SUPPORT_WMF_EMF
+	/**
+	 * @brief CMetaFile::ConvertToXml
+	 * @param wsFilePath - path to the file being saving (must be .xml)
+	 *
+	 * Convert and save metafile data to .xml
+	 */
 	void CMetaFile::ConvertToXml(const wchar_t *wsFilePath)
 	{
 		if (NULL == wsFilePath)
@@ -112,129 +135,17 @@ namespace MetaFile
 		m_oEmfFile.PlayMetaFile();
 	}
 
-	void CMetaFile::ConvertToXmlAndRaster(const wchar_t *wsXmlFilePath, const wchar_t *wsOutFilePath, unsigned int unFileType, int nWidth, int nHeight)
-	{
-		if (NULL == wsXmlFilePath || NULL == wsOutFilePath)
-			return;
-
-		m_oEmfFile.SetOutputDevice(NULL, wsXmlFilePath);
-
-		NSGraphics::IGraphicsRenderer* pGrRenderer = NSGraphics::Create();
-
-		NSFonts::IFontManager* pFontManager = m_pAppFonts->GenerateFontManager();
-		NSFonts::IFontsCache* pFontCache = NSFonts::NSFontCache::Create();
-		pFontCache->SetStreams(m_pAppFonts->GetStreams());
-		pFontManager->SetOwnerCache(pFontCache);
-
-		pGrRenderer->SetFontManager(pFontManager);
-
-		if (-1 == nHeight)
-		{
-			double dX, dY, dW, dH;
-			GetBounds(&dX, &dY, &dW, &dH);
-
-			if (dW < 0)
-				dW = -dW;
-			if (dH < 0)
-				dH = -dH;
-
-			if (nWidth < 0) nWidth = (int)(dW * 96 / 25.4);
-			nHeight = (int)((double)nWidth * dH / dW);
-		}
-
-		double dWidth  = 25.4 * nWidth / 96;
-		double dHeight = 25.4 * nHeight / 96;
-
-		BYTE* pBgraData = new(std::nothrow) BYTE[nWidth * nHeight * 4];
-		if (!pBgraData)
-			return;
-
-		unsigned int alfa = 0xffffff;
-		//дефолтный тон должен быть прозрачным, а не белым
-		//memset(pBgraData, 0xff, nWidth * nHeight * 4);
-		for (int i = 0; i < nWidth * nHeight; i++)
-		{
-			((unsigned int*)pBgraData)[i] = alfa;
-		}
-		CBgraFrame oFrame;
-		oFrame.put_Data(pBgraData);
-		oFrame.put_Width(nWidth);
-		oFrame.put_Height(nHeight);
-		oFrame.put_Stride(-4 * nWidth);
-
-		pGrRenderer->CreateFromBgraFrame(&oFrame);
-		pGrRenderer->SetSwapRGB(false);
-		pGrRenderer->put_Width(dWidth);
-		pGrRenderer->put_Height(dHeight);
-
-		DrawOnRenderer(wsXmlFilePath, pGrRenderer, 0, 0, dWidth, dHeight);
-
-		oFrame.SaveFile(wsOutFilePath, unFileType);
-
-		RELEASEINTERFACE(pFontManager);
-		RELEASEINTERFACE(pGrRenderer);
-	}
-
-	bool CMetaFile::DrawOnRenderer(const wchar_t *wsXmlFilePath, IRenderer *pRenderer, double dX, double dY, double dWidth, double dHeight)
-	{
-		if (NULL == wsXmlFilePath || NULL == pRenderer)
-			return false;
-
-		pRenderer->BeginCommand(c_nImageType);
-
-		switch (m_lType)
-		{
-		#ifdef METAFILE_SUPPORT_WMF_EMF
-			case c_lMetaWmf:
-			{
-				CMetaFileRenderer oWmfOut(m_oWmfFile.GetWmfParser(), pRenderer, dX, dY, dWidth, dHeight);
-				m_oWmfFile.SetOutputDevice((IOutputDevice*)&oWmfOut);
-				m_oWmfFile.PlayMetaFile();
-				break;
-			}
-			case c_lMetaEmf:
-			{
-				CMetaFileRenderer oEmfOut(m_oEmfFile.GetEmfParser(), pRenderer, dX, dY, dWidth, dHeight);
-				m_oEmfFile.SetOutputDevice((IOutputDevice*)&oEmfOut, wsXmlFilePath);
-				m_oEmfFile.PlayMetaFile();
-				break;
-			}
-		#endif
-		#ifdef METAFILE_SUPPORT_SVM
-			case c_lMetaSvm:
-			{
-				CMetaFileRenderer oSvmOut(&m_oSvmFile, pRenderer, dX, dY, dWidth, dHeight);
-				m_oSvmFile.SetOutputDevice((IOutputDevice*)&oSvmOut);
-				m_oSvmFile.PlayMetaFile();
-				break;
-			}
-		#endif
-		#ifdef METAFILE_SUPPORT_SVG
-			case c_lMetaSvg:
-			{
-				m_oSvgFile.Draw(pRenderer, dX, dY, dWidth, dHeight);
-				break;
-			}
-		#endif
-			default:
-				break;
-		}
-
-		pRenderer->EndCommand(c_nImageType);
-		return true;
-	}
-
+	/**
+	 * @brief CMetaFile::LoadFromXmlFile
+	 * @param wsFilePath - path to the source file (must be .xml)
+	 * @return if correct reading - return true, elde - false
+	 *
+	 * Load meta file content from source .xml file.
+	 * Remake Font Manager for metafile
+	 */
 	bool CMetaFile::LoadFromXmlFile(const wchar_t *wsFilePath)
 	{
-		RELEASEINTERFACE(m_pFontManager);
-
-		if (m_pAppFonts)
-		{
-			m_pFontManager = m_pAppFonts->GenerateFontManager();
-			NSFonts::IFontsCache* pMeasurerCache = NSFonts::NSFontCache::Create();
-			pMeasurerCache->SetStreams(m_pAppFonts->GetStreams());
-			m_pFontManager->SetOwnerCache(pMeasurerCache);
-		}
+		m_pFontManager->ClearOwnerCache();
 
 		m_oWmfFile.SetFontManager(m_pFontManager);
 		m_oEmfFile.SetFontManager(m_pFontManager);
@@ -264,6 +175,10 @@ namespace MetaFile
 		return false;
 	}
 
+	/**
+	 * @brief CMetaFile::ConvertToEmf
+	 * @param wsFilePath - path to the file being saving (must be .emf)
+	 */
 	void CMetaFile::ConvertToEmf(const wchar_t *wsFilePath)
 	{
 		if (m_lType != c_lMetaEmf || m_oEmfFile.GetEmfParser()->GetType() != EmfParserType::EmfxParser)
@@ -276,21 +191,18 @@ namespace MetaFile
 	}
 #endif
 
+	/**
+	 * @brief CMetaFile::LoadFromFile
+	 * @param wsFilePath - path to source file
+	 * @return if correct reading - return true, elde - false
+	 *
+	 * Load from source file
+	 * Remake Font Manager for metafile, for each picture
+	 * Check file extansion (wmf, emf, svm, svg)
+	 */
 	bool CMetaFile::LoadFromFile(const wchar_t *wsFilePath)
 	{
-		// TODO: Сейчас при загрузке каждой новой картинки мы пересоздаем
-		//       FontManager, потому что сейчас в нем кэш без ограничения.
-		//------------------------------------------------------
-
-		RELEASEINTERFACE(m_pFontManager);
-
-		if (m_pAppFonts)
-		{
-			m_pFontManager = m_pAppFonts->GenerateFontManager();
-			NSFonts::IFontsCache* pMeasurerCache = NSFonts::NSFontCache::Create();
-			pMeasurerCache->SetStreams(m_pAppFonts->GetStreams());
-			m_pFontManager->SetOwnerCache(pMeasurerCache);
-		}
+		m_pFontManager->ClearOwnerCache();
 
 	#ifdef METAFILE_SUPPORT_WMF_EMF
 		m_oWmfFile.SetFontManager(m_pFontManager);
@@ -305,10 +217,7 @@ namespace MetaFile
 		m_oSvgFile.SetFontManager(m_pFontManager);
 	#endif
 
-		//------------------------------------------------------
-
 	#ifdef METAFILE_SUPPORT_WMF_EMF
-		// Сначала пытаемся открыть файл как Wmf
 		if (m_oWmfFile.OpenFromWmfFile(wsFilePath) == true)
 		{
 			m_oWmfFile.Scan();
@@ -320,7 +229,7 @@ namespace MetaFile
 			}
 			m_oWmfFile.Close();
 		}
-		// Это не Wmf
+
 		if (m_oEmfFile.OpenFromEmfFile(wsFilePath) == true)
 		{
 			m_oEmfFile.Scan();
@@ -333,7 +242,7 @@ namespace MetaFile
 			m_oEmfFile.Close();
 		}
 	#endif
-		// Это не Emf
+
 	#ifdef METAFILE_SUPPORT_SVM
 		if (m_oSvmFile.OpenFromFile(wsFilePath) == true)
 		{
@@ -348,37 +257,47 @@ namespace MetaFile
 			m_oSvmFile.Close();
 		}
 	#endif
-		// Это не svm
+
 	#ifdef METAFILE_SUPPORT_SVG
 		if (m_oSvgFile.OpenFromFile(wsFilePath) == true)
 		{
 			m_lType = c_lMetaSvg;
 			return true;
 		}
-
 	#endif
 
 		return false;
 	}
 
+	/**
+	 * @brief CMetaFile::LoadFromBuffer
+	 * @param pBuffer - pointer of buffer whith metacontent
+	 *  for example, the buffer obtained after reading the file
+	 *   @code
+	 *   	NSFile::CFileBinary file;
+	 *  	file.OpenFile(L"file_name");
+	 *  	DWORD file_size = file.GetFileSize();
+	 *  	BYTE* data = new BYTE[file_size];
+	 *  	file.ReadFile(data, file_size);
+	 *   @endcode
+	 * @param unSize - buffer size (size of file or readed size)
+	 *   @code
+	 *   	DWORD readed_size;
+	 *   	file.ReadFile(data, file_size, readed_size);
+	 *   @endcode
+	 * @return if correct format load for extansion - return true,
+	 *   else - false
+	 *
+	 * Load metafile content from buffer
+	 * Remake Font Manager for metafile, for each picture
+	 * Check type of content in buffer, appropriate extension (wmf, emf, svm, svg)
+	 */
 	bool CMetaFile::LoadFromBuffer(BYTE *pBuffer, unsigned int unSize)
 	{
 		if (NULL == pBuffer || 0 == unSize)
 			return false;
 
-		// TODO: Сейчас при загрузке каждой новой картинки мы пересоздаем
-		//       FontManager, потому что сейчас в нем кэш без ограничения.
-		//------------------------------------------------------
-
-		RELEASEINTERFACE(m_pFontManager);
-
-		if (m_pAppFonts)
-		{
-			m_pFontManager = m_pAppFonts->GenerateFontManager();
-			NSFonts::IFontsCache* pMeasurerCache = NSFonts::NSFontCache::Create();
-			pMeasurerCache->SetStreams(m_pAppFonts->GetStreams());
-			m_pFontManager->SetOwnerCache(pMeasurerCache);
-		}
+		m_pFontManager->ClearOwnerCache();
 
 	#ifdef METAFILE_SUPPORT_WMF_EMF
 		m_oWmfFile.SetFontManager(m_pFontManager);
@@ -393,10 +312,7 @@ namespace MetaFile
 		m_oSvgFile.SetFontManager(m_pFontManager);
 	#endif
 
-		//------------------------------------------------------
-
 	#ifdef METAFILE_SUPPORT_WMF_EMF
-		// Сначала пытаемся открыть файл как Wmf
 		if (m_oWmfFile.ReadFromBuffer(pBuffer, unSize) == true)
 		{
 			m_oWmfFile.Scan();
@@ -408,7 +324,7 @@ namespace MetaFile
 			}
 			m_oWmfFile.Close();
 		}
-		// Это не Wmf
+
 		if (m_oEmfFile.ReadFromBuffer(pBuffer, unSize) == true)
 		{
 			m_oEmfFile.Scan();
@@ -421,7 +337,7 @@ namespace MetaFile
 			m_oEmfFile.Close();
 		}
 	#endif
-		// Это не Emf
+
 	#ifdef METAFILE_SUPPORT_SVM
 		if (m_oSvmFile.ReadFromBuffer(pBuffer, unSize) == true)
 		{
@@ -436,7 +352,7 @@ namespace MetaFile
 			m_oSvmFile.Close();
 		}
 	#endif
-		// Это не svm
+
 	#ifdef METAFILE_SUPPORT_SVG
 		if (m_oSvgFile.ReadFromBuffer(pBuffer, unSize) == true)
 		{
@@ -448,19 +364,18 @@ namespace MetaFile
 		return false;
 	}
 
+	/**
+	 * @brief CMetaFile::LoadFromString
+	 * @param data - source string, containing svg metadata (.svg extension type)
+	 * @return if correct read svg content - return true, else - false
+	 *
+	 * Load .svg content from wide string
+	 * Remake Font Manager for metafile, for each picture
+	 */
 	bool CMetaFile::LoadFromString(const std::wstring& data)
 	{
+		m_pFontManager->ClearOwnerCache();
 #ifdef METAFILE_SUPPORT_SVG
-		RELEASEINTERFACE(m_pFontManager);
-
-		if (m_pAppFonts)
-		{
-			m_pFontManager = m_pAppFonts->GenerateFontManager();
-			NSFonts::IFontsCache* pMeasurerCache = NSFonts::NSFontCache::Create();
-			pMeasurerCache->SetStreams(m_pAppFonts->GetStreams());
-			m_pFontManager->SetOwnerCache(pMeasurerCache);
-		}
-
 		m_oSvgFile.SetFontManager(m_pFontManager);
 
 		if (m_oSvgFile.ReadFromWString(data) == true)
@@ -472,6 +387,10 @@ namespace MetaFile
 		return false;
 	}
 
+	/**
+	 * @brief CMetaFile::SetTempDirectory
+	 * @param dir - path to working directory
+	 */
 	void CMetaFile::SetTempDirectory(const std::wstring& dir)
 	{
 #ifdef METAFILE_SUPPORT_SVG
@@ -479,7 +398,23 @@ namespace MetaFile
 #endif
 	}
 
-	bool CMetaFile::DrawOnRenderer(IRenderer* pRenderer, double dX, double dY, double dWidth, double dHeight)
+	/**
+	 * @brief CMetaFile::DrawOnRenderer
+	 * @param pRenderer - class instance of CGraphicsRenderer, which will render
+	 *  meta content
+	 * @param dX - start coordinate for X axis
+	 * @param dY - start coordinate for Y axis
+	 * @param dWidth - width of picture from metafile
+	 * @param dHeight - height of picture from metafile
+	 * @param wsXmlFilePath - path to the file being saveing as xml commands from
+	 * 	metafile (default - nullptr)
+	 * @return if none render - return false, else - true
+	 *
+	 * Check type of metacontent
+	 * Draw the meta file picture on renderer
+	 */
+	bool CMetaFile::DrawOnRenderer(IRenderer* pRenderer, double dX, double dY,
+								   double dWidth, double dHeight, const wchar_t* wsXmlFilePath)
 	{
 		if (NULL == pRenderer)
 			return false;
@@ -499,7 +434,10 @@ namespace MetaFile
 			case c_lMetaEmf:
 			{
 				CMetaFileRenderer oEmfOut(m_oEmfFile.GetEmfParser(), pRenderer, dX, dY, dWidth, dHeight);
-				m_oEmfFile.SetOutputDevice((IOutputDevice*)&oEmfOut);
+				if (wsXmlFilePath)
+					m_oEmfFile.SetOutputDevice((IOutputDevice*)&oEmfOut, wsXmlFilePath);
+				else
+					m_oEmfFile.SetOutputDevice((IOutputDevice*)&oEmfOut);
 				m_oEmfFile.PlayMetaFile();
 				break;
 			}
@@ -528,6 +466,11 @@ namespace MetaFile
 		return true;
 	}
 
+	/**
+	 * @brief CMetaFile::Close
+	 *
+	 * Close each type file (type = 0)
+	 */
 	void CMetaFile::Close()
 	{
 	#ifdef METAFILE_SUPPORT_WMF_EMF
@@ -542,11 +485,27 @@ namespace MetaFile
 		m_lType  = 0;
 	}
 
+	/**
+	 * @brief CMetaFile::GetType
+	 * @return type of metafile
+	 * @enum
+	 *	c_lMetaWmf = 0x01;
+	 *  c_lMetaEmf = 0x02;
+	 *  c_lMetaSvg = 0x04;
+	 *  c_lMetaSvm = 0x05;
+	 */
 	int  CMetaFile::GetType()
 	{
 		return m_lType;
 	}
 
+	/**
+	 * @brief CMetaFile::GetBounds
+	 * @param pdX - pointer to saving X coordinate of bounds
+	 * @param pdY - pointer to saving Y coordinate of bounds
+	 * @param pdW - pointer to saving Width of bounds
+	 * @param pdH - pointer to saving height of bounds
+	 */
 	void CMetaFile::GetBounds(double* pdX, double* pdY, double* pdW, double* pdH)
 	{
 		switch (m_lType)
@@ -609,11 +568,31 @@ namespace MetaFile
 		if (*pdH < 0) *pdH = -*pdH;
 	}
 
-	void CMetaFile::ConvertToRaster(const wchar_t* wsOutFilePath, unsigned int unFileType, int nWidth, int nHeight)
+	/**
+	 * @brief CMetaFile::ConvertToRaster
+	 * @param wsOutFilePath - path to the file being saving (must be raster graphics
+	 *  like .bmp, .png, etc.)
+	 * @param unFileType - type of raster file, see ENUM_CXIMAGE_FORMATS
+	 * 	for example .bmp = 1, .png = 4
+	 * @param unWidth - width of picture from metafile
+	 * @param unHeight - height of picture from metafile (default -1)
+	 * @param wsXmlOutFile(optional) - path to the file being saving metafile
+	 *	commands to .xml (default nullptr)
+	 *
+	 * Create Graphics Renderer and Font Manager
+	 * Draw metafile content on created renderer and save in raster graphics file
+	 */
+	void CMetaFile::ConvertToRaster(const wchar_t* wsOutFilePath, unsigned int unFileType, int nWidth, int nHeight, const wchar_t* wsXmlOutFile)
 	{
 		if (nWidth == 0 || nHeight == 0)
 			return;
 
+		if (NULL == wsOutFilePath)
+			return;
+
+		if (wsXmlOutFile != NULL)
+			m_oEmfFile.SetOutputDevice(NULL, wsXmlOutFile);
+
 		NSGraphics::IGraphicsRenderer* pGrRenderer = NSGraphics::Create();
 
 		NSFonts::IFontManager* pFontManager = m_pAppFonts->GenerateFontManager();
@@ -637,8 +616,8 @@ namespace MetaFile
 			nHeight = (int)((double)nWidth * dH / dW);
 		}
 
-		double dWidth  = 25.4 * nWidth / 96;
-		double dHeight = 25.4 * nHeight / 96;
+		double dWidth  = 25.4 * nWidth / 96;				// Get the width and height from pixels to mm
+		double dHeight = 25.4 * nHeight / 96;				// 96 - standart DPI for inch
 
 		BYTE* pBgraData = (BYTE*)malloc(nWidth * nHeight * 4);
 		if (!pBgraData)
@@ -658,12 +637,11 @@ namespace MetaFile
 			return;
 
 		unsigned int alfa = 0xffffff;
-		//дефолтный тон должен быть прозрачным, а не белым
-		//memset(pBgraData, 0xff, nWidth * nHeight * 4);
 		for (int i = 0; i < nWidth * nHeight; i++)
 		{
-			((unsigned int*)pBgraData)[i] = alfa;
+			((unsigned int*)pBgraData)[i] = alfa;			// Set default tone (must be transparent and not white)
 		}
+
 		CBgraFrame oFrame;
 		oFrame.put_Data(pBgraData);
 		oFrame.put_Width(nWidth);
@@ -675,10 +653,11 @@ namespace MetaFile
 		pGrRenderer->put_Width(dWidth);
 		pGrRenderer->put_Height(dHeight);
 
-		DrawOnRenderer(pGrRenderer, 0, 0, dWidth, dHeight);
+		DrawOnRenderer(pGrRenderer, 0, 0, dWidth, dHeight, wsXmlOutFile);
 
 		oFrame.SaveFile(wsOutFilePath, unFileType);
 		oFrame.put_Data(NULL);
+
 		RELEASEINTERFACE(pFontManager);
 		RELEASEINTERFACE(pGrRenderer);
 

DesktopEditor/raster/Metafile/MetaFile.h

@@ -56,36 +56,39 @@ typedef CSVGTransformer CSvgFile;
 
 namespace MetaFile
 {
+	/**
+	 * @class CMetaFile
+	 *
+	 * The interface provides various options for loading a metafile and saving it
+	 * in another format.
+	 */
 	class CMetaFile : public IMetaFile
 	{
 	public:
 		CMetaFile(NSFonts::IApplicationFonts *pAppFonts);
 		virtual ~CMetaFile();
+		void Close();
+
+		void SetTempDirectory(const std::wstring& dir);
 
 		bool LoadFromFile(const wchar_t* wsFilePath);
 		bool LoadFromBuffer(BYTE* pBuffer, unsigned int unSize);
 		bool LoadFromString(const std::wstring& data);
-		bool DrawOnRenderer(IRenderer* pRenderer, double dX, double dY, double dWidth, double dHeight);
-		void Close();
-		void GetBounds(double* pdX, double* pdY, double* pdW, double* pdH);
-		int GetType();
-		void ConvertToRaster(const wchar_t* wsOutFilePath, unsigned int unFileType, int nWidth, int nHeight = -1);
 
+		void ConvertToRaster(const wchar_t* wsOutFilePath, unsigned int unFileType,
+							 int nWidth, int nHeight = -1, const wchar_t* wsXmlOutFile = NULL);
+		std::wstring ConvertToSvg(unsigned int unWidth = 0, unsigned int unHeight = 0);
+		bool DrawOnRenderer(IRenderer* pRenderer, double dX, double dY,
+							double dWidth, double dHeight, const wchar_t* wsXmlFilePath = NULL);
+
+		int GetType();
+		void GetBounds(double* pdX, double* pdY, double* pdW, double* pdH);
 		NSFonts::IFontManager* get_FontManager();
 
-		//конвертация в Svg
-		std::wstring ConvertToSvg(unsigned int unWidth = 0, unsigned int unHeight = 0);
-
-		void SetTempDirectory(const std::wstring& dir);
-
-		//Для тестов
-	#ifdef METAFILE_SUPPORT_WMF_EMF
+		// For tests
 		void ConvertToXml(const wchar_t *wsFilePath);
-		void ConvertToXmlAndRaster(const wchar_t *wsXmlFilePath, const wchar_t* wsOutFilePath, unsigned int unFileType, int nWidth, int nHeight = -1);
 		bool LoadFromXmlFile(const wchar_t* wsFilePath);
-		bool DrawOnRenderer(const wchar_t *wsXmlFilePath, IRenderer* pRenderer, double dX, double dY, double dWidth, double dHeight);
 		void ConvertToEmf(const wchar_t* wsFilePath);
-	#endif
 
 
 	private: