Yajbir Singh
655 lines
21 KiB
C++
655 lines
21 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_RENDERER_H_
|
|
#define _BUILD_GRAPHICS_RENDERER_H_
|
|
|
|
#include "Graphics.h"
|
|
#include "ImageFilesCache.h"
|
|
#include "../raster/BgraFrame.h"
|
|
#include "./pro/Graphics.h"
|
|
|
|
class IGraphicsRenderer_State
|
|
{
|
|
public:
|
|
int Type;
|
|
|
|
IGraphicsRenderer_State()
|
|
{
|
|
// пока не используется
|
|
Type = 0;
|
|
}
|
|
virtual ~IGraphicsRenderer_State()
|
|
{
|
|
}
|
|
};
|
|
|
|
class CGraphicsRenderer : public NSGraphics::IGraphicsRenderer
|
|
{
|
|
private:
|
|
CFontManager* m_pFontManager;
|
|
Aggplus::CGraphics* m_pRenderer;
|
|
Aggplus::CGraphicsPath* m_pPath;
|
|
|
|
NSStructures::CPen m_oPen;
|
|
NSStructures::CBrush m_oBrush;
|
|
NSStructures::CFont m_oFont;
|
|
NSStructures::CFont m_oInstalledFont;
|
|
|
|
double m_dWidth;
|
|
double m_dHeight;
|
|
|
|
double m_dPixelsWidth;
|
|
double m_dPixelsHeight;
|
|
|
|
DWORD m_lCurrentCommandType;
|
|
|
|
LONG m_lCurrentClipMode;
|
|
INT m_bIsSetupClip;
|
|
|
|
// область отсечения
|
|
LONG m_lClipLeft;
|
|
LONG m_lClipTop;
|
|
LONG m_lClipWidth;
|
|
LONG m_lClipHeight;
|
|
|
|
// пикселы
|
|
BYTE* m_pPixels;
|
|
Aggplus::CDIB* m_pDIB;
|
|
|
|
CImageFilesCache* m_pCache;
|
|
|
|
double m_dGlobalAlpha;
|
|
bool m_bGlobalAlphaEnabled;
|
|
|
|
double m_dGammaStroke;
|
|
|
|
std::vector<IGraphicsRenderer_State*> m_arStates;
|
|
|
|
public:
|
|
CGraphicsRenderer();
|
|
virtual ~CGraphicsRenderer();
|
|
|
|
public:
|
|
virtual void SetImageCache(NSImages::IImageFilesCache* pCache);
|
|
virtual void SetFontManager(NSFonts::IFontManager* pManager = NULL);
|
|
virtual void CheckFontManager();
|
|
|
|
virtual NSFonts::IFontManager* GetFontManager();
|
|
BYTE* GetPixels(LONG& lWidth, LONG& lHeight);
|
|
|
|
virtual void ClearInstallFont();
|
|
void SetClipRect(double x, double y, double w, double h);
|
|
|
|
protected:
|
|
INT CheckValidate(INT bOnlyGraphics = FALSE);
|
|
void Clear();
|
|
|
|
void UpdateSize();
|
|
|
|
public:
|
|
void SavePen(NSStructures::CPen& oPen) { oPen = m_oPen; }
|
|
void RestorePen(const NSStructures::CPen& oPen) { m_oPen = oPen; }
|
|
|
|
void SaveBrush(NSStructures::CBrush& oBrush) { oBrush = m_oBrush; }
|
|
void RestoreBrush(const NSStructures::CBrush& oBrush) { m_oBrush = oBrush; }
|
|
virtual void SetSwapRGB(bool bValue){ if (m_pRenderer) m_pRenderer->m_bSwapRGB = bValue; }
|
|
virtual void SetTileImageDpi(const double& dDpi) { if (m_pRenderer) m_pRenderer->m_dDpiTile = dDpi; }
|
|
|
|
virtual void Save();
|
|
virtual void Restore();
|
|
|
|
public:
|
|
// тип рендерера-----------------------------------------------------------------------------
|
|
virtual HRESULT get_Type(LONG* lType);
|
|
//-------- Функции для работы со страницей --------------------------------------------------
|
|
virtual HRESULT NewPage();
|
|
virtual HRESULT get_Height(double* dHeight);
|
|
virtual HRESULT put_Height(const double& dHeight);
|
|
virtual HRESULT get_Width(double* dWidth);
|
|
virtual HRESULT put_Width(const double& dWidth);
|
|
virtual HRESULT get_DpiX(double* dDpiX);
|
|
virtual HRESULT get_DpiY(double* dDpiY);
|
|
|
|
// pen --------------------------------------------------------------------------------------
|
|
virtual HRESULT get_PenColor(LONG* lColor);
|
|
virtual HRESULT put_PenColor(const LONG& lColor);
|
|
virtual HRESULT get_PenAlpha(LONG* lAlpha);
|
|
virtual HRESULT put_PenAlpha(const LONG& lAlpha);
|
|
virtual HRESULT get_PenSize(double* dSize);
|
|
virtual HRESULT put_PenSize(const double& dSize);
|
|
virtual HRESULT get_PenDashStyle(BYTE* val);
|
|
virtual HRESULT put_PenDashStyle(const BYTE& val);
|
|
virtual HRESULT get_PenLineStartCap(BYTE* val);
|
|
virtual HRESULT put_PenLineStartCap(const BYTE& val);
|
|
virtual HRESULT get_PenLineEndCap(BYTE* val);
|
|
virtual HRESULT put_PenLineEndCap(const BYTE& val);
|
|
virtual HRESULT get_PenLineJoin(BYTE* val);
|
|
virtual HRESULT put_PenLineJoin(const BYTE& val);
|
|
virtual HRESULT get_PenDashOffset(double* dOffset);
|
|
virtual HRESULT put_PenDashOffset(const double& dOffset);
|
|
virtual HRESULT get_PenAlign(LONG* lAlign);
|
|
virtual HRESULT put_PenAlign(const LONG& lAlign);
|
|
virtual HRESULT get_PenMiterLimit(double* dOffset);
|
|
virtual HRESULT put_PenMiterLimit(const double& dOffset);
|
|
virtual HRESULT PenDashPattern(double* pPattern, LONG lCount);
|
|
|
|
// brush ------------------------------------------------------------------------------------
|
|
virtual void put_BrushGradInfo(void* pGradInfo) override {
|
|
m_oBrush.m_oGradientInfo = *((NSStructures::GradientInfo*)pGradInfo);
|
|
}
|
|
|
|
virtual HRESULT get_BrushType(LONG* lType);
|
|
virtual HRESULT put_BrushType(const LONG& lType);
|
|
virtual HRESULT get_BrushColor1(LONG* lColor);
|
|
virtual HRESULT put_BrushColor1(const LONG& lColor);
|
|
virtual HRESULT get_BrushAlpha1(LONG* lAlpha);
|
|
virtual HRESULT put_BrushAlpha1(const LONG& lAlpha);
|
|
virtual HRESULT get_BrushColor2(LONG* lColor);
|
|
virtual HRESULT put_BrushColor2(const LONG& lColor);
|
|
virtual HRESULT get_BrushAlpha2(LONG* lAlpha);
|
|
virtual HRESULT put_BrushAlpha2(const LONG& lAlpha);
|
|
virtual HRESULT get_BrushTexturePath(std::wstring* bsPath);
|
|
virtual HRESULT put_BrushTexturePath(const std::wstring& bsPath);
|
|
virtual HRESULT get_BrushTextureImage(Aggplus::CImage** pImage);
|
|
virtual HRESULT put_BrushTextureImage(Aggplus::CImage* pImage);
|
|
virtual HRESULT get_BrushTextureMode(LONG* lMode);
|
|
virtual HRESULT put_BrushTextureMode(const LONG& lMode);
|
|
virtual HRESULT get_BrushTextureAlpha(LONG* lTxAlpha);
|
|
virtual HRESULT put_BrushTextureAlpha(const LONG& lTxAlpha);
|
|
virtual HRESULT get_BrushLinearAngle(double* dAngle);
|
|
virtual HRESULT put_BrushLinearAngle(const double& dAngle);
|
|
virtual HRESULT get_BrushTransform(Aggplus::CMatrix& oMatrix);
|
|
virtual HRESULT put_BrushTransform(const Aggplus::CMatrix& oMatrix);
|
|
virtual HRESULT BrushRect(const INT& val, const double& left, const double& top, const double& width, const double& height);
|
|
virtual HRESULT BrushBounds(const double& left, const double& top, const double& width, const double& height);
|
|
virtual HRESULT put_BrushGradientColors(LONG* lColors, double* pPositions, LONG nCount);
|
|
|
|
// font -------------------------------------------------------------------------------------
|
|
virtual HRESULT get_FontName(std::wstring* bsName);
|
|
virtual HRESULT put_FontName(const std::wstring& bsName);
|
|
virtual HRESULT get_FontPath(std::wstring* bsName);
|
|
virtual HRESULT put_FontPath(const std::wstring& bsName);
|
|
virtual HRESULT get_FontSize(double* dSize);
|
|
virtual HRESULT put_FontSize(const double& dSize);
|
|
virtual HRESULT get_FontStyle(LONG* lStyle);
|
|
virtual HRESULT put_FontStyle(const LONG& lStyle);
|
|
virtual HRESULT get_FontStringGID(INT* bGID);
|
|
virtual HRESULT put_FontStringGID(const INT& bGID);
|
|
virtual HRESULT get_FontCharSpace(double* dSpace);
|
|
virtual HRESULT put_FontCharSpace(const double& dSpace);
|
|
virtual HRESULT get_FontFaceIndex(int* lFaceIndex);
|
|
virtual HRESULT put_FontFaceIndex(const int& lFaceIndex);
|
|
|
|
//-------- Функции для вывода текста --------------------------------------------------------
|
|
virtual HRESULT CommandDrawTextCHAR(const LONG& c, const double& x, const double& y, const double& w, const double& h);
|
|
virtual HRESULT CommandDrawText(const std::wstring& bsText, const double& x, const double& y, const double& w, const double& h);
|
|
|
|
virtual HRESULT CommandDrawTextExCHAR(const LONG& c, const LONG& gid, const double& x, const double& y, const double& w, const double& h);
|
|
virtual HRESULT CommandDrawTextEx(const std::wstring& bsUnicodeText, const unsigned int* pGids, const unsigned int nGidsCount, const double& x, const double& y, const double& w, const double& h);
|
|
|
|
//-------- Маркеры для команд ---------------------------------------------------------------
|
|
virtual HRESULT BeginCommand(const DWORD& lType);
|
|
virtual HRESULT EndCommand(const DWORD& lType);
|
|
|
|
//-------- Функции для работы с Graphics Path -----------------------------------------------
|
|
virtual HRESULT PathCommandMoveTo(const double& x, const double& y);
|
|
virtual HRESULT PathCommandLineTo(const double& x, const double& y);
|
|
virtual HRESULT PathCommandLinesTo(double* points, const int& count);
|
|
virtual HRESULT PathCommandCurveTo(const double& x1, const double& y1, const double& x2, const double& y2, const double& x3, const double& y3);
|
|
virtual HRESULT PathCommandCurvesTo(double* points, const int& count);
|
|
virtual HRESULT PathCommandArcTo(const double& x, const double& y, const double& w, const double& h, const double& startAngle, const double& sweepAngle);
|
|
virtual HRESULT PathCommandClose();
|
|
virtual HRESULT PathCommandEnd();
|
|
virtual HRESULT DrawPath(const LONG& nType);
|
|
virtual HRESULT PathCommandStart();
|
|
virtual HRESULT PathCommandGetCurrentPoint(double* x, double* y);
|
|
|
|
virtual HRESULT PathCommandTextCHAR(const LONG& c, const double& x, const double& y, const double& w, const double& h);
|
|
virtual HRESULT PathCommandText(const std::wstring& bsText, const double& x, const double& y, const double& w, const double& h);
|
|
|
|
virtual HRESULT PathCommandTextExCHAR(const LONG& c, const LONG& gid, const double& x, const double& y, const double& w, const double& h);
|
|
virtual HRESULT PathCommandTextEx(const std::wstring& sText, const unsigned int* pGids, const unsigned int nGidsCount, const double& x, const double& y, const double& w, const double& h);
|
|
|
|
//-------- Функции для вывода изображений ---------------------------------------------------
|
|
virtual HRESULT DrawImage(IGrObject* pImage, const double& x, const double& y, const double& w, const double& h);
|
|
virtual HRESULT DrawImageFromFile(const std::wstring& sFile, const double& x, const double& y, const double& w, const double& h, const BYTE& lAlpha = 255);
|
|
|
|
// transform --------------------------------------------------------------------------------
|
|
virtual HRESULT SetTransform(const double& m1, const double& m2, const double& m3, const double& m4, const double& m5, const double& m6);
|
|
virtual HRESULT GetTransform(double *pdA, double *pdB, double *pdC, double *pdD, double *pdE, double *pdF);
|
|
virtual HRESULT ResetTransform();
|
|
|
|
// -----------------------------------------------------------------------------------------
|
|
virtual HRESULT get_ClipMode(LONG* plMode);
|
|
virtual HRESULT put_ClipMode(const LONG& lMode);
|
|
|
|
// additiaonal params ----------------------------------------------------------------------
|
|
virtual HRESULT CommandLong(const LONG& lType, const LONG& lCommand);
|
|
virtual HRESULT CommandDouble(const LONG& lType, const double& dCommand);
|
|
virtual HRESULT CommandString(const LONG& lType, const std::wstring& sCommand);
|
|
|
|
virtual HRESULT StartConvertCoordsToIdentity();
|
|
virtual HRESULT EndConvertCoordsToIdentity();
|
|
|
|
void put_GlobalAlphaEnabled(const bool& bEnabled, const double& dVal);
|
|
inline void put_IntegerGrid(const bool& bEnabled)
|
|
{
|
|
if (!m_pRenderer)
|
|
return;
|
|
m_pRenderer->m_bIntegerGrid = bEnabled;
|
|
}
|
|
inline bool get_IntegerGrid()
|
|
{
|
|
if (!m_pRenderer)
|
|
return false;
|
|
return m_pRenderer->m_bIntegerGrid;
|
|
}
|
|
void AddRect(const double& x, const double& y, const double& w, const double& h);
|
|
inline void SetFontAttack()
|
|
{
|
|
_SetFont();
|
|
}
|
|
virtual void put_BlendMode(const unsigned int& nBlendMode) override;
|
|
|
|
public:
|
|
virtual void CloseFont()
|
|
{
|
|
if (NULL != m_pFontManager)
|
|
m_pFontManager->CloseFont();
|
|
m_oInstalledFont.SetDefaultParams();
|
|
m_oInstalledFont.Name = L"";
|
|
}
|
|
|
|
void SetGammaStroke(double value);
|
|
|
|
protected:
|
|
void _SetFont();
|
|
void ApplyTransform(const double& d1, const double& d2, const double& d3, const double& d4, const double& d5, const double& d6);
|
|
void ApplyTransform(Aggplus::CMatrix* pMatrix);
|
|
void _ResetTransform();
|
|
Aggplus::CBrush* CreateBrush(NSStructures::CBrush* pBrush);
|
|
|
|
public:
|
|
virtual void CreateFromBgraFrame(CBgraFrame* pFrame);
|
|
void Create(BYTE* pPixels, const Aggplus::CDoubleRect& oRect, LONG lWidthControl, LONG lHeightControl, Aggplus::CDIB* pDib = NULL);
|
|
void CreateFlip(BYTE* pPixels, const Aggplus::CDoubleRect& oRect, LONG lWidthControl, LONG lHeightControl, Aggplus::CDIB* pDib = NULL);
|
|
|
|
inline Aggplus::CMatrix* GetFullTransform()
|
|
{
|
|
return m_pRenderer->GetFullTransform();
|
|
}
|
|
inline Aggplus::CMatrix* GetTransformMatrix()
|
|
{
|
|
return m_pRenderer->GetTransform();
|
|
}
|
|
virtual void SetCoordTransformOffset(double dOffsetX, double dOffsetY)
|
|
{
|
|
Aggplus::CMatrix* pCoord = m_pRenderer->GetCoordTransform();
|
|
pCoord->m_internal->m_agg_mtx.tx = dOffsetX;
|
|
pCoord->m_internal->m_agg_mtx.ty = dOffsetY;
|
|
|
|
m_pRenderer->CalculateFullTransform();
|
|
}
|
|
inline void CalculateFullTransform()
|
|
{
|
|
m_pRenderer->CalculateFullTransform();
|
|
}
|
|
|
|
public:
|
|
inline void PathCommandRect(double x, double y, double w, double h)
|
|
{
|
|
PathCommandMoveTo(x, y);
|
|
PathCommandLineTo(x + w, y);
|
|
PathCommandLineTo(x + w, y + h);
|
|
PathCommandLineTo(x, y + h);
|
|
PathCommandClose();
|
|
}
|
|
inline Aggplus::CMatrix* GetCoordTransform()
|
|
{
|
|
return m_pRenderer->GetCoordTransform();
|
|
}
|
|
inline void Fill()
|
|
{
|
|
DrawPath(c_nWindingFillMode);
|
|
}
|
|
inline void Stroke()
|
|
{
|
|
DrawPath(1);
|
|
}
|
|
|
|
inline double GetPixW() { return m_pRenderer->GetPixW(); }
|
|
inline double GetPixH() { return m_pRenderer->GetPixH(); }
|
|
|
|
// alpha mask methods
|
|
void SetAlphaMask(Aggplus::CAlphaMask* pAlphaMask);
|
|
virtual Aggplus::CSoftMask* CreateSoftMask(bool bAlpha) override;
|
|
virtual void SetSoftMask(Aggplus::CSoftMask* pSoftMask) override;
|
|
|
|
// layer methods
|
|
virtual HRESULT put_LayerOpacity(double dValue) override;
|
|
|
|
// smart methods
|
|
void drawHorLine(BYTE align, double y, double x, double r, double penW)
|
|
{
|
|
int pen_w = (int)((m_pRenderer->GetDpiX() * penW / 25.4) + 0.5);
|
|
if (0 == pen_w)
|
|
pen_w = 1;
|
|
|
|
double __x = x;
|
|
double __y1 = y;
|
|
double __r = r;
|
|
double __y2 = y;
|
|
Aggplus::CMatrix* pMatrix = GetFullTransform();
|
|
pMatrix->TransformPoint(__x, __y1);
|
|
pMatrix->TransformPoint(__r, __y2);
|
|
|
|
double _x = (int)__x;
|
|
double _r = (int)__r + 1;
|
|
|
|
m_oPen.Size = pen_w;
|
|
|
|
switch (align)
|
|
{
|
|
case 0:
|
|
{
|
|
double _top = (int)__y1 + 0.5;
|
|
_top = _top + pen_w / 2.0 - 0.5;
|
|
m_pPath->Reset();
|
|
m_pPath->MoveTo(_x, _top);
|
|
m_pPath->LineTo(_r, _top);
|
|
Stroke();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
// center
|
|
double _center = (int)__y1 + 0.5;
|
|
|
|
m_pPath->Reset();
|
|
if (0 == (pen_w % 2))
|
|
{
|
|
m_pPath->MoveTo(_x, _center - 0.5);
|
|
m_pPath->LineTo(_r, _center - 0.5);
|
|
}
|
|
else
|
|
{
|
|
m_pPath->MoveTo(_x, _center);
|
|
m_pPath->LineTo(_r, _center);
|
|
}
|
|
Stroke();
|
|
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
double _bottom = (int)__y1 + 0.5;
|
|
_bottom = _bottom - pen_w / 2.0 + 0.5;
|
|
m_pPath->Reset();
|
|
m_pPath->MoveTo(_x, _bottom);
|
|
m_pPath->LineTo(_r, _bottom);
|
|
Stroke();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void drawHorLine2(BYTE align, double y, double x, double r, double penW)
|
|
{
|
|
int pen_w = (int)((m_pRenderer->GetDpiX() * penW / 25.4) + 0.5);
|
|
if (0 == pen_w)
|
|
pen_w = 1;
|
|
|
|
double __x = x;
|
|
double __y1 = y;
|
|
double __r = r;
|
|
double __y2 = y;
|
|
Aggplus::CMatrix* pMatrix = GetFullTransform();
|
|
pMatrix->TransformPoint(__x, __y1);
|
|
pMatrix->TransformPoint(__r, __y2);
|
|
|
|
double _x = (int)__x;
|
|
double _r = (int)__r + 1;
|
|
|
|
switch (align)
|
|
{
|
|
case 0:
|
|
{
|
|
// top
|
|
double _top = (int)__y1 + 0.5;
|
|
|
|
double _pos1 = _top + pen_w / 2.0 - 0.5 - pen_w;
|
|
double _pos2 = _pos1 + pen_w * 2.0;
|
|
|
|
m_pPath->Reset();
|
|
m_pPath->MoveTo(_x, _pos1);
|
|
m_pPath->LineTo(_r, _pos1);
|
|
Stroke();
|
|
|
|
m_pPath->Reset();
|
|
m_pPath->MoveTo(_x, _pos2);
|
|
m_pPath->LineTo(_r, _pos2);
|
|
Stroke();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
// center
|
|
// TODO:
|
|
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
// bottom
|
|
// TODO:
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void drawVerLine(BYTE align, double x, double y, double b, double penW)
|
|
{
|
|
int pen_w = (int)((m_pRenderer->GetDpiX() * penW / 25.4) + 0.5);
|
|
if (0 == pen_w)
|
|
pen_w = 1;
|
|
|
|
double __x1 = x;
|
|
double __y = y;
|
|
double __x2 = x;
|
|
double __b = b;
|
|
|
|
Aggplus::CMatrix* pMatrix = GetFullTransform();
|
|
pMatrix->TransformPoint(__x1, __y);
|
|
pMatrix->TransformPoint(__x2, __b);
|
|
|
|
double _y = (int)__y;
|
|
double _b = (int)__b + 1;
|
|
|
|
m_oPen.Size = pen_w;
|
|
switch (align)
|
|
{
|
|
case 0:
|
|
{
|
|
// left
|
|
double _left = (int)__x1 + 0.5;
|
|
_left = _left + pen_w / 2.0 - 0.5;
|
|
|
|
m_pPath->Reset();
|
|
m_pPath->MoveTo(_left, _y);
|
|
m_pPath->LineTo(_left, _b);
|
|
Stroke();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
// center
|
|
double _center = (int)__x1 + 0.5;
|
|
|
|
m_pPath->Reset();
|
|
if (0 == (pen_w % 2))
|
|
{
|
|
m_pPath->MoveTo(_center - 0.5, _y);
|
|
m_pPath->LineTo(_center - 0.5, _b);
|
|
}
|
|
else
|
|
{
|
|
m_pPath->MoveTo(_center, _y);
|
|
m_pPath->LineTo(_center, _b);
|
|
}
|
|
Stroke();
|
|
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
// right
|
|
double _right = (int)__x1 + 0.5;
|
|
_right = _right - pen_w / 2.0 + 0.5;
|
|
|
|
m_pPath->Reset();
|
|
m_pPath->MoveTo(_right, _y);
|
|
m_pPath->LineTo(_right, _b);
|
|
Stroke();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void drawHorLineExt(BYTE align, double y, double x, double r, double penW, double leftMW, double rightMW)
|
|
{
|
|
int pen_w = (int)((m_pRenderer->GetDpiX() * penW / 25.4) + 0.5);
|
|
if (0 == pen_w)
|
|
pen_w = 1;
|
|
|
|
double __x = x;
|
|
double __y1 = y;
|
|
double __r = r;
|
|
double __y2 = y;
|
|
Aggplus::CMatrix* pMatrix = GetFullTransform();
|
|
pMatrix->TransformPoint(__x, __y1);
|
|
pMatrix->TransformPoint(__r, __y2);
|
|
|
|
double _x = (int)__x + 0.5;
|
|
double _r = (int)__r + 0.5;
|
|
|
|
if (leftMW != 0)
|
|
{
|
|
double _center = _x;
|
|
|
|
int pen_mw = (int)((m_pRenderer->GetDpiX() * fabs(leftMW) * 2 / 25.4) + 0.5);
|
|
if (0 == pen_mw)
|
|
pen_mw = 1;
|
|
|
|
if (leftMW < 0)
|
|
{
|
|
_x = _center - (pen_mw >> 1);
|
|
}
|
|
else
|
|
{
|
|
_x = _center + ((pen_mw - 1) >> 1);
|
|
}
|
|
}
|
|
if (rightMW != 0)
|
|
{
|
|
double _center = _r;
|
|
|
|
int pen_mw = (int)((m_pRenderer->GetDpiX() * fabs(rightMW) * 2 / 25.4) + 0.5);
|
|
if (0 == pen_mw)
|
|
pen_mw = 1;
|
|
|
|
if (rightMW < 0)
|
|
{
|
|
_r = _center - (pen_mw >> 1);
|
|
}
|
|
else
|
|
{
|
|
_r = _center + ((pen_mw - 1) >> 1);
|
|
}
|
|
}
|
|
|
|
m_oPen.Size = pen_w;
|
|
|
|
_x -= 0.5;
|
|
_r += 0.5;
|
|
|
|
switch (align)
|
|
{
|
|
case 0:
|
|
{
|
|
// top
|
|
double _top = (int)__y1 + 0.5;
|
|
_top = _top + pen_w / 2.0 - 0.5;
|
|
|
|
m_pPath->Reset();
|
|
m_pPath->MoveTo(_x, _top);
|
|
m_pPath->LineTo(_r, _top);
|
|
Stroke();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
// center
|
|
double _center = (int)__y1 + 0.5;
|
|
|
|
m_pPath->Reset();
|
|
if (0 == (pen_w % 2))
|
|
{
|
|
m_pPath->MoveTo(_x, _center - 0.5);
|
|
m_pPath->LineTo(_r, _center - 0.5);
|
|
}
|
|
else
|
|
{
|
|
m_pPath->MoveTo(_x, _center);
|
|
m_pPath->LineTo(_r, _center);
|
|
}
|
|
Stroke();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
// bottom
|
|
double _bottom = (int)__y1 + 0.5;
|
|
_bottom = _bottom - pen_w / 2.0 + 0.5;
|
|
|
|
m_pPath->Reset();
|
|
m_pPath->MoveTo(_x, _bottom);
|
|
m_pPath->LineTo(_r, _bottom);
|
|
Stroke();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
#endif // _BUILD_GRAPHICS_RENDERER_H_
|