722 lines
16 KiB
C++
722 lines
16 KiB
C++
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2023
|
|
*
|
|
* This program is a free software product. You can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
|
* version 3 as published by the Free Software Foundation. In accordance with
|
|
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
|
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
|
* of any third-party rights.
|
|
*
|
|
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
|
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
*
|
|
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
|
* street, Riga, Latvia, EU, LV-1050.
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of the Program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU AGPL version 3.
|
|
*
|
|
* Pursuant to Section 7(b) of the License you must retain the original Product
|
|
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
|
* grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
* All the Product's GUI elements, including illustrations and icon sets, as
|
|
* well as technical writing content are licensed under the terms of the
|
|
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
|
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
*
|
|
*/
|
|
#ifndef _BUILD_GRAPHICS_STRUCTURES_H_
|
|
#define _BUILD_GRAPHICS_STRUCTURES_H_
|
|
|
|
#include <cmath>
|
|
#include <string>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "shading_info.h"
|
|
#include "Matrix.h"
|
|
#include "../common/IGrObject.h"
|
|
|
|
// pen -----------------------------------------------------------
|
|
const long c_ag_LineCapFlat = 0;
|
|
const long c_ag_LineCapSquare = 1;
|
|
const long c_ag_LineCapTriangle = 3;
|
|
const long c_ag_LineCapNoAnchor = 16;
|
|
const long c_ag_LineCapSquareAnchor = 17;
|
|
const long c_ag_LineCapRoundAnchor = 18;
|
|
const long c_ag_LineCapDiamondAnchor = 19;
|
|
const long c_ag_LineCapArrowAnchor = 20;
|
|
const long c_ag_LineCapAnchorMask = 240;
|
|
const long c_ag_LineCapCustom = 255;
|
|
|
|
const long c_ag_DashCapFlat = 0;
|
|
const long c_ag_DashCapRound = 2;
|
|
const long c_ag_DashCapTriangle = 3;
|
|
|
|
const long c_ag_LineJoinMiter = 0;
|
|
const long c_ag_LineJoinBevel = 1;
|
|
const long c_ag_LineJoinRound = 2;
|
|
const long c_ag_LineJoinMiterClipped = 3;
|
|
|
|
const long c_ag_PenAlignmentCenter = 0;
|
|
const long c_ag_PenAlignmentInset = 1;
|
|
const long c_ag_PenAlignmentOutset = 2;
|
|
const long c_ag_PenAlignmentLeft = 3;
|
|
const long c_ag_PenAlignmentRight = 4;
|
|
// --------------------------------------------------------------
|
|
// brush --------------------------------------------------------
|
|
// old constants for brush type
|
|
const long c_BrushTypeSolid_ = 0;
|
|
const long c_BrushTypeHorizontal_ = 1;
|
|
const long c_BrushTypeVertical_ = 2;
|
|
const long c_BrushTypeDiagonal1_ = 3;
|
|
const long c_BrushTypeDiagonal2_ = 4;
|
|
const long c_BrushTypeCenter_ = 5;
|
|
const long c_BrushTypePathGradient1_ = 6;
|
|
const long c_BrushTypePathGradient2_ = 7;
|
|
const long c_BrushTypeTexture_ = 8;
|
|
const long c_BrushTypeHatch1_ = 9;
|
|
const long c_BrushTypeHatch53_ = 61;
|
|
const long c_BrushTypeGradient1_ = 62;
|
|
const long c_BrushTypeGradient6_ = 70;
|
|
|
|
const long c_BrushTypeSolid = 1000;
|
|
const long c_BrushTypeHorizontal = 2001;
|
|
const long c_BrushTypeVertical = 2002;
|
|
const long c_BrushTypeDiagonal1 = 2003;
|
|
const long c_BrushTypeDiagonal2 = 2004;
|
|
const long c_BrushTypeCenter = 2005;
|
|
const long c_BrushTypePathGradient1 = 2006; // left for comparability
|
|
const long c_BrushTypePathGradient2 = 2007; // left for comparability
|
|
const long c_BrushTypeCylinderHor = 2008;
|
|
const long c_BrushTypeCylinderVer = 2009;
|
|
const long c_BrushTypeTexture = 3008;
|
|
const long c_BrushTypePattern = 3009;
|
|
const long c_BrushTypeHatch1 = 4009;
|
|
const long c_BrushTypeHatch53 = 4061;
|
|
const long c_BrushTypeNoFill = 5000;
|
|
const long c_BrushTypeNotSet = 5001;
|
|
|
|
const long c_BrushTypeMyTestGradient = 6000;
|
|
const long c_BrushTypePathRadialGradient = 6001;
|
|
const long c_BrushTypePathConicalGradient = 6002;
|
|
const long c_BrushTypePathDiamondGradient = 6003;
|
|
const long c_BrushTypePathNewLinearGradient = 6004;
|
|
const long c_BrushTypeTriagnleMeshGradient = 6005;
|
|
const long c_BrushTypeCurveGradient = 6006;
|
|
const long c_BrushTypeTensorCurveGradient = 6007;
|
|
|
|
|
|
const long c_BrushTextureModeStretch = 0;
|
|
const long c_BrushTextureModeTile = 1;
|
|
const long c_BrushTextureModeTileCenter = 2;
|
|
// --------------------------------------------------------------
|
|
|
|
namespace Aggplus { class CImage; }
|
|
|
|
namespace NSStructures
|
|
{
|
|
class CPen
|
|
{
|
|
public:
|
|
long Color;
|
|
long Alpha;
|
|
double Size;
|
|
|
|
unsigned char DashStyle;
|
|
unsigned char LineStartCap;
|
|
unsigned char LineEndCap;
|
|
unsigned char LineJoin;
|
|
|
|
double *DashPattern;
|
|
long Count;
|
|
|
|
double DashOffset;
|
|
|
|
long Align;
|
|
double MiterLimit;
|
|
|
|
public:
|
|
void GetDashPattern(double *arrDashPattern, long &nCount) const
|
|
{
|
|
if (nCount == Count)
|
|
{
|
|
for (int i = 0; i < Count; ++i)
|
|
{
|
|
arrDashPattern[i] = DashPattern[i];
|
|
}
|
|
}
|
|
}
|
|
void SetDashPattern(double *arrDashPattern, long nCount)
|
|
{
|
|
if ((arrDashPattern == NULL) || (nCount == 0))
|
|
{
|
|
Count = 0;
|
|
RELEASEARRAYOBJECTS(DashPattern);
|
|
}
|
|
else
|
|
{
|
|
if (Count != nCount)
|
|
{
|
|
Count = nCount;
|
|
RELEASEARRAYOBJECTS(DashPattern);
|
|
DashPattern = new double[Count];
|
|
}
|
|
|
|
for (int i = 0; i < Count; ++i)
|
|
{
|
|
DashPattern[i] = arrDashPattern[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
void ScaleAlpha(double dScale)
|
|
{
|
|
long dNewAlpha = long(Alpha * dScale + 0.5);
|
|
|
|
if (dNewAlpha > 255)
|
|
dNewAlpha = 255;
|
|
else if (dNewAlpha < 0)
|
|
dNewAlpha = 0;
|
|
|
|
Alpha = dNewAlpha;
|
|
}
|
|
|
|
INT IsEqual(CPen *pPen)
|
|
{
|
|
if (NULL == pPen)
|
|
return FALSE;
|
|
|
|
return ((Color == pPen->Color) && (Alpha == pPen->Alpha) && (Size == pPen->Size) &&
|
|
(DashStyle == pPen->DashStyle) && (LineStartCap == pPen->LineStartCap) &&
|
|
(LineEndCap == pPen->LineEndCap) && (LineJoin == pPen->LineJoin));
|
|
}
|
|
void SetDefaultParams()
|
|
{
|
|
Color = 0;
|
|
Alpha = 255;
|
|
Size = 1;
|
|
|
|
DashStyle = 0;
|
|
LineStartCap = 0;
|
|
LineEndCap = 0;
|
|
LineJoin = 0;
|
|
|
|
DashPattern = NULL;
|
|
Count = 0;
|
|
|
|
DashOffset = 0;
|
|
Align = Aggplus::PenAlignmentCenter;
|
|
MiterLimit = 0.5;
|
|
}
|
|
|
|
public:
|
|
CPen()
|
|
{
|
|
SetDefaultParams();
|
|
}
|
|
CPen(const CPen &other)
|
|
{
|
|
*this = other;
|
|
}
|
|
CPen &operator=(const CPen &other)
|
|
{
|
|
Color = other.Color;
|
|
Alpha = other.Alpha;
|
|
Size = other.Size;
|
|
|
|
DashStyle = other.DashStyle;
|
|
LineStartCap = other.LineStartCap;
|
|
LineEndCap = other.LineEndCap;
|
|
LineJoin = other.LineJoin;
|
|
|
|
RELEASEARRAYOBJECTS(DashPattern);
|
|
Count = other.Count;
|
|
if (Count != 0)
|
|
{
|
|
DashPattern = new double[Count];
|
|
memcpy(DashPattern, other.DashPattern, Count * sizeof(double));
|
|
}
|
|
|
|
DashOffset = other.DashOffset;
|
|
|
|
Align = other.Align;
|
|
MiterLimit = other.MiterLimit;
|
|
|
|
return *this;
|
|
}
|
|
virtual ~CPen()
|
|
{
|
|
RELEASEARRAYOBJECTS(DashPattern);
|
|
}
|
|
};
|
|
|
|
class CBrush
|
|
{
|
|
public:
|
|
int test;
|
|
struct TSubColor
|
|
{
|
|
long color;
|
|
long position; // [0..65536]
|
|
};
|
|
|
|
public:
|
|
long Type;
|
|
|
|
long Color1;
|
|
long Color2;
|
|
long Alpha1;
|
|
long Alpha2;
|
|
|
|
Aggplus::CImage *Image;
|
|
Aggplus::CMatrix Transform;
|
|
|
|
std::wstring TexturePath;
|
|
long TextureAlpha;
|
|
long TextureMode;
|
|
|
|
int Rectable;
|
|
Aggplus::RectF Rect;
|
|
Aggplus::CDoubleRect Bounds;
|
|
|
|
double LinearAngle;
|
|
std::vector<TSubColor> m_arrSubColors;
|
|
NSStructures::GradientInfo m_oGradientInfo;
|
|
|
|
public:
|
|
void LoadSubColors(const std::string &str)
|
|
{
|
|
m_arrSubColors.clear();
|
|
|
|
if (str.empty())
|
|
return;
|
|
|
|
TSubColor subcolor;
|
|
int start = 0;
|
|
|
|
for (;;)
|
|
{
|
|
int pos = (int)str.find((wchar_t)',', start);
|
|
if (pos < 0)
|
|
break;
|
|
|
|
subcolor.color = ::atoi(str.substr(start, pos - start).c_str());
|
|
start = pos + 1;
|
|
|
|
pos = (int)str.find((wchar_t)';', start);
|
|
if (pos < 0)
|
|
break;
|
|
|
|
subcolor.position = ::atoi(str.substr(start, pos - start).c_str());
|
|
start = pos + 1;
|
|
|
|
m_arrSubColors.push_back(subcolor);
|
|
}
|
|
}
|
|
|
|
inline long ConstantCompatible(long nConstant)
|
|
{
|
|
if (c_BrushTypeDiagonal1_ == nConstant)
|
|
nConstant = c_BrushTypeDiagonal2_;
|
|
else if (c_BrushTypeDiagonal2_ == nConstant)
|
|
nConstant = c_BrushTypeDiagonal1_;
|
|
|
|
if (1000 <= nConstant)
|
|
return nConstant;
|
|
if (c_BrushTypeSolid_ == nConstant)
|
|
return nConstant + 1000;
|
|
if (c_BrushTypeHorizontal_ <= nConstant && c_BrushTypePathGradient2_ >= nConstant)
|
|
return nConstant + 2000;
|
|
if (c_BrushTypeTexture_ == nConstant)
|
|
return nConstant + 3000;
|
|
if (c_BrushTypeHatch1_ <= nConstant && c_BrushTypeHatch53_ >= nConstant)
|
|
return nConstant + 4000;
|
|
if (c_BrushTypeGradient1_ <= nConstant && c_BrushTypeGradient6_ >= nConstant)
|
|
return nConstant + 2000 - 61;
|
|
|
|
return 1000;
|
|
}
|
|
|
|
void ScaleAlpha1(double dScale)
|
|
{
|
|
long dNewAlpha = long(Alpha1 * dScale + 0.5);
|
|
|
|
if (dNewAlpha > 255)
|
|
dNewAlpha = 255;
|
|
else if (dNewAlpha < 0)
|
|
dNewAlpha = 0;
|
|
|
|
Alpha1 = dNewAlpha;
|
|
}
|
|
void ScaleAlpha2(double dScale)
|
|
{
|
|
long dNewAlpha = long(Alpha2 * dScale + 0.5);
|
|
|
|
if (dNewAlpha > 255)
|
|
dNewAlpha = 255;
|
|
else if (dNewAlpha < 0)
|
|
dNewAlpha = 0;
|
|
|
|
Alpha2 = dNewAlpha;
|
|
}
|
|
|
|
void ScaleTextureAlpha(double dScale)
|
|
{
|
|
long dNewAlpha = long(TextureAlpha * dScale + 0.5);
|
|
|
|
if (dNewAlpha > 255)
|
|
dNewAlpha = 255;
|
|
else if (dNewAlpha < 0)
|
|
dNewAlpha = 0;
|
|
|
|
TextureAlpha = dNewAlpha;
|
|
}
|
|
|
|
INT IsEqual(const CBrush *pBrush)
|
|
{
|
|
if (NULL == pBrush)
|
|
return FALSE;
|
|
|
|
return ((Type == pBrush->Type) && (Image == pBrush->Image) && Aggplus::CMatrix::IsEqual(&Transform, &pBrush->Transform) &&
|
|
(Color1 == pBrush->Color1) && (Color2 == pBrush->Color2) &&
|
|
(Alpha1 == pBrush->Alpha1) && (Alpha2 == pBrush->Alpha2) && (LinearAngle == pBrush->LinearAngle) &&
|
|
(TexturePath == pBrush->TexturePath) && (TextureAlpha == pBrush->TextureAlpha) && (TextureMode == pBrush->TextureMode) &&
|
|
(Rectable == pBrush->Rectable) && (Rect.Equals(pBrush->Rect)));
|
|
}
|
|
|
|
void SetDefaultParams()
|
|
{
|
|
Type = c_BrushTypeSolid;
|
|
|
|
Color1 = 0;
|
|
Alpha1 = 255;
|
|
Color2 = 0;
|
|
Alpha2 = 255;
|
|
|
|
Image = NULL;
|
|
Transform.SetElements(1., 0., 0., 1., 0., 0.);
|
|
|
|
TextureAlpha = 255;
|
|
TextureMode = c_BrushTextureModeStretch;
|
|
|
|
LinearAngle = 0;
|
|
|
|
TexturePath = L"";
|
|
|
|
Rectable = FALSE;
|
|
|
|
Rect.X = 0.0F;
|
|
Rect.Y = 0.0F;
|
|
Rect.Width = 0.0F;
|
|
Rect.Height = 0.0F;
|
|
|
|
Bounds.left = 0;
|
|
Bounds.top = 0;
|
|
Bounds.right = 0;
|
|
Bounds.bottom = 0;
|
|
|
|
m_arrSubColors.clear();
|
|
}
|
|
|
|
public:
|
|
CBrush()
|
|
{
|
|
SetDefaultParams();
|
|
}
|
|
CBrush(const CBrush &other)
|
|
{
|
|
*this = other;
|
|
}
|
|
CBrush &operator=(const CBrush &other)
|
|
{
|
|
Type = other.Type;
|
|
|
|
Color1 = other.Color1;
|
|
Alpha1 = other.Alpha1;
|
|
Color2 = other.Color2;
|
|
Alpha2 = other.Alpha2;
|
|
|
|
Image = other.Image;
|
|
if (Image)
|
|
((IGrObject*)Image)->AddRef();
|
|
Transform = other.Transform;
|
|
|
|
TexturePath = other.TexturePath;
|
|
TextureAlpha = other.TextureAlpha;
|
|
TextureMode = other.TextureMode;
|
|
|
|
Rectable = other.Rectable;
|
|
Rect = other.Rect;
|
|
Bounds = other.Bounds;
|
|
|
|
LinearAngle = other.LinearAngle;
|
|
m_arrSubColors = other.m_arrSubColors;
|
|
m_oGradientInfo = other.m_oGradientInfo;
|
|
|
|
return *this;
|
|
}
|
|
virtual ~CBrush()
|
|
{
|
|
if (NULL != Image)
|
|
{
|
|
((IGrObject*)Image)->Release();
|
|
Image = NULL;
|
|
}
|
|
}
|
|
|
|
int IsTexture()
|
|
{
|
|
return (c_BrushTypeTexture == Type || c_BrushTypePattern == Type);
|
|
}
|
|
int IsOneColor()
|
|
{
|
|
return (c_BrushTypeSolid == Type);
|
|
}
|
|
int IsTwoColor()
|
|
{
|
|
return ((c_BrushTypeHorizontal <= Type && c_BrushTypeCylinderVer >= Type) ||
|
|
(c_BrushTypeHatch1 <= Type && c_BrushTypeHatch53 >= Type));
|
|
}
|
|
};
|
|
class CFont
|
|
{
|
|
public:
|
|
std::wstring Path;
|
|
std::wstring Name;
|
|
double Size;
|
|
int Bold;
|
|
int Italic;
|
|
unsigned char Underline;
|
|
unsigned char Strikeout;
|
|
|
|
int StringGID;
|
|
double CharSpace;
|
|
|
|
int FaceIndex;
|
|
|
|
int IsEqual(const CFont *pFont)
|
|
{
|
|
if (NULL == pFont)
|
|
return FALSE;
|
|
|
|
return ((Name == pFont->Name) && (Path == pFont->Path) && (FaceIndex == pFont->FaceIndex) && (StringGID == pFont->StringGID) && (Size == pFont->Size) &&
|
|
(Bold == pFont->Bold) && (Italic == pFont->Italic) &&
|
|
(Underline == pFont->Underline) && (Strikeout == pFont->Strikeout));
|
|
}
|
|
|
|
int IsEqual2(const CFont *pFont)
|
|
{
|
|
if (NULL == pFont)
|
|
return FALSE;
|
|
|
|
if (Path != pFont->Path)
|
|
return FALSE;
|
|
|
|
if (Path.empty() && Name != pFont->Name)
|
|
return FALSE;
|
|
|
|
return ((FaceIndex == pFont->FaceIndex) && (StringGID == pFont->StringGID) && (Size == pFont->Size) &&
|
|
(Bold == pFont->Bold) && (Italic == pFont->Italic) &&
|
|
(Underline == pFont->Underline) && (Strikeout == pFont->Strikeout));
|
|
}
|
|
|
|
long GetStyle() const
|
|
{
|
|
long lStyle = 0;
|
|
if (Bold)
|
|
lStyle |= 0x01;
|
|
if (Italic)
|
|
lStyle |= 0x02;
|
|
lStyle |= Underline << 2;
|
|
lStyle |= Strikeout << 7;
|
|
return lStyle;
|
|
}
|
|
long GetStyle2() const
|
|
{
|
|
long lStyle = 0;
|
|
if (Bold)
|
|
lStyle |= 0x01;
|
|
if (Italic)
|
|
lStyle |= 0x02;
|
|
return lStyle;
|
|
}
|
|
void SetStyle(long const &lStyle)
|
|
{
|
|
Bold = (0x01 == (0x01 & lStyle));
|
|
Italic = (0x02 == (0x02 & lStyle));
|
|
Underline = (unsigned char)(0x7C & lStyle) >> 2;
|
|
Strikeout = (unsigned char)(0x0180 & lStyle) >> 7;
|
|
}
|
|
void SetDefaultParams()
|
|
{
|
|
Name = L"Arial";
|
|
Path = L"";
|
|
|
|
Size = 0;
|
|
Bold = FALSE;
|
|
Italic = FALSE;
|
|
Underline = 0;
|
|
Strikeout = 0;
|
|
|
|
StringGID = FALSE;
|
|
CharSpace = 0.0;
|
|
FaceIndex = 0;
|
|
}
|
|
LONG GetTextDecorationStyle()
|
|
{
|
|
if ((0 == Underline) && (0 == Strikeout))
|
|
return 0;
|
|
if ((1 == Underline) && (0 == Strikeout))
|
|
return 1;
|
|
if ((0 == Underline) && (1 == Strikeout))
|
|
return 2;
|
|
if ((1 == Underline) && (1 == Strikeout))
|
|
return 3;
|
|
return 4;
|
|
}
|
|
|
|
LONG GetTextFontStyle() const
|
|
{
|
|
if ((0 == Bold) && (0 == Italic))
|
|
return 0;
|
|
if ((0 == Bold) && (1 == Italic))
|
|
return 1;
|
|
if ((1 == Bold) && (0 == Italic))
|
|
return 2;
|
|
if ((1 == Bold) && (1 == Italic))
|
|
return 3;
|
|
return 4;
|
|
}
|
|
|
|
CFont()
|
|
{
|
|
SetDefaultParams();
|
|
}
|
|
CFont(const CFont &other)
|
|
{
|
|
*this = other;
|
|
}
|
|
CFont &operator=(const CFont &other)
|
|
{
|
|
Name = other.Name;
|
|
Path = other.Path;
|
|
Size = other.Size;
|
|
Bold = other.Bold;
|
|
Italic = other.Italic;
|
|
Underline = other.Underline;
|
|
Strikeout = other.Strikeout;
|
|
|
|
StringGID = other.StringGID;
|
|
CharSpace = other.CharSpace;
|
|
|
|
FaceIndex = other.FaceIndex;
|
|
|
|
return *this;
|
|
}
|
|
virtual ~CFont()
|
|
{
|
|
}
|
|
};
|
|
class CShadow
|
|
{
|
|
public:
|
|
INT Visible;
|
|
double DistanceX;
|
|
double DistanceY;
|
|
double BlurSize;
|
|
long Color;
|
|
long Alpha;
|
|
|
|
public:
|
|
void SetDefaultParams()
|
|
{
|
|
Visible = FALSE;
|
|
DistanceX = 15;
|
|
DistanceY = 15;
|
|
BlurSize = 0;
|
|
Color = 0;
|
|
Alpha = 120;
|
|
}
|
|
|
|
public:
|
|
CShadow()
|
|
{
|
|
SetDefaultParams();
|
|
}
|
|
CShadow(const CShadow &other)
|
|
{
|
|
Visible = other.Visible;
|
|
DistanceX = other.DistanceX;
|
|
DistanceY = other.DistanceY;
|
|
BlurSize = other.BlurSize;
|
|
Color = other.Color;
|
|
Alpha = other.Alpha;
|
|
}
|
|
CShadow &operator=(const CShadow &other)
|
|
{
|
|
Visible = other.Visible;
|
|
DistanceX = other.DistanceX;
|
|
DistanceY = other.DistanceY;
|
|
BlurSize = other.BlurSize;
|
|
Color = other.Color;
|
|
Alpha = other.Alpha;
|
|
|
|
return *this;
|
|
}
|
|
virtual ~CShadow()
|
|
{
|
|
}
|
|
};
|
|
|
|
class CEdgeText
|
|
{
|
|
public:
|
|
long Visible;
|
|
double Dist;
|
|
long Color;
|
|
long Alpha;
|
|
|
|
public:
|
|
void SetDefaultParams()
|
|
{
|
|
Visible = 0;
|
|
Dist = 5;
|
|
Color = 0;
|
|
Alpha = 255;
|
|
}
|
|
|
|
public:
|
|
CEdgeText()
|
|
{
|
|
SetDefaultParams();
|
|
}
|
|
CEdgeText(const CEdgeText &other)
|
|
{
|
|
Visible = other.Visible;
|
|
Dist = other.Dist;
|
|
Color = other.Color;
|
|
Alpha = other.Alpha;
|
|
}
|
|
CEdgeText &operator=(const CEdgeText &other)
|
|
{
|
|
Visible = other.Visible;
|
|
Dist = other.Dist;
|
|
Color = other.Color;
|
|
Alpha = other.Alpha;
|
|
|
|
return *this;
|
|
}
|
|
virtual ~CEdgeText()
|
|
{
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
#endif // _BUILD_GRAPHICS_STRUCTURES_H_
|