mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-07-11 06:22:44 +08:00
474 lines
11 KiB
C++
474 lines
11 KiB
C++
#include "Brush.h"
|
|
|
|
namespace Aggplus
|
|
{
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
CBrush::CBrush(BrushType bType) : m_bType(bType)
|
|
{
|
|
}
|
|
|
|
CBrush::~CBrush()
|
|
{
|
|
}
|
|
|
|
BrushType CBrush::GetType() const
|
|
{
|
|
return m_bType;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
CBrushSolid::CBrushSolid(CColor dwColor) : CBrush(BrushTypeSolidColor), m_dwColor(dwColor)
|
|
{
|
|
}
|
|
CBrushSolid::~CBrushSolid()
|
|
{
|
|
}
|
|
CBrush* CBrushSolid::Clone() const
|
|
{
|
|
return new CBrushSolid(m_dwColor);
|
|
}
|
|
|
|
void CBrushSolid::GetColor(CColor* color) const { *color = m_dwColor; }
|
|
void CBrushSolid::SetColor(const CColor &color) { m_dwColor = color; }
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
CBrushHatch::CBrushHatch() : CBrush(BrushTypeHatchFill)
|
|
{
|
|
}
|
|
CBrushHatch::~CBrushHatch()
|
|
{
|
|
}
|
|
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 )
|
|
: 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 )
|
|
: 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_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 RectF& rect, const CColor& c1, const CColor& c2, float angle, BOOL isAngleScalable )
|
|
: 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_colors[0] = c1;
|
|
m_colors[1] = c2;
|
|
|
|
m_angle = angle;
|
|
|
|
m_wrap = Aggplus::WrapModeTile;
|
|
|
|
m_bAngleScalable = isAngleScalable;
|
|
m_bRectable = TRUE;
|
|
m_bRelativeCoords = FALSE;
|
|
}
|
|
|
|
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_colors[0] = c1;
|
|
m_colors[1] = c2;
|
|
|
|
m_angle = angle;
|
|
|
|
m_wrap = Aggplus::WrapModeTile;
|
|
|
|
m_bAngleScalable = isAngleScalable;
|
|
m_bRectable = TRUE;
|
|
m_bRelativeCoords = FALSE;
|
|
}
|
|
|
|
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();
|
|
|
|
switch( mode )
|
|
{
|
|
case LinearGradientModeHorizontal:
|
|
m_angle = 0;
|
|
break;
|
|
|
|
case LinearGradientModeVertical:
|
|
m_angle = 90;
|
|
break;
|
|
|
|
case LinearGradientModeForwardDiagonal:
|
|
m_angle = 45;
|
|
break;
|
|
|
|
default:
|
|
m_angle = 315;
|
|
}
|
|
|
|
m_colors[0] = c1;
|
|
m_colors[1] = c2;
|
|
|
|
m_wrap = Aggplus::WrapModeTile;
|
|
|
|
m_bAngleScalable = TRUE;
|
|
m_bRectable = TRUE;
|
|
m_bRelativeCoords = FALSE;
|
|
}
|
|
|
|
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();
|
|
|
|
switch( mode )
|
|
{
|
|
case LinearGradientModeHorizontal:
|
|
m_angle = 0;
|
|
break;
|
|
|
|
case LinearGradientModeVertical:
|
|
m_angle = 90;
|
|
break;
|
|
|
|
case LinearGradientModeForwardDiagonal:
|
|
m_angle = 45;
|
|
break;
|
|
|
|
default:
|
|
m_angle = 315;
|
|
}
|
|
|
|
m_colors[0] = c1;
|
|
m_colors[1] = c2;
|
|
|
|
m_wrap = Aggplus::WrapModeTile;
|
|
|
|
m_bAngleScalable = TRUE;
|
|
m_bRectable = TRUE;
|
|
m_bRelativeCoords = FALSE;
|
|
}
|
|
|
|
|
|
CBrushLinearGradient::CBrushLinearGradient( const CBrushLinearGradient& out )
|
|
: CBrush(out.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;
|
|
}
|
|
|
|
Status CBrushLinearGradient::GetLinearColors( CColor* colors ) const
|
|
{
|
|
if( !colors )
|
|
return InvalidParameter;
|
|
|
|
colors[0] = m_colors[0];
|
|
colors[1] = m_colors[1];
|
|
|
|
return Ok;
|
|
}
|
|
|
|
Status CBrushLinearGradient::GetRectangle( Rect *rect ) const
|
|
{
|
|
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;
|
|
|
|
return Ok;
|
|
}
|
|
|
|
Status CBrushLinearGradient::GetRectangle( RectF *rect ) const
|
|
{
|
|
if( !rect )
|
|
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;
|
|
|
|
return Ok;
|
|
}
|
|
|
|
Status CBrushLinearGradient::GetTransform( CMatrix* matrix ) const
|
|
{
|
|
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 );
|
|
|
|
return Ok;
|
|
}
|
|
|
|
Status CBrushLinearGradient::ResetTransform()
|
|
{
|
|
m_matrix.Reset();
|
|
|
|
return Ok;
|
|
}
|
|
|
|
Status CBrushLinearGradient::RotateTransform( REAL angle, MatrixOrder order )
|
|
{
|
|
m_matrix.Rotate( angle, order );
|
|
|
|
return Ok;
|
|
}
|
|
|
|
Status CBrushLinearGradient::ScaleTransform( REAL sx, REAL sy, MatrixOrder order )
|
|
{
|
|
m_matrix.Scale( sx, sy, order );
|
|
|
|
return Ok;
|
|
}
|
|
|
|
void CBrushLinearGradient::SetWrapMode( WrapMode mode )
|
|
{
|
|
m_wrap = mode;
|
|
}
|
|
|
|
WrapMode CBrushLinearGradient::GetWrapMode() const
|
|
{
|
|
return m_wrap;
|
|
}
|
|
|
|
CBrush* CBrushLinearGradient::Clone() const
|
|
{
|
|
return new CBrushLinearGradient( *this );
|
|
}
|
|
|
|
Status CBrushLinearGradient::SetInterpolationColors( const CColor *presetColors, const REAL *blendPositions, INT count )
|
|
{
|
|
m_subcolors.RemoveAll();
|
|
|
|
if( count > 0 && presetColors && blendPositions )
|
|
{
|
|
m_subcolors.SetCount( count );
|
|
|
|
for( int i = 0; i < count; i++ )
|
|
{
|
|
m_subcolors[i].color = presetColors[i];
|
|
m_subcolors[i].position = blendPositions[i];
|
|
}
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
|
|
Status CBrushLinearGradient::GetInterpolationColors( CColor *presetColors, REAL *blendPositions, INT count ) const
|
|
{
|
|
if( count > 0 && count <= (INT)m_subcolors.GetCount() && presetColors && blendPositions )
|
|
{
|
|
for( int i = 0; i < count; i++ )
|
|
{
|
|
presetColors[i] = m_subcolors[i].color;
|
|
blendPositions[i] = m_subcolors[i].position;
|
|
}
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
|
|
INT CBrushLinearGradient::GetInterpolationColorsCount() const
|
|
{
|
|
return (INT)m_subcolors.GetCount();
|
|
}
|
|
|
|
// additional methods
|
|
void CBrushLinearGradient::GetSubColor( int nIndex, CColor* pColor, float* pPosition ) const
|
|
{
|
|
*pColor = m_subcolors[nIndex].color;
|
|
*pPosition = m_subcolors[nIndex].position;
|
|
}
|
|
|
|
void CBrushLinearGradient::SetRelativeCoords( BOOL bRelative )
|
|
{
|
|
m_bRelativeCoords = bRelative;
|
|
}
|
|
BOOL CBrushLinearGradient::IsRelativeCoords() const
|
|
{
|
|
return m_bRelativeCoords;
|
|
}
|
|
|
|
BOOL CBrushLinearGradient::IsAngleScalable() const
|
|
{
|
|
return m_bAngleScalable;
|
|
}
|
|
BOOL CBrushLinearGradient::IsRectable() const
|
|
{
|
|
return m_bRectable;
|
|
}
|
|
float CBrushLinearGradient::GetAngle() const
|
|
{
|
|
return m_angle;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
CBrushTexture::CBrushTexture() : CBrush(BrushTypeTextureFill)
|
|
{
|
|
m_pImage = NULL;
|
|
m_bReleaseImage = FALSE;
|
|
m_bUsePattern = FALSE;
|
|
}
|
|
|
|
CBrushTexture::CBrushTexture(const std::wstring& strName, WrapMode wrapMode) : CBrush(BrushTypeTextureFill), m_wrapMode(wrapMode)
|
|
{
|
|
m_pImage = new CImage(strName);
|
|
m_bReleaseImage = TRUE;
|
|
m_bUsePattern = FALSE;
|
|
}
|
|
|
|
CBrushTexture::CBrushTexture(CImage *pImage, WrapMode wrapMode) : CBrush(BrushTypeTextureFill), m_wrapMode(wrapMode)
|
|
{
|
|
m_pImage = pImage;
|
|
m_bReleaseImage = FALSE;
|
|
m_bUsePattern = FALSE;
|
|
}
|
|
|
|
CBrushTexture::~CBrushTexture()
|
|
{
|
|
if (m_bReleaseImage)
|
|
{
|
|
RELEASEOBJECT(m_pImage);
|
|
}
|
|
}
|
|
|
|
CBrush* CBrushTexture::Clone() const
|
|
{
|
|
CBrushTexture *pRet = new CBrushTexture(m_pImage, m_wrapMode);
|
|
if( pRet )
|
|
{
|
|
pRet->m_mtx = m_mtx;
|
|
pRet->m_bUsePattern = m_bUsePattern;
|
|
}
|
|
|
|
return pRet;
|
|
}
|
|
|
|
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::SetWrapMode(WrapMode wMode)
|
|
{
|
|
m_wrapMode = wMode;
|
|
}
|
|
WrapMode CBrushTexture::GetWrapMode() const
|
|
{
|
|
return(m_wrapMode);
|
|
}
|
|
|
|
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;
|
|
}
|
|
} |