include/vcl/salgtype.hxx | 9 ---
vcl/headless/svpgdi.cxx | 32 +++++-----
vcl/inc/headless/svpgdi.hxx | 14 ++--
vcl/inc/opengl/gdiimpl.hxx | 18 +++---
vcl/inc/qt5/Qt5Graphics.hxx | 14 ++--
vcl/inc/quartz/salgdi.h | 14 ++--
vcl/inc/salgdi.hxx | 30 +++++-----
vcl/inc/salgdiimpl.hxx | 14 ++--
vcl/inc/skia/gdiimpl.hxx | 14 ++--
vcl/inc/unx/genpspgraphics.h | 14 ++--
vcl/inc/unx/salgdi.h | 14 ++--
vcl/inc/win/salgdi.h | 14 ++--
vcl/opengl/gdiimpl.cxx | 70 +++++++++++------------
vcl/qt5/Qt5Graphics_GDI.cxx | 44 +++++++-------
vcl/quartz/salgdicommon.cxx | 60 ++++++++++----------
vcl/skia/gdiimpl.cxx | 35 ++++++-----
vcl/source/gdi/salgdilayout.cxx | 50 ++++++++--------
vcl/source/outdev/curvedshapes.cxx | 8 +-
vcl/source/outdev/line.cxx | 4 -
vcl/source/outdev/polygon.cxx | 22 +++----
vcl/source/outdev/polyline.cxx | 6 +-
vcl/source/outdev/rect.cxx | 4 -
vcl/unx/generic/gdi/gdiimpl.cxx | 28 ++++-----
vcl/unx/generic/gdi/gdiimpl.hxx | 16 ++---
vcl/unx/generic/gdi/salgdi.cxx | 14 ++--
vcl/unx/generic/print/genpspgraphics.cxx | 30 +++++-----
vcl/win/gdi/gdiimpl.cxx | 93 +++++++++++++++----------------
vcl/win/gdi/gdiimpl.hxx | 14 ++--
vcl/win/gdi/salgdi.cxx | 12 ++--
vcl/win/gdi/salgdi2.cxx | 2
30 files changed, 352 insertions(+), 361 deletions(-)
New commits:
commit 0f04b8204a77ecaee7d9ebe6868808445c8b138a
Author: Noel Grandin <n...@peralex.com>
AuthorDate: Thu Nov 12 12:29:08 2020 +0200
Commit: Caolán McNamara <caol...@redhat.com>
CommitDate: Sat Nov 14 20:43:07 2020 +0100
remove SalPoint
<caolan> that "SalPoint" doesn't really seem to to have a purpose
except to highlight that "Point" is assumed to use LONG under windows
and can be passed unchanged to those windows drawing apis
<caolan> so I guess remove SalPoint entirely, use Point instead,
and convert to "POINT" under windows ?
Change-Id: Ic15a7f4516e2075a228fa65cac4e8494d5b3abaa
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/105634
Tested-by: Jenkins
Reviewed-by: Caolán McNamara <caol...@redhat.com>
diff --git a/include/vcl/salgtype.hxx b/include/vcl/salgtype.hxx
index d19bf776a31f..902170555526 100644
--- a/include/vcl/salgtype.hxx
+++ b/include/vcl/salgtype.hxx
@@ -36,15 +36,6 @@ enum class DeviceFormat {
constexpr ::Color SALCOLOR_NONE ( 0xFF, 0xFF, 0xFF, 0xFF );
-// must equal to the Windows POINT type, which is why we use sal_Int32
-struct SalPoint
-{
- sal_Int32 mnX;
- sal_Int32 mnY;
-};
-
-typedef const SalPoint* PCONSTSALPOINT;
-
struct SalTwoRect
{
tools::Long mnSrcX;
diff --git a/vcl/headless/svpgdi.cxx b/vcl/headless/svpgdi.cxx
index d878527562c2..40e2ad1542b1 100644
--- a/vcl/headless/svpgdi.cxx
+++ b/vcl/headless/svpgdi.cxx
@@ -1082,12 +1082,12 @@ void SvpSalGraphics::drawRect( tools::Long nX,
tools::Long nY, tools::Long nWidt
m_aLineColor = aOrigLineColor;
}
-void SvpSalGraphics::drawPolyLine(sal_uInt32 nPoints, const SalPoint* pPtAry)
+void SvpSalGraphics::drawPolyLine(sal_uInt32 nPoints, const Point* pPtAry)
{
basegfx::B2DPolygon aPoly;
- aPoly.append(basegfx::B2DPoint(pPtAry->mnX, pPtAry->mnY), nPoints);
+ aPoly.append(basegfx::B2DPoint(pPtAry->getX(), pPtAry->getY()), nPoints);
for (sal_uInt32 i = 1; i < nPoints; ++i)
- aPoly.setB2DPoint(i, basegfx::B2DPoint(pPtAry[i].mnX, pPtAry[i].mnY));
+ aPoly.setB2DPoint(i, basegfx::B2DPoint(pPtAry[i].getX(),
pPtAry[i].getY()));
aPoly.setClosed(false);
drawPolyLine(
@@ -1102,12 +1102,12 @@ void SvpSalGraphics::drawPolyLine(sal_uInt32 nPoints,
const SalPoint* pPtAry)
false);
}
-void SvpSalGraphics::drawPolygon(sal_uInt32 nPoints, const SalPoint* pPtAry)
+void SvpSalGraphics::drawPolygon(sal_uInt32 nPoints, const Point* pPtAry)
{
basegfx::B2DPolygon aPoly;
- aPoly.append(basegfx::B2DPoint(pPtAry->mnX, pPtAry->mnY), nPoints);
+ aPoly.append(basegfx::B2DPoint(pPtAry->getX(), pPtAry->getY()), nPoints);
for (sal_uInt32 i = 1; i < nPoints; ++i)
- aPoly.setB2DPoint(i, basegfx::B2DPoint(pPtAry[i].mnX, pPtAry[i].mnY));
+ aPoly.setB2DPoint(i, basegfx::B2DPoint(pPtAry[i].getX(),
pPtAry[i].getY()));
drawPolyPolygon(
basegfx::B2DHomMatrix(),
@@ -1117,7 +1117,7 @@ void SvpSalGraphics::drawPolygon(sal_uInt32 nPoints,
const SalPoint* pPtAry)
void SvpSalGraphics::drawPolyPolygon(sal_uInt32 nPoly,
const sal_uInt32* pPointCounts,
- PCONSTSALPOINT* pPtAry)
+ const Point** pPtAry)
{
basegfx::B2DPolyPolygon aPolyPoly;
for(sal_uInt32 nPolygon = 0; nPolygon < nPoly; ++nPolygon)
@@ -1125,11 +1125,11 @@ void SvpSalGraphics::drawPolyPolygon(sal_uInt32 nPoly,
sal_uInt32 nPoints = pPointCounts[nPolygon];
if (nPoints)
{
- PCONSTSALPOINT pPoints = pPtAry[nPolygon];
+ const Point* pPoints = pPtAry[nPolygon];
basegfx::B2DPolygon aPoly;
- aPoly.append( basegfx::B2DPoint(pPoints->mnX, pPoints->mnY),
nPoints);
+ aPoly.append( basegfx::B2DPoint(pPoints->getX(), pPoints->getY()),
nPoints);
for (sal_uInt32 i = 1; i < nPoints; ++i)
- aPoly.setB2DPoint(i, basegfx::B2DPoint( pPoints[i].mnX,
pPoints[i].mnY));
+ aPoly.setB2DPoint(i, basegfx::B2DPoint( pPoints[i].getX(),
pPoints[i].getY()));
aPolyPoly.append(aPoly);
}
@@ -1772,7 +1772,7 @@ bool SvpSalGraphics::drawPolyLine(
}
bool SvpSalGraphics::drawPolyLineBezier( sal_uInt32,
- const SalPoint*,
+ const Point*,
const PolyFlags* )
{
SAL_INFO("vcl.gdi", "unsupported SvpSalGraphics::drawPolyLineBezier case");
@@ -1780,7 +1780,7 @@ bool SvpSalGraphics::drawPolyLineBezier( sal_uInt32,
}
bool SvpSalGraphics::drawPolygonBezier( sal_uInt32,
- const SalPoint*,
+ const Point*,
const PolyFlags* )
{
SAL_INFO("vcl.gdi", "unsupported SvpSalGraphics::drawPolygonBezier case");
@@ -1789,7 +1789,7 @@ bool SvpSalGraphics::drawPolygonBezier( sal_uInt32,
bool SvpSalGraphics::drawPolyPolygonBezier( sal_uInt32,
const sal_uInt32*,
- const SalPoint* const*,
+ const Point* const*,
const PolyFlags* const* )
{
SAL_INFO("vcl.gdi", "unsupported SvpSalGraphics::drawPolyPolygonBezier
case");
@@ -2413,12 +2413,12 @@ void SvpSalGraphics::invert( tools::Long nX,
tools::Long nY, tools::Long nWidth,
invert(aRect, nFlags);
}
-void SvpSalGraphics::invert(sal_uInt32 nPoints, const SalPoint* pPtAry,
SalInvert nFlags)
+void SvpSalGraphics::invert(sal_uInt32 nPoints, const Point* pPtAry, SalInvert
nFlags)
{
basegfx::B2DPolygon aPoly;
- aPoly.append(basegfx::B2DPoint(pPtAry->mnX, pPtAry->mnY), nPoints);
+ aPoly.append(basegfx::B2DPoint(pPtAry->getX(), pPtAry->getY()), nPoints);
for (sal_uInt32 i = 1; i < nPoints; ++i)
- aPoly.setB2DPoint(i, basegfx::B2DPoint(pPtAry[i].mnX, pPtAry[i].mnY));
+ aPoly.setB2DPoint(i, basegfx::B2DPoint(pPtAry[i].getX(),
pPtAry[i].getY()));
aPoly.setClosed(true);
invert(aPoly, nFlags);
diff --git a/vcl/inc/headless/svpgdi.hxx b/vcl/inc/headless/svpgdi.hxx
index 0ce14b3a5274..d9ec43c0b0ef 100644
--- a/vcl/inc/headless/svpgdi.hxx
+++ b/vcl/inc/headless/svpgdi.hxx
@@ -217,20 +217,20 @@ public:
css::drawing::LineCap,
double fMiterMinimumAngle,
bool bPixelSnapHairline) override;
- virtual void drawPolyLine( sal_uInt32 nPoints, const SalPoint*
pPtAry ) override;
- virtual void drawPolygon( sal_uInt32 nPoints, const SalPoint*
pPtAry ) override;
+ virtual void drawPolyLine( sal_uInt32 nPoints, const Point*
pPtAry ) override;
+ virtual void drawPolygon( sal_uInt32 nPoints, const Point*
pPtAry ) override;
virtual void drawPolyPolygon( sal_uInt32 nPoly,
const sal_uInt32* pPoints,
- PCONSTSALPOINT* pPtAry ) override;
+ const Point** pPtAry ) override;
virtual bool drawPolyLineBezier( sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
const PolyFlags* pFlgAry )
override;
virtual bool drawPolygonBezier( sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
const PolyFlags* pFlgAry )
override;
virtual bool drawPolyPolygonBezier( sal_uInt32 nPoly,
const sal_uInt32* pPoints,
- const SalPoint* const*
pPtAry,
+ const Point* const* pPtAry,
const PolyFlags* const*
pFlgAry ) override;
virtual bool drawGradient(tools::PolyPolygon const & rPolyPolygon,
Gradient const & rGradient) override;
@@ -260,7 +260,7 @@ public:
virtual std::shared_ptr<SalBitmap> getBitmap( tools::Long nX, tools::Long
nY, tools::Long nWidth, tools::Long nHeight ) override;
virtual Color getPixel( tools::Long nX, tools::Long nY )
override;
virtual void invert( tools::Long nX, tools::Long nY,
tools::Long nWidth, tools::Long nHeight, SalInvert nFlags ) override;
- virtual void invert( sal_uInt32 nPoints, const SalPoint*
pPtAry, SalInvert nFlags ) override;
+ virtual void invert( sal_uInt32 nPoints, const Point* pPtAry,
SalInvert nFlags ) override;
virtual bool drawEPS( tools::Long nX, tools::Long nY, tools::Long
nWidth, tools::Long nHeight, void* pPtr, sal_uInt32 nSize ) override;
diff --git a/vcl/inc/opengl/gdiimpl.hxx b/vcl/inc/opengl/gdiimpl.hxx
index 13f75ae19b3f..8eaa454ef73e 100644
--- a/vcl/inc/opengl/gdiimpl.hxx
+++ b/vcl/inc/opengl/gdiimpl.hxx
@@ -121,12 +121,12 @@ public:
bool UseInvert50();
bool UseInvert(SalInvert nFlags);
- void DrawConvexPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry, bool
blockAA = false );
+ void DrawConvexPolygon( sal_uInt32 nPoints, const Point* pPtAry, bool
blockAA = false );
void DrawConvexPolygon( const tools::Polygon& rPolygon, bool blockAA );
void DrawTrapezoid( const basegfx::B2DTrapezoid& trapezoid, bool blockAA );
void DrawRect( tools::Long nX, tools::Long nY, tools::Long nWidth,
tools::Long nHeight );
void DrawRect( const tools::Rectangle& rRect );
- void DrawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry );
+ void DrawPolygon( sal_uInt32 nPoints, const Point* pPtAry );
void DrawLineSegment(float x1, float y1, float x2, float y2);
void DrawPolyPolygon( const basegfx::B2DPolyPolygon& rPolyPolygon, bool
blockAA = false );
void DrawRegionBand( const RegionBand& rRegion );
@@ -244,11 +244,11 @@ public:
virtual void drawRect( tools::Long nX, tools::Long nY, tools::Long nWidth,
tools::Long nHeight ) override;
- virtual void drawPolyLine( sal_uInt32 nPoints, const SalPoint* pPtAry )
override;
+ virtual void drawPolyLine( sal_uInt32 nPoints, const Point* pPtAry )
override;
- virtual void drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry )
override;
+ virtual void drawPolygon( sal_uInt32 nPoints, const Point* pPtAry )
override;
- virtual void drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints,
PCONSTSALPOINT* pPtAry ) override;
+ virtual void drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints,
const Point** pPtAry ) override;
virtual bool drawPolyPolygon(
const basegfx::B2DHomMatrix& rObjectToDevice,
@@ -268,18 +268,18 @@ public:
virtual bool drawPolyLineBezier(
sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
const PolyFlags* pFlgAry ) override;
virtual bool drawPolygonBezier(
sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
const PolyFlags* pFlgAry ) override;
virtual bool drawPolyPolygonBezier(
sal_uInt32 nPoly,
const sal_uInt32* pPoints,
- const SalPoint* const* pPtAry,
+ const Point* const* pPtAry,
const PolyFlags* const* pFlgAry ) override;
// CopyArea --> No RasterOp, but ClipRegion
@@ -325,7 +325,7 @@ public:
tools::Long nWidth, tools::Long nHeight,
SalInvert nFlags) override;
- virtual void invert( sal_uInt32 nPoints, const SalPoint* pPtAry, SalInvert
nFlags ) override;
+ virtual void invert( sal_uInt32 nPoints, const Point* pPtAry, SalInvert
nFlags ) override;
virtual bool drawEPS(
tools::Long nX, tools::Long nY,
diff --git a/vcl/inc/qt5/Qt5Graphics.hxx b/vcl/inc/qt5/Qt5Graphics.hxx
index 5abecb39f261..a163db87d94a 100644
--- a/vcl/inc/qt5/Qt5Graphics.hxx
+++ b/vcl/inc/qt5/Qt5Graphics.hxx
@@ -101,18 +101,18 @@ public:
tools::Long nY2) override;
virtual void drawRect(tools::Long nX, tools::Long nY, tools::Long nWidth,
tools::Long nHeight) override;
- virtual void drawPolyLine(sal_uInt32 nPoints, const SalPoint* pPtAry)
override;
- virtual void drawPolygon(sal_uInt32 nPoints, const SalPoint* pPtAry)
override;
+ virtual void drawPolyLine(sal_uInt32 nPoints, const Point* pPtAry)
override;
+ virtual void drawPolygon(sal_uInt32 nPoints, const Point* pPtAry) override;
virtual void drawPolyPolygon(sal_uInt32 nPoly, const sal_uInt32* pPoints,
- PCONSTSALPOINT* pPtAry) override;
+ const Point** pPtAry) override;
virtual bool drawPolyPolygon(const basegfx::B2DHomMatrix& rObjectToDevice,
const basegfx::B2DPolyPolygon&, double
fTransparency) override;
- virtual bool drawPolyLineBezier(sal_uInt32 nPoints, const SalPoint* pPtAry,
+ virtual bool drawPolyLineBezier(sal_uInt32 nPoints, const Point* pPtAry,
const PolyFlags* pFlgAry) override;
- virtual bool drawPolygonBezier(sal_uInt32 nPoints, const SalPoint* pPtAry,
+ virtual bool drawPolygonBezier(sal_uInt32 nPoints, const Point* pPtAry,
const PolyFlags* pFlgAry) override;
virtual bool drawPolyPolygonBezier(sal_uInt32 nPoly, const sal_uInt32*
pPoints,
- const SalPoint* const* pPtAry,
+ const Point* const* pPtAry,
const PolyFlags* const* pFlgAry)
override;
virtual bool drawPolyLine(const basegfx::B2DHomMatrix& rObjectToDevice,
const basegfx::B2DPolygon&, double
fTransparency, double fLineWidths,
@@ -138,7 +138,7 @@ public:
virtual void invert(tools::Long nX, tools::Long nY, tools::Long nWidth,
tools::Long nHeight,
SalInvert nFlags) override;
- virtual void invert(sal_uInt32 nPoints, const SalPoint* pPtAry, SalInvert
nFlags) override;
+ virtual void invert(sal_uInt32 nPoints, const Point* pPtAry, SalInvert
nFlags) override;
virtual bool drawEPS(tools::Long nX, tools::Long nY, tools::Long nWidth,
tools::Long nHeight,
void* pPtr, sal_uInt32 nSize) override;
diff --git a/vcl/inc/quartz/salgdi.h b/vcl/inc/quartz/salgdi.h
index 0aaf71f0f839..d10ea2879559 100644
--- a/vcl/inc/quartz/salgdi.h
+++ b/vcl/inc/quartz/salgdi.h
@@ -228,16 +228,16 @@ public:
virtual void drawPixel( long nX, long nY, Color nColor )
override;
virtual void drawLine( long nX1, long nY1, long nX2, long nY2 )
override;
virtual void drawRect( long nX, long nY, long nWidth, long
nHeight ) override;
- virtual void drawPolyLine( sal_uInt32 nPoints, const SalPoint*
pPtAry ) override;
- virtual void drawPolygon( sal_uInt32 nPoints, const SalPoint*
pPtAry ) override;
- virtual void drawPolyPolygon( sal_uInt32 nPoly, const
sal_uInt32* pPoints, PCONSTSALPOINT* pPtAry ) override;
+ virtual void drawPolyLine( sal_uInt32 nPoints, const Point*
pPtAry ) override;
+ virtual void drawPolygon( sal_uInt32 nPoints, const Point*
pPtAry ) override;
+ virtual void drawPolyPolygon( sal_uInt32 nPoly, const
sal_uInt32* pPoints, const Point** pPtAry ) override;
virtual bool drawPolyPolygon(
const basegfx::B2DHomMatrix& rObjectToDevice,
const basegfx::B2DPolyPolygon&,
double fTransparency) override;
- virtual bool drawPolyLineBezier( sal_uInt32 nPoints, const
SalPoint* pPtAry, const PolyFlags* pFlgAry ) override;
- virtual bool drawPolygonBezier( sal_uInt32 nPoints, const
SalPoint* pPtAry, const PolyFlags* pFlgAry ) override;
- virtual bool drawPolyPolygonBezier( sal_uInt32 nPoly, const
sal_uInt32* pPoints, const SalPoint* const* pPtAry, const PolyFlags* const*
pFlgAry ) override;
+ virtual bool drawPolyLineBezier( sal_uInt32 nPoints, const
Point* pPtAry, const PolyFlags* pFlgAry ) override;
+ virtual bool drawPolygonBezier( sal_uInt32 nPoints, const
Point* pPtAry, const PolyFlags* pFlgAry ) override;
+ virtual bool drawPolyPolygonBezier( sal_uInt32 nPoly, const
sal_uInt32* pPoints, const Point* const* pPtAry, const PolyFlags* const*
pFlgAry ) override;
virtual bool drawPolyLine(
const basegfx::B2DHomMatrix& rObjectToDevice,
const basegfx::B2DPolygon&,
@@ -270,7 +270,7 @@ public:
// invert --> ClipRegion (only Windows or VirDevs)
virtual void invert( long nX, long nY, long nWidth, long
nHeight, SalInvert nFlags) override;
- virtual void invert( sal_uInt32 nPoints, const SalPoint*
pPtAry, SalInvert nFlags ) override;
+ virtual void invert( sal_uInt32 nPoints, const Point* pPtAry,
SalInvert nFlags ) override;
virtual bool drawEPS( long nX, long nY, long nWidth, long
nHeight, void* pPtr, sal_uInt32 nSize ) override;
diff --git a/vcl/inc/salgdi.hxx b/vcl/inc/salgdi.hxx
index 0ae0653ee484..9fa687123bfa 100644
--- a/vcl/inc/salgdi.hxx
+++ b/vcl/inc/salgdi.hxx
@@ -207,7 +207,7 @@ public:
[[nodiscard]]
tools::Long mirror2( tools::Long nX, const
OutputDevice *pOutDev ) const;
void mirror( tools::Long& nX, tools::Long nWidth,
const OutputDevice *pOutDev, bool bBack = false ) const;
- bool mirror( sal_uInt32 nPoints, const SalPoint
*pPtAry, SalPoint *pPtAry2, const OutputDevice *pOutDev ) const;
+ bool mirror( sal_uInt32 nPoints, const Point
*pPtAry, Point *pPtAry2, const OutputDevice *pOutDev ) const;
void mirror( tools::Rectangle& rRect, const
OutputDevice*, bool bBack = false ) const;
void mirror( vcl::Region& rRgn, const OutputDevice
*pOutDev ) const;
void mirror( ImplControlValue&, const OutputDevice*
) const;
@@ -226,14 +226,14 @@ public:
void DrawRect( tools::Long nX, tools::Long nY,
tools::Long nWidth, tools::Long nHeight, const OutputDevice *pOutDev );
- void DrawPolyLine( sal_uInt32 nPoints, SalPoint
const * pPtAry, const OutputDevice *pOutDev );
+ void DrawPolyLine( sal_uInt32 nPoints, Point const
* pPtAry, const OutputDevice *pOutDev );
- void DrawPolygon( sal_uInt32 nPoints, const
SalPoint* pPtAry, const OutputDevice *pOutDev );
+ void DrawPolygon( sal_uInt32 nPoints, const Point*
pPtAry, const OutputDevice *pOutDev );
void DrawPolyPolygon(
sal_uInt32 nPoly,
const sal_uInt32* pPoints,
- PCONSTSALPOINT* pPtAry,
+ const Point** pPtAry,
const OutputDevice *pOutDev );
bool DrawPolyPolygon(
@@ -256,20 +256,20 @@ public:
bool DrawPolyLineBezier(
sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
const PolyFlags* pFlgAry,
const OutputDevice *pOutDev );
bool DrawPolygonBezier(
sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
const PolyFlags* pFlgAry,
const OutputDevice *pOutDev );
bool DrawPolyPolygonBezier(
sal_uInt32 nPoly,
const sal_uInt32* pPoints,
- const SalPoint* const* pPtAry,
+ const Point* const* pPtAry,
const PolyFlags* const* pFlgAry,
const OutputDevice *pOutDev );
@@ -330,7 +330,7 @@ public:
void Invert(
sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
SalInvert nFlags,
const OutputDevice *pOutDev );
@@ -450,11 +450,11 @@ protected:
virtual void drawRect( tools::Long nX, tools::Long nY,
tools::Long nWidth, tools::Long nHeight ) = 0;
- virtual void drawPolyLine( sal_uInt32 nPoints, const
SalPoint* pPtAry ) = 0;
+ virtual void drawPolyLine( sal_uInt32 nPoints, const Point*
pPtAry ) = 0;
- virtual void drawPolygon( sal_uInt32 nPoints, const
SalPoint* pPtAry ) = 0;
+ virtual void drawPolygon( sal_uInt32 nPoints, const Point*
pPtAry ) = 0;
- virtual void drawPolyPolygon( sal_uInt32 nPoly, const
sal_uInt32* pPoints, PCONSTSALPOINT* pPtAry ) = 0;
+ virtual void drawPolyPolygon( sal_uInt32 nPoly, const
sal_uInt32* pPoints, const Point** pPtAry ) = 0;
virtual bool drawPolyPolygon(
const basegfx::B2DHomMatrix&
rObjectToDevice,
@@ -474,18 +474,18 @@ protected:
virtual bool drawPolyLineBezier(
sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
const PolyFlags* pFlgAry ) = 0;
virtual bool drawPolygonBezier(
sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
const PolyFlags* pFlgAry ) = 0;
virtual bool drawPolyPolygonBezier(
sal_uInt32 nPoly,
const sal_uInt32* pPoints,
- const SalPoint* const* pPtAry,
+ const Point* const* pPtAry,
const PolyFlags* const* pFlgAry ) = 0;
virtual bool drawGradient(
@@ -531,7 +531,7 @@ protected:
tools::Long nWidth, tools::Long nHeight,
SalInvert nFlags) = 0;
- virtual void invert( sal_uInt32 nPoints, const SalPoint*
pPtAry, SalInvert nFlags ) = 0;
+ virtual void invert( sal_uInt32 nPoints, const Point*
pPtAry, SalInvert nFlags ) = 0;
virtual bool drawEPS(
tools::Long nX, tools::Long nY,
diff --git a/vcl/inc/salgdiimpl.hxx b/vcl/inc/salgdiimpl.hxx
index ce86fcbd74df..1b60c59e0188 100644
--- a/vcl/inc/salgdiimpl.hxx
+++ b/vcl/inc/salgdiimpl.hxx
@@ -95,11 +95,11 @@ public:
virtual void drawRect( tools::Long nX, tools::Long nY, tools::Long nWidth,
tools::Long nHeight ) = 0;
- virtual void drawPolyLine( sal_uInt32 nPoints, const SalPoint* pPtAry ) =
0;
+ virtual void drawPolyLine( sal_uInt32 nPoints, const Point* pPtAry ) = 0;
- virtual void drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry ) = 0;
+ virtual void drawPolygon( sal_uInt32 nPoints, const Point* pPtAry ) = 0;
- virtual void drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints,
PCONSTSALPOINT* pPtAry ) = 0;
+ virtual void drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints,
const Point** pPtAry ) = 0;
virtual bool drawPolyPolygon(
const basegfx::B2DHomMatrix& rObjectToDevice,
@@ -119,18 +119,18 @@ public:
virtual bool drawPolyLineBezier(
sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
const PolyFlags* pFlgAry ) = 0;
virtual bool drawPolygonBezier(
sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
const PolyFlags* pFlgAry ) = 0;
virtual bool drawPolyPolygonBezier(
sal_uInt32 nPoly,
const sal_uInt32* pPoints,
- const SalPoint* const* pPtAry,
+ const Point* const* pPtAry,
const PolyFlags* const* pFlgAry ) = 0;
// CopyArea --> No RasterOp, but ClipRegion
@@ -166,7 +166,7 @@ public:
tools::Long nWidth, tools::Long nHeight,
SalInvert nFlags) = 0;
- virtual void invert( sal_uInt32 nPoints, const SalPoint* pPtAry, SalInvert
nFlags ) = 0;
+ virtual void invert( sal_uInt32 nPoints, const Point* pPtAry, SalInvert
nFlags ) = 0;
virtual bool drawEPS(
tools::Long nX, tools::Long nY,
diff --git a/vcl/inc/skia/gdiimpl.hxx b/vcl/inc/skia/gdiimpl.hxx
index a1c32dd00910..8e14df458a23 100644
--- a/vcl/inc/skia/gdiimpl.hxx
+++ b/vcl/inc/skia/gdiimpl.hxx
@@ -95,12 +95,12 @@ public:
virtual void drawRect(tools::Long nX, tools::Long nY, tools::Long nWidth,
tools::Long nHeight) override;
- virtual void drawPolyLine(sal_uInt32 nPoints, const SalPoint* pPtAry)
override;
+ virtual void drawPolyLine(sal_uInt32 nPoints, const Point* pPtAry)
override;
- virtual void drawPolygon(sal_uInt32 nPoints, const SalPoint* pPtAry)
override;
+ virtual void drawPolygon(sal_uInt32 nPoints, const Point* pPtAry) override;
virtual void drawPolyPolygon(sal_uInt32 nPoly, const sal_uInt32* pPoints,
- PCONSTSALPOINT* pPtAry) override;
+ const Point** pPtAry) override;
virtual bool drawPolyPolygon(const basegfx::B2DHomMatrix& rObjectToDevice,
const basegfx::B2DPolyPolygon&, double
fTransparency) override;
@@ -111,14 +111,14 @@ public:
css::drawing::LineCap, double fMiterMinimumAngle,
bool bPixelSnapHairline) override;
- virtual bool drawPolyLineBezier(sal_uInt32 nPoints, const SalPoint* pPtAry,
+ virtual bool drawPolyLineBezier(sal_uInt32 nPoints, const Point* pPtAry,
const PolyFlags* pFlgAry) override;
- virtual bool drawPolygonBezier(sal_uInt32 nPoints, const SalPoint* pPtAry,
+ virtual bool drawPolygonBezier(sal_uInt32 nPoints, const Point* pPtAry,
const PolyFlags* pFlgAry) override;
virtual bool drawPolyPolygonBezier(sal_uInt32 nPoly, const sal_uInt32*
pPoints,
- const SalPoint* const* pPtAry,
+ const Point* const* pPtAry,
const PolyFlags* const* pFlgAry)
override;
// CopyArea --> No RasterOp, but ClipRegion
@@ -151,7 +151,7 @@ public:
virtual void invert(tools::Long nX, tools::Long nY, tools::Long nWidth,
tools::Long nHeight,
SalInvert nFlags) override;
- virtual void invert(sal_uInt32 nPoints, const SalPoint* pPtAry, SalInvert
nFlags) override;
+ virtual void invert(sal_uInt32 nPoints, const Point* pPtAry, SalInvert
nFlags) override;
virtual bool drawEPS(tools::Long nX, tools::Long nY, tools::Long nWidth,
tools::Long nHeight,
void* pPtr, sal_uInt32 nSize) override;
diff --git a/vcl/inc/unx/genpspgraphics.h b/vcl/inc/unx/genpspgraphics.h
index 8eb37ac187dd..b8e55627cf8c 100644
--- a/vcl/inc/unx/genpspgraphics.h
+++ b/vcl/inc/unx/genpspgraphics.h
@@ -117,11 +117,11 @@ public:
virtual void drawPixel( tools::Long nX, tools::Long nY, Color
nColor ) override;
virtual void drawLine( tools::Long nX1, tools::Long nY1,
tools::Long nX2, tools::Long nY2 ) override;
virtual void drawRect( tools::Long nX, tools::Long nY,
tools::Long nWidth, tools::Long nHeight ) override;
- virtual void drawPolyLine( sal_uInt32 nPoints, const SalPoint*
pPtAry ) override;
- virtual void drawPolygon( sal_uInt32 nPoints, const SalPoint*
pPtAry ) override;
+ virtual void drawPolyLine( sal_uInt32 nPoints, const Point*
pPtAry ) override;
+ virtual void drawPolygon( sal_uInt32 nPoints, const Point*
pPtAry ) override;
virtual void drawPolyPolygon( sal_uInt32 nPoly,
const sal_uInt32* pPoints,
- PCONSTSALPOINT* pPtAry ) override;
+ const Point** pPtAry ) override;
virtual bool drawPolyPolygon(
const basegfx::B2DHomMatrix& rObjectToDevice,
@@ -139,14 +139,14 @@ public:
double fMiterMinimumAngle,
bool bPixelSnapHairline) override;
virtual bool drawPolyLineBezier( sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
const PolyFlags* pFlgAry )
override;
virtual bool drawPolygonBezier( sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
const PolyFlags* pFlgAry )
override;
virtual bool drawPolyPolygonBezier( sal_uInt32 nPoly,
const sal_uInt32* pPoints,
- const SalPoint* const*
pPtAry,
+ const Point* const* pPtAry,
const PolyFlags* const*
pFlgAry ) override;
virtual bool drawGradient( const tools::PolyPolygon&, const
Gradient& ) override { return false; };
@@ -171,7 +171,7 @@ public:
virtual Color getPixel( tools::Long nX, tools::Long nY )
override;
virtual void invert( tools::Long nX, tools::Long nY,
tools::Long nWidth, tools::Long nHeight,
SalInvert nFlags ) override;
- virtual void invert( sal_uInt32 nPoints, const SalPoint* pPtAry,
+ virtual void invert( sal_uInt32 nPoints, const Point* pPtAry,
SalInvert nFlags ) override;
virtual bool drawEPS( tools::Long nX, tools::Long nY,
tools::Long nWidth, tools::Long nHeight,
diff --git a/vcl/inc/unx/salgdi.h b/vcl/inc/unx/salgdi.h
index fdae63d33e41..166b308c30e8 100644
--- a/vcl/inc/unx/salgdi.h
+++ b/vcl/inc/unx/salgdi.h
@@ -155,13 +155,13 @@ public:
virtual void drawPixel( tools::Long nX, tools::Long nY,
Color nColor ) override;
virtual void drawLine( tools::Long nX1, tools::Long
nY1, tools::Long nX2, tools::Long nY2 ) override;
virtual void drawRect( tools::Long nX, tools::Long nY,
tools::Long nWidth, tools::Long nHeight ) override;
- virtual void drawPolyLine( sal_uInt32 nPoints, const
SalPoint* pPtAry ) override;
- virtual void drawPolygon( sal_uInt32 nPoints, const
SalPoint* pPtAry ) override;
+ virtual void drawPolyLine( sal_uInt32 nPoints, const
Point* pPtAry ) override;
+ virtual void drawPolygon( sal_uInt32 nPoints, const
Point* pPtAry ) override;
virtual void drawPolyPolygon(
sal_uInt32 nPoly,
const sal_uInt32* pPoints,
- PCONSTSALPOINT* pPtAry ) override;
+ const Point** pPtAry ) override;
virtual bool drawPolyPolygon(
const basegfx::B2DHomMatrix&
rObjectToDevice,
@@ -186,18 +186,18 @@ public:
#if 1 // TODO: remove these obsolete methods
virtual bool drawPolyLineBezier(
sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
const PolyFlags* pFlgAry ) override;
virtual bool drawPolygonBezier(
sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
const PolyFlags* pFlgAry ) override;
virtual bool drawPolyPolygonBezier(
sal_uInt32 nPoly,
const sal_uInt32* pPoints,
- const SalPoint* const* pPtAry,
+ const Point* const* pPtAry,
const PolyFlags* const* pFlgAry )
override;
#endif
@@ -231,7 +231,7 @@ public:
virtual std::shared_ptr<SalBitmap> getBitmap( tools::Long nX, tools::Long
nY, tools::Long nWidth, tools::Long nHeight ) override;
virtual Color getPixel( tools::Long nX, tools::Long nY )
override;
virtual void invert( tools::Long nX, tools::Long nY,
tools::Long nWidth, tools::Long nHeight, SalInvert nFlags ) override;
- virtual void invert( sal_uInt32 nPoints, const
SalPoint* pPtAry, SalInvert nFlags ) override;
+ virtual void invert( sal_uInt32 nPoints, const Point*
pPtAry, SalInvert nFlags ) override;
virtual bool drawEPS( tools::Long nX, tools::Long nY,
tools::Long nWidth, tools::Long nHeight, void* pPtr, sal_uInt32 nSize )
override;
diff --git a/vcl/inc/win/salgdi.h b/vcl/inc/win/salgdi.h
index 585cdd913825..815262cdca65 100644
--- a/vcl/inc/win/salgdi.h
+++ b/vcl/inc/win/salgdi.h
@@ -231,9 +231,9 @@ protected:
virtual void drawPixel( tools::Long nX, tools::Long nY, Color
nColor ) override;
virtual void drawLine( tools::Long nX1, tools::Long nY1,
tools::Long nX2, tools::Long nY2 ) override;
virtual void drawRect( tools::Long nX, tools::Long nY, tools::Long
nWidth, tools::Long nHeight ) override;
- virtual void drawPolyLine( sal_uInt32 nPoints, const SalPoint*
pPtAry ) override;
- virtual void drawPolygon( sal_uInt32 nPoints, const SalPoint*
pPtAry ) override;
- virtual void drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32*
pPoints, PCONSTSALPOINT* pPtAry ) override;
+ virtual void drawPolyLine( sal_uInt32 nPoints, const Point* pPtAry
) override;
+ virtual void drawPolygon( sal_uInt32 nPoints, const Point* pPtAry )
override;
+ virtual void drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32*
pPoints, const Point** pPtAry ) override;
virtual bool drawPolyPolygon(
const basegfx::B2DHomMatrix& rObjectToDevice,
const basegfx::B2DPolyPolygon&,
@@ -248,9 +248,9 @@ protected:
css::drawing::LineCap,
double fMiterMinimumAngle,
bool bPixelSnapHairline) override;
- virtual bool drawPolyLineBezier( sal_uInt32 nPoints, const
SalPoint* pPtAry, const PolyFlags* pFlgAry ) override;
- virtual bool drawPolygonBezier( sal_uInt32 nPoints, const SalPoint*
pPtAry, const PolyFlags* pFlgAry ) override;
- virtual bool drawPolyPolygonBezier( sal_uInt32 nPoly, const
sal_uInt32* pPoints, const SalPoint* const* pPtAry, const PolyFlags* const*
pFlgAry ) override;
+ virtual bool drawPolyLineBezier( sal_uInt32 nPoints, const Point*
pPtAry, const PolyFlags* pFlgAry ) override;
+ virtual bool drawPolygonBezier( sal_uInt32 nPoints, const Point*
pPtAry, const PolyFlags* pFlgAry ) override;
+ virtual bool drawPolyPolygonBezier( sal_uInt32 nPoly, const
sal_uInt32* pPoints, const Point* const* pPtAry, const PolyFlags* const*
pFlgAry ) override;
virtual bool drawGradient( const tools::PolyPolygon&, const
Gradient& ) override;
virtual bool implDrawGradient(basegfx::B2DPolyPolygon const &
rPolyPolygon, SalGradient const & rGradient) override;
@@ -274,7 +274,7 @@ protected:
// invert --> ClipRegion (only Windows or VirDevs)
virtual void invert( tools::Long nX, tools::Long nY, tools::Long
nWidth, tools::Long nHeight, SalInvert nFlags) override;
- virtual void invert( sal_uInt32 nPoints, const SalPoint* pPtAry,
SalInvert nFlags ) override;
+ virtual void invert( sal_uInt32 nPoints, const Point* pPtAry,
SalInvert nFlags ) override;
virtual bool drawEPS( tools::Long nX, tools::Long nY, tools::Long
nWidth, tools::Long nHeight, void* pPtr, sal_uInt32 nSize ) override;
diff --git a/vcl/opengl/gdiimpl.cxx b/vcl/opengl/gdiimpl.cxx
index a44ddbff68c8..6329cb92301c 100644
--- a/vcl/opengl/gdiimpl.cxx
+++ b/vcl/opengl/gdiimpl.cxx
@@ -712,7 +712,7 @@ void OpenGLSalGraphicsImpl::UseLine(GLfloat fLineWidth,
bool bUseAA)
mpProgram->SetBlendMode(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
-void OpenGLSalGraphicsImpl::DrawConvexPolygon( sal_uInt32 nPoints, const
SalPoint* pPtAry, bool blockAA )
+void OpenGLSalGraphicsImpl::DrawConvexPolygon( sal_uInt32 nPoints, const
Point* pPtAry, bool blockAA )
{
OpenGLZone aZone;
@@ -721,8 +721,8 @@ void OpenGLSalGraphicsImpl::DrawConvexPolygon( sal_uInt32
nPoints, const SalPoin
for( i = 0, j = 0; i < nPoints; i++, j += 2 )
{
- aVertices[j] = GLfloat(pPtAry[i].mnX);
- aVertices[j+1] = GLfloat(pPtAry[i].mnY);
+ aVertices[j] = GLfloat(pPtAry[i].getX());
+ aVertices[j+1] = GLfloat(pPtAry[i].getY());
}
ApplyProgramMatrices();
@@ -747,9 +747,9 @@ void OpenGLSalGraphicsImpl::DrawConvexPolygon( sal_uInt32
nPoints, const SalPoin
{
for( i = 0; i < nPoints; ++i )
{
- const SalPoint& rPt1 = pPtAry[ i ];
- const SalPoint& rPt2 = pPtAry[ ( i + 1 ) % nPoints ];
- DrawLineSegment(rPt1.mnX, rPt1.mnY, rPt2.mnX, rPt2.mnY);
+ const Point& rPt1 = pPtAry[ i ];
+ const Point& rPt2 = pPtAry[ ( i + 1 ) % nPoints ];
+ DrawLineSegment(rPt1.getX(), rPt1.getY(), rPt2.getX(),
rPt2.getY());
}
UseSolid( lastSolidColor, lastSolidTransparency );
}
@@ -858,7 +858,7 @@ void OpenGLSalGraphicsImpl::DrawRect( tools::Long nX,
tools::Long nY, tools::Lon
tools::Long nY1( nY );
tools::Long nX2( nX + nWidth );
tools::Long nY2( nY + nHeight );
- const SalPoint aPoints[] = { { static_cast<sal_Int32>(nX1),
static_cast<sal_Int32>(nY2) }, { static_cast<sal_Int32>(nX1),
static_cast<sal_Int32>(nY1) },
+ const Point aPoints[] = { { static_cast<sal_Int32>(nX1),
static_cast<sal_Int32>(nY2) }, { static_cast<sal_Int32>(nX1),
static_cast<sal_Int32>(nY1) },
{ static_cast<sal_Int32>(nX2),
static_cast<sal_Int32>(nY1) }, { static_cast<sal_Int32>(nX2),
static_cast<sal_Int32>(nY2) }};
DrawConvexPolygon( 4, aPoints, true );
@@ -870,18 +870,18 @@ void OpenGLSalGraphicsImpl::DrawRect( const
tools::Rectangle& rRect )
tools::Long nY1( rRect.Top() );
tools::Long nX2( rRect.Right() );
tools::Long nY2( rRect.Bottom() );
- const SalPoint aPoints[] = { { static_cast<sal_Int32>(nX1),
static_cast<sal_Int32>(nY2) }, { static_cast<sal_Int32>(nX1),
static_cast<sal_Int32>(nY1) },
+ const Point aPoints[] = { { static_cast<sal_Int32>(nX1),
static_cast<sal_Int32>(nY2) }, { static_cast<sal_Int32>(nX1),
static_cast<sal_Int32>(nY1) },
{ static_cast<sal_Int32>(nX2),
static_cast<sal_Int32>(nY1) }, { static_cast<sal_Int32>(nX2),
static_cast<sal_Int32>(nY2) }};
DrawConvexPolygon( 4, aPoints, true );
}
-void OpenGLSalGraphicsImpl::DrawPolygon( sal_uInt32 nPoints, const SalPoint*
pPtAry )
+void OpenGLSalGraphicsImpl::DrawPolygon( sal_uInt32 nPoints, const Point*
pPtAry )
{
basegfx::B2DPolygon aPolygon;
for( sal_uInt32 i = 0; i < nPoints; i++ )
- aPolygon.append( basegfx::B2DPoint( pPtAry[i].mnX, pPtAry[i].mnY ) );
+ aPolygon.append( basegfx::B2DPoint( pPtAry[i].getX(), pPtAry[i].getY()
) );
aPolygon.setClosed( true );
if( basegfx::utils::isConvex( aPolygon ) )
@@ -1547,13 +1547,13 @@ void OpenGLSalGraphicsImpl::drawRect( tools::Long nX,
tools::Long nY, tools::Lon
PostBatchDraw();
}
-void OpenGLSalGraphicsImpl::drawPolyLine( sal_uInt32 nPoints, const SalPoint*
pPtAry )
+void OpenGLSalGraphicsImpl::drawPolyLine( sal_uInt32 nPoints, const Point*
pPtAry )
{
VCL_GL_INFO("::drawPolyLine legacy -> redirecting to drawPolyLine");
basegfx::B2DPolygon aPoly;
- aPoly.append(basegfx::B2DPoint(pPtAry->mnX, pPtAry->mnY), nPoints);
+ aPoly.append(basegfx::B2DPoint(pPtAry->getX(), pPtAry->getY()), nPoints);
for (sal_uInt32 i = 1; i < nPoints; ++i)
- aPoly.setB2DPoint(i, basegfx::B2DPoint(pPtAry[i].mnX, pPtAry[i].mnY));
+ aPoly.setB2DPoint(i, basegfx::B2DPoint(pPtAry[i].getX(),
pPtAry[i].getY()));
aPoly.setClosed(false);
drawPolyLine(
@@ -1568,13 +1568,13 @@ void OpenGLSalGraphicsImpl::drawPolyLine( sal_uInt32
nPoints, const SalPoint* pP
false);
}
-void OpenGLSalGraphicsImpl::drawPolygon( sal_uInt32 nPoints, const SalPoint*
pPtAry )
+void OpenGLSalGraphicsImpl::drawPolygon( sal_uInt32 nPoints, const Point*
pPtAry )
{
VCL_GL_INFO("::drawPolygon legacy -> redirecting to drawPolyPolygon with
transparency");
basegfx::B2DPolygon aPoly;
- aPoly.append(basegfx::B2DPoint(pPtAry->mnX, pPtAry->mnY), nPoints);
+ aPoly.append(basegfx::B2DPoint(pPtAry->getX(), pPtAry->getY()), nPoints);
for (sal_uInt32 i = 1; i < nPoints; ++i)
- aPoly.setB2DPoint(i, basegfx::B2DPoint(pPtAry[i].mnX, pPtAry[i].mnY));
+ aPoly.setB2DPoint(i, basegfx::B2DPoint(pPtAry[i].getX(),
pPtAry[i].getY()));
drawPolyPolygon(
basegfx::B2DHomMatrix(),
@@ -1582,7 +1582,7 @@ void OpenGLSalGraphicsImpl::drawPolygon( sal_uInt32
nPoints, const SalPoint* pPt
0.0);
}
-void OpenGLSalGraphicsImpl::drawPolyPolygon( sal_uInt32 nPoly, const
sal_uInt32* pPointCounts, PCONSTSALPOINT* pPtAry )
+void OpenGLSalGraphicsImpl::drawPolyPolygon( sal_uInt32 nPoly, const
sal_uInt32* pPointCounts, const Point** pPtAry )
{
VCL_GL_INFO("::drawPolyPolygon legacy -> redirecting to drawPolyPolygon
with transparency");
basegfx::B2DPolyPolygon aPolyPoly;
@@ -1591,11 +1591,11 @@ void OpenGLSalGraphicsImpl::drawPolyPolygon( sal_uInt32
nPoly, const sal_uInt32*
sal_uInt32 nPoints = pPointCounts[nPolygon];
if (nPoints)
{
- PCONSTSALPOINT pPoints = pPtAry[nPolygon];
+ const Point* pPoints = pPtAry[nPolygon];
basegfx::B2DPolygon aPoly;
- aPoly.append( basegfx::B2DPoint(pPoints->mnX, pPoints->mnY),
nPoints);
+ aPoly.append( basegfx::B2DPoint(pPoints->getX(), pPoints->getY()),
nPoints);
for (sal_uInt32 i = 1; i < nPoints; ++i)
- aPoly.setB2DPoint(i, basegfx::B2DPoint( pPoints[i].mnX,
pPoints[i].mnY));
+ aPoly.setB2DPoint(i, basegfx::B2DPoint( pPoints[i].getX(),
pPoints[i].getY()));
aPolyPoly.append(aPoly);
}
@@ -1712,7 +1712,7 @@ bool OpenGLSalGraphicsImpl::drawPolyLine(
bool OpenGLSalGraphicsImpl::drawPolyLineBezier(
sal_uInt32 /*nPoints*/,
- const SalPoint* /*pPtAry*/,
+ const Point* /*pPtAry*/,
const PolyFlags* /*pFlgAry*/ )
{
return false;
@@ -1720,7 +1720,7 @@ bool OpenGLSalGraphicsImpl::drawPolyLineBezier(
bool OpenGLSalGraphicsImpl::drawPolygonBezier(
sal_uInt32 /*nPoints*/,
- const SalPoint* /*pPtAry*/,
+ const Point* /*pPtAry*/,
const PolyFlags* /*pFlgAry*/ )
{
return false;
@@ -1729,7 +1729,7 @@ bool OpenGLSalGraphicsImpl::drawPolygonBezier(
bool OpenGLSalGraphicsImpl::drawPolyPolygonBezier(
sal_uInt32 /*nPoly*/,
const sal_uInt32* /*pPoints*/,
- const SalPoint* const* /*pPtAry*/,
+ const Point* const* /*pPtAry*/,
const PolyFlags* const* /*pFlgAry*/ )
{
return false;
@@ -1892,7 +1892,7 @@ void OpenGLSalGraphicsImpl::invert(
PostDraw();
}
-void OpenGLSalGraphicsImpl::invert( sal_uInt32 nPoints, const SalPoint*
pPtAry, SalInvert nFlags )
+void OpenGLSalGraphicsImpl::invert( sal_uInt32 nPoints, const Point* pPtAry,
SalInvert nFlags )
{
PreDraw();
@@ -1905,26 +1905,26 @@ void OpenGLSalGraphicsImpl::invert( sal_uInt32 nPoints,
const SalPoint* pPtAry,
// can't be used. Draw the edge of the polygon as polygons instead.
for (size_t nPoint = 0; nPoint < nPoints; ++nPoint)
{
- const SalPoint& rFrom = pPtAry[nPoint];
- const SalPoint& rTo = pPtAry[(nPoint + 1) % nPoints];
- if (rFrom.mnX == rTo.mnX)
+ const Point& rFrom = pPtAry[nPoint];
+ const Point& rTo = pPtAry[(nPoint + 1) % nPoints];
+ if (rFrom.getX() == rTo.getX())
{
// Extend to the right, comments assuming "to" is above
// "from":
- const SalPoint aPoints[] = { { rFrom.mnX + 1, rFrom.mnY },
// bottom right
- { rFrom.mnX, rFrom.mnY }, //
bottom left
- { rTo.mnX, rTo.mnY }, // top
left
- { rTo.mnX + 1, rTo.mnY } };
// top right
+ const Point aPoints[] = { { rFrom.getX() + 1, rFrom.getY()
}, // bottom right
+ { rFrom.getX(), rFrom.getY()
}, // bottom left
+ { rTo.getX(), rTo.getY() },
// top left
+ { rTo.getX() + 1, rTo.getY()
} }; // top right
DrawConvexPolygon(4, aPoints, true);
}
else
{
// Otherwise can extend downwards, comments assuming "to"
// is above and on the right of "from":
- const SalPoint aPoints[] = { { rFrom.mnX, rFrom.mnY + 1 },
// bottom left
- { rFrom.mnX, rFrom.mnY }, //
top left
- { rTo.mnX, rTo.mnY }, // top
right
- { rTo.mnX, rTo.mnY + 1 } };
// bottom right
+ const Point aPoints[] = { { rFrom.getX(), rFrom.getY() + 1
}, // bottom left
+ { rFrom.getX(), rFrom.getY()
}, // top left
+ { rTo.getX(), rTo.getY() },
// top right
+ { rTo.getX(), rTo.getY() + 1
} }; // bottom right
DrawConvexPolygon(4, aPoints, true);
}
}
diff --git a/vcl/qt5/Qt5Graphics_GDI.cxx b/vcl/qt5/Qt5Graphics_GDI.cxx
index d9a9a2b12f16..559ff4baca39 100644
--- a/vcl/qt5/Qt5Graphics_GDI.cxx
+++ b/vcl/qt5/Qt5Graphics_GDI.cxx
@@ -216,44 +216,44 @@ void Qt5Graphics::drawRect(tools::Long nX, tools::Long
nY, tools::Long nWidth, t
aPainter.update(nX, nY, nWidth, nHeight);
}
-void Qt5Graphics::drawPolyLine(sal_uInt32 nPoints, const SalPoint* pPtAry)
+void Qt5Graphics::drawPolyLine(sal_uInt32 nPoints, const Point* pPtAry)
{
if (0 == nPoints)
return;
Qt5Painter aPainter(*this);
QPoint* pPoints = new QPoint[nPoints];
- QPoint aTopLeft(pPtAry->mnX, pPtAry->mnY);
+ QPoint aTopLeft(pPtAry->getX(), pPtAry->getY());
QPoint aBottomRight = aTopLeft;
for (sal_uInt32 i = 0; i < nPoints; ++i, ++pPtAry)
{
- pPoints[i] = QPoint(pPtAry->mnX, pPtAry->mnY);
- if (pPtAry->mnX < aTopLeft.x())
- aTopLeft.setX(pPtAry->mnX);
- if (pPtAry->mnY < aTopLeft.y())
- aTopLeft.setY(pPtAry->mnY);
- if (pPtAry->mnX > aBottomRight.x())
- aBottomRight.setX(pPtAry->mnX);
- if (pPtAry->mnY > aBottomRight.y())
- aBottomRight.setY(pPtAry->mnY);
+ pPoints[i] = QPoint(pPtAry->getX(), pPtAry->getY());
+ if (pPtAry->getX() < aTopLeft.x())
+ aTopLeft.setX(pPtAry->getX());
+ if (pPtAry->getY() < aTopLeft.y())
+ aTopLeft.setY(pPtAry->getY());
+ if (pPtAry->getX() > aBottomRight.x())
+ aBottomRight.setX(pPtAry->getX());
+ if (pPtAry->getY() > aBottomRight.y())
+ aBottomRight.setY(pPtAry->getY());
}
aPainter.drawPolyline(pPoints, nPoints);
delete[] pPoints;
aPainter.update(QRect(aTopLeft, aBottomRight));
}
-void Qt5Graphics::drawPolygon(sal_uInt32 nPoints, const SalPoint* pPtAry)
+void Qt5Graphics::drawPolygon(sal_uInt32 nPoints, const Point* pPtAry)
{
Qt5Painter aPainter(*this, true);
QPolygon aPolygon(nPoints);
for (sal_uInt32 i = 0; i < nPoints; ++i, ++pPtAry)
- aPolygon.setPoint(i, pPtAry->mnX, pPtAry->mnY);
+ aPolygon.setPoint(i, pPtAry->getX(), pPtAry->getY());
aPainter.drawPolygon(aPolygon);
aPainter.update(aPolygon.boundingRect());
}
void Qt5Graphics::drawPolyPolygon(sal_uInt32 nPolyCount, const sal_uInt32*
pPoints,
- PCONSTSALPOINT* ppPtAry)
+ const Point** ppPtAry)
{
// ignore invisible polygons
if (SALCOLOR_NONE == m_aFillColor && SALCOLOR_NONE == m_aLineColor)
@@ -265,11 +265,11 @@ void Qt5Graphics::drawPolyPolygon(sal_uInt32 nPolyCount,
const sal_uInt32* pPoin
const sal_uInt32 nPoints = pPoints[nPoly];
if (nPoints > 1)
{
- const SalPoint* pPtAry = ppPtAry[nPoly];
- aPath.moveTo(pPtAry->mnX, pPtAry->mnY);
+ const Point* pPtAry = ppPtAry[nPoly];
+ aPath.moveTo(pPtAry->getX(), pPtAry->getY());
pPtAry++;
for (sal_uInt32 nPoint = 1; nPoint < nPoints; nPoint++, pPtAry++)
- aPath.lineTo(pPtAry->mnX, pPtAry->mnY);
+ aPath.lineTo(pPtAry->getX(), pPtAry->getY());
aPath.closeSubpath();
}
}
@@ -303,20 +303,20 @@ bool Qt5Graphics::drawPolyPolygon(const
basegfx::B2DHomMatrix& rObjectToDevice,
return true;
}
-bool Qt5Graphics::drawPolyLineBezier(sal_uInt32 /*nPoints*/, const SalPoint*
/*pPtAry*/,
+bool Qt5Graphics::drawPolyLineBezier(sal_uInt32 /*nPoints*/, const Point*
/*pPtAry*/,
const PolyFlags* /*pFlgAry*/)
{
return false;
}
-bool Qt5Graphics::drawPolygonBezier(sal_uInt32 /*nPoints*/, const SalPoint*
/*pPtAry*/,
+bool Qt5Graphics::drawPolygonBezier(sal_uInt32 /*nPoints*/, const Point*
/*pPtAry*/,
const PolyFlags* /*pFlgAry*/)
{
return false;
}
bool Qt5Graphics::drawPolyPolygonBezier(sal_uInt32 /*nPoly*/, const
sal_uInt32* /*pPoints*/,
- const SalPoint* const* /*pPtAry*/,
+ const Point* const* /*pPtAry*/,
const PolyFlags* const* /*pFlgAry*/)
{
return false;
@@ -547,9 +547,7 @@ void Qt5Graphics::invert(tools::Long nX, tools::Long nY,
tools::Long nWidth, too
aPainter.update(nX, nY, nWidth, nHeight);
}
-void Qt5Graphics::invert(sal_uInt32 /*nPoints*/, const SalPoint* /*pPtAry*/,
SalInvert /*nFlags*/)
-{
-}
+void Qt5Graphics::invert(sal_uInt32 /*nPoints*/, const Point* /*pPtAry*/,
SalInvert /*nFlags*/) {}
bool Qt5Graphics::drawEPS(tools::Long /*nX*/, tools::Long /*nY*/, tools::Long
/*nWidth*/,
tools::Long /*nHeight*/, void* /*pPtr*/, sal_uInt32
/*nSize*/)
diff --git a/vcl/quartz/salgdicommon.cxx b/vcl/quartz/salgdicommon.cxx
index 7c7dcac7898f..0e1508fd9104 100644
--- a/vcl/quartz/salgdicommon.cxx
+++ b/vcl/quartz/salgdicommon.cxx
@@ -193,10 +193,10 @@ bool AquaSalGraphics::CreateFontSubset( const OUString&
rToFile,
return bRet;
}
-static void alignLinePoint( const SalPoint* i_pIn, float& o_fX, float& o_fY )
+static void alignLinePoint( const Point* i_pIn, float& o_fX, float& o_fY )
{
- o_fX = static_cast<float>(i_pIn->mnX ) + 0.5;
- o_fY = static_cast<float>(i_pIn->mnY ) + 0.5;
+ o_fX = static_cast<float>(i_pIn->getX() ) + 0.5;
+ o_fY = static_cast<float>(i_pIn->getY() ) + 0.5;
}
void AquaSalGraphics::copyBits( const SalTwoRect& rPosAry, SalGraphics
*pSrcGraphics )
@@ -309,31 +309,31 @@ static void DrawPattern50( void*, CGContextRef rContext )
CGContextFillPath( rContext );
}
-static void getBoundRect( sal_uInt32 nPoints, const SalPoint *pPtAry,
+static void getBoundRect( sal_uInt32 nPoints, const Point *pPtAry,
long &rX, long& rY, long& rWidth, long& rHeight )
{
- long nX1 = pPtAry->mnX;
+ long nX1 = pPtAry->getX();
long nX2 = nX1;
- long nY1 = pPtAry->mnY;
+ long nY1 = pPtAry->getY();
long nY2 = nY1;
for( sal_uInt32 n = 1; n < nPoints; n++ )
{
- if( pPtAry[n].mnX < nX1 )
+ if( pPtAry[n].getX() < nX1 )
{
- nX1 = pPtAry[n].mnX;
+ nX1 = pPtAry[n].getX();
}
- else if( pPtAry[n].mnX > nX2 )
+ else if( pPtAry[n].getX() > nX2 )
{
- nX2 = pPtAry[n].mnX;
+ nX2 = pPtAry[n].getX();
}
- if( pPtAry[n].mnY < nY1 )
+ if( pPtAry[n].getY() < nY1 )
{
- nY1 = pPtAry[n].mnY;
+ nY1 = pPtAry[n].getY();
}
- else if( pPtAry[n].mnY > nY2 )
+ else if( pPtAry[n].getY() > nY2 )
{
- nY2 = pPtAry[n].mnY;
+ nY2 = pPtAry[n].getY();
}
}
rX = nX1;
@@ -857,7 +857,7 @@ bool AquaSalGraphics::drawPolyLine(
return true;
}
-bool AquaSalGraphics::drawPolyLineBezier( sal_uInt32, const SalPoint*, const
PolyFlags* )
+bool AquaSalGraphics::drawPolyLineBezier( sal_uInt32, const Point*, const
PolyFlags* )
{
return false;
}
@@ -938,7 +938,7 @@ bool AquaSalGraphics::drawPolyPolygon(
return true;
}
-void AquaSalGraphics::drawPolyPolygon( sal_uInt32 nPolyCount, const sal_uInt32
*pPoints, PCONSTSALPOINT *ppPtAry )
+void AquaSalGraphics::drawPolyPolygon( sal_uInt32 nPolyCount, const sal_uInt32
*pPoints, const Point* *ppPtAry )
{
if( nPolyCount <= 0 )
return;
@@ -1003,7 +1003,7 @@ void AquaSalGraphics::drawPolyPolygon( sal_uInt32
nPolyCount, const sal_uInt32 *
const sal_uInt32 nPoints = pPoints[nPoly];
if( nPoints > 1 )
{
- const SalPoint *pPtAry = ppPtAry[nPoly];
+ const Point *pPtAry = ppPtAry[nPoly];
float fX, fY;
alignLinePoint( pPtAry, fX, fY );
@@ -1026,12 +1026,12 @@ void AquaSalGraphics::drawPolyPolygon( sal_uInt32
nPolyCount, const sal_uInt32 *
const sal_uInt32 nPoints = pPoints[nPoly];
if( nPoints > 1 )
{
- const SalPoint *pPtAry = ppPtAry[nPoly];
- CGContextMoveToPoint( maContextHolder.get(), pPtAry->mnX,
pPtAry->mnY );
+ const Point *pPtAry = ppPtAry[nPoly];
+ CGContextMoveToPoint( maContextHolder.get(), pPtAry->getX(),
pPtAry->getY() );
pPtAry++;
for( sal_uInt32 nPoint = 1; nPoint < nPoints; nPoint++,
pPtAry++ )
{
- CGContextAddLineToPoint( maContextHolder.get(),
pPtAry->mnX, pPtAry->mnY );
+ CGContextAddLineToPoint( maContextHolder.get(),
pPtAry->getX(), pPtAry->getY() );
}
CGContextClosePath(maContextHolder.get());
}
@@ -1043,7 +1043,7 @@ void AquaSalGraphics::drawPolyPolygon( sal_uInt32
nPolyCount, const sal_uInt32 *
RefreshRect( leftX, topY, maxWidth, maxHeight );
}
-void AquaSalGraphics::drawPolygon( sal_uInt32 nPoints, const SalPoint *pPtAry )
+void AquaSalGraphics::drawPolygon( sal_uInt32 nPoints, const Point *pPtAry )
{
if( nPoints <= 1 )
return;
@@ -1089,11 +1089,11 @@ void AquaSalGraphics::drawPolygon( sal_uInt32 nPoints,
const SalPoint *pPtAry )
}
else
{
- CGContextMoveToPoint( maContextHolder.get(), pPtAry->mnX, pPtAry->mnY
);
+ CGContextMoveToPoint( maContextHolder.get(), pPtAry->getX(),
pPtAry->getY() );
pPtAry++;
for( sal_uInt32 nPoint = 1; nPoint < nPoints; nPoint++, pPtAry++ )
{
- CGContextAddLineToPoint( maContextHolder.get(), pPtAry->mnX,
pPtAry->mnY );
+ CGContextAddLineToPoint( maContextHolder.get(), pPtAry->getX(),
pPtAry->getY() );
}
}
@@ -1102,13 +1102,13 @@ void AquaSalGraphics::drawPolygon( sal_uInt32 nPoints,
const SalPoint *pPtAry )
RefreshRect( nX, nY, nWidth, nHeight );
}
-bool AquaSalGraphics::drawPolygonBezier( sal_uInt32, const SalPoint*, const
PolyFlags* )
+bool AquaSalGraphics::drawPolygonBezier( sal_uInt32, const Point*, const
PolyFlags* )
{
return false;
}
bool AquaSalGraphics::drawPolyPolygonBezier( sal_uInt32, const sal_uInt32*,
- const SalPoint* const*, const
PolyFlags* const* )
+ const Point* const*, const
PolyFlags* const* )
{
return false;
}
@@ -1138,7 +1138,7 @@ void AquaSalGraphics::drawRect( long nX, long nY, long
nWidth, long nHeight )
RefreshRect( nX, nY, nWidth, nHeight );
}
-void AquaSalGraphics::drawPolyLine( sal_uInt32 nPoints, const SalPoint *pPtAry
)
+void AquaSalGraphics::drawPolyLine( sal_uInt32 nPoints, const Point *pPtAry )
{
if( nPoints < 1 )
return;
@@ -1441,20 +1441,20 @@ void AquaSalGraphics::invert( long nX, long nY, long
nWidth, long nHeight, SalIn
namespace {
-CGPoint* makeCGptArray(sal_uInt32 nPoints, const SalPoint* pPtAry)
+CGPoint* makeCGptArray(sal_uInt32 nPoints, const Point* pPtAry)
{
CGPoint *CGpoints = new CGPoint[nPoints];
for(sal_uLong i=0;i<nPoints;i++)
{
- CGpoints[i].x = pPtAry[i].mnX;
- CGpoints[i].y = pPtAry[i].mnY;
+ CGpoints[i].x = pPtAry[i].getX();
+ CGpoints[i].y = pPtAry[i].getY();
}
return CGpoints;
}
}
-void AquaSalGraphics::invert( sal_uInt32 nPoints, const SalPoint* pPtAry,
SalInvert nSalFlags )
+void AquaSalGraphics::invert( sal_uInt32 nPoints, const Point* pPtAry,
SalInvert nSalFlags )
{
if ( CheckContext() )
{
diff --git a/vcl/skia/gdiimpl.cxx b/vcl/skia/gdiimpl.cxx
index 9659f8c91ee9..a489d0385cfa 100644
--- a/vcl/skia/gdiimpl.cxx
+++ b/vcl/skia/gdiimpl.cxx
@@ -767,30 +767,30 @@ void SkiaSalGraphicsImpl::drawRect(tools::Long nX,
tools::Long nY, tools::Long n
privateDrawAlphaRect(nX, nY, nWidth, nHeight, 0.0, true);
}
-void SkiaSalGraphicsImpl::drawPolyLine(sal_uInt32 nPoints, const SalPoint*
pPtAry)
+void SkiaSalGraphicsImpl::drawPolyLine(sal_uInt32 nPoints, const Point* pPtAry)
{
basegfx::B2DPolygon aPolygon;
- aPolygon.append(basegfx::B2DPoint(pPtAry->mnX, pPtAry->mnY), nPoints);
+ aPolygon.append(basegfx::B2DPoint(pPtAry->getX(), pPtAry->getY()),
nPoints);
for (sal_uInt32 i = 1; i < nPoints; ++i)
- aPolygon.setB2DPoint(i, basegfx::B2DPoint(pPtAry[i].mnX,
pPtAry[i].mnY));
+ aPolygon.setB2DPoint(i, basegfx::B2DPoint(pPtAry[i].getX(),
pPtAry[i].getY()));
aPolygon.setClosed(false);
drawPolyLine(basegfx::B2DHomMatrix(), aPolygon, 0.0, 1.0, nullptr,
basegfx::B2DLineJoin::Miter,
css::drawing::LineCap_BUTT, basegfx::deg2rad(15.0)
/*default*/, false);
}
-void SkiaSalGraphicsImpl::drawPolygon(sal_uInt32 nPoints, const SalPoint*
pPtAry)
+void SkiaSalGraphicsImpl::drawPolygon(sal_uInt32 nPoints, const Point* pPtAry)
{
basegfx::B2DPolygon aPolygon;
- aPolygon.append(basegfx::B2DPoint(pPtAry->mnX, pPtAry->mnY), nPoints);
+ aPolygon.append(basegfx::B2DPoint(pPtAry->getX(), pPtAry->getY()),
nPoints);
for (sal_uInt32 i = 1; i < nPoints; ++i)
- aPolygon.setB2DPoint(i, basegfx::B2DPoint(pPtAry[i].mnX,
pPtAry[i].mnY));
+ aPolygon.setB2DPoint(i, basegfx::B2DPoint(pPtAry[i].getX(),
pPtAry[i].getY()));
drawPolyPolygon(basegfx::B2DHomMatrix(),
basegfx::B2DPolyPolygon(aPolygon), 0.0);
}
void SkiaSalGraphicsImpl::drawPolyPolygon(sal_uInt32 nPoly, const sal_uInt32*
pPoints,
- PCONSTSALPOINT* pPtAry)
+ const Point** pPtAry)
{
basegfx::B2DPolyPolygon aPolyPolygon;
for (sal_uInt32 nPolygon = 0; nPolygon < nPoly; ++nPolygon)
@@ -798,11 +798,12 @@ void SkiaSalGraphicsImpl::drawPolyPolygon(sal_uInt32
nPoly, const sal_uInt32* pP
sal_uInt32 nPoints = pPoints[nPolygon];
if (nPoints)
{
- PCONSTSALPOINT pSalPoints = pPtAry[nPolygon];
+ const Point* pSubPoints = pPtAry[nPolygon];
basegfx::B2DPolygon aPolygon;
- aPolygon.append(basegfx::B2DPoint(pSalPoints->mnX,
pSalPoints->mnY), nPoints);
+ aPolygon.append(basegfx::B2DPoint(pSubPoints->getX(),
pSubPoints->getY()), nPoints);
for (sal_uInt32 i = 1; i < nPoints; ++i)
- aPolygon.setB2DPoint(i, basegfx::B2DPoint(pSalPoints[i].mnX,
pSalPoints[i].mnY));
+ aPolygon.setB2DPoint(i,
+ basegfx::B2DPoint(pSubPoints[i].getX(),
pSubPoints[i].getY()));
aPolyPolygon.append(aPolygon);
}
@@ -1116,18 +1117,18 @@ bool SkiaSalGraphicsImpl::drawPolyLine(const
basegfx::B2DHomMatrix& rObjectToDev
return true;
}
-bool SkiaSalGraphicsImpl::drawPolyLineBezier(sal_uInt32, const SalPoint*,
const PolyFlags*)
+bool SkiaSalGraphicsImpl::drawPolyLineBezier(sal_uInt32, const Point*, const
PolyFlags*)
{
return false;
}
-bool SkiaSalGraphicsImpl::drawPolygonBezier(sal_uInt32, const SalPoint*, const
PolyFlags*)
+bool SkiaSalGraphicsImpl::drawPolygonBezier(sal_uInt32, const Point*, const
PolyFlags*)
{
return false;
}
-bool SkiaSalGraphicsImpl::drawPolyPolygonBezier(sal_uInt32, const sal_uInt32*,
- const SalPoint* const*, const
PolyFlags* const*)
+bool SkiaSalGraphicsImpl::drawPolyPolygonBezier(sal_uInt32, const sal_uInt32*,
const Point* const*,
+ const PolyFlags* const*)
{
return false;
}
@@ -1472,13 +1473,13 @@ void SkiaSalGraphicsImpl::invert(tools::Long nX,
tools::Long nY, tools::Long nWi
invert(aRect, eFlags);
}
-void SkiaSalGraphicsImpl::invert(sal_uInt32 nPoints, const SalPoint*
pPointArray, SalInvert eFlags)
+void SkiaSalGraphicsImpl::invert(sal_uInt32 nPoints, const Point* pPointArray,
SalInvert eFlags)
{
basegfx::B2DPolygon aPolygon;
- aPolygon.append(basegfx::B2DPoint(pPointArray[0].mnX, pPointArray[0].mnY),
nPoints);
+ aPolygon.append(basegfx::B2DPoint(pPointArray[0].getX(),
pPointArray[0].getY()), nPoints);
for (sal_uInt32 i = 1; i < nPoints; ++i)
{
- aPolygon.setB2DPoint(i, basegfx::B2DPoint(pPointArray[i].mnX,
pPointArray[i].mnY));
+ aPolygon.setB2DPoint(i, basegfx::B2DPoint(pPointArray[i].getX(),
pPointArray[i].getY()));
}
aPolygon.setClosed(true);
diff --git a/vcl/source/gdi/salgdilayout.cxx b/vcl/source/gdi/salgdilayout.cxx
index 4b6891dc6936..5878ebdd8e73 100644
--- a/vcl/source/gdi/salgdilayout.cxx
+++ b/vcl/source/gdi/salgdilayout.cxx
@@ -202,7 +202,7 @@ void SalGraphics::mirror( tools::Long& x, tools::Long
nWidth, const OutputDevice
x = w-nWidth-x;
}
-bool SalGraphics::mirror( sal_uInt32 nPoints, const SalPoint *pPtAry, SalPoint
*pPtAry2, const OutputDevice *pOutDev ) const
+bool SalGraphics::mirror( sal_uInt32 nPoints, const Point *pPtAry, Point
*pPtAry2, const OutputDevice *pOutDev ) const
{
const tools::Long w = GetDeviceWidth(pOutDev);
if( w )
@@ -218,8 +218,8 @@ bool SalGraphics::mirror( sal_uInt32 nPoints, const
SalPoint *pPtAry, SalPoint *
tools::Long devX =
w-pOutDevRef->GetOutputWidthPixel()-pOutDevRef->GetOutOffXPixel(); //
re-mirrored mnOutOffX
for( i=0, j=nPoints-1; i<nPoints; i++,j-- )
{
- pPtAry2[j].mnX = devX + (pPtAry[i].mnX -
pOutDevRef->GetOutOffXPixel());
- pPtAry2[j].mnY = pPtAry[i].mnY;
+ pPtAry2[j].setX( devX + (pPtAry[i].getX() -
pOutDevRef->GetOutOffXPixel()) );
+ pPtAry2[j].setY( pPtAry[i].getY() );
}
}
else
@@ -227,8 +227,8 @@ bool SalGraphics::mirror( sal_uInt32 nPoints, const
SalPoint *pPtAry, SalPoint *
tools::Long devX = pOutDevRef->GetOutOffXPixel(); //
re-mirrored mnOutOffX
for( i=0, j=nPoints-1; i<nPoints; i++,j-- )
{
- pPtAry2[j].mnX = pOutDevRef->GetOutputWidthPixel() -
(pPtAry[i].mnX - devX) + pOutDevRef->GetOutOffXPixel() - 1;
- pPtAry2[j].mnY = pPtAry[i].mnY;
+ pPtAry2[j].setX( pOutDevRef->GetOutputWidthPixel() -
(pPtAry[i].getX() - devX) + pOutDevRef->GetOutOffXPixel() - 1 );
+ pPtAry2[j].setY( pPtAry[i].getY() );
}
}
}
@@ -236,8 +236,8 @@ bool SalGraphics::mirror( sal_uInt32 nPoints, const
SalPoint *pPtAry, SalPoint *
{
for( i=0, j=nPoints-1; i<nPoints; i++,j-- )
{
- pPtAry2[j].mnX = w-1-pPtAry[i].mnX;
- pPtAry2[j].mnY = pPtAry[i].mnY;
+ pPtAry2[j].setX( w-1-pPtAry[i].getX() );
+ pPtAry2[j].setY( pPtAry[i].getY() );
}
}
return true;
@@ -400,11 +400,11 @@ void SalGraphics::DrawRect( tools::Long nX, tools::Long
nY, tools::Long nWidth,
drawRect( nX, nY, nWidth, nHeight );
}
-void SalGraphics::DrawPolyLine( sal_uInt32 nPoints, SalPoint const * pPtAry,
const OutputDevice *pOutDev )
+void SalGraphics::DrawPolyLine( sal_uInt32 nPoints, Point const * pPtAry,
const OutputDevice *pOutDev )
{
if( (m_nLayout & SalLayoutFlags::BiDiRtl) || (pOutDev &&
pOutDev->IsRTLEnabled()) )
{
- std::unique_ptr<SalPoint[]> pPtAry2(new SalPoint[nPoints]);
+ std::unique_ptr<Point[]> pPtAry2(new Point[nPoints]);
bool bCopied = mirror( nPoints, pPtAry, pPtAry2.get(), pOutDev );
drawPolyLine( nPoints, bCopied ? pPtAry2.get() : pPtAry );
}
@@ -412,11 +412,11 @@ void SalGraphics::DrawPolyLine( sal_uInt32 nPoints,
SalPoint const * pPtAry, con
drawPolyLine( nPoints, pPtAry );
}
-void SalGraphics::DrawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry,
const OutputDevice *pOutDev )
+void SalGraphics::DrawPolygon( sal_uInt32 nPoints, const Point* pPtAry, const
OutputDevice *pOutDev )
{
if( (m_nLayout & SalLayoutFlags::BiDiRtl) || (pOutDev &&
pOutDev->IsRTLEnabled()) )
{
- std::unique_ptr<SalPoint[]> pPtAry2(new SalPoint[nPoints]);
+ std::unique_ptr<Point[]> pPtAry2(new Point[nPoints]);
bool bCopied = mirror( nPoints, pPtAry, pPtAry2.get(), pOutDev );
drawPolygon( nPoints, bCopied ? pPtAry2.get() : pPtAry );
}
@@ -424,21 +424,21 @@ void SalGraphics::DrawPolygon( sal_uInt32 nPoints, const
SalPoint* pPtAry, const
drawPolygon( nPoints, pPtAry );
}
-void SalGraphics::DrawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32*
pPoints, PCONSTSALPOINT* pPtAry, const OutputDevice *pOutDev )
+void SalGraphics::DrawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32*
pPoints, const Point** pPtAry, const OutputDevice *pOutDev )
{
if( (m_nLayout & SalLayoutFlags::BiDiRtl) || (pOutDev &&
pOutDev->IsRTLEnabled()) )
{
// TODO: optimize, reduce new/delete calls
- std::unique_ptr<SalPoint*[]> pPtAry2( new SalPoint*[nPoly] );
+ std::unique_ptr<Point*[]> pPtAry2( new Point*[nPoly] );
sal_uLong i;
for(i=0; i<nPoly; i++)
{
sal_uLong nPoints = pPoints[i];
- pPtAry2[i] = new SalPoint[ nPoints ];
+ pPtAry2[i] = new Point[ nPoints ];
mirror( nPoints, pPtAry[i], pPtAry2[i], pOutDev );
}
- drawPolyPolygon( nPoly, pPoints,
const_cast<PCONSTSALPOINT*>(pPtAry2.get()) );
+ drawPolyPolygon( nPoly, pPoints, const_cast<const
Point**>(pPtAry2.get()) );
for(i=0; i<nPoly; i++)
delete [] pPtAry2[i];
@@ -486,12 +486,12 @@ bool SalGraphics::DrawPolyPolygon(
i_fTransparency);
}
-bool SalGraphics::DrawPolyLineBezier( sal_uInt32 nPoints, const SalPoint*
pPtAry, const PolyFlags* pFlgAry, const OutputDevice* pOutDev )
+bool SalGraphics::DrawPolyLineBezier( sal_uInt32 nPoints, const Point* pPtAry,
const PolyFlags* pFlgAry, const OutputDevice* pOutDev )
{
bool bResult = false;
if( (m_nLayout & SalLayoutFlags::BiDiRtl) || (pOutDev &&
pOutDev->IsRTLEnabled()) )
{
- std::unique_ptr<SalPoint[]> pPtAry2(new SalPoint[nPoints]);
+ std::unique_ptr<Point[]> pPtAry2(new Point[nPoints]);
bool bCopied = mirror( nPoints, pPtAry, pPtAry2.get(), pOutDev );
bResult = drawPolyLineBezier( nPoints, bCopied ? pPtAry2.get() :
pPtAry, pFlgAry );
}
@@ -500,12 +500,12 @@ bool SalGraphics::DrawPolyLineBezier( sal_uInt32 nPoints,
const SalPoint* pPtAry
return bResult;
}
-bool SalGraphics::DrawPolygonBezier( sal_uInt32 nPoints, const SalPoint*
pPtAry, const PolyFlags* pFlgAry, const OutputDevice* pOutDev )
+bool SalGraphics::DrawPolygonBezier( sal_uInt32 nPoints, const Point* pPtAry,
const PolyFlags* pFlgAry, const OutputDevice* pOutDev )
{
bool bResult = false;
if( (m_nLayout & SalLayoutFlags::BiDiRtl) || (pOutDev &&
pOutDev->IsRTLEnabled()) )
{
- std::unique_ptr<SalPoint[]> pPtAry2(new SalPoint[nPoints]);
+ std::unique_ptr<Point[]> pPtAry2(new Point[nPoints]);
bool bCopied = mirror( nPoints, pPtAry, pPtAry2.get(), pOutDev );
bResult = drawPolygonBezier( nPoints, bCopied ? pPtAry2.get() :
pPtAry, pFlgAry );
}
@@ -515,22 +515,22 @@ bool SalGraphics::DrawPolygonBezier( sal_uInt32 nPoints,
const SalPoint* pPtAry,
}
bool SalGraphics::DrawPolyPolygonBezier( sal_uInt32 i_nPoly, const sal_uInt32*
i_pPoints,
- const SalPoint* const* i_pPtAry,
const PolyFlags* const* i_pFlgAry, const OutputDevice* i_pOutDev )
+ const Point* const* i_pPtAry, const
PolyFlags* const* i_pFlgAry, const OutputDevice* i_pOutDev )
{
bool bRet = false;
if( (m_nLayout & SalLayoutFlags::BiDiRtl) || (i_pOutDev &&
i_pOutDev->IsRTLEnabled()) )
{
// TODO: optimize, reduce new/delete calls
- std::unique_ptr<SalPoint*[]> pPtAry2( new SalPoint*[i_nPoly] );
+ std::unique_ptr<Point*[]> pPtAry2( new Point*[i_nPoly] );
sal_uLong i;
for(i=0; i<i_nPoly; i++)
{
sal_uLong nPoints = i_pPoints[i];
- pPtAry2[i] = new SalPoint[ nPoints ];
+ pPtAry2[i] = new Point[ nPoints ];
mirror( nPoints, i_pPtAry[i], pPtAry2[i], i_pOutDev );
}
- bRet = drawPolyPolygonBezier( i_nPoly, i_pPoints,
const_cast<PCONSTSALPOINT const *>(pPtAry2.get()), i_pFlgAry );
+ bRet = drawPolyPolygonBezier( i_nPoly, i_pPoints, const_cast<const
Point* const *>(pPtAry2.get()), i_pFlgAry );
for(i=0; i<i_nPoly; i++)
delete [] pPtAry2[i];
@@ -690,11 +690,11 @@ void SalGraphics::Invert( tools::Long nX, tools::Long nY,
tools::Long nWidth, to
invert( nX, nY, nWidth, nHeight, nFlags );
}
-void SalGraphics::Invert( sal_uInt32 nPoints, const SalPoint* pPtAry,
SalInvert nFlags, const OutputDevice *pOutDev )
+void SalGraphics::Invert( sal_uInt32 nPoints, const Point* pPtAry, SalInvert
nFlags, const OutputDevice *pOutDev )
{
if( (m_nLayout & SalLayoutFlags::BiDiRtl) || (pOutDev &&
pOutDev->IsRTLEnabled()) )
{
- std::unique_ptr<SalPoint[]> pPtAry2(new SalPoint[nPoints]);
+ std::unique_ptr<Point[]> pPtAry2(new Point[nPoints]);
bool bCopied = mirror( nPoints, pPtAry, pPtAry2.get(), pOutDev );
invert( nPoints, bCopied ? pPtAry2.get() : pPtAry, nFlags );
}
diff --git a/vcl/source/outdev/curvedshapes.cxx
b/vcl/source/outdev/curvedshapes.cxx
index d25d69ad1918..a02abfb6e69e 100644
--- a/vcl/source/outdev/curvedshapes.cxx
+++ b/vcl/source/outdev/curvedshapes.cxx
@@ -55,7 +55,7 @@ void OutputDevice::DrawEllipse( const tools::Rectangle& rRect
)
tools::Polygon aRectPoly( aRect.Center(), aRect.GetWidth() >> 1,
aRect.GetHeight() >> 1 );
if ( aRectPoly.GetSize() >= 2 )
{
- SalPoint* pPtAry =
reinterpret_cast<SalPoint*>(aRectPoly.GetPointAry());
+ Point* pPtAry = aRectPoly.GetPointAry();
if ( !mbFillColor )
mpGraphics->DrawPolyLine( aRectPoly.GetSize(), pPtAry, this );
else
@@ -103,7 +103,7 @@ void OutputDevice::DrawArc( const tools::Rectangle& rRect,
if ( aArcPoly.GetSize() >= 2 )
{
- SalPoint* pPtAry = reinterpret_cast<SalPoint*>(aArcPoly.GetPointAry());
+ Point* pPtAry = aArcPoly.GetPointAry();
mpGraphics->DrawPolyLine( aArcPoly.GetSize(), pPtAry, this );
}
@@ -144,7 +144,7 @@ void OutputDevice::DrawPie( const tools::Rectangle& rRect,
if ( aPiePoly.GetSize() >= 2 )
{
- SalPoint* pPtAry = reinterpret_cast<SalPoint*>(aPiePoly.GetPointAry());
+ Point* pPtAry = aPiePoly.GetPointAry();
if ( !mbFillColor )
mpGraphics->DrawPolyLine( aPiePoly.GetSize(), pPtAry, this );
else
@@ -192,7 +192,7 @@ void OutputDevice::DrawChord( const tools::Rectangle& rRect,
if ( aChordPoly.GetSize() >= 2 )
{
- SalPoint* pPtAry =
reinterpret_cast<SalPoint*>(aChordPoly.GetPointAry());
+ Point* pPtAry = aChordPoly.GetPointAry();
if ( !mbFillColor )
mpGraphics->DrawPolyLine( aChordPoly.GetSize(), pPtAry, this );
else
diff --git a/vcl/source/outdev/line.cxx b/vcl/source/outdev/line.cxx
index a715c25521ae..95d2c44458d7 100644
--- a/vcl/source/outdev/line.cxx
+++ b/vcl/source/outdev/line.cxx
@@ -252,7 +252,7 @@ void OutputDevice::drawLine( basegfx::B2DPolyPolygon
aLinePolyPolygon, const Lin
tools::Polygon aPolygon(rB2DPolygon);
mpGraphics->DrawPolyLine(
aPolygon.GetSize(),
- reinterpret_cast<SalPoint*>(aPolygon.GetPointAry()),
+ aPolygon.GetPointAry(),
this);
}
}
@@ -287,7 +287,7 @@ void OutputDevice::drawLine( basegfx::B2DPolyPolygon
aLinePolyPolygon, const Lin
// need to subdivide, mpGraphics->DrawPolygon ignores curves
aPolygon.AdaptiveSubdivide(aPolygon);
- mpGraphics->DrawPolygon(aPolygon.GetSize(),
reinterpret_cast<const SalPoint*>(aPolygon.GetConstPointAry()), this);
+ mpGraphics->DrawPolygon(aPolygon.GetSize(),
aPolygon.GetConstPointAry(), this);
}
}
diff --git a/vcl/source/outdev/polygon.cxx b/vcl/source/outdev/polygon.cxx
index 4d76578d376a..208858fc381b 100644
--- a/vcl/source/outdev/polygon.cxx
+++ b/vcl/source/outdev/polygon.cxx
@@ -230,7 +230,7 @@ void OutputDevice::DrawPolygon( const tools::Polygon& rPoly
)
}
tools::Polygon aPoly = ImplLogicToDevicePixel( rPoly );
- const SalPoint* pPtAry = reinterpret_cast<const
SalPoint*>(aPoly.GetConstPointAry());
+ const Point* pPtAry = aPoly.GetConstPointAry();
// #100127# Forward beziers to sal, if any
if( aPoly.HasFlags() )
@@ -239,7 +239,7 @@ void OutputDevice::DrawPolygon( const tools::Polygon& rPoly
)
if( !mpGraphics->DrawPolygonBezier( nPoints, pPtAry, pFlgAry, this ) )
{
aPoly = tools::Polygon::SubdivideBezier(aPoly);
- pPtAry = reinterpret_cast<const
SalPoint*>(aPoly.GetConstPointAry());
+ pPtAry = aPoly.GetConstPointAry();
mpGraphics->DrawPolygon( aPoly.GetSize(), pPtAry, this );
}
}
@@ -356,10 +356,10 @@ void OutputDevice::ImplDrawPolyPolygon( sal_uInt16 nPoly,
const tools::PolyPolyg
return;
sal_uInt32 aStackAry1[OUTDEV_POLYPOLY_STACKBUF];
- PCONSTSALPOINT aStackAry2[OUTDEV_POLYPOLY_STACKBUF];
+ const Point* aStackAry2[OUTDEV_POLYPOLY_STACKBUF];
PolyFlags* aStackAry3[OUTDEV_POLYPOLY_STACKBUF];
sal_uInt32* pPointAry;
- PCONSTSALPOINT* pPointAryAry;
+ const Point** pPointAryAry;
const PolyFlags** pFlagAryAry;
sal_uInt16 i = 0;
sal_uInt16 j = 0;
@@ -368,7 +368,7 @@ void OutputDevice::ImplDrawPolyPolygon( sal_uInt16 nPoly,
const tools::PolyPolyg
if ( nPoly > OUTDEV_POLYPOLY_STACKBUF )
{
pPointAry = new sal_uInt32[nPoly];
- pPointAryAry = new PCONSTSALPOINT[nPoly];
+ pPointAryAry = new const Point*[nPoly];
pFlagAryAry = new const PolyFlags*[nPoly];
}
else
@@ -385,7 +385,7 @@ void OutputDevice::ImplDrawPolyPolygon( sal_uInt16 nPoly,
const tools::PolyPolyg
if ( nSize )
{
pPointAry[j] = nSize;
- pPointAryAry[j] =
reinterpret_cast<PCONSTSALPOINT>(rPoly.GetConstPointAry());
+ pPointAryAry[j] = rPoly.GetConstPointAry();
pFlagAryAry[j] = rPoly.GetConstFlagAry();
last = i;
@@ -406,7 +406,7 @@ void OutputDevice::ImplDrawPolyPolygon( sal_uInt16 nPoly,
const tools::PolyPolyg
if( !mpGraphics->DrawPolygonBezier( *pPointAry, *pPointAryAry,
*pFlagAryAry, this ) )
{
tools::Polygon aPoly = tools::Polygon::SubdivideBezier(
rPolyPoly.GetObject( last ) );
- mpGraphics->DrawPolygon( aPoly.GetSize(),
reinterpret_cast<const SalPoint*>(aPoly.GetConstPointAry()), this );
+ mpGraphics->DrawPolygon( aPoly.GetSize(),
aPoly.GetConstPointAry(), this );
}
}
else
@@ -452,7 +452,7 @@ void OutputDevice::ImplDrawPolygon( const tools::Polygon&
rPoly, const tools::Po
if ( nPoints < 2 )
return;
- const SalPoint* pPtAry = reinterpret_cast<const
SalPoint*>(rPoly.GetConstPointAry());
+ const Point* pPtAry = rPoly.GetConstPointAry();
mpGraphics->DrawPolygon( nPoints, pPtAry, this );
}
}
@@ -477,7 +477,7 @@ void OutputDevice::ImplDrawPolyPolygon( const
tools::PolyPolygon& rPolyPoly, con
if( nSize >= 2 )
{
- const SalPoint* pPtAry = reinterpret_cast<const
SalPoint*>(rPoly.GetConstPointAry());
+ const Point* pPtAry = rPoly.GetConstPointAry();
mpGraphics->DrawPolygon( nSize, pPtAry, this );
}
}
@@ -485,7 +485,7 @@ void OutputDevice::ImplDrawPolyPolygon( const
tools::PolyPolygon& rPolyPoly, con
{
sal_uInt16 nCount = pPolyPoly->Count();
std::unique_ptr<sal_uInt32[]> pPointAry(new sal_uInt32[nCount]);
- std::unique_ptr<PCONSTSALPOINT[]> pPointAryAry(new
PCONSTSALPOINT[nCount]);
+ std::unique_ptr<const Point*[]> pPointAryAry(new const Point*[nCount]);
sal_uInt16 i = 0;
do
{
@@ -494,7 +494,7 @@ void OutputDevice::ImplDrawPolyPolygon( const
tools::PolyPolygon& rPolyPoly, con
if ( nSize )
{
pPointAry[i] = nSize;
- pPointAryAry[i] =
reinterpret_cast<PCONSTSALPOINT>(rPoly.GetConstPointAry());
+ pPointAryAry[i] = rPoly.GetConstPointAry();
i++;
}
else
diff --git a/vcl/source/outdev/polyline.cxx b/vcl/source/outdev/polyline.cxx
index a1bd0df6f82e..a79ebf74ab6f 100644
--- a/vcl/source/outdev/polyline.cxx
+++ b/vcl/source/outdev/polyline.cxx
@@ -82,7 +82,7 @@ void OutputDevice::DrawPolyLine( const tools::Polygon& rPoly )
if(!bDrawn)
{
tools::Polygon aPoly = ImplLogicToDevicePixel( rPoly );
- SalPoint* pPtAry = reinterpret_cast<SalPoint*>(aPoly.GetPointAry());
+ Point* pPtAry = aPoly.GetPointAry();
// #100127# Forward beziers to sal, if any
if( aPoly.HasFlags() )
@@ -91,7 +91,7 @@ void OutputDevice::DrawPolyLine( const tools::Polygon& rPoly )
if( !mpGraphics->DrawPolyLineBezier( nPoints, pPtAry, pFlgAry,
this ) )
{
aPoly = tools::Polygon::SubdivideBezier(aPoly);
- pPtAry = reinterpret_cast<SalPoint*>(aPoly.GetPointAry());
+ pPtAry = aPoly.GetPointAry();
mpGraphics->DrawPolyLine( aPoly.GetSize(), pPtAry, this );
}
}
@@ -280,7 +280,7 @@ void OutputDevice::drawPolyLine(const tools::Polygon&
rPoly, const LineInfo& rLi
nPoints = aPoly.GetSize();
}
- mpGraphics->DrawPolyLine(nPoints,
reinterpret_cast<SalPoint*>(aPoly.GetPointAry()), this);
+ mpGraphics->DrawPolyLine(nPoints, aPoly.GetPointAry(), this);
}
if( mpAlphaVDev )
diff --git a/vcl/source/outdev/rect.cxx b/vcl/source/outdev/rect.cxx
index 9252959d0f5e..c6a53fbee3c0 100644
--- a/vcl/source/outdev/rect.cxx
+++ b/vcl/source/outdev/rect.cxx
@@ -131,7 +131,7 @@ void OutputDevice::DrawRect( const tools::Rectangle& rRect,
if ( aRoundRectPoly.GetSize() >= 2 )
{
- SalPoint* pPtAry =
reinterpret_cast<SalPoint*>(aRoundRectPoly.GetPointAry());
+ Point* pPtAry = aRoundRectPoly.GetPointAry();
if ( !mbFillColor )
mpGraphics->DrawPolyLine( aRoundRectPoly.GetSize(), pPtAry,
this );
@@ -202,7 +202,7 @@ void OutputDevice::Invert( const tools::Polygon& rPoly,
InvertFlags nFlags )
nSalFlags |= SalInvert::N50;
if ( nFlags & InvertFlags::TrackFrame )
nSalFlags |= SalInvert::TrackFrame;
- const SalPoint* pPtAry = reinterpret_cast<const
SalPoint*>(aPoly.GetConstPointAry());
+ const Point* pPtAry = aPoly.GetConstPointAry();
mpGraphics->Invert( nPoints, pPtAry, nSalFlags, this );
}
diff --git a/vcl/unx/generic/gdi/gdiimpl.cxx b/vcl/unx/generic/gdi/gdiimpl.cxx
index eaccc865cd41..97d9067d0be7 100644
--- a/vcl/unx/generic/gdi/gdiimpl.cxx
+++ b/vcl/unx/generic/gdi/gdiimpl.cxx
@@ -70,13 +70,13 @@ class SalPolyLine
{
std::vector<XPoint> Points_;
public:
- SalPolyLine(sal_uLong nPoints, const SalPoint *p)
+ SalPolyLine(sal_uLong nPoints, const Point *p)
: Points_(nPoints+1)
{
for (sal_uLong i = 0; i < nPoints; ++i)
{
- Points_[i].x = static_cast<short>(p[i].mnX);
- Points_[i].y = static_cast<short>(p[i].mnY);
+ Points_[i].x = static_cast<short>(p[i].getX());
+ Points_[i].y = static_cast<short>(p[i].getY());
}
Points_[nPoints] = Points_[0]; // close polyline
}
@@ -1176,12 +1176,12 @@ void X11SalGraphicsImpl::drawRect( tools::Long nX,
tools::Long nY, tools::Long n
nX, nY, nDX-1, nDY-1 );
}
-void X11SalGraphicsImpl::drawPolyLine( sal_uInt32 nPoints, const SalPoint
*pPtAry )
+void X11SalGraphicsImpl::drawPolyLine( sal_uInt32 nPoints, const Point *pPtAry
)
{
drawPolyLine( nPoints, pPtAry, false );
}
-void X11SalGraphicsImpl::drawPolyLine( sal_uInt32 nPoints, const SalPoint
*pPtAry, bool bClose )
+void X11SalGraphicsImpl::drawPolyLine( sal_uInt32 nPoints, const Point
*pPtAry, bool bClose )
{
if( mnPenColor != SALCOLOR_NONE )
{
@@ -1191,7 +1191,7 @@ void X11SalGraphicsImpl::drawPolyLine( sal_uInt32
nPoints, const SalPoint *pPtAr
}
}
-void X11SalGraphicsImpl::drawPolygon( sal_uInt32 nPoints, const SalPoint*
pPtAry )
+void X11SalGraphicsImpl::drawPolygon( sal_uInt32 nPoints, const Point* pPtAry )
{
if( nPoints == 0 )
return;
@@ -1201,10 +1201,10 @@ void X11SalGraphicsImpl::drawPolygon( sal_uInt32
nPoints, const SalPoint* pPtAry
if( !mbXORMode )
{
if( 1 == nPoints )
- drawPixel( pPtAry[0].mnX, pPtAry[0].mnY );
+ drawPixel( pPtAry[0].getX(), pPtAry[0].getY() );
else
- drawLine( pPtAry[0].mnX, pPtAry[0].mnY,
- pPtAry[1].mnX, pPtAry[1].mnY );
+ drawLine( pPtAry[0].getX(), pPtAry[0].getY(),
+ pPtAry[1].getX(), pPtAry[1].getY() );
}
return;
}
@@ -1259,7 +1259,7 @@ void X11SalGraphicsImpl::drawPolygon( sal_uInt32 nPoints,
const SalPoint* pPtAry
void X11SalGraphicsImpl::drawPolyPolygon( sal_uInt32 nPoly,
const sal_uInt32 *pPoints,
- PCONSTSALPOINT *pPtAry )
+ const Point* *pPtAry )
{
if( mnBrushColor != SALCOLOR_NONE )
{
@@ -1304,18 +1304,18 @@ void X11SalGraphicsImpl::drawPolyPolygon( sal_uInt32
nPoly,
drawPolyLine( pPoints[i], pPtAry[i], true );
}
-bool X11SalGraphicsImpl::drawPolyLineBezier( sal_uInt32, const SalPoint*,
const PolyFlags* )
+bool X11SalGraphicsImpl::drawPolyLineBezier( sal_uInt32, const Point*, const
PolyFlags* )
{
return false;
}
-bool X11SalGraphicsImpl::drawPolygonBezier( sal_uInt32, const SalPoint*, const
PolyFlags* )
+bool X11SalGraphicsImpl::drawPolygonBezier( sal_uInt32, const Point*, const
PolyFlags* )
{
return false;
}
bool X11SalGraphicsImpl::drawPolyPolygonBezier( sal_uInt32, const sal_uInt32*,
- const SalPoint* const*, const
PolyFlags* const* )
+ const Point* const*, const
PolyFlags* const* )
{
return false;
}
@@ -1348,7 +1348,7 @@ void X11SalGraphicsImpl::invert( tools::Long nX,
}
void X11SalGraphicsImpl::invert( sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
SalInvert nFlags )
{
SalPolyLine Points ( nPoints, pPtAry );
diff --git a/vcl/unx/generic/gdi/gdiimpl.hxx b/vcl/unx/generic/gdi/gdiimpl.hxx
index 1379deca6f83..bb3092b25356 100644
--- a/vcl/unx/generic/gdi/gdiimpl.hxx
+++ b/vcl/unx/generic/gdi/gdiimpl.hxx
@@ -102,7 +102,7 @@ private:
const SalBitmap& rSalBitmap,
const SalBitmap&
rTransparentBitmap );
- void drawPolyLine( sal_uInt32 nPoints, const SalPoint* pPtAry, bool bClose
);
+ void drawPolyLine( sal_uInt32 nPoints, const Point* pPtAry, bool bClose );
public:
@@ -156,11 +156,11 @@ public:
virtual void drawRect( tools::Long nX, tools::Long nY, tools::Long nWidth,
tools::Long nHeight ) override;
- virtual void drawPolyLine( sal_uInt32 nPoints, const SalPoint* pPtAry )
override;
+ virtual void drawPolyLine( sal_uInt32 nPoints, const Point* pPtAry )
override;
- virtual void drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry )
override;
+ virtual void drawPolygon( sal_uInt32 nPoints, const Point* pPtAry )
override;
- virtual void drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints,
PCONSTSALPOINT* pPtAry ) override;
+ virtual void drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints,
const Point** pPtAry ) override;
virtual bool drawPolyPolygon(
const basegfx::B2DHomMatrix& rObjectToDevice,
@@ -180,18 +180,18 @@ public:
virtual bool drawPolyLineBezier(
sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
const PolyFlags* pFlgAry ) override;
virtual bool drawPolygonBezier(
sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
const PolyFlags* pFlgAry ) override;
virtual bool drawPolyPolygonBezier(
sal_uInt32 nPoly,
const sal_uInt32* pPoints,
- const SalPoint* const* pPtAry,
+ const Point* const* pPtAry,
const PolyFlags* const* pFlgAry ) override;
// CopyArea --> No RasterOp, but ClipRegion
@@ -227,7 +227,7 @@ public:
tools::Long nWidth, tools::Long nHeight,
SalInvert nFlags) override;
- virtual void invert( sal_uInt32 nPoints, const SalPoint* pPtAry, SalInvert
nFlags ) override;
+ virtual void invert( sal_uInt32 nPoints, const Point* pPtAry, SalInvert
nFlags ) override;
virtual bool drawEPS(
tools::Long nX, tools::Long nY,
diff --git a/vcl/unx/generic/gdi/salgdi.cxx b/vcl/unx/generic/gdi/salgdi.cxx
index dcb46c37ebfe..4390b4c1bd6b 100644
--- a/vcl/unx/generic/gdi/salgdi.cxx
+++ b/vcl/unx/generic/gdi/salgdi.cxx
@@ -433,41 +433,41 @@ void X11SalGraphics::drawRect( tools::Long nX,
tools::Long nY, tools::Long nDX,
mxImpl->drawRect( nX, nY, nDX, nDY );
}
-void X11SalGraphics::drawPolyLine( sal_uInt32 nPoints, const SalPoint *pPtAry )
+void X11SalGraphics::drawPolyLine( sal_uInt32 nPoints, const Point *pPtAry )
{
mxImpl->drawPolyLine( nPoints, pPtAry );
}
-void X11SalGraphics::drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry )
+void X11SalGraphics::drawPolygon( sal_uInt32 nPoints, const Point* pPtAry )
{
mxImpl->drawPolygon( nPoints, pPtAry );
}
void X11SalGraphics::drawPolyPolygon( sal_uInt32 nPoly,
const sal_uInt32 *pPoints,
- PCONSTSALPOINT *pPtAry )
+ const Point* *pPtAry )
{
mxImpl->drawPolyPolygon( nPoly, pPoints, pPtAry );
}
-bool X11SalGraphics::drawPolyLineBezier( sal_uInt32 nPoints, const SalPoint*
pPtAry, const PolyFlags* pFlgAry )
+bool X11SalGraphics::drawPolyLineBezier( sal_uInt32 nPoints, const Point*
pPtAry, const PolyFlags* pFlgAry )
{
return mxImpl->drawPolyLineBezier( nPoints, pPtAry, pFlgAry );
}
-bool X11SalGraphics::drawPolygonBezier( sal_uInt32 nPoints, const SalPoint*
pPtAry, const PolyFlags* pFlgAry )
+bool X11SalGraphics::drawPolygonBezier( sal_uInt32 nPoints, const Point*
pPtAry, const PolyFlags* pFlgAry )
{
return mxImpl->drawPolygonBezier( nPoints, pPtAry, pFlgAry );
}
bool X11SalGraphics::drawPolyPolygonBezier( sal_uInt32 nPoints, const
sal_uInt32* pPoints,
- const SalPoint* const* pPtAry,
const PolyFlags* const* pFlgAry)
+ const Point* const* pPtAry,
const PolyFlags* const* pFlgAry)
{
return mxImpl->drawPolyPolygonBezier( nPoints, pPoints, pPtAry, pFlgAry );
}
void X11SalGraphics::invert( sal_uInt32 nPoints,
- const SalPoint* pPtAry,
+ const Point* pPtAry,
SalInvert nFlags )
{
mxImpl->invert( nPoints, pPtAry, nFlags );
diff --git a/vcl/unx/generic/print/genpspgraphics.cxx
b/vcl/unx/generic/print/genpspgraphics.cxx
index 79e3b29175d1..8a53b52d3ee1 100644
--- a/vcl/unx/generic/print/genpspgraphics.cxx
+++ b/vcl/unx/generic/print/genpspgraphics.cxx
@@ -345,22 +345,22 @@ void GenPspGraphics::drawRect( tools::Long nX,
tools::Long nY, tools::Long nDX,
m_pPrinterGfx->DrawRect (tools::Rectangle(Point(nX, nY), Size(nDX, nDY)));
}
-void GenPspGraphics::drawPolyLine( sal_uInt32 nPoints, const SalPoint *pPtAry )
+void GenPspGraphics::drawPolyLine( sal_uInt32 nPoints, const Point *pPtAry )
{
- m_pPrinterGfx->DrawPolyLine (nPoints, reinterpret_cast<const Point
*>(pPtAry));
+ m_pPrinterGfx->DrawPolyLine (nPoints, pPtAry);
}
-void GenPspGraphics::drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry )
+void GenPspGraphics::drawPolygon( sal_uInt32 nPoints, const Point* pPtAry )
{
- // Point must be equal to SalPoint! see include/vcl/salgtype.hxx
- m_pPrinterGfx->DrawPolygon (nPoints, reinterpret_cast<const Point
*>(pPtAry));
+ // Point must be equal to Point! see include/vcl/salgtype.hxx
+ m_pPrinterGfx->DrawPolygon (nPoints, pPtAry);
}
void GenPspGraphics::drawPolyPolygon( sal_uInt32 nPoly,
const sal_uInt32 *pPoints,
- PCONSTSALPOINT *pPtAry )
+ const Point* *pPtAry )
{
- m_pPrinterGfx->DrawPolyPolygon (nPoly, pPoints, reinterpret_cast<const
Point**>(pPtAry));
+ m_pPrinterGfx->DrawPolyPolygon (nPoly, pPoints, pPtAry);
}
bool GenPspGraphics::drawPolyPolygon(
@@ -387,30 +387,30 @@ bool GenPspGraphics::drawPolyLine(
return false;
}
-bool GenPspGraphics::drawPolyLineBezier( sal_uInt32 nPoints, const SalPoint*
pPtAry, const PolyFlags* pFlgAry )
+bool GenPspGraphics::drawPolyLineBezier( sal_uInt32 nPoints, const Point*
pPtAry, const PolyFlags* pFlgAry )
{
- m_pPrinterGfx->DrawPolyLineBezier (nPoints, reinterpret_cast<Point const
*>(pPtAry), pFlgAry);
+ m_pPrinterGfx->DrawPolyLineBezier (nPoints, pPtAry, pFlgAry);
return true;
}
-bool GenPspGraphics::drawPolygonBezier( sal_uInt32 nPoints, const SalPoint*
pPtAry, const PolyFlags* pFlgAry )
+bool GenPspGraphics::drawPolygonBezier( sal_uInt32 nPoints, const Point*
pPtAry, const PolyFlags* pFlgAry )
{
- m_pPrinterGfx->DrawPolygonBezier (nPoints, reinterpret_cast<Point const
*>(pPtAry), pFlgAry);
+ m_pPrinterGfx->DrawPolygonBezier (nPoints, pPtAry, pFlgAry);
return true;
}
bool GenPspGraphics::drawPolyPolygonBezier( sal_uInt32 nPoly,
const sal_uInt32* pPoints,
- const SalPoint* const* pPtAry,
+ const Point* const* pPtAry,
const PolyFlags* const* pFlgAry )
{
- // Point must be equal to SalPoint! see include/vcl/salgtype.hxx
- m_pPrinterGfx->DrawPolyPolygonBezier (nPoly, pPoints,
reinterpret_cast<Point const * const *>(pPtAry), pFlgAry);
+ // Point must be equal to Point! see include/vcl/salgtype.hxx
+ m_pPrinterGfx->DrawPolyPolygonBezier (nPoly, pPoints, pPtAry, pFlgAry);
return true;
}
void GenPspGraphics::invert( sal_uInt32,
- const SalPoint*,
+ const Point*,
SalInvert )
{
SAL_WARN( "vcl", "Error: PrinterGfx::Invert() not implemented" );
diff --git a/vcl/win/gdi/gdiimpl.cxx b/vcl/win/gdi/gdiimpl.cxx
index 102f009dd632..cff1ccb59ad6 100644
--- a/vcl/win/gdi/gdiimpl.cxx
+++ b/vcl/win/gdi/gdiimpl.cxx
@@ -79,7 +79,7 @@ namespace {
void ImplPreparePolyDraw( bool bCloseFigures,
sal_uLong nPoly,
const sal_uInt32* pPoints,
- const SalPoint* const* pPtAry,
+ const Point* const* pPtAry,
const PolyFlags* const* pFlgAry,
POINT* pWinPointAry,
BYTE* pWinFlagAry )
@@ -87,7 +87,7 @@ void ImplPreparePolyDraw( bool
bCloseFigures,
sal_uLong nCurrPoly;
for( nCurrPoly=0; nCurrPoly<nPoly; ++nCurrPoly )
{
- const POINT* pCurrPoint = reinterpret_cast<const POINT*>( *pPtAry++ );
+ const Point* pCurrPoint = *pPtAry++;
const PolyFlags* pCurrFlag = *pFlgAry++;
const sal_uInt32 nCurrPoints = *pPoints++;
const bool bHaveFlagArray( pCurrFlag );
@@ -96,7 +96,8 @@ void ImplPreparePolyDraw( bool
bCloseFigures,
if( nCurrPoints )
{
// start figure
- *pWinPointAry++ = *pCurrPoint++;
+ *pWinPointAry++ = POINT { static_cast<LONG>(pCurrPoint->getX()),
static_cast<LONG>(pCurrPoint->getY()) };
+ pCurrPoint++;
*pWinFlagAry++ = PT_MOVETO;
++pCurrFlag;
@@ -113,15 +114,18 @@ void ImplPreparePolyDraw( bool
bCloseFigures,
( PolyFlags::Normal == P4 || PolyFlags::Smooth == P4
|| PolyFlags::Symmetric == P4 ) )
{
// control point one
- *pWinPointAry++ = *pCurrPoint++;
+ *pWinPointAry++ = POINT {
static_cast<LONG>(pCurrPoint->getX()), static_cast<LONG>(pCurrPoint->getY()) };
+ pCurrPoint++;
*pWinFlagAry++ = PT_BEZIERTO;
// control point two
- *pWinPointAry++ = *pCurrPoint++;
+ *pWinPointAry++ = POINT {
static_cast<LONG>(pCurrPoint->getX()), static_cast<LONG>(pCurrPoint->getY()) };
+ pCurrPoint++;
*pWinFlagAry++ = PT_BEZIERTO;
// end point
- *pWinPointAry++ = *pCurrPoint++;
+ *pWinPointAry++ = POINT {
static_cast<LONG>(pCurrPoint->getX()), static_cast<LONG>(pCurrPoint->getY()) };
+ pCurrPoint++;
*pWinFlagAry++ = PT_BEZIERTO;
nCurrPoint += 3;
@@ -131,7 +135,8 @@ void ImplPreparePolyDraw( bool
bCloseFigures,
}
// regular line point
- *pWinPointAry++ = *pCurrPoint++;
+ *pWinPointAry++ = POINT {
static_cast<LONG>(pCurrPoint->getX()), static_cast<LONG>(pCurrPoint->getY()) };
+ pCurrPoint++;
*pWinFlagAry++ = PT_LINETO;
++pCurrFlag;
++nCurrPoint;
@@ -894,7 +899,7 @@ void WinSalGraphicsImpl::invert( tools::Long nX,
tools::Long nY, tools::Long nWi
}
}
-void WinSalGraphicsImpl::invert( sal_uInt32 nPoints, const SalPoint* pPtAry,
SalInvert nSalFlags )
+void WinSalGraphicsImpl::invert( sal_uInt32 nPoints, const Point* pPtAry,
SalInvert nSalFlags )
{
HPEN hPen;
HPEN hOldPen;
@@ -919,21 +924,20 @@ void WinSalGraphicsImpl::invert( sal_uInt32 nPoints,
const SalPoint* pPtAry, Sal
}
hOldPen = SelectPen( mrParent.getHDC(), hPen );
- POINT const * pWinPtAry;
- // for NT, we can handover the array directly
... etc. - the rest is truncated
_______________________________________________
Libreoffice-commits mailing list
libreoffice-comm...@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/libreoffice-commits
