[Libreoffice-commits] core.git: canvas/source filter/source include/svx include/tools oox/source sd/source svx/inc svx/source tools/inc tools/source vcl/headless vcl/inc vcl/opengl vcl/quartz vcl/source vcl/unx vcl/win
Noel Grandin
noel.grandin at collabora.co.uk
Wed Dec 7 10:34:49 UTC 2016
canvas/source/vcl/canvashelper.cxx | 8 +-
filter/source/flash/swfwriter1.cxx | 8 +-
filter/source/graphicfilter/eps/eps.cxx | 16 ++---
filter/source/graphicfilter/icgm/actimpr.cxx | 6 +-
filter/source/graphicfilter/icgm/class4.cxx | 8 +-
filter/source/graphicfilter/icgm/outact.hxx | 2
filter/source/msfilter/escherex.cxx | 6 +-
filter/source/msfilter/msdffimp.cxx | 2
filter/source/svg/svgwriter.cxx | 2
include/svx/xpoly.hxx | 17 +----
include/tools/poly.hxx | 14 ++--
oox/source/export/drawingml.cxx | 8 +-
sd/source/ui/func/fucon3d.cxx | 16 ++---
svx/inc/xpolyimp.hxx | 2
svx/source/svdraw/svdoedge.cxx | 36 ++++++------
svx/source/svdraw/svdopath.cxx | 62 ++++++++++-----------
svx/source/xoutdev/_xpoly.cxx | 48 ++++++++--------
tools/inc/poly.h | 7 +-
tools/source/generic/poly.cxx | 71 ++++++++++++-------------
vcl/headless/svpgdi.cxx | 6 +-
vcl/inc/headless/svpgdi.hxx | 6 +-
vcl/inc/openglgdiimpl.hxx | 6 +-
vcl/inc/quartz/salgdi.h | 6 +-
vcl/inc/salgdi.hxx | 12 ++--
vcl/inc/salgdiimpl.hxx | 7 +-
vcl/inc/unx/genpspgraphics.h | 6 +-
vcl/inc/unx/printergfx.hxx | 6 +-
vcl/inc/unx/salgdi.h | 6 +-
vcl/inc/win/salgdi.h | 6 +-
vcl/opengl/gdiimpl.cxx | 6 +-
vcl/quartz/salgdicommon.cxx | 6 +-
vcl/source/filter/wmf/emfwr.cxx | 4 -
vcl/source/filter/wmf/winmtf.cxx | 6 +-
vcl/source/gdi/pdfwriter_impl.cxx | 6 +-
vcl/source/gdi/pdfwriter_impl2.cxx | 4 -
vcl/source/gdi/salgdilayout.cxx | 6 +-
vcl/source/gdi/svmconverter.cxx | 2
vcl/source/outdev/font.cxx | 11 +++
vcl/source/outdev/polygon.cxx | 12 ++--
vcl/source/outdev/polyline.cxx | 2
vcl/unx/generic/gdi/gdiimpl.cxx | 6 +-
vcl/unx/generic/gdi/gdiimpl.hxx | 6 +-
vcl/unx/generic/gdi/salgdi.cxx | 6 +-
vcl/unx/generic/glyphs/freetype_glyphcache.cxx | 38 ++++++-------
vcl/unx/generic/print/common_gfx.cxx | 22 +++----
vcl/unx/generic/print/genpspgraphics.cxx | 6 +-
vcl/win/gdi/gdiimpl.cxx | 32 +++++------
vcl/win/gdi/gdiimpl.hxx | 6 +-
vcl/win/gdi/salfont.cxx | 16 ++---
vcl/win/gdi/salgdi.cxx | 6 +-
50 files changed, 308 insertions(+), 307 deletions(-)
New commits:
commit a08cb3b52ea4a071ce8eb5a1786ea45fd211ab78
Author: Noel Grandin <noel.grandin at collabora.co.uk>
Date: Mon Dec 5 12:47:37 2016 +0200
convert PolyFlags to scoped enum
and remove the XPolyFlags enum, which has the same values and was being
converted to PolyFlags anyhow
Change-Id: Iaead84933c79a7603698a4e50257dd944df89c41
Reviewed-on: https://gerrit.libreoffice.org/31627
Reviewed-by: Noel Grandin <noel.grandin at collabora.co.uk>
Tested-by: Noel Grandin <noel.grandin at collabora.co.uk>
diff --git a/canvas/source/vcl/canvashelper.cxx b/canvas/source/vcl/canvashelper.cxx
index ea67fa1..90c399b 100644
--- a/canvas/source/vcl/canvashelper.cxx
+++ b/canvas/source/vcl/canvashelper.cxx
@@ -261,13 +261,13 @@ namespace vclcanvas
::tools::Polygon aPoly(4);
aPoly.SetPoint( rStartPoint, 0 );
- aPoly.SetFlags( 0, POLY_NORMAL );
+ aPoly.SetFlags( 0, PolyFlags::Normal );
aPoly.SetPoint( rCtrlPoint1, 1 );
- aPoly.SetFlags( 1, POLY_CONTROL );
+ aPoly.SetFlags( 1, PolyFlags::Control );
aPoly.SetPoint( rCtrlPoint2, 2 );
- aPoly.SetFlags( 2, POLY_CONTROL );
+ aPoly.SetFlags( 2, PolyFlags::Control );
aPoly.SetPoint( rEndPoint, 3 );
- aPoly.SetFlags( 3, POLY_NORMAL );
+ aPoly.SetFlags( 3, PolyFlags::Normal );
// TODO(F2): alpha
mpOutDev->getOutDev().DrawPolygon( aPoly );
diff --git a/filter/source/flash/swfwriter1.cxx b/filter/source/flash/swfwriter1.cxx
index f5d4dba..ef3bbf5 100644
--- a/filter/source/flash/swfwriter1.cxx
+++ b/filter/source/flash/swfwriter1.cxx
@@ -127,10 +127,10 @@ void Writer::Impl_addPolygon( BitStream& rBits, const tools::Polygon& rPoly, boo
PolyFlags P1( rPoly.GetFlags( i ) );
PolyFlags P4( rPoly.GetFlags( i + 3 ) );
- if( ( POLY_NORMAL == P1 || POLY_SMOOTH == P1 || POLY_SYMMTR == P1 ) &&
- ( POLY_CONTROL == rPoly.GetFlags( i + 1 ) ) &&
- ( POLY_CONTROL == rPoly.GetFlags( i + 2 ) ) &&
- ( POLY_NORMAL == P4 || POLY_SMOOTH == P4 || POLY_SYMMTR == P4 ) )
+ if( ( PolyFlags::Normal == P1 || PolyFlags::Smooth == P1 || PolyFlags::Symmetric == P1 ) &&
+ ( PolyFlags::Control == rPoly.GetFlags( i + 1 ) ) &&
+ ( PolyFlags::Control == rPoly.GetFlags( i + 2 ) ) &&
+ ( PolyFlags::Normal == P4 || PolyFlags::Smooth == P4 || PolyFlags::Symmetric == P4 ) )
{
Impl_quadBezierApprox( rBits, aLastPoint, d*d,
rPoly.GetPoint( i ).X(), rPoly.GetPoint( i ).Y(),
diff --git a/filter/source/graphicfilter/eps/eps.cxx b/filter/source/graphicfilter/eps/eps.cxx
index 4b79fbc..46a5ebf 100644
--- a/filter/source/graphicfilter/eps/eps.cxx
+++ b/filter/source/graphicfilter/eps/eps.cxx
@@ -718,9 +718,9 @@ void PSWriter::ImplWriteActions( const GDIMetaFile& rMtf, VirtualDevice& rVDev )
for(sal_uInt16 a(0); a + 1 < nPoints; a++)
{
if(bCurve
- && POLY_NORMAL != aPoly.GetFlags(a + 1)
+ && PolyFlags::Normal != aPoly.GetFlags(a + 1)
&& a + 2 < nPoints
- && POLY_NORMAL != aPoly.GetFlags(a + 2)
+ && PolyFlags::Normal != aPoly.GetFlags(a + 2)
&& a + 3 < nPoints)
{
const tools::Polygon aSnippet(4,
@@ -1503,10 +1503,10 @@ void PSWriter::ImplAddPath( const tools::Polygon & rPolygon )
ImplMoveTo( rPolygon.GetPoint( 0 ) );
while ( i < nPointCount )
{
- if ( ( rPolygon.GetFlags( i ) == POLY_CONTROL )
+ if ( ( rPolygon.GetFlags( i ) == PolyFlags::Control )
&& ( ( i + 2 ) < nPointCount )
- && ( rPolygon.GetFlags( i + 1 ) == POLY_CONTROL )
- && ( rPolygon.GetFlags( i + 2 ) != POLY_CONTROL ) )
+ && ( rPolygon.GetFlags( i + 1 ) == PolyFlags::Control )
+ && ( rPolygon.GetFlags( i + 2 ) != PolyFlags::Control ) )
{
ImplCurveTo( rPolygon[ i ], rPolygon[ i + 1 ], rPolygon[ i + 2 ], PS_WRAP );
i += 3;
@@ -1591,10 +1591,10 @@ void PSWriter::ImplPolyLine( const tools::Polygon & rPoly )
i = 1;
while ( i < nPointCount )
{
- if ( ( rPoly.GetFlags( i ) == POLY_CONTROL )
+ if ( ( rPoly.GetFlags( i ) == PolyFlags::Control )
&& ( ( i + 2 ) < nPointCount )
- && ( rPoly.GetFlags( i + 1 ) == POLY_CONTROL )
- && ( rPoly.GetFlags( i + 2 ) != POLY_CONTROL ) )
+ && ( rPoly.GetFlags( i + 1 ) == PolyFlags::Control )
+ && ( rPoly.GetFlags( i + 2 ) != PolyFlags::Control ) )
{
ImplCurveTo( rPoly[ i ], rPoly[ i + 1 ], rPoly[ i + 2 ], PS_WRAP );
i += 3;
diff --git a/filter/source/graphicfilter/icgm/actimpr.cxx b/filter/source/graphicfilter/icgm/actimpr.cxx
index 1ad3c30..0a63a8e 100644
--- a/filter/source/graphicfilter/icgm/actimpr.cxx
+++ b/filter/source/graphicfilter/icgm/actimpr.cxx
@@ -61,7 +61,7 @@ CGMImpressOutAct::CGMImpressOutAct( CGM& rCGM, const uno::Reference< frame::XMod
mnGroupActCount = mnGroupLevel = 0;
mpGroupLevel = new sal_uInt32[CGM_OUTACT_MAX_GROUP_LEVEL] ();
mpPoints = reinterpret_cast<Point*>(new sal_Int8[ 0x2000 * sizeof( Point ) ]);
- mpFlags = new sal_uInt8[ 0x2000 ];
+ mpFlags = new PolyFlags[ 0x2000 ];
mnIndex = 0;
mpGradient = nullptr;
@@ -941,7 +941,7 @@ void CGMImpressOutAct::RegPolyLine( tools::Polygon& rPolygon, bool bReverse )
for ( sal_uInt16 i = 0; i < nPoints; i++ )
{
mpPoints[ mnIndex + i ] = rPolygon.GetPoint( nPoints - i - 1 );
- mpFlags[ mnIndex + i ] = (sal_Int8)rPolygon.GetFlags( nPoints - i - 1 );
+ mpFlags[ mnIndex + i ] = rPolygon.GetFlags( nPoints - i - 1 );
}
}
else
@@ -949,7 +949,7 @@ void CGMImpressOutAct::RegPolyLine( tools::Polygon& rPolygon, bool bReverse )
for ( sal_uInt16 i = 0; i < nPoints; i++ )
{
mpPoints[ mnIndex + i ] = rPolygon.GetPoint( i );
- mpFlags[ mnIndex + i ] = (sal_Int8)rPolygon.GetFlags( i );
+ mpFlags[ mnIndex + i ] = rPolygon.GetFlags( i );
}
}
mnIndex = mnIndex + nPoints;
diff --git a/filter/source/graphicfilter/icgm/class4.cxx b/filter/source/graphicfilter/icgm/class4.cxx
index b215b40..805b927 100644
--- a/filter/source/graphicfilter/icgm/class4.cxx
+++ b/filter/source/graphicfilter/icgm/class4.cxx
@@ -715,9 +715,9 @@ void CGM::ImplDoClass4()
for ( sal_uInt16 i = 0; i < nNumberOfPoints; i++ )
{
if ( ( i % 3 ) == 0 )
- aPolygon.SetFlags( i, POLY_NORMAL );
+ aPolygon.SetFlags( i, PolyFlags::Normal );
else
- aPolygon.SetFlags( i, POLY_CONTROL );
+ aPolygon.SetFlags( i, PolyFlags::Control );
}
}
else
@@ -727,8 +727,8 @@ void CGM::ImplDoClass4()
switch ( i & 3 )
{
case 0 :
- case 3 : aPolygon.SetFlags( i, POLY_NORMAL ); break;
- default : aPolygon.SetFlags( i, POLY_CONTROL ); break;
+ case 3 : aPolygon.SetFlags( i, PolyFlags::Normal ); break;
+ default : aPolygon.SetFlags( i, PolyFlags::Control ); break;
}
}
}
diff --git a/filter/source/graphicfilter/icgm/outact.hxx b/filter/source/graphicfilter/icgm/outact.hxx
index a94a4991..a83d3b1 100644
--- a/filter/source/graphicfilter/icgm/outact.hxx
+++ b/filter/source/graphicfilter/icgm/outact.hxx
@@ -46,7 +46,7 @@ class CGMImpressOutAct
sal_uInt32* mpGroupLevel;
sal_uInt16 mnIndex; // figure
- sal_uInt8* mpFlags;
+ PolyFlags* mpFlags;
Point* mpPoints;
tools::PolyPolygon maPolyPolygon;
css::awt::Gradient* mpGradient;
diff --git a/filter/source/msfilter/escherex.cxx b/filter/source/msfilter/escherex.cxx
index 8810f9f..c7d31c4 100644
--- a/filter/source/msfilter/escherex.cxx
+++ b/filter/source/msfilter/escherex.cxx
@@ -1951,7 +1951,7 @@ bool EscherPropertyContainer::CreatePolygonProperties(
nTotalPoints += k;
for (sal_uInt16 j = 0; j < k; ++j)
{
- if ( aPolyPolygon[ i ].GetFlags( j ) != POLY_CONTROL )
+ if ( aPolyPolygon[ i ].GetFlags( j ) != PolyFlags::Control )
nTotalBezPoints++;
}
}
@@ -2013,7 +2013,7 @@ bool EscherPropertyContainer::CreatePolygonProperties(
if ( ( i + 1 ) != nPoints )
{
*pPtr++ = 1;
- if ( aPolygon.GetFlags( i + 1 ) == POLY_CONTROL )
+ if ( aPolygon.GetFlags( i + 1 ) == PolyFlags::Control )
{
*pPtr++ = 0x20;
i += 2;
@@ -4669,7 +4669,7 @@ sal_uInt32 EscherConnectorListEntry::GetConnectorRule( bool bFirst )
const tools::Polygon& rPoly = aPolyPoly.GetObject( a );
for ( b = 0; b < rPoly.GetSize(); b++ )
{
- if ( rPoly.GetFlags( b ) != POLY_NORMAL )
+ if ( rPoly.GetFlags( b ) != PolyFlags::Normal )
continue;
const Point& rPt = rPoly[ b ];
sal_uInt32 nDist = (sal_uInt32)hypot( aRefPoint.X - rPt.X(), aRefPoint.Y - rPt.Y() );
diff --git a/filter/source/msfilter/msdffimp.cxx b/filter/source/msfilter/msdffimp.cxx
index 517a7e5..841c546 100644
--- a/filter/source/msfilter/msdffimp.cxx
+++ b/filter/source/msfilter/msdffimp.cxx
@@ -545,7 +545,7 @@ void SvxMSDffManager::SolveSolver( const SvxMSDffSolverContainer& rSolver )
for ( j = 0; bNotFound && ( j < rPolygon.GetSize() ); j++ )
{
PolyFlags eFlags = rPolygon.GetFlags( j );
- if ( eFlags == POLY_NORMAL )
+ if ( eFlags == PolyFlags::Normal )
{
if ( nC == nPointCount )
{
diff --git a/filter/source/svg/svgwriter.cxx b/filter/source/svg/svgwriter.cxx
index a12fc06..0fdfaa0 100644
--- a/filter/source/svg/svgwriter.cxx
+++ b/filter/source/svg/svgwriter.cxx
@@ -1833,7 +1833,7 @@ OUString SVGActionWriter::GetPathString( const tools::PolyPolygon& rPolyPoly, bo
{
aPathData += aBlank;
- if ( ( rPoly.GetFlags( n ) == POLY_CONTROL ) && ( ( n + 2 ) < nSize ) )
+ if ( ( rPoly.GetFlags( n ) == PolyFlags::Control ) && ( ( n + 2 ) < nSize ) )
{
if ( nCurrentMode != 'C' )
{
diff --git a/include/svx/xpoly.hxx b/include/svx/xpoly.hxx
index e9fe31f..430df7b 100644
--- a/include/svx/xpoly.hxx
+++ b/include/svx/xpoly.hxx
@@ -22,6 +22,7 @@
#include <basegfx/polygon/b2dpolypolygon.hxx>
#include <svx/svxdllapi.h>
#include <o3tl/cow_wrapper.hxx>
+#include <tools/poly.hxx>
class Point;
class Rectangle;
@@ -36,15 +37,7 @@ class OutputDevice;
#define XPOLY_APPEND 0xFFFF
-// point-styles in XPolygon:
-// Normal : start-/endpoint of a curve or a line
-// Smooth : smooth transition between curves
-// Control: control handles of a Bezier curve
-// Symmetric : smooth and symmetrical transition between curves
-
-enum class XPolyFlags { Normal, Smooth, Control, Symmetric };
-
-// Class XPolygon;has a point-array and a flag-array, which contains information about a particular point
+// Class XPolygon has a point-array and a flag-array, which contains information about a particular point
class ImpXPolygon;
@@ -77,7 +70,7 @@ public:
void SetPointCount( sal_uInt16 nPoints );
sal_uInt16 GetPointCount() const;
- void Insert( sal_uInt16 nPos, const Point& rPt, XPolyFlags eFlags );
+ void Insert( sal_uInt16 nPos, const Point& rPt, PolyFlags eFlags );
void Insert( sal_uInt16 nPos, const XPolygon& rXPoly );
void Remove( sal_uInt16 nPos, sal_uInt16 nCount );
void Move( long nHorzMove, long nVertMove );
@@ -89,8 +82,8 @@ public:
XPolygon& operator=( XPolygon&& rXPoly );
bool operator==( const XPolygon& rXPoly ) const;
- XPolyFlags GetFlags( sal_uInt16 nPos ) const;
- void SetFlags( sal_uInt16 nPos, XPolyFlags eFlags );
+ PolyFlags GetFlags( sal_uInt16 nPos ) const;
+ void SetFlags( sal_uInt16 nPos, PolyFlags eFlags );
bool IsControl(sal_uInt16 nPos) const;
bool IsSmooth(sal_uInt16 nPos) const;
diff --git a/include/tools/poly.hxx b/include/tools/poly.hxx
index 383a8f7..065eb6c 100644
--- a/include/tools/poly.hxx
+++ b/include/tools/poly.hxx
@@ -49,12 +49,12 @@ enum class PolyStyle
Chord = 3
};
-enum PolyFlags
+enum class PolyFlags : sal_uInt8
{
- POLY_NORMAL,
- POLY_SMOOTH,
- POLY_CONTROL,
- POLY_SYMMTR
+ Normal, // start-/endpoint of a curve or a line
+ Smooth, // smooth transition between curves
+ Control, // control handles of a Bezier curve
+ Symmetric // smooth and symmetrical transition between curves
};
class SvStream;
@@ -86,7 +86,7 @@ public:
Polygon();
Polygon( sal_uInt16 nSize );
Polygon( sal_uInt16 nPoints, const Point* pPtAry,
- const sal_uInt8* pFlagAry = nullptr );
+ const PolyFlags* pFlagAry = nullptr );
Polygon( const Rectangle& rRect );
Polygon( const Rectangle& rRect,
sal_uInt32 nHorzRound, sal_uInt32 nVertRound );
@@ -174,7 +174,7 @@ public:
void Write( SvStream& rOStream ) const;
const Point* GetConstPointAry() const;
- const sal_uInt8* GetConstFlagAry() const;
+ const PolyFlags* GetConstFlagAry() const;
// convert to ::basegfx::B2DPolygon and return
::basegfx::B2DPolygon getB2DPolygon() const;
diff --git a/oox/source/export/drawingml.cxx b/oox/source/export/drawingml.cxx
index 8d02565..6bd90d5 100644
--- a/oox/source/export/drawingml.cxx
+++ b/oox/source/export/drawingml.cxx
@@ -2586,11 +2586,11 @@ void DrawingML::WritePolyPolygon( const tools::PolyPolygon& rPolyPolygon )
for( sal_uInt16 j = 1; j < rPoly.GetSize(); j ++ )
{
- enum PolyFlags flags = rPoly.GetFlags(j);
- if( flags == POLY_CONTROL )
+ PolyFlags flags = rPoly.GetFlags(j);
+ if( flags == PolyFlags::Control )
{
// a:cubicBezTo can only contain 3 a:pt elements, so we need to make sure of this
- if( j+2 < rPoly.GetSize() && rPoly.GetFlags(j+1) == POLY_CONTROL && rPoly.GetFlags(j+2) != POLY_CONTROL )
+ if( j+2 < rPoly.GetSize() && rPoly.GetFlags(j+1) == PolyFlags::Control && rPoly.GetFlags(j+2) != PolyFlags::Control )
{
mpFS->startElementNS( XML_a, XML_cubicBezTo, FSEND );
@@ -2606,7 +2606,7 @@ void DrawingML::WritePolyPolygon( const tools::PolyPolygon& rPolyPolygon )
j += 2;
}
}
- else if( flags == POLY_NORMAL )
+ else if( flags == PolyFlags::Normal )
{
mpFS->startElementNS( XML_a, XML_lnTo, FSEND );
mpFS->singleElementNS( XML_a, XML_pt,
diff --git a/sd/source/ui/func/fucon3d.cxx b/sd/source/ui/func/fucon3d.cxx
index 0fed0a3..22480c2 100644
--- a/sd/source/ui/func/fucon3d.cxx
+++ b/sd/source/ui/func/fucon3d.cxx
@@ -128,14 +128,14 @@ E3dCompoundObject* FuConstruct3dObject::ImpCreateBasic3DShape()
XPolygon aXPoly(Point (0, 1250), 2500, 2500, 0, 900, false);
aXPoly.Scale(5.0, 5.0);
- aXPoly.Insert(0, Point (2400*5, 1250*5), XPolyFlags::Normal);
- aXPoly.Insert(0, Point (2000*5, 1250*5), XPolyFlags::Normal);
- aXPoly.Insert(0, Point (1500*5, 1250*5), XPolyFlags::Normal);
- aXPoly.Insert(0, Point (1000*5, 1250*5), XPolyFlags::Normal);
- aXPoly.Insert(0, Point (500*5, 1250*5), XPolyFlags::Normal);
- aXPoly.Insert(0, Point (250*5, 1250*5), XPolyFlags::Normal);
- aXPoly.Insert(0, Point (50*5, 1250*5), XPolyFlags::Normal);
- aXPoly.Insert(0, Point (0*5, 1250*5), XPolyFlags::Normal);
+ aXPoly.Insert(0, Point (2400*5, 1250*5), PolyFlags::Normal);
+ aXPoly.Insert(0, Point (2000*5, 1250*5), PolyFlags::Normal);
+ aXPoly.Insert(0, Point (1500*5, 1250*5), PolyFlags::Normal);
+ aXPoly.Insert(0, Point (1000*5, 1250*5), PolyFlags::Normal);
+ aXPoly.Insert(0, Point (500*5, 1250*5), PolyFlags::Normal);
+ aXPoly.Insert(0, Point (250*5, 1250*5), PolyFlags::Normal);
+ aXPoly.Insert(0, Point (50*5, 1250*5), PolyFlags::Normal);
+ aXPoly.Insert(0, Point (0*5, 1250*5), PolyFlags::Normal);
::basegfx::B2DPolygon aB2DPolygon(aXPoly.getB2DPolygon());
if(aB2DPolygon.areControlPointsUsed())
diff --git a/svx/inc/xpolyimp.hxx b/svx/inc/xpolyimp.hxx
index 0fbd187..35ead6c 100644
--- a/svx/inc/xpolyimp.hxx
+++ b/svx/inc/xpolyimp.hxx
@@ -29,7 +29,7 @@ class ImpXPolygon
{
public:
Point* pPointAry;
- sal_uInt8* pFlagAry;
+ PolyFlags* pFlagAry;
Point* pOldPointAry;
bool bDeleteOldPoints;
sal_uInt16 nSize;
diff --git a/svx/source/svdraw/svdoedge.cxx b/svx/source/svdraw/svdoedge.cxx
index ff76043..5b7c594 100644
--- a/svx/source/svdraw/svdoedge.cxx
+++ b/svx/source/svdraw/svdoedge.cxx
@@ -630,7 +630,7 @@ SdrEscapeDirection SdrEdgeObj::ImpCalcEscAngle(SdrObject* pObj, const Point& rPt
XPolygon SdrEdgeObj::ImpCalcObjToCenter(const Point& rStPt, long nEscAngle, const Rectangle& rRect, const Point& rMeeting)
{
XPolygon aXP;
- aXP.Insert(XPOLY_APPEND,rStPt,XPolyFlags::Normal);
+ aXP.Insert(XPOLY_APPEND,rStPt,PolyFlags::Normal);
bool bRts=nEscAngle==0;
bool bObn=nEscAngle==9000;
bool bLks=nEscAngle==18000;
@@ -647,7 +647,7 @@ XPolygon SdrEdgeObj::ImpCalcObjToCenter(const Point& rStPt, long nEscAngle, cons
if (bRts && rMeeting.X()>=aP2.X()) aP2.X()=rMeeting.X();
if (bObn && rMeeting.Y()<=aP2.Y()) aP2.Y()=rMeeting.Y();
if (bUnt && rMeeting.Y()>=aP2.Y()) aP2.Y()=rMeeting.Y();
- aXP.Insert(XPOLY_APPEND,aP2,XPolyFlags::Normal);
+ aXP.Insert(XPOLY_APPEND,aP2,PolyFlags::Normal);
Point aP3(aP2);
if ((bLks && rMeeting.X()>aP2.X()) || (bRts && rMeeting.X()<aP2.X())) { // around
@@ -658,10 +658,10 @@ XPolygon SdrEdgeObj::ImpCalcObjToCenter(const Point& rStPt, long nEscAngle, cons
aP3.Y()=rRect.Bottom();
if (rMeeting.Y()>aP3.Y()) aP3.Y()=rMeeting.Y();
}
- aXP.Insert(XPOLY_APPEND,aP3,XPolyFlags::Normal);
+ aXP.Insert(XPOLY_APPEND,aP3,PolyFlags::Normal);
if (aP3.Y()!=rMeeting.Y()) {
aP3.X()=rMeeting.X();
- aXP.Insert(XPOLY_APPEND,aP3,XPolyFlags::Normal);
+ aXP.Insert(XPOLY_APPEND,aP3,PolyFlags::Normal);
}
}
if ((bObn && rMeeting.Y()>aP2.Y()) || (bUnt && rMeeting.Y()<aP2.Y())) { // around
@@ -672,10 +672,10 @@ XPolygon SdrEdgeObj::ImpCalcObjToCenter(const Point& rStPt, long nEscAngle, cons
aP3.X()=rRect.Right();
if (rMeeting.X()>aP3.X()) aP3.X()=rMeeting.X();
}
- aXP.Insert(XPOLY_APPEND,aP3,XPolyFlags::Normal);
+ aXP.Insert(XPOLY_APPEND,aP3,PolyFlags::Normal);
if (aP3.X()!=rMeeting.X()) {
aP3.Y()=rMeeting.Y();
- aXP.Insert(XPOLY_APPEND,aP3,XPolyFlags::Normal);
+ aXP.Insert(XPOLY_APPEND,aP3,PolyFlags::Normal);
}
}
#ifdef DBG_UTIL
@@ -1229,7 +1229,7 @@ XPolygon SdrEdgeObj::ImpCalcEdgeTrack(const Point& rPt1, long nAngle1, const Rec
nXP2Anz--; aXP2.Remove(nXP2Anz,1);
}
if (bInsMeetingPoint) {
- aXP1.Insert(XPOLY_APPEND,aMeeting,XPolyFlags::Normal);
+ aXP1.Insert(XPOLY_APPEND,aMeeting,PolyFlags::Normal);
if (bInfo) {
// Inserting a MeetingPoint adds 2 new lines,
// either might become the center line.
@@ -1254,7 +1254,7 @@ XPolygon SdrEdgeObj::ImpCalcEdgeTrack(const Point& rPt1, long nAngle1, const Rec
if (aXP1[nXP1Anz-1]==aXP2[nXP2Anz-1] && nXP1Anz>1 && nXP2Anz>1) nNum--;
while (nNum>0) {
nNum--;
- aXP1.Insert(XPOLY_APPEND,aXP2[nNum],XPolyFlags::Normal);
+ aXP1.Insert(XPOLY_APPEND,aXP2[nNum],PolyFlags::Normal);
}
sal_uInt16 nPointCount=aXP1.GetPointCount();
char cForm;
@@ -1460,9 +1460,9 @@ XPolygon SdrEdgeObj::ImpCalcEdgeTrack(const Point& rPt1, long nAngle1, const Rec
long dx2=pPt3->X()-pPt4->X();
long dy2=pPt3->Y()-pPt4->Y();
if (cForm=='L') { // nPointCount==3
- aXP1.SetFlags(1,XPolyFlags::Control);
+ aXP1.SetFlags(1,PolyFlags::Control);
Point aPt3(*pPt2);
- aXP1.Insert(2,aPt3,XPolyFlags::Control);
+ aXP1.Insert(2,aPt3,PolyFlags::Control);
nPointCount=aXP1.GetPointCount();
pPt2=&aXP1[1];
pPt3=&aXP1[nPointCount-2];
@@ -1473,8 +1473,8 @@ XPolygon SdrEdgeObj::ImpCalcEdgeTrack(const Point& rPt1, long nAngle1, const Rec
} else if (nPointCount>=4 && nPointCount<=6) { // Z or U or ...
// To all others, the end points of the original lines become control
// points for now. Thus, we need to do some more work for nPointCount>4!
- aXP1.SetFlags(1,XPolyFlags::Control);
- aXP1.SetFlags(nPointCount-2,XPolyFlags::Control);
+ aXP1.SetFlags(1,PolyFlags::Control);
+ aXP1.SetFlags(nPointCount-2,PolyFlags::Control);
// distance x1.5
pPt2->X()+=dx1/2;
pPt2->Y()+=dy1/2;
@@ -1487,9 +1487,9 @@ XPolygon SdrEdgeObj::ImpCalcEdgeTrack(const Point& rPt1, long nAngle1, const Rec
long dy1b=aCenter.Y()-aXP1[1].Y();
long dx2b=aCenter.X()-aXP1[3].X();
long dy2b=aCenter.Y()-aXP1[3].Y();
- aXP1.Insert(2,aCenter,XPolyFlags::Control);
- aXP1.SetFlags(3,XPolyFlags::Symmetric);
- aXP1.Insert(4,aCenter,XPolyFlags::Control);
+ aXP1.Insert(2,aCenter,PolyFlags::Control);
+ aXP1.SetFlags(3,PolyFlags::Symmetric);
+ aXP1.Insert(4,aCenter,PolyFlags::Control);
aXP1[2].X()-=dx1b/2;
aXP1[2].Y()-=dy1b/2;
aXP1[3].X()-=(dx1b+dx2b)/4;
@@ -1500,13 +1500,13 @@ XPolygon SdrEdgeObj::ImpCalcEdgeTrack(const Point& rPt1, long nAngle1, const Rec
if (nPointCount==6) {
Point aPt1b(aXP1[2]);
Point aPt2b(aXP1[3]);
- aXP1.Insert(2,aPt1b,XPolyFlags::Control);
- aXP1.Insert(5,aPt2b,XPolyFlags::Control);
+ aXP1.Insert(2,aPt1b,PolyFlags::Control);
+ aXP1.Insert(5,aPt2b,PolyFlags::Control);
long dx=aPt1b.X()-aPt2b.X();
long dy=aPt1b.Y()-aPt2b.Y();
aXP1[3].X()-=dx/2;
aXP1[3].Y()-=dy/2;
- aXP1.SetFlags(3,XPolyFlags::Symmetric);
+ aXP1.SetFlags(3,PolyFlags::Symmetric);
aXP1.Remove(4,1); // because it's identical with aXP1[3]
}
}
diff --git a/svx/source/svdraw/svdopath.cxx b/svx/source/svdraw/svdopath.cxx
index 1ba7ff8..0d84293 100644
--- a/svx/source/svdraw/svdopath.cxx
+++ b/svx/source/svdraw/svdopath.cxx
@@ -199,8 +199,8 @@ ImpSdrPathDragData::ImpSdrPathDragData(const SdrPathObj& rPO, const SdrHdl& rHdl
bIsPrevControl=aTmpXP.IsControl(nPrevPnt);
bIsNextControl=!bIsPrevControl;
} else {
- bPrevIsControl=!bBegPnt && !bPrevIsBegPnt && aTmpXP.GetFlags(nPrevPnt)==XPolyFlags::Control;
- bNextIsControl=!bEndPnt && !bNextIsEndPnt && aTmpXP.GetFlags(nNextPnt)==XPolyFlags::Control;
+ bPrevIsControl=!bBegPnt && !bPrevIsBegPnt && aTmpXP.GetFlags(nPrevPnt)==PolyFlags::Control;
+ bNextIsControl=!bEndPnt && !bNextIsEndPnt && aTmpXP.GetFlags(nNextPnt)==PolyFlags::Control;
}
nPrevPrevPnt0=nPrevPrevPnt;
nPrevPnt0 =nPrevPnt;
@@ -303,9 +303,9 @@ void ImpPathCreateUser::CalcBezier(const Point& rP1, const Point& rP2, const Poi
XPolygon ImpPathCreateUser::GetBezierPoly() const
{
XPolygon aXP(4);
- aXP[0]=aBezStart; aXP.SetFlags(0,XPolyFlags::Smooth);
- aXP[1]=aBezCtrl1; aXP.SetFlags(1,XPolyFlags::Control);
- aXP[2]=aBezCtrl2; aXP.SetFlags(2,XPolyFlags::Control);
+ aXP[0]=aBezStart; aXP.SetFlags(0,PolyFlags::Smooth);
+ aXP[1]=aBezCtrl1; aXP.SetFlags(1,PolyFlags::Control);
+ aXP[2]=aBezCtrl2; aXP.SetFlags(2,PolyFlags::Control);
aXP[3]=aBezEnd;
return aXP;
}
@@ -362,7 +362,7 @@ XPolygon ImpPathCreateUser::GetCirclePoly() const
if (nCircRelAngle>=0) {
XPolygon aXP(aCircCenter,nCircRadius,nCircRadius,
sal_uInt16((nCircStAngle+5)/10),sal_uInt16((nCircStAngle+nCircRelAngle+5)/10),false);
- aXP[0]=aCircStart; aXP.SetFlags(0,XPolyFlags::Smooth);
+ aXP[0]=aCircStart; aXP.SetFlags(0,PolyFlags::Smooth);
if (!bAngleSnap) aXP[aXP.GetPointCount()-1]=aCircEnd;
return aXP;
} else {
@@ -376,7 +376,7 @@ XPolygon ImpPathCreateUser::GetCirclePoly() const
aXP[nNum]=aXP[n2];
aXP[n2]=aPt;
}
- aXP[0]=aCircStart; aXP.SetFlags(0,XPolyFlags::Smooth);
+ aXP[0]=aCircStart; aXP.SetFlags(0,PolyFlags::Smooth);
if (!bAngleSnap) aXP[aXP.GetPointCount()-1]=aCircEnd;
return aXP;
}
@@ -430,7 +430,7 @@ void ImpPathCreateUser::CalcLine(const Point& rP1, const Point& rP2, const Point
XPolygon ImpPathCreateUser::GetLinePoly() const
{
XPolygon aXP(2);
- aXP[0]=aLineStart; if (!bLine90) aXP.SetFlags(0,XPolyFlags::Smooth);
+ aXP[0]=aLineStart; if (!bLine90) aXP.SetFlags(0,PolyFlags::Smooth);
aXP[1]=aLineEnd;
return aXP;
}
@@ -490,7 +490,7 @@ void ImpPathCreateUser::CalcRect(const Point& rP1, const Point& rP2, const Point
XPolygon ImpPathCreateUser::GetRectPoly() const
{
XPolygon aXP(3);
- aXP[0]=aRectP1; aXP.SetFlags(0,XPolyFlags::Smooth);
+ aXP[0]=aRectP1; aXP.SetFlags(0,PolyFlags::Smooth);
aXP[1]=aRectP2;
if (aRectP3!=aRectP2) aXP[2]=aRectP3;
return aXP;
@@ -1196,8 +1196,8 @@ basegfx::B2DPolyPolygon ImpPathForDragAndCreate::getSpecialDragPoly(const SdrDra
aLine2[0]=mpSdrPathDragData->aXP[nNextNextPnt];
aLine2[1]=mpSdrPathDragData->aXP[nNextPnt];
if (mpSdrPathDragData->aXP.IsSmooth(nPrevPnt) && !bPrevIsBegPnt && mpSdrPathDragData->aXP.IsControl(nPrevPrevPnt)) {
- aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-1],XPolyFlags::Control);
- aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-2],XPolyFlags::Normal);
+ aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-1],PolyFlags::Control);
+ aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-2],PolyFlags::Normal);
// leverage lines for the opposing curve segment
aLine3[0]=mpSdrPathDragData->aXP[nPrevPnt];
aLine3[1]=mpSdrPathDragData->aXP[nPrevPrevPnt];
@@ -1211,8 +1211,8 @@ basegfx::B2DPolyPolygon ImpPathForDragAndCreate::getSpecialDragPoly(const SdrDra
aLine2[0]=mpSdrPathDragData->aXP[nPrevPrevPnt];
aLine2[1]=mpSdrPathDragData->aXP[nPrevPnt];
if (mpSdrPathDragData->aXP.IsSmooth(nNextPnt) && !bNextIsEndPnt && mpSdrPathDragData->aXP.IsControl(nNextNextPnt)) {
- aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+1],XPolyFlags::Control);
- aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+2],XPolyFlags::Normal);
+ aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+1],PolyFlags::Control);
+ aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+2],PolyFlags::Normal);
// leverage lines for the opposing curve segment
aLine3[0]=mpSdrPathDragData->aXP[nNextPnt];
aLine3[1]=mpSdrPathDragData->aXP[nNextNextPnt];
@@ -1226,18 +1226,18 @@ basegfx::B2DPolyPolygon ImpPathForDragAndCreate::getSpecialDragPoly(const SdrDra
if (mpSdrPathDragData->bEliminate) {
aXPoly.Remove(2,1);
}
- if (bPrevIsControl) aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-1],XPolyFlags::Normal);
+ if (bPrevIsControl) aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-1],PolyFlags::Normal);
else if (!bBegPnt && !bPrevIsBegPnt && mpSdrPathDragData->aXP.IsControl(nPrevPrevPnt)) {
- aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-1],XPolyFlags::Control);
- aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-2],XPolyFlags::Normal);
+ aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-1],PolyFlags::Control);
+ aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-2],PolyFlags::Normal);
} else {
aXPoly.Remove(0,1);
if (bBegPnt) aXPoly.Remove(0,1);
}
- if (bNextIsControl) aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+1],XPolyFlags::Normal);
+ if (bNextIsControl) aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+1],PolyFlags::Normal);
else if (!bEndPnt && !bNextIsEndPnt && mpSdrPathDragData->aXP.IsControl(nNextNextPnt)) {
- aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+1],XPolyFlags::Control);
- aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+2],XPolyFlags::Normal);
+ aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+1],PolyFlags::Control);
+ aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+2],PolyFlags::Normal);
} else {
aXPoly.Remove(aXPoly.GetPointCount()-1,1);
if (bEndPnt) aXPoly.Remove(aXPoly.GetPointCount()-1,1);
@@ -1366,12 +1366,12 @@ bool ImpPathForDragAndCreate::MovCreate(SdrDragStat& rStat)
if (nActPoint-pU->nBezierStartPoint>=3 && ((nActPoint-pU->nBezierStartPoint)%3)==0) {
rXPoly.PointsToBezier(nActPoint-3);
- rXPoly.SetFlags(nActPoint-1,XPolyFlags::Control);
- rXPoly.SetFlags(nActPoint-2,XPolyFlags::Control);
+ rXPoly.SetFlags(nActPoint-1,PolyFlags::Control);
+ rXPoly.SetFlags(nActPoint-2,PolyFlags::Control);
if (nActPoint>=6 && rXPoly.IsControl(nActPoint-4)) {
rXPoly.CalcTangent(nActPoint-3,nActPoint-4,nActPoint-2);
- rXPoly.SetFlags(nActPoint-3,XPolyFlags::Smooth);
+ rXPoly.SetFlags(nActPoint-3,PolyFlags::Smooth);
}
}
rXPoly[nActPoint+1]=rStat.Now();
@@ -1439,12 +1439,12 @@ bool ImpPathForDragAndCreate::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
if (pU->nBezierStartPoint>nActPoint) pU->nBezierStartPoint=nActPoint;
if (IsBezier(pU->eAktKind) && nActPoint-pU->nBezierStartPoint>=3 && ((nActPoint-pU->nBezierStartPoint)%3)==0) {
rXPoly.PointsToBezier(nActPoint-3);
- rXPoly.SetFlags(nActPoint-1,XPolyFlags::Control);
- rXPoly.SetFlags(nActPoint-2,XPolyFlags::Control);
+ rXPoly.SetFlags(nActPoint-1,PolyFlags::Control);
+ rXPoly.SetFlags(nActPoint-2,PolyFlags::Control);
if (nActPoint>=6 && rXPoly.IsControl(nActPoint-4)) {
rXPoly.CalcTangent(nActPoint-3,nActPoint-4,nActPoint-2);
- rXPoly.SetFlags(nActPoint-3,XPolyFlags::Smooth);
+ rXPoly.SetFlags(nActPoint-3,PolyFlags::Smooth);
}
}
} else {
@@ -2061,7 +2061,7 @@ void SdrPathObj::AddToHdlList(SdrHdlList& rHdlList) const
if (bClosed && nPntCnt>1) nPntCnt--;
for (sal_uInt16 j=0; j<nPntCnt; j++) {
- if (rXPoly.GetFlags(j)!=XPolyFlags::Control) {
+ if (rXPoly.GetFlags(j)!=PolyFlags::Control) {
const Point& rPnt=rXPoly[j];
SdrHdl* pHdl=new SdrHdl(rPnt,SdrHdlKind::Poly);
pHdl->SetPolyNum(i);
@@ -2092,12 +2092,12 @@ sal_uInt32 SdrPathObj::GetPlusHdlCount(const SdrHdl& rHdl) const
nPntMax--;
if (nPnt<=nPntMax)
{
- if (rXPoly.GetFlags(nPnt)!=XPolyFlags::Control)
+ if (rXPoly.GetFlags(nPnt)!=PolyFlags::Control)
{
if (nPnt==0 && IsClosed()) nPnt=nPntMax;
- if (nPnt>0 && rXPoly.GetFlags(nPnt-1)==XPolyFlags::Control) nCnt++;
+ if (nPnt>0 && rXPoly.GetFlags(nPnt-1)==PolyFlags::Control) nCnt++;
if (nPnt==nPntMax && IsClosed()) nPnt=0;
- if (nPnt<nPntMax && rXPoly.GetFlags(nPnt+1)==XPolyFlags::Control) nCnt++;
+ if (nPnt<nPntMax && rXPoly.GetFlags(nPnt+1)==PolyFlags::Control) nCnt++;
}
}
}
@@ -2128,7 +2128,7 @@ SdrHdl* SdrPathObj::GetPlusHdl(const SdrHdl& rHdl, sal_uInt32 nPlusNum) const
pHdl->SetPolyNum(rHdl.GetPolyNum());
if (nPnt==0 && IsClosed()) nPnt=nPntMax;
- if (nPnt>0 && rXPoly.GetFlags(nPnt-1)==XPolyFlags::Control && nPlusNum==0)
+ if (nPnt>0 && rXPoly.GetFlags(nPnt-1)==PolyFlags::Control && nPlusNum==0)
{
pHdl->SetPos(rXPoly[nPnt-1]);
pHdl->SetPointNum(nPnt-1);
@@ -2136,7 +2136,7 @@ SdrHdl* SdrPathObj::GetPlusHdl(const SdrHdl& rHdl, sal_uInt32 nPlusNum) const
else
{
if (nPnt==nPntMax && IsClosed()) nPnt=0;
- if (nPnt<rXPoly.GetPointCount()-1 && rXPoly.GetFlags(nPnt+1)==XPolyFlags::Control)
+ if (nPnt<rXPoly.GetPointCount()-1 && rXPoly.GetFlags(nPnt+1)==PolyFlags::Control)
{
pHdl->SetPos(rXPoly[nPnt+1]);
pHdl->SetPointNum(nPnt+1);
diff --git a/svx/source/xoutdev/_xpoly.cxx b/svx/source/xoutdev/_xpoly.cxx
index 711a57c..e289a45 100644
--- a/svx/source/xoutdev/_xpoly.cxx
+++ b/svx/source/xoutdev/_xpoly.cxx
@@ -97,7 +97,7 @@ void ImpXPolygon::Resize( sal_uInt16 nNewSize, bool bDeletePoints )
if( nNewSize == nSize )
return;
- sal_uInt8* pOldFlagAry = pFlagAry;
+ PolyFlags* pOldFlagAry = pFlagAry;
sal_uInt16 nOldSize = nSize;
CheckPointDelete();
@@ -116,7 +116,7 @@ void ImpXPolygon::Resize( sal_uInt16 nNewSize, bool bDeletePoints )
memset( pPointAry, 0, nSize*sizeof( Point ) );
// create flag array
- pFlagAry = new sal_uInt8[ nSize ];
+ pFlagAry = new PolyFlags[ nSize ];
memset( pFlagAry, 0, nSize );
// copy if needed
@@ -227,7 +227,7 @@ XPolygon::XPolygon( const tools::Polygon& rPoly )
for( sal_uInt16 i = 0; i < nSize; i++ )
{
pImpXPolygon->pPointAry[i] = rPoly[i];
- pImpXPolygon->pFlagAry[i] = (sal_uInt8) rPoly.GetFlags( i );
+ pImpXPolygon->pFlagAry[i] = rPoly.GetFlags( i );
}
}
@@ -275,8 +275,8 @@ XPolygon::XPolygon(const Rectangle& rRect, long nRx, long nRy)
break;
}
GenBezArc(aCenter, nRx, nRy, nXHdl, nYHdl, 0, 900, nQuad, nPos);
- pImpXPolygon->pFlagAry[nPos ] = (sal_uInt8) XPolyFlags::Smooth;
- pImpXPolygon->pFlagAry[nPos+3] = (sal_uInt8) XPolyFlags::Smooth;
+ pImpXPolygon->pFlagAry[nPos ] = PolyFlags::Smooth;
+ pImpXPolygon->pFlagAry[nPos+3] = PolyFlags::Smooth;
nPos += 4;
}
}
@@ -315,7 +315,7 @@ XPolygon::XPolygon(const Point& rCenter, long nRx, long nRy,
GenBezArc(rCenter, nRx, nRy, nXHdl, nYHdl, nA1, nA2, nQuad, nPos);
nPos += 3;
if ( !bLoopEnd )
- pImpXPolygon->pFlagAry[nPos] = (sal_uInt8) XPolyFlags::Smooth;
+ pImpXPolygon->pFlagAry[nPos] = PolyFlags::Smooth;
} while ( !bLoopEnd );
@@ -325,8 +325,8 @@ XPolygon::XPolygon(const Point& rCenter, long nRx, long nRy,
if ( bFull )
{
- pImpXPolygon->pFlagAry[0 ] = (sal_uInt8) XPolyFlags::Smooth;
- pImpXPolygon->pFlagAry[nPos] = (sal_uInt8) XPolyFlags::Smooth;
+ pImpXPolygon->pFlagAry[0 ] = PolyFlags::Smooth;
+ pImpXPolygon->pFlagAry[nPos] = PolyFlags::Smooth;
}
pImpXPolygon->nPoints = nPos + 1;
}
@@ -363,12 +363,12 @@ sal_uInt16 XPolygon::GetPointCount() const
return pImpXPolygon->nPoints;
}
-void XPolygon::Insert( sal_uInt16 nPos, const Point& rPt, XPolyFlags eFlags )
+void XPolygon::Insert( sal_uInt16 nPos, const Point& rPt, PolyFlags eFlags )
{
if (nPos>pImpXPolygon->nPoints) nPos=pImpXPolygon->nPoints;
pImpXPolygon->InsertSpace( nPos, 1 );
pImpXPolygon->pPointAry[nPos] = rPt;
- pImpXPolygon->pFlagAry[nPos] = (sal_uInt8)eFlags;
+ pImpXPolygon->pFlagAry[nPos] = eFlags;
}
void XPolygon::Insert( sal_uInt16 nPos, const XPolygon& rXPoly )
@@ -471,30 +471,30 @@ bool XPolygon::operator==( const XPolygon& rXPoly ) const
}
/// get the flags for the point at the given position
-XPolyFlags XPolygon::GetFlags( sal_uInt16 nPos ) const
+PolyFlags XPolygon::GetFlags( sal_uInt16 nPos ) const
{
pImpXPolygon->CheckPointDelete();
- return (XPolyFlags) pImpXPolygon->pFlagAry[nPos];
+ return (PolyFlags) pImpXPolygon->pFlagAry[nPos];
}
/// set the flags for the point at the given position
-void XPolygon::SetFlags( sal_uInt16 nPos, XPolyFlags eFlags )
+void XPolygon::SetFlags( sal_uInt16 nPos, PolyFlags eFlags )
{
pImpXPolygon->CheckPointDelete();
- pImpXPolygon->pFlagAry[nPos] = (sal_uInt8) eFlags;
+ pImpXPolygon->pFlagAry[nPos] = eFlags;
}
/// short path to read the CONTROL flag directly (TODO: better explain what the sense behind this flag is!)
bool XPolygon::IsControl(sal_uInt16 nPos) const
{
- return ( (XPolyFlags) pImpXPolygon->pFlagAry[nPos] == XPolyFlags::Control );
+ return ( (PolyFlags) pImpXPolygon->pFlagAry[nPos] == PolyFlags::Control );
}
/// short path to read the SMOOTH and SYMMTR flag directly (TODO: better explain what the sense behind these flags is!)
bool XPolygon::IsSmooth(sal_uInt16 nPos) const
{
- XPolyFlags eFlag = (XPolyFlags) pImpXPolygon->pFlagAry[nPos];
- return ( eFlag == XPolyFlags::Smooth || eFlag == XPolyFlags::Symmetric );
+ PolyFlags eFlag = (PolyFlags) pImpXPolygon->pFlagAry[nPos];
+ return ( eFlag == PolyFlags::Smooth || eFlag == PolyFlags::Symmetric );
}
/** calculate the euclidean distance between two points
@@ -598,8 +598,8 @@ void XPolygon::GenBezArc(const Point& rCenter, long nRx, long nRy,
SubdivideBezier(nFirst, false, (double)nStart / 900);
if ( nEnd < 900 )
SubdivideBezier(nFirst, true, (double)(nEnd-nStart) / (900-nStart));
- SetFlags(nFirst+1, XPolyFlags::Control);
- SetFlags(nFirst+2, XPolyFlags::Control);
+ SetFlags(nFirst+1, PolyFlags::Control);
+ SetFlags(nFirst+2, PolyFlags::Control);
}
bool XPolygon::CheckAngles(sal_uInt16& nStart, sal_uInt16 nEnd, sal_uInt16& nA1, sal_uInt16& nA2)
@@ -648,7 +648,7 @@ void XPolygon::CalcSmoothJoin(sal_uInt16 nCenter, sal_uInt16 nDrag, sal_uInt16 n
{
double fRatio = CalcDistance(nCenter, nPnt) / fDiv;
// keep the length if SMOOTH
- if ( GetFlags(nCenter) == XPolyFlags::Smooth || !IsControl(nDrag) )
+ if ( GetFlags(nCenter) == PolyFlags::Smooth || !IsControl(nDrag) )
{
aDiff.X() = (long) (fRatio * aDiff.X());
aDiff.Y() = (long) (fRatio * aDiff.Y());
@@ -677,7 +677,7 @@ void XPolygon::CalcTangent(sal_uInt16 nCenter, sal_uInt16 nPrev, sal_uInt16 nNex
double fPrevLen = CalcDistance(nCenter, nPrev) / fAbsLen;
// same length for both sides if SYMMTR
- if ( GetFlags(nCenter) == XPolyFlags::Symmetric )
+ if ( GetFlags(nCenter) == PolyFlags::Symmetric )
{
fPrevLen = (fNextLen + fPrevLen) / 2;
fNextLen = fPrevLen;
@@ -752,8 +752,8 @@ void XPolygon::PointsToBezier(sal_uInt16 nFirst)
pPoints[nFirst+1] = Point((long) fX1, (long) fY1);
pPoints[nFirst+2] = Point((long) fX2, (long) fY2);
- SetFlags(nFirst+1, XPolyFlags::Control);
- SetFlags(nFirst+2, XPolyFlags::Control);
+ SetFlags(nFirst+1, PolyFlags::Control);
+ SetFlags(nFirst+2, PolyFlags::Control);
}
/// scale in X- and/or Y-direction
@@ -854,7 +854,7 @@ XPolygon::XPolygon(const basegfx::B2DPolygon& rPolygon)
for( sal_uInt16 i = 0; i < nSize; i++ )
{
pImpXPolygon->pPointAry[i] = aSource[i];
- pImpXPolygon->pFlagAry[i] = (sal_uInt8) aSource.GetFlags( i );
+ pImpXPolygon->pFlagAry[i] = aSource.GetFlags( i );
}
}
diff --git a/tools/inc/poly.h b/tools/inc/poly.h
index 3be1189..6ad1b5b 100644
--- a/tools/inc/poly.h
+++ b/tools/inc/poly.h
@@ -20,6 +20,7 @@
#define INCLUDED_TOOLS_INC_POLY_H
#include <sal/types.h>
+#include <tools/poly.hxx>
class Point;
@@ -27,8 +28,8 @@ class SAL_WARN_UNUSED ImplPolygonData
{
public:
Point* mpPointAry;
- sal_uInt8* mpFlagAry;
- sal_uInt16 mnPoints;
+ PolyFlags* mpFlagAry;
+ sal_uInt16 mnPoints;
sal_uInt32 mnRefCount;
};
@@ -36,7 +37,7 @@ class SAL_WARN_UNUSED ImplPolygon : public ImplPolygonData
{
public:
ImplPolygon( sal_uInt16 nInitSize, bool bFlags = false );
- ImplPolygon( sal_uInt16 nPoints, const Point* pPtAry, const sal_uInt8* pInitFlags );
+ ImplPolygon( sal_uInt16 nPoints, const Point* pPtAry, const PolyFlags* pInitFlags );
ImplPolygon( const ImplPolygon& rImplPoly );
~ImplPolygon();
diff --git a/tools/source/generic/poly.cxx b/tools/source/generic/poly.cxx
index 20391e3..b327569 100644
--- a/tools/source/generic/poly.cxx
+++ b/tools/source/generic/poly.cxx
@@ -70,7 +70,7 @@ ImplPolygon::ImplPolygon( sal_uInt16 nInitSize, bool bFlags )
if( bFlags )
{
- mpFlagAry = new sal_uInt8[ nInitSize ];
+ mpFlagAry = new PolyFlags[ nInitSize ];
memset( mpFlagAry, 0, nInitSize );
}
else
@@ -90,7 +90,7 @@ ImplPolygon::ImplPolygon( const ImplPolygon& rImpPoly )
if( rImpPoly.mpFlagAry )
{
- mpFlagAry = new sal_uInt8[ rImpPoly.mnPoints ];
+ mpFlagAry = new PolyFlags[ rImpPoly.mnPoints ];
memcpy( mpFlagAry, rImpPoly.mpFlagAry, rImpPoly.mnPoints );
}
else
@@ -106,7 +106,7 @@ ImplPolygon::ImplPolygon( const ImplPolygon& rImpPoly )
mnPoints = rImpPoly.mnPoints;
}
-ImplPolygon::ImplPolygon( sal_uInt16 nInitSize, const Point* pInitAry, const sal_uInt8* pInitFlags )
+ImplPolygon::ImplPolygon( sal_uInt16 nInitSize, const Point* pInitAry, const PolyFlags* pInitFlags )
{
if ( nInitSize )
{
@@ -116,7 +116,7 @@ ImplPolygon::ImplPolygon( sal_uInt16 nInitSize, const Point* pInitAry, const sal
if( pInitFlags )
{
- mpFlagAry = new sal_uInt8[ nInitSize ];
+ mpFlagAry = new PolyFlags[ nInitSize ];
memcpy( mpFlagAry, pInitFlags, nInitSize );
}
else
@@ -182,11 +182,11 @@ void ImplPolygon::ImplSetSize( sal_uInt16 nNewSize, bool bResize )
// ggf. FlagArray beruecksichtigen
if( mpFlagAry )
{
- sal_uInt8* pNewFlagAry;
+ PolyFlags* pNewFlagAry;
if( nNewSize )
{
- pNewFlagAry = new sal_uInt8[ nNewSize ];
+ pNewFlagAry = new PolyFlags[ nNewSize ];
if( bResize )
{
@@ -255,7 +255,7 @@ void ImplPolygon::ImplSplit( sal_uInt16 nPos, sal_uInt16 nSpace, ImplPolygon con
// consider FlagArray
if( mpFlagAry )
{
- sal_uInt8* pNewFlagAry = new sal_uInt8[ nNewSize ];
+ PolyFlags* pNewFlagAry = new PolyFlags[ nNewSize ];
memcpy( pNewFlagAry, mpFlagAry, nPos );
@@ -278,7 +278,7 @@ void ImplPolygon::ImplCreateFlagArray()
{
if( !mpFlagAry )
{
- mpFlagAry = new sal_uInt8[ mnPoints ];
+ mpFlagAry = new PolyFlags[ mnPoints ];
memset( mpFlagAry, 0, mnPoints );
}
}
@@ -534,9 +534,8 @@ Polygon::Polygon( sal_uInt16 nSize )
mpImplPolygon = static_cast<ImplPolygon*>(&aStaticImplPolygon);
}
-Polygon::Polygon( sal_uInt16 nPoints, const Point* pPtAry, const sal_uInt8* pFlagAry )
+Polygon::Polygon( sal_uInt16 nPoints, const Point* pPtAry, const PolyFlags* pFlagAry )
{
-
if( nPoints )
mpImplPolygon = new ImplPolygon( nPoints, pPtAry, pFlagAry );
else
@@ -798,7 +797,7 @@ const Point* Polygon::GetConstPointAry() const
return mpImplPolygon->mpPointAry;
}
-const sal_uInt8* Polygon::GetConstFlagAry() const
+const PolyFlags* Polygon::GetConstFlagAry() const
{
return mpImplPolygon->mpFlagAry;
}
@@ -818,12 +817,12 @@ void Polygon::SetFlags( sal_uInt16 nPos, PolyFlags eFlags )
"Polygon::SetFlags(): nPos >= nPoints" );
// we do only want to create the flag array if there
- // is at least one flag different to POLY_NORMAL
- if ( eFlags != POLY_NORMAL )
+ // is at least one flag different to PolyFlags::Normal
+ if ( eFlags != PolyFlags::Normal )
{
ImplMakeUnique();
mpImplPolygon->ImplCreateFlagArray();
- mpImplPolygon->mpFlagAry[ nPos ] = (sal_uInt8) eFlags;
+ mpImplPolygon->mpFlagAry[ nPos ] = eFlags;
}
}
@@ -841,7 +840,7 @@ PolyFlags Polygon::GetFlags( sal_uInt16 nPos ) const
"Polygon::GetFlags(): nPos >= nPoints" );
return( mpImplPolygon->mpFlagAry ?
(PolyFlags) mpImplPolygon->mpFlagAry[ nPos ] :
- POLY_NORMAL );
+ PolyFlags::Normal );
}
bool Polygon::HasFlags() const
@@ -1083,13 +1082,13 @@ void Polygon::AdaptiveSubdivide( Polygon& rResult, const double d ) const
{
if( ( i + 3 ) < nPts )
{
- sal_uInt8 P1( mpImplPolygon->mpFlagAry[ i ] );
- sal_uInt8 P4( mpImplPolygon->mpFlagAry[ i + 3 ] );
+ PolyFlags P1( mpImplPolygon->mpFlagAry[ i ] );
+ PolyFlags P4( mpImplPolygon->mpFlagAry[ i + 3 ] );
- if( ( POLY_NORMAL == P1 || POLY_SMOOTH == P1 || POLY_SYMMTR == P1 ) &&
- ( POLY_CONTROL == mpImplPolygon->mpFlagAry[ i + 1 ] ) &&
- ( POLY_CONTROL == mpImplPolygon->mpFlagAry[ i + 2 ] ) &&
- ( POLY_NORMAL == P4 || POLY_SMOOTH == P4 || POLY_SYMMTR == P4 ) )
+ if( ( PolyFlags::Normal == P1 || PolyFlags::Smooth == P1 || PolyFlags::Symmetric == P1 ) &&
+ ( PolyFlags::Control == mpImplPolygon->mpFlagAry[ i + 1 ] ) &&
+ ( PolyFlags::Control == mpImplPolygon->mpFlagAry[ i + 2 ] ) &&
+ ( PolyFlags::Normal == P4 || PolyFlags::Smooth == P4 || PolyFlags::Symmetric == P4 ) )
{
ImplAdaptiveSubdivide( aPointIter, d*d+1.0, 0, d*d,
mpImplPolygon->mpPointAry[ i ].X(), mpImplPolygon->mpPointAry[ i ].Y(),
@@ -1653,7 +1652,7 @@ void Polygon::ImplRead( SvStream& rIStream )
if ( bHasPolyFlags )
{
- mpImplPolygon->mpFlagAry = new sal_uInt8[ mpImplPolygon->mnPoints ];
+ mpImplPolygon->mpFlagAry = new PolyFlags[ mpImplPolygon->mnPoints ];
rIStream.ReadBytes(mpImplPolygon->mpFlagAry, mpImplPolygon->mnPoints);
}
}
@@ -1683,12 +1682,12 @@ void Polygon::Write( SvStream& rOStream ) const
}
// #i74631#/#i115917# numerical correction method for B2DPolygon
-void impCorrectContinuity(basegfx::B2DPolygon& roPolygon, sal_uInt32 nIndex, sal_uInt8 nCFlag)
+void impCorrectContinuity(basegfx::B2DPolygon& roPolygon, sal_uInt32 nIndex, PolyFlags nCFlag)
{
const sal_uInt32 nPointCount(roPolygon.count());
OSL_ENSURE(nIndex < nPointCount, "impCorrectContinuity: index access out of range (!)");
- if(nIndex < nPointCount && (POLY_SMOOTH == nCFlag || POLY_SYMMTR == nCFlag))
+ if(nIndex < nPointCount && (PolyFlags::Smooth == nCFlag || PolyFlags::Symmetric == nCFlag))
{
if(roPolygon.isPrevControlPointUsed(nIndex) && roPolygon.isNextControlPointUsed(nIndex))
{
@@ -1718,14 +1717,14 @@ void impCorrectContinuity(basegfx::B2DPolygon& roPolygon, sal_uInt32 nIndex, sal
// calculate common direction vector, normalize
const basegfx::B2DVector aDirection(aNext + aPrev);
- if(POLY_SMOOTH == nCFlag)
+ if(PolyFlags::Smooth == nCFlag)
{
// C1: apply common direction vector, preserve individual lengths
const double fInvDirectionLen(1.0 / aDirection.getLength());
roPolygon.setNextControlPoint(nIndex, basegfx::B2DPoint(aPoint + (aDirection * (aNext.getLength() * fInvDirectionLen))));
roPolygon.setPrevControlPoint(nIndex, basegfx::B2DPoint(aPoint - (aDirection * (aPrev.getLength() * fInvDirectionLen))));
}
- else // POLY_SYMMTR
+ else // PolyFlags::Symmetric
{
// C2: get mediated length. Taking half of the unnormalized direction would be
// an approximation, but not correct.
@@ -1752,7 +1751,7 @@ basegfx::B2DPolygon Polygon::getB2DPolygon() const
{
// handling for curves. Add start point
const Point aStartPoint(mpImplPolygon->mpPointAry[0]);
- sal_uInt8 nPointFlag(mpImplPolygon->mpFlagAry[0]);
+ PolyFlags nPointFlag(mpImplPolygon->mpFlagAry[0]);
aRetval.append(basegfx::B2DPoint(aStartPoint.X(), aStartPoint.Y()));
Point aControlA, aControlB;
@@ -1761,13 +1760,13 @@ basegfx::B2DPolygon Polygon::getB2DPolygon() const
bool bControlA(false);
bool bControlB(false);
- if(POLY_CONTROL == mpImplPolygon->mpFlagAry[a])
+ if(PolyFlags::Control == mpImplPolygon->mpFlagAry[a])
{
aControlA = mpImplPolygon->mpPointAry[a++];
bControlA = true;
}
- if(a < nCount && POLY_CONTROL == mpImplPolygon->mpFlagAry[a])
+ if(a < nCount && PolyFlags::Control == mpImplPolygon->mpFlagAry[a])
{
aControlB = mpImplPolygon->mpPointAry[a++];
bControlB = true;
@@ -1871,7 +1870,7 @@ Polygon::Polygon(const basegfx::B2DPolygon& rPolygon)
const Point aStartPoint(FRound(aBezier.getStartPoint().getX()), FRound(aBezier.getStartPoint().getY()));
const sal_uInt32 nStartPointIndex(nArrayInsert);
mpImplPolygon->mpPointAry[nStartPointIndex] = aStartPoint;
- mpImplPolygon->mpFlagAry[nStartPointIndex] = (sal_uInt8)POLY_NORMAL;
+ mpImplPolygon->mpFlagAry[nStartPointIndex] = PolyFlags::Normal;
nArrayInsert++;
// prepare next segment
@@ -1884,11 +1883,11 @@ Polygon::Polygon(const basegfx::B2DPolygon& rPolygon)
{
// if one is used, add always two control points due to the old schema
mpImplPolygon->mpPointAry[nArrayInsert] = Point(FRound(aBezier.getControlPointA().getX()), FRound(aBezier.getControlPointA().getY()));
- mpImplPolygon->mpFlagAry[nArrayInsert] = (sal_uInt8)POLY_CONTROL;
+ mpImplPolygon->mpFlagAry[nArrayInsert] = PolyFlags::Control;
nArrayInsert++;
mpImplPolygon->mpPointAry[nArrayInsert] = Point(FRound(aBezier.getControlPointB().getX()), FRound(aBezier.getControlPointB().getY()));
- mpImplPolygon->mpFlagAry[nArrayInsert] = (sal_uInt8)POLY_CONTROL;
+ mpImplPolygon->mpFlagAry[nArrayInsert] = PolyFlags::Control;
nArrayInsert++;
}
@@ -1899,11 +1898,11 @@ Polygon::Polygon(const basegfx::B2DPolygon& rPolygon)
if(basegfx::B2VectorContinuity::C1 == eCont)
{
- mpImplPolygon->mpFlagAry[nStartPointIndex] = (sal_uInt8)POLY_SMOOTH;
+ mpImplPolygon->mpFlagAry[nStartPointIndex] = PolyFlags::Smooth;
}
else if(basegfx::B2VectorContinuity::C2 == eCont)
{
- mpImplPolygon->mpFlagAry[nStartPointIndex] = (sal_uInt8)POLY_SYMMTR;
+ mpImplPolygon->mpFlagAry[nStartPointIndex] = PolyFlags::Symmetric;
}
}
@@ -1915,7 +1914,7 @@ Polygon::Polygon(const basegfx::B2DPolygon& rPolygon)
{
// add first point again as closing point due to old definition
mpImplPolygon->mpPointAry[nArrayInsert] = mpImplPolygon->mpPointAry[0];
- mpImplPolygon->mpFlagAry[nArrayInsert] = (sal_uInt8)POLY_NORMAL;
+ mpImplPolygon->mpFlagAry[nArrayInsert] = PolyFlags::Normal;
nArrayInsert++;
}
else
@@ -1924,7 +1923,7 @@ Polygon::Polygon(const basegfx::B2DPolygon& rPolygon)
const basegfx::B2DPoint aClosingPoint(rPolygon.getB2DPoint(nB2DLocalCount - 1L));
const Point aEnd(FRound(aClosingPoint.getX()), FRound(aClosingPoint.getY()));
mpImplPolygon->mpPointAry[nArrayInsert] = aEnd;
- mpImplPolygon->mpFlagAry[nArrayInsert] = (sal_uInt8)POLY_NORMAL;
+ mpImplPolygon->mpFlagAry[nArrayInsert] = PolyFlags::Normal;
nArrayInsert++;
}
diff --git a/vcl/headless/svpgdi.cxx b/vcl/headless/svpgdi.cxx
index 3f4a042..de5596f 100644
--- a/vcl/headless/svpgdi.cxx
+++ b/vcl/headless/svpgdi.cxx
@@ -814,7 +814,7 @@ bool SvpSalGraphics::drawPolyLine(
bool SvpSalGraphics::drawPolyLineBezier( sal_uInt32,
const SalPoint*,
- const sal_uInt8* )
+ const PolyFlags* )
{
SAL_INFO("vcl.gdi", "unsupported SvpSalGraphics::drawPolyLineBezier case");
return false;
@@ -822,7 +822,7 @@ bool SvpSalGraphics::drawPolyLineBezier( sal_uInt32,
bool SvpSalGraphics::drawPolygonBezier( sal_uInt32,
const SalPoint*,
- const sal_uInt8* )
+ const PolyFlags* )
{
SAL_INFO("vcl.gdi", "unsupported SvpSalGraphics::drawPolygonBezier case");
return false;
@@ -831,7 +831,7 @@ bool SvpSalGraphics::drawPolygonBezier( sal_uInt32,
bool SvpSalGraphics::drawPolyPolygonBezier( sal_uInt32,
const sal_uInt32*,
const SalPoint* const*,
- const sal_uInt8* const* )
+ const PolyFlags* const* )
{
SAL_INFO("vcl.gdi", "unsupported SvpSalGraphics::drawPolyPolygonBezier case");
return false;
diff --git a/vcl/inc/headless/svpgdi.hxx b/vcl/inc/headless/svpgdi.hxx
index ad6e4bf..a8f3362 100644
--- a/vcl/inc/headless/svpgdi.hxx
+++ b/vcl/inc/headless/svpgdi.hxx
@@ -182,14 +182,14 @@ public:
PCONSTSALPOINT* pPtAry ) override;
virtual bool drawPolyLineBezier( sal_uInt32 nPoints,
const SalPoint* pPtAry,
- const sal_uInt8* pFlgAry ) override;
+ const PolyFlags* pFlgAry ) override;
virtual bool drawPolygonBezier( sal_uInt32 nPoints,
const SalPoint* pPtAry,
- const sal_uInt8* pFlgAry ) override;
+ const PolyFlags* pFlgAry ) override;
virtual bool drawPolyPolygonBezier( sal_uInt32 nPoly,
const sal_uInt32* pPoints,
const SalPoint* const* pPtAry,
- const sal_uInt8* const* pFlgAry ) override;
+ const PolyFlags* const* pFlgAry ) override;
virtual bool drawGradient( const tools::PolyPolygon&, const Gradient& ) override { return false; };
virtual void copyArea( long nDestX,
diff --git a/vcl/inc/openglgdiimpl.hxx b/vcl/inc/openglgdiimpl.hxx
index 1457004..ea79b6c 100644
--- a/vcl/inc/openglgdiimpl.hxx
+++ b/vcl/inc/openglgdiimpl.hxx
@@ -260,18 +260,18 @@ public:
virtual bool drawPolyLineBezier(
sal_uInt32 nPoints,
const SalPoint* pPtAry,
- const sal_uInt8* pFlgAry ) override;
+ const PolyFlags* pFlgAry ) override;
virtual bool drawPolygonBezier(
sal_uInt32 nPoints,
const SalPoint* pPtAry,
- const sal_uInt8* pFlgAry ) override;
+ const PolyFlags* pFlgAry ) override;
virtual bool drawPolyPolygonBezier(
sal_uInt32 nPoly,
const sal_uInt32* pPoints,
const SalPoint* const* pPtAry,
- const sal_uInt8* const* pFlgAry ) override;
+ const PolyFlags* const* pFlgAry ) override;
// CopyArea --> No RasterOp, but ClipRegion
virtual void copyArea(
diff --git a/vcl/inc/quartz/salgdi.h b/vcl/inc/quartz/salgdi.h
index 382641e..6ea5bf3 100644
--- a/vcl/inc/quartz/salgdi.h
+++ b/vcl/inc/quartz/salgdi.h
@@ -232,9 +232,9 @@ public:
virtual void drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry ) override;
virtual void drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints, PCONSTSALPOINT* pPtAry ) override;
virtual bool drawPolyPolygon( const basegfx::B2DPolyPolygon&, double fTransparency ) override;
- virtual bool drawPolyLineBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const sal_uInt8* pFlgAry ) override;
- virtual bool drawPolygonBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const sal_uInt8* pFlgAry ) override;
- virtual bool drawPolyPolygonBezier( sal_uInt32 nPoly, const sal_uInt32* pPoints, const SalPoint* const* pPtAry, const sal_uInt8* const* pFlgAry ) 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 drawPolyLine(
const basegfx::B2DPolygon&,
double fTransparency,
diff --git a/vcl/inc/salgdi.hxx b/vcl/inc/salgdi.hxx
index 13e5e71..ef228fa 100644
--- a/vcl/inc/salgdi.hxx
+++ b/vcl/inc/salgdi.hxx
@@ -252,20 +252,20 @@ public:
bool DrawPolyLineBezier(
sal_uInt32 nPoints,
const SalPoint* pPtAry,
- const sal_uInt8* pFlgAry,
+ const PolyFlags* pFlgAry,
const OutputDevice *pOutDev );
bool DrawPolygonBezier(
sal_uInt32 nPoints,
const SalPoint* pPtAry,
- const sal_uInt8* pFlgAry,
+ const PolyFlags* pFlgAry,
const OutputDevice *pOutDev );
bool DrawPolyPolygonBezier(
sal_uInt32 nPoly,
const sal_uInt32* pPoints,
const SalPoint* const* pPtAry,
- const sal_uInt8* const* pFlgAry,
+ const PolyFlags* const* pFlgAry,
const OutputDevice *pOutDev );
bool DrawGradient(
@@ -449,18 +449,18 @@ protected:
virtual bool drawPolyLineBezier(
sal_uInt32 nPoints,
const SalPoint* pPtAry,
- const sal_uInt8* pFlgAry ) = 0;
+ const PolyFlags* pFlgAry ) = 0;
virtual bool drawPolygonBezier(
sal_uInt32 nPoints,
const SalPoint* pPtAry,
- const sal_uInt8* pFlgAry ) = 0;
+ const PolyFlags* pFlgAry ) = 0;
virtual bool drawPolyPolygonBezier(
sal_uInt32 nPoly,
const sal_uInt32* pPoints,
const SalPoint* const* pPtAry,
- const sal_uInt8* const* pFlgAry ) = 0;
+ const PolyFlags* const* pFlgAry ) = 0;
virtual bool drawGradient(
diff --git a/vcl/inc/salgdiimpl.hxx b/vcl/inc/salgdiimpl.hxx
index 35ce26b..1771afa 100644
--- a/vcl/inc/salgdiimpl.hxx
+++ b/vcl/inc/salgdiimpl.hxx
@@ -24,6 +24,7 @@
#include <rtl/ustring.hxx>
+#include <tools/poly.hxx>
#include <tools/solar.h>
#include <vcl/salgtype.hxx>
@@ -111,18 +112,18 @@ public:
virtual bool drawPolyLineBezier(
sal_uInt32 nPoints,
const SalPoint* pPtAry,
- const sal_uInt8* pFlgAry ) = 0;
+ const PolyFlags* pFlgAry ) = 0;
virtual bool drawPolygonBezier(
sal_uInt32 nPoints,
const SalPoint* pPtAry,
- const sal_uInt8* pFlgAry ) = 0;
+ const PolyFlags* pFlgAry ) = 0;
virtual bool drawPolyPolygonBezier(
sal_uInt32 nPoly,
const sal_uInt32* pPoints,
const SalPoint* const* pPtAry,
- const sal_uInt8* const* pFlgAry ) = 0;
+ const PolyFlags* const* pFlgAry ) = 0;
// CopyArea --> No RasterOp, but ClipRegion
virtual void copyArea(
diff --git a/vcl/inc/unx/genpspgraphics.h b/vcl/inc/unx/genpspgraphics.h
index 71bd81f..1dcb7ab 100644
--- a/vcl/inc/unx/genpspgraphics.h
+++ b/vcl/inc/unx/genpspgraphics.h
@@ -139,14 +139,14 @@ public:
double fMiterMinimumAngle) override;
virtual bool drawPolyLineBezier( sal_uInt32 nPoints,
const SalPoint* pPtAry,
- const sal_uInt8* pFlgAry ) override;
+ const PolyFlags* pFlgAry ) override;
virtual bool drawPolygonBezier( sal_uInt32 nPoints,
const SalPoint* pPtAry,
- const sal_uInt8* pFlgAry ) override;
+ const PolyFlags* pFlgAry ) override;
virtual bool drawPolyPolygonBezier( sal_uInt32 nPoly,
const sal_uInt32* pPoints,
const SalPoint* const* pPtAry,
- const sal_uInt8* const* pFlgAry ) override;
+ const PolyFlags* const* pFlgAry ) override;
virtual bool drawGradient( const tools::PolyPolygon&, const Gradient& ) override { return false; };
virtual void copyArea( long nDestX,
diff --git a/vcl/inc/unx/printergfx.hxx b/vcl/inc/unx/printergfx.hxx
index 7f8a735..871469e8 100644
--- a/vcl/inc/unx/printergfx.hxx
+++ b/vcl/inc/unx/printergfx.hxx
@@ -300,14 +300,14 @@ public:
const Point** pPolygonList);
void DrawPolyLineBezier (sal_uInt32 nPoints,
const Point* pPath,
- const sal_uInt8* pFlgAry );
+ const PolyFlags* pFlgAry );
void DrawPolygonBezier (sal_uInt32 nPoints,
const Point* pPath,
- const sal_uInt8* pFlgAry);
+ const PolyFlags* pFlgAry);
void DrawPolyPolygonBezier (sal_uInt32 nPoly,
const sal_uInt32* pPoints,
const Point* const* pPtAry,
- const sal_uInt8* const* pFlgAry);
+ const PolyFlags* const* pFlgAry);
// eps
bool DrawEPS ( const Rectangle& rBoundingBox, void* pPtr, sal_uInt32 nSize);
diff --git a/vcl/inc/unx/salgdi.h b/vcl/inc/unx/salgdi.h
index 27b0c84..b3de804 100644
--- a/vcl/inc/unx/salgdi.h
+++ b/vcl/inc/unx/salgdi.h
@@ -174,18 +174,18 @@ public:
virtual bool drawPolyLineBezier(
sal_uInt32 nPoints,
const SalPoint* pPtAry,
- const sal_uInt8* pFlgAry ) override;
+ const PolyFlags* pFlgAry ) override;
virtual bool drawPolygonBezier(
sal_uInt32 nPoints,
const SalPoint* pPtAry,
- const sal_uInt8* pFlgAry ) override;
+ const PolyFlags* pFlgAry ) override;
virtual bool drawPolyPolygonBezier(
sal_uInt32 nPoly,
const sal_uInt32* pPoints,
const SalPoint* const* pPtAry,
- const sal_uInt8* const* pFlgAry ) override;
+ const PolyFlags* const* pFlgAry ) override;
#endif
virtual void copyArea(
diff --git a/vcl/inc/win/salgdi.h b/vcl/inc/win/salgdi.h
index d3a7185..198c61c 100644
--- a/vcl/inc/win/salgdi.h
+++ b/vcl/inc/win/salgdi.h
@@ -237,9 +237,9 @@ protected:
basegfx::B2DLineJoin,
css::drawing::LineCap,
double fMiterMinimumAngle) override;
- virtual bool drawPolyLineBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const sal_uInt8* pFlgAry ) override;
- virtual bool drawPolygonBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const sal_uInt8* pFlgAry ) override;
- virtual bool drawPolyPolygonBezier( sal_uInt32 nPoly, const sal_uInt32* pPoints, const SalPoint* const* pPtAry, const BYTE* const* pFlgAry ) 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 drawGradient( const tools::PolyPolygon&, const Gradient& ) override { return false; };
// CopyArea --> No RasterOp, but ClipRegion
diff --git a/vcl/opengl/gdiimpl.cxx b/vcl/opengl/gdiimpl.cxx
index 006b5c6..61fb63d 100644
--- a/vcl/opengl/gdiimpl.cxx
+++ b/vcl/opengl/gdiimpl.cxx
@@ -1608,7 +1608,7 @@ bool OpenGLSalGraphicsImpl::drawPolyLine(const basegfx::B2DPolygon& rPolygon, do
bool OpenGLSalGraphicsImpl::drawPolyLineBezier(
sal_uInt32 /*nPoints*/,
const SalPoint* /*pPtAry*/,
- const sal_uInt8* /*pFlgAry*/ )
+ const PolyFlags* /*pFlgAry*/ )
{
return false;
}
@@ -1616,7 +1616,7 @@ bool OpenGLSalGraphicsImpl::drawPolyLineBezier(
bool OpenGLSalGraphicsImpl::drawPolygonBezier(
sal_uInt32 /*nPoints*/,
const SalPoint* /*pPtAry*/,
- const sal_uInt8* /*pFlgAry*/ )
+ const PolyFlags* /*pFlgAry*/ )
{
return false;
}
@@ -1625,7 +1625,7 @@ bool OpenGLSalGraphicsImpl::drawPolyPolygonBezier(
sal_uInt32 /*nPoly*/,
const sal_uInt32* /*pPoints*/,
const SalPoint* const* /*pPtAry*/,
- const sal_uInt8* const* /*pFlgAry*/ )
+ const PolyFlags* const* /*pFlgAry*/ )
{
return false;
}
diff --git a/vcl/quartz/salgdicommon.cxx b/vcl/quartz/salgdicommon.cxx
index d289e01..57a930a 100644
--- a/vcl/quartz/salgdicommon.cxx
+++ b/vcl/quartz/salgdicommon.cxx
@@ -1053,7 +1053,7 @@ bool AquaSalGraphics::drawPolyLine( const basegfx::B2DPolygon& rPolyLine,
return true;
}
-bool AquaSalGraphics::drawPolyLineBezier( sal_uInt32, const SalPoint*, const sal_uInt8* )
+bool AquaSalGraphics::drawPolyLineBezier( sal_uInt32, const SalPoint*, const PolyFlags* )
{
return false;
}
@@ -1349,13 +1349,13 @@ void AquaSalGraphics::drawPolygon( sal_uInt32 nPoints, const SalPoint *pPtAry )
DBG_DRAW_OPERATION_EXIT("drawPolygon");
}
-bool AquaSalGraphics::drawPolygonBezier( sal_uInt32, const SalPoint*, const sal_uInt8* )
+bool AquaSalGraphics::drawPolygonBezier( sal_uInt32, const SalPoint*, const PolyFlags* )
{
return false;
}
bool AquaSalGraphics::drawPolyPolygonBezier( sal_uInt32, const sal_uInt32*,
- const SalPoint* const*, const sal_uInt8* const* )
+ const SalPoint* const*, const PolyFlags* const* )
{
return false;
}
diff --git a/vcl/source/filter/wmf/emfwr.cxx b/vcl/source/filter/wmf/emfwr.cxx
index 9b7afb0..947d139 100644
--- a/vcl/source/filter/wmf/emfwr.cxx
+++ b/vcl/source/filter/wmf/emfwr.cxx
@@ -715,7 +715,7 @@ void EMFWriter::ImplWritePath( const tools::PolyPolygon& rPolyPoly, bool bClosed
sal_uInt16 nBezPoints = 0;
- while ( ( ( nBezPoints + n + 2 ) < rPoly.GetSize() ) && ( rPoly.GetFlags( nBezPoints + n ) == POLY_CONTROL ) )
+ while ( ( ( nBezPoints + n + 2 ) < rPoly.GetSize() ) && ( rPoly.GetFlags( nBezPoints + n ) == PolyFlags::Control ) )
nBezPoints += 3;
if ( nBezPoints )
@@ -735,7 +735,7 @@ void EMFWriter::ImplWritePath( const tools::PolyPolygon& rPolyPoly, bool bClosed
else
{
sal_uInt16 nPoints = 1;
- while( ( nPoints + n ) < rPoly.GetSize() && ( rPoly.GetFlags( nPoints + n ) != POLY_CONTROL ) )
+ while( ( nPoints + n ) < rPoly.GetSize() && ( rPoly.GetFlags( nPoints + n ) != PolyFlags::Control ) )
nPoints++;
if ( nPoints > 1 )
diff --git a/vcl/source/filter/wmf/winmtf.cxx b/vcl/source/filter/wmf/winmtf.cxx
index d855a29..c318956 100644
--- a/vcl/source/filter/wmf/winmtf.cxx
+++ b/vcl/source/filter/wmf/winmtf.cxx
@@ -1334,9 +1334,9 @@ void WinMtfOutput::DrawPolyBezier( tools::Polygon& rPolygon, bool bTo, bool bRec
sal_uInt16 i;
for ( i = 0; ( i + 2 ) < nPoints; )
{
- rPolygon.SetFlags( i++, POLY_NORMAL );
- rPolygon.SetFlags( i++, POLY_CONTROL );
- rPolygon.SetFlags( i++, POLY_CONTROL );
+ rPolygon.SetFlags( i++, PolyFlags::Normal );
+ rPolygon.SetFlags( i++, PolyFlags::Control );
+ rPolygon.SetFlags( i++, PolyFlags::Control );
}
if ( bRecordPath )
aPathObj.AddPolyLine( rPolygon );
diff --git a/vcl/source/gdi/pdfwriter_impl.cxx b/vcl/source/gdi/pdfwriter_impl.cxx
index 01d60bb..d754428 100644
--- a/vcl/source/gdi/pdfwriter_impl.cxx
+++ b/vcl/source/gdi/pdfwriter_impl.cxx
@@ -1440,15 +1440,15 @@ void PDFWriterImpl::PDFPage::appendPolygon( const tools::Polygon& rPoly, OString
sal_uInt32 nBufLen = rBuffer.getLength();
if( nPoints > 0 )
{
- const sal_uInt8* pFlagArray = rPoly.GetConstFlagAry();
+ const PolyFlags* pFlagArray = rPoly.GetConstFlagAry();
appendPoint( rPoly[0], rBuffer );
rBuffer.append( " m\n" );
for( sal_uInt16 i = 1; i < nPoints; i++ )
{
- if( pFlagArray && pFlagArray[i] == POLY_CONTROL && nPoints-i > 2 )
+ if( pFlagArray && pFlagArray[i] == PolyFlags::Control && nPoints-i > 2 )
{
// bezier
- SAL_WARN_IF( pFlagArray[i+1] != POLY_CONTROL || pFlagArray[i+2] == POLY_CONTROL, "vcl", "unexpected sequence of control points" );
+ SAL_WARN_IF( pFlagArray[i+1] != PolyFlags::Control || pFlagArray[i+2] == PolyFlags::Control, "vcl", "unexpected sequence of control points" );
appendPoint( rPoly[i], rBuffer );
rBuffer.append( " " );
appendPoint( rPoly[i+1], rBuffer );
diff --git a/vcl/source/gdi/pdfwriter_impl2.cxx b/vcl/source/gdi/pdfwriter_impl2.cxx
index 84e0ed4..8afd8b7 100644
--- a/vcl/source/gdi/pdfwriter_impl2.cxx
+++ b/vcl/source/gdi/pdfwriter_impl2.cxx
@@ -628,9 +628,9 @@ void PDFWriterImpl::playMetafile( const GDIMetaFile& i_rMtf, vcl::PDFExtOutDevDa
for(sal_uInt16 a(0); a + 1 < nPoints; a++)
{
if(bCurve
- && POLY_NORMAL != aPath.GetFlags(a + 1)
+ && PolyFlags::Normal != aPath.GetFlags(a + 1)
&& a + 2 < nPoints
- && POLY_NORMAL != aPath.GetFlags(a + 2)
+ && PolyFlags::Normal != aPath.GetFlags(a + 2)
&& a + 3 < nPoints)
{
const tools::Polygon aSnippet(4,
diff --git a/vcl/source/gdi/salgdilayout.cxx b/vcl/source/gdi/salgdilayout.cxx
index 4d0746f..28e19b0 100644
--- a/vcl/source/gdi/salgdilayout.cxx
+++ b/vcl/source/gdi/salgdilayout.cxx
@@ -422,7 +422,7 @@ bool SalGraphics::DrawPolyPolygon( const basegfx::B2DPolyPolygon& i_rPolyPolygon
return bRet;
}
-bool SalGraphics::DrawPolyLineBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const sal_uInt8* pFlgAry, const OutputDevice* pOutDev )
+bool SalGraphics::DrawPolyLineBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const PolyFlags* pFlgAry, const OutputDevice* pOutDev )
{
bool bResult = false;
if( (m_nLayout & SalLayoutFlags::BiDiRtl) || (pOutDev && pOutDev->IsRTLEnabled()) )
@@ -436,7 +436,7 @@ bool SalGraphics::DrawPolyLineBezier( sal_uInt32 nPoints, const SalPoint* pPtAry
return bResult;
}
-bool SalGraphics::DrawPolygonBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const sal_uInt8* pFlgAry, const OutputDevice* pOutDev )
+bool SalGraphics::DrawPolygonBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const PolyFlags* pFlgAry, const OutputDevice* pOutDev )
{
bool bResult = false;
if( (m_nLayout & SalLayoutFlags::BiDiRtl) || (pOutDev && pOutDev->IsRTLEnabled()) )
@@ -451,7 +451,7 @@ 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 sal_uInt8* const* i_pFlgAry, const OutputDevice* i_pOutDev )
+ const SalPoint* 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()) )
diff --git a/vcl/source/gdi/svmconverter.cxx b/vcl/source/gdi/svmconverter.cxx
index 6c67903..2eb7630 100644
--- a/vcl/source/gdi/svmconverter.cxx
+++ b/vcl/source/gdi/svmconverter.cxx
@@ -376,7 +376,7 @@ bool ImplWriteExtendedPolyPolygonAction(SvStream& rOStm, const tools::PolyPolygo
for(sal_uInt16 c(0); c < nPointCount; c++)
{
- rOStm.WriteUChar( rCandidate.GetFlags(c) );
+ rOStm.WriteUChar( (sal_uInt8)rCandidate.GetFlags(c) );
}
}
else
diff --git a/vcl/source/outdev/font.cxx b/vcl/source/outdev/font.cxx
index 5763c8e..9b0a5dd 100644
--- a/vcl/source/outdev/font.cxx
+++ b/vcl/source/outdev/font.cxx
@@ -292,9 +292,16 @@ void OutputDevice::ImplGetEmphasisMark( tools::PolyPolygon& rPolyPoly, bool& rPo
FontEmphasisMark eEmphasis,
long nHeight, short /*nOrient*/ )
{
- static const sal_uInt8 aAccentPolyFlags[24] =
+ static const PolyFlags aAccentPolyFlags[24] =
{
- 0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 0, 2, 0, 2, 2
+ PolyFlags::Normal, PolyFlags::Control, PolyFlags::Control,
+ PolyFlags::Normal, PolyFlags::Control, PolyFlags::Control,
+ PolyFlags::Normal, PolyFlags::Control, PolyFlags::Control,
+ PolyFlags::Normal, PolyFlags::Control, PolyFlags::Control,
+ PolyFlags::Normal, PolyFlags::Control, PolyFlags::Control,
+ PolyFlags::Normal, PolyFlags::Control, PolyFlags::Control,
+ PolyFlags::Normal, PolyFlags::Normal, PolyFlags::Control,
+ PolyFlags::Normal, PolyFlags::Control, PolyFlags::Control
};
static const long aAccentPos[48] =
diff --git a/vcl/source/outdev/polygon.cxx b/vcl/source/outdev/polygon.cxx
index 76d9ec6..e20caaf 100644
--- a/vcl/source/outdev/polygon.cxx
+++ b/vcl/source/outdev/polygon.cxx
@@ -226,7 +226,7 @@ void OutputDevice::DrawPolygon( const tools::Polygon& rPoly )
// #100127# Forward beziers to sal, if any
if( aPoly.HasFlags() )
{
- const sal_uInt8* pFlgAry = aPoly.GetConstFlagAry();
+ const PolyFlags* pFlgAry = aPoly.GetConstFlagAry();
if( !mpGraphics->DrawPolygonBezier( nPoints, pPtAry, pFlgAry, this ) )
{
aPoly = tools::Polygon::SubdivideBezier(aPoly);
@@ -339,10 +339,10 @@ void OutputDevice::ImplDrawPolyPolygon( sal_uInt16 nPoly, const tools::PolyPolyg
sal_uInt32 aStackAry1[OUTDEV_POLYPOLY_STACKBUF];
PCONSTSALPOINT aStackAry2[OUTDEV_POLYPOLY_STACKBUF];
- sal_uInt8* aStackAry3[OUTDEV_POLYPOLY_STACKBUF];
+ PolyFlags* aStackAry3[OUTDEV_POLYPOLY_STACKBUF];
sal_uInt32* pPointAry;
- PCONSTSALPOINT* pPointAryAry;
- const sal_uInt8** pFlagAryAry;
+ PCONSTSALPOINT* pPointAryAry;
+ const PolyFlags** pFlagAryAry;
sal_uInt16 i = 0;
sal_uInt16 j = 0;
sal_uInt16 last = 0;
@@ -351,13 +351,13 @@ void OutputDevice::ImplDrawPolyPolygon( sal_uInt16 nPoly, const tools::PolyPolyg
{
pPointAry = new sal_uInt32[nPoly];
pPointAryAry = new PCONSTSALPOINT[nPoly];
- pFlagAryAry = new const sal_uInt8*[nPoly];
+ pFlagAryAry = new const PolyFlags*[nPoly];
}
else
{
pPointAry = aStackAry1;
pPointAryAry = aStackAry2;
- pFlagAryAry = const_cast<const sal_uInt8**>(aStackAry3);
+ pFlagAryAry = const_cast<const PolyFlags**>(aStackAry3);
}
do
diff --git a/vcl/source/outdev/polyline.cxx b/vcl/source/outdev/polyline.cxx
index b3e4780..c69621b 100644
--- a/vcl/source/outdev/polyline.cxx
+++ b/vcl/source/outdev/polyline.cxx
@@ -91,7 +91,7 @@ void OutputDevice::DrawPolyLine( const tools::Polygon& rPoly )
// #100127# Forward beziers to sal, if any
if( aPoly.HasFlags() )
{
- const sal_uInt8* pFlgAry = aPoly.GetConstFlagAry();
+ const PolyFlags* pFlgAry = aPoly.GetConstFlagAry();
if( !mpGraphics->DrawPolyLineBezier( nPoints, pPtAry, pFlgAry, this ) )
{
aPoly = tools::Polygon::SubdivideBezier(aPoly);
diff --git a/vcl/unx/generic/gdi/gdiimpl.cxx b/vcl/unx/generic/gdi/gdiimpl.cxx
index 4e367a6..134ef02 100644
--- a/vcl/unx/generic/gdi/gdiimpl.cxx
+++ b/vcl/unx/generic/gdi/gdiimpl.cxx
@@ -1386,18 +1386,18 @@ void X11SalGraphicsImpl::drawPolyPolygon( sal_uInt32 nPoly,
drawPolyLine( pPoints[i], pPtAry[i], true );
}
-bool X11SalGraphicsImpl::drawPolyLineBezier( sal_uInt32, const SalPoint*, const sal_uInt8* )
+bool X11SalGraphicsImpl::drawPolyLineBezier( sal_uInt32, const SalPoint*, const PolyFlags* )
{
return false;
}
-bool X11SalGraphicsImpl::drawPolygonBezier( sal_uInt32, const SalPoint*, const sal_uInt8* )
+bool X11SalGraphicsImpl::drawPolygonBezier( sal_uInt32, const SalPoint*, const PolyFlags* )
{
return false;
}
bool X11SalGraphicsImpl::drawPolyPolygonBezier( sal_uInt32, const sal_uInt32*,
- const SalPoint* const*, const sal_uInt8* const* )
+ const SalPoint* const*, const PolyFlags* const* )
{
return false;
}
diff --git a/vcl/unx/generic/gdi/gdiimpl.hxx b/vcl/unx/generic/gdi/gdiimpl.hxx
index 84e5ee8..b277b9a 100644
--- a/vcl/unx/generic/gdi/gdiimpl.hxx
+++ b/vcl/unx/generic/gdi/gdiimpl.hxx
@@ -170,18 +170,18 @@ public:
virtual bool drawPolyLineBezier(
sal_uInt32 nPoints,
const SalPoint* pPtAry,
- const sal_uInt8* pFlgAry ) override;
+ const PolyFlags* pFlgAry ) override;
virtual bool drawPolygonBezier(
sal_uInt32 nPoints,
const SalPoint* pPtAry,
- const sal_uInt8* pFlgAry ) override;
+ const PolyFlags* pFlgAry ) override;
virtual bool drawPolyPolygonBezier(
sal_uInt32 nPoly,
const sal_uInt32* pPoints,
const SalPoint* const* pPtAry,
- const sal_uInt8* const* pFlgAry ) override;
+ const PolyFlags* const* pFlgAry ) override;
// CopyArea --> No RasterOp, but ClipRegion
virtual void copyArea(
diff --git a/vcl/unx/generic/gdi/salgdi.cxx b/vcl/unx/generic/gdi/salgdi.cxx
index 915ff37..a7c7df8 100644
--- a/vcl/unx/generic/gdi/salgdi.cxx
+++ b/vcl/unx/generic/gdi/salgdi.cxx
@@ -448,18 +448,18 @@ void X11SalGraphics::drawPolyPolygon( sal_uInt32 nPoly,
mxImpl->drawPolyPolygon( nPoly, pPoints, pPtAry );
}
-bool X11SalGraphics::drawPolyLineBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const sal_uInt8* pFlgAry )
+bool X11SalGraphics::drawPolyLineBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const PolyFlags* pFlgAry )
{
return mxImpl->drawPolyLineBezier( nPoints, pPtAry, pFlgAry );
}
-bool X11SalGraphics::drawPolygonBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const sal_uInt8* pFlgAry )
+bool X11SalGraphics::drawPolygonBezier( sal_uInt32 nPoints, const SalPoint* 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 sal_uInt8* const* pFlgAry)
+ const SalPoint* const* pPtAry, const PolyFlags* const* pFlgAry)
{
return mxImpl->drawPolyPolygonBezier( nPoints, pPoints, pPtAry, pFlgAry );
}
diff --git a/vcl/unx/generic/glyphs/freetype_glyphcache.cxx b/vcl/unx/generic/glyphs/freetype_glyphcache.cxx
index 0d19d82..36b262f 100644
--- a/vcl/unx/generic/glyphs/freetype_glyphcache.cxx
+++ b/vcl/unx/generic/glyphs/freetype_glyphcache.cxx
@@ -862,14 +862,14 @@ public:
private:
tools::PolyPolygon& mrPolyPoly;
- Point* mpPointAry;
- sal_uInt8* mpFlagAry;
+ Point* mpPointAry;
+ PolyFlags* mpFlagAry;
- FT_Vector maPosition;
+ FT_Vector maPosition;
sal_uInt16 mnMaxPoints;
sal_uInt16 mnPoints;
sal_uInt16 mnPoly;
- bool bHasOffline;
+ bool bHasOffline;
PolyArgs(const PolyArgs&) = delete;
PolyArgs& operator=(const PolyArgs&) = delete;
@@ -883,7 +883,7 @@ PolyArgs::PolyArgs( tools::PolyPolygon& rPolyPoly, sal_uInt16 nMaxPoints )
bHasOffline(false)
{
mpPointAry = new Point[ mnMaxPoints ];
- mpFlagAry = new sal_uInt8 [ mnMaxPoints ];
+ mpFlagAry = new PolyFlags [ mnMaxPoints ];
maPosition.x = maPosition.y = 0;
}
@@ -903,7 +903,7 @@ void PolyArgs::AddPoint( long nX, long nY, PolyFlags aFlag )
maPosition.y = nY;
mpPointAry[ mnPoints ] = Point( nX, nY );
mpFlagAry[ mnPoints++ ]= aFlag;
- bHasOffline |= (aFlag != POLY_NORMAL);
+ bHasOffline |= (aFlag != PolyFlags::Normal);
}
void PolyArgs::ClosePolygon()
@@ -916,8 +916,8 @@ void PolyArgs::ClosePolygon()
SAL_WARN_IF( (mnPoints < 2), "vcl", "FTGlyphOutline: PolyFinishNum failed!" );
--mnPoints;
SAL_WARN_IF( (mpPointAry[0]!=mpPointAry[mnPoints]), "vcl", "FTGlyphOutline: PolyFinishEq failed!" );
- SAL_WARN_IF( (mpFlagAry[0]!=POLY_NORMAL), "vcl", "FTGlyphOutline: PolyFinishFE failed!" );
- SAL_WARN_IF( (mpFlagAry[mnPoints]!=POLY_NORMAL), "vcl", "FTGlyphOutline: PolyFinishFS failed!" );
+ SAL_WARN_IF( (mpFlagAry[0]!=PolyFlags::Normal), "vcl", "FTGlyphOutline: PolyFinishFE failed!" );
+ SAL_WARN_IF( (mpFlagAry[mnPoints]!=PolyFlags::Normal), "vcl", "FTGlyphOutline: PolyFinishFS failed!" );
tools::Polygon aPoly( mnPoints, mpPointAry, (bHasOffline ? mpFlagAry : nullptr) );
@@ -928,11 +928,11 @@ void PolyArgs::ClosePolygon()
// #i48298#
// Now really duplicating the first point, to close or correct the
// polygon. Also no longer duplicating the flags, but enforcing
- // POLY_NORMAL for the newly added last point.
+ // PolyFlags::Normal for the newly added last point.
const sal_uInt16 nPolySize(aPoly.GetSize());
if(nPolySize)
{
- if((aPoly.HasFlags() && POLY_CONTROL == aPoly.GetFlags(nPolySize - 1))
+ if((aPoly.HasFlags() && PolyFlags::Control == aPoly.GetFlags(nPolySize - 1))
|| (aPoly.GetPoint(nPolySize - 1) != aPoly.GetPoint(0)))
{
aPoly.SetSize(nPolySize + 1);
@@ -940,7 +940,7 @@ void PolyArgs::ClosePolygon()
if(aPoly.HasFlags())
{
- aPoly.SetFlags(nPolySize, POLY_NORMAL);
+ aPoly.SetFlags(nPolySize, PolyFlags::Normal);
}
}
}
@@ -962,14 +962,14 @@ static int FT_move_to( const FT_Vector* p0, void* vpPolyArgs )
// move_to implies a new polygon => finish old polygon first
rA.ClosePolygon();
- rA.AddPoint( p0->x, p0->y, POLY_NORMAL );
+ rA.AddPoint( p0->x, p0->y, PolyFlags::Normal );
return 0;
}
static int FT_line_to( const FT_Vector* p1, void* vpPolyArgs )
{
PolyArgs& rA = *static_cast<PolyArgs*>(vpPolyArgs);
- rA.AddPoint( p1->x, p1->y, POLY_NORMAL );
+ rA.AddPoint( p1->x, p1->y, PolyFlags::Normal );
return 0;
}
@@ -980,22 +980,22 @@ static int FT_conic_to( const FT_Vector* p1, const FT_Vector* p2, void* vpPolyAr
// VCL's Polygon only knows cubic beziers
const long nX1 = (2 * rA.GetPosX() + 4 * p1->x + 3) / 6;
const long nY1 = (2 * rA.GetPosY() + 4 * p1->y + 3) / 6;
- rA.AddPoint( nX1, nY1, POLY_CONTROL );
+ rA.AddPoint( nX1, nY1, PolyFlags::Control );
const long nX2 = (2 * p2->x + 4 * p1->x + 3) / 6;
const long nY2 = (2 * p2->y + 4 * p1->y + 3) / 6;
- rA.AddPoint( nX2, nY2, POLY_CONTROL );
+ rA.AddPoint( nX2, nY2, PolyFlags::Control );
- rA.AddPoint( p2->x, p2->y, POLY_NORMAL );
+ rA.AddPoint( p2->x, p2->y, PolyFlags::Normal );
return 0;
}
static int FT_cubic_to( const FT_Vector* p1, const FT_Vector* p2, const FT_Vector* p3, void* vpPolyArgs )
{
PolyArgs& rA = *static_cast<PolyArgs*>(vpPolyArgs);
- rA.AddPoint( p1->x, p1->y, POLY_CONTROL );
- rA.AddPoint( p2->x, p2->y, POLY_CONTROL );
- rA.AddPoint( p3->x, p3->y, POLY_NORMAL );
+ rA.AddPoint( p1->x, p1->y, PolyFlags::Control );
+ rA.AddPoint( p2->x, p2->y, PolyFlags::Control );
+ rA.AddPoint( p3->x, p3->y, PolyFlags::Normal );
return 0;
}
diff --git a/vcl/unx/generic/print/common_gfx.cxx b/vcl/unx/generic/print/common_gfx.cxx
index b771073..793bd3c 100644
--- a/vcl/unx/generic/print/common_gfx.cxx
+++ b/vcl/unx/generic/print/common_gfx.cxx
@@ -477,7 +477,7 @@ PrinterGfx::DrawPolyPolygon (sal_uInt32 nPoly, const sal_uInt32* pSizes, const P
*/
void
-PrinterGfx::DrawPolyLineBezier (sal_uInt32 nPoints, const Point* pPath, const sal_uInt8* pFlgAry)
+PrinterGfx::DrawPolyLineBezier (sal_uInt32 nPoints, const Point* pPath, const PolyFlags* pFlgAry)
{
const sal_uInt32 nBezString= 1024;
sal_Char pString[nBezString];
@@ -496,7 +496,7 @@ PrinterGfx::DrawPolyLineBezier (sal_uInt32 nPoints, const Point* pPath, const sa
// - a normal point followed by 2 control points and a normal point is a curve
for (unsigned int i=1; i<nPoints;)
{
- if (pFlgAry[i] != POLY_CONTROL) //If the next point is a POLY_NORMAL, we're drawing a line
+ if (pFlgAry[i] != PolyFlags::Control) //If the next point is a PolyFlags::Normal, we're drawing a line
{
snprintf(pString, nBezString, "%li %li lineto\n", pPath[i].X(), pPath[i].Y());
i++;
@@ -505,8 +505,8 @@ PrinterGfx::DrawPolyLineBezier (sal_uInt32 nPoints, const Point* pPath, const sa
{
if (i+2 >= nPoints)
return; //Error: wrong sequence of contol/normal points somehow
- if ((pFlgAry[i] == POLY_CONTROL) && (pFlgAry[i+1] == POLY_CONTROL) &&
- (pFlgAry[i+2] != POLY_CONTROL))
+ if ((pFlgAry[i] == PolyFlags::Control) && (pFlgAry[i+1] == PolyFlags::Control) &&
+ (pFlgAry[i+2] != PolyFlags::Control))
{
snprintf(pString, nBezString, "%li %li %li %li %li %li curveto\n",
pPath[i].X(), pPath[i].Y(),
@@ -528,7 +528,7 @@ PrinterGfx::DrawPolyLineBezier (sal_uInt32 nPoints, const Point* pPath, const sa
}
void
-PrinterGfx::DrawPolygonBezier (sal_uInt32 nPoints, const Point* pPath, const sal_uInt8* pFlgAry)
+PrinterGfx::DrawPolygonBezier (sal_uInt32 nPoints, const Point* pPath, const PolyFlags* pFlgAry)
{
const sal_uInt32 nBezString = 1024;
sal_Char pString[nBezString];
@@ -540,7 +540,7 @@ PrinterGfx::DrawPolygonBezier (sal_uInt32 nPoints, const Point* pPath, const sal
WritePS(mpPageBody, pString); //Move to the starting point for the PolyPoygon
for (unsigned int i=1; i < nPoints;)
{
- if (pFlgAry[i] != POLY_CONTROL)
+ if (pFlgAry[i] != PolyFlags::Control)
{
snprintf(pString, nBezString, "%li %li lineto\n", pPath[i].X(), pPath[i].Y());
WritePS(mpPageBody, pString);
@@ -550,8 +550,8 @@ PrinterGfx::DrawPolygonBezier (sal_uInt32 nPoints, const Point* pPath, const sal
{
if (i+2 >= nPoints)
return; //Error: wrong sequence of contol/normal points somehow
- if ((pFlgAry[i] == POLY_CONTROL) && (pFlgAry[i+1] == POLY_CONTROL) &&
- (pFlgAry[i+2] != POLY_CONTROL))
+ if ((pFlgAry[i] == PolyFlags::Control) && (pFlgAry[i+1] == PolyFlags::Control) &&
+ (pFlgAry[i+2] != PolyFlags::Control))
{
snprintf(pString, nBezString, "%li %li %li %li %li %li curveto\n",
pPath[i].X(), pPath[i].Y(),
@@ -584,7 +584,7 @@ PrinterGfx::DrawPolygonBezier (sal_uInt32 nPoints, const Point* pPath, const sal
}
void
-PrinterGfx::DrawPolyPolygonBezier (sal_uInt32 nPoly, const sal_uInt32 * pPoints, const Point* const * pPtAry, const sal_uInt8* const* pFlgAry)
+PrinterGfx::DrawPolyPolygonBezier (sal_uInt32 nPoly, const sal_uInt32 * pPoints, const Point* const * pPtAry, const PolyFlags* const* pFlgAry)
{
const sal_uInt32 nBezString = 1024;
sal_Char pString[nBezString];
@@ -604,7 +604,7 @@ PrinterGfx::DrawPolyPolygonBezier (sal_uInt32 nPoly, const sal_uInt32 * pPoints,
{
// if no flag array exists for this polygon, then it must be a regular
// polygon without beziers
- if ( ! pFlgAry[i] || pFlgAry[i][j] != POLY_CONTROL)
+ if ( ! pFlgAry[i] || pFlgAry[i][j] != PolyFlags::Control)
{
snprintf(pString, nBezString, "%li %li lineto\n", pPtAry[i][j].X(), pPtAry[i][j].Y());
WritePS(mpPageBody, pString);
@@ -614,7 +614,7 @@ PrinterGfx::DrawPolyPolygonBezier (sal_uInt32 nPoly, const sal_uInt32 * pPoints,
{
if (j+2 >= nPoints)
break; //Error: wrong sequence of contol/normal points somehow
- if ((pFlgAry[i][j] == POLY_CONTROL) && (pFlgAry[i][j+1] == POLY_CONTROL) && (pFlgAry[i][j+2] != POLY_CONTROL))
+ if ((pFlgAry[i][j] == PolyFlags::Control) && (pFlgAry[i][j+1] == PolyFlags::Control) && (pFlgAry[i][j+2] != PolyFlags::Control))
{
snprintf(pString, nBezString, "%li %li %li %li %li %li curveto\n",
pPtAry[i][j].X(), pPtAry[i][j].Y(),
diff --git a/vcl/unx/generic/print/genpspgraphics.cxx b/vcl/unx/generic/print/genpspgraphics.cxx
index 3788768..b1e4435 100644
--- a/vcl/unx/generic/print/genpspgraphics.cxx
+++ b/vcl/unx/generic/print/genpspgraphics.cxx
@@ -439,13 +439,13 @@ bool GenPspGraphics::drawPolyLine(
return false;
}
-bool GenPspGraphics::drawPolyLineBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const sal_uInt8* pFlgAry )
+bool GenPspGraphics::drawPolyLineBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const PolyFlags* pFlgAry )
{
m_pPrinterGfx->DrawPolyLineBezier (nPoints, reinterpret_cast<Point const *>(pPtAry), pFlgAry);
return true;
}
-bool GenPspGraphics::drawPolygonBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const sal_uInt8* pFlgAry )
+bool GenPspGraphics::drawPolygonBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const PolyFlags* pFlgAry )
{
m_pPrinterGfx->DrawPolygonBezier (nPoints, reinterpret_cast<Point const *>(pPtAry), pFlgAry);
return true;
@@ -454,7 +454,7 @@ bool GenPspGraphics::drawPolygonBezier( sal_uInt32 nPoints, const SalPoint* pPtA
bool GenPspGraphics::drawPolyPolygonBezier( sal_uInt32 nPoly,
const sal_uInt32* pPoints,
const SalPoint* const* pPtAry,
- const sal_uInt8* const* pFlgAry )
+ 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);
diff --git a/vcl/win/gdi/gdiimpl.cxx b/vcl/win/gdi/gdiimpl.cxx
index 82c03ff..9c05466 100644
--- a/vcl/win/gdi/gdiimpl.cxx
+++ b/vcl/win/gdi/gdiimpl.cxx
@@ -74,7 +74,7 @@
namespace {
// #100127# draw an array of points which might also contain bezier control points
-void ImplRenderPath( HDC hdc, sal_uLong nPoints, const SalPoint* pPtAry, const BYTE* pFlgAry )
+void ImplRenderPath( HDC hdc, sal_uLong nPoints, const SalPoint* pPtAry, const PolyFlags* pFlgAry )
{
if( nPoints )
{
@@ -88,7 +88,7 @@ void ImplRenderPath( HDC hdc, sal_uLong nPoints, const SalPoint* pPtAry, const B
for( i=1; i<nPoints; ++i, ++pPtAry, ++pFlgAry )
{
- if( *pFlgAry != POLY_CONTROL )
+ if( *pFlgAry != PolyFlags::Control )
{
LineTo( hdc, pPtAry->mnX, pPtAry->mnY );
}
@@ -105,10 +105,10 @@ void ImplRenderPath( HDC hdc, sal_uLong nPoints, const SalPoint* pPtAry, const B
// might also contain bezier control points for the PolyDraw() GDI method
// Make sure pWinPointAry and pWinFlagAry are big enough
void ImplPreparePolyDraw( bool bCloseFigures,
- sal_uLong nPoly,
+ sal_uLong nPoly,
const sal_uInt32* pPoints,
const SalPoint* const* pPtAry,
- const BYTE* const* pFlgAry,
+ const PolyFlags* const* pFlgAry,
POINT* pWinPointAry,
BYTE* pWinFlagAry )
{
@@ -116,7 +116,7 @@ void ImplPreparePolyDraw( bool bCloseFigures,
for( nCurrPoly=0; nCurrPoly<nPoly; ++nCurrPoly )
{
const POINT* pCurrPoint = reinterpret_cast<const POINT*>( *pPtAry++ );
... etc. - the rest is truncated
More information about the Libreoffice-commits
mailing list