convert HANDLE_FLAGS constants to scoped enum

Change-Id: Ie6751bc97914e4b8ac1fe00aae41c02fff2773d9

2 files changed, 52 insertions, 43 deletions

diff --git a/include/svx/EnhancedCustomShape2d.hxx b/include/svx/EnhancedCustomShape2d.hxx
index 547fe6f98142..b9ed6f2b937c 100644
--- a/include/svx/EnhancedCustomShape2d.hxx
+++ b/include/svx/EnhancedCustomShape2d.hxx
@@ -34,6 +34,7 @@
 #include <com/sun/star/drawing/EnhancedCustomShapeAdjustmentValue.hpp>
 #include <svx/EnhancedCustomShapeFunctionParser.hxx>
 #include <tools/gen.hxx>
+#include <o3tl/typed_flags_set.hxx>
 
 #include <memory>
 #include <vector>
@@ -45,20 +46,28 @@ struct SvxMSDffVertPair;
 struct SvxMSDffCalculationData;
 struct SvxMSDffTextRectangles;
 
-#define HANDLE_FLAGS_MIRRORED_X             0x0001
-#define HANDLE_FLAGS_MIRRORED_Y             0x0002
-#define HANDLE_FLAGS_SWITCHED               0x0004
-#define HANDLE_FLAGS_POLAR                  0x0008
-#define HANDLE_FLAGS_RANGE_X_MINIMUM        0x0020
-#define HANDLE_FLAGS_RANGE_X_MAXIMUM        0x0040
-#define HANDLE_FLAGS_RANGE_Y_MINIMUM        0x0080
-#define HANDLE_FLAGS_RANGE_Y_MAXIMUM        0x0100
-#define HANDLE_FLAGS_RADIUS_RANGE_MINIMUM   0x0200
-#define HANDLE_FLAGS_RADIUS_RANGE_MAXIMUM   0x0400
-#define HANDLE_FLAGS_REFX                   0x0800
-#define HANDLE_FLAGS_REFY                   0x1000
-#define HANDLE_FLAGS_REFANGLE               0x2000
-#define HANDLE_FLAGS_REFR                   0x4000
+enum class HandleFlags
+{
+    NONE                   = 0x0000,
+    MIRRORED_X             = 0x0001,
+    MIRRORED_Y             = 0x0002,
+    SWITCHED               = 0x0004,
+    POLAR                  = 0x0008,
+    RANGE_X_MINIMUM        = 0x0020,
+    RANGE_X_MAXIMUM        = 0x0040,
+    RANGE_Y_MINIMUM        = 0x0080,
+    RANGE_Y_MAXIMUM        = 0x0100,
+    RADIUS_RANGE_MINIMUM   = 0x0200,
+    RADIUS_RANGE_MAXIMUM   = 0x0400,
+    REFX                   = 0x0800,
+    REFY                   = 0x1000,
+    REFANGLE               = 0x2000,
+    REFR                   = 0x4000,
+};
+namespace o3tl
+{
+    template<> struct typed_flags<HandleFlags> : is_typed_flags<HandleFlags, 0x7fef> {};
+}
 
 // MSDFF_HANDLE_FLAGS_RANGE_Y seems to be not defined in
 // escher, but we are using it internally in to differentiate
@@ -139,7 +148,7 @@ class SVX_DLLPUBLIC EnhancedCustomShape2d : public SfxItemSet
 
         struct SAL_DLLPRIVATE Handle
         {
-            sal_uInt32  nFlags;
+            HandleFlags nFlags;
 
             bool        bMirroredX;
             bool        bMirroredY;
@@ -161,7 +170,7 @@ class SVX_DLLPUBLIC EnhancedCustomShape2d : public SfxItemSet
             com::sun::star::drawing::EnhancedCustomShapeParameter       aYRangeMaximum;
 
             Handle()
-                : nFlags(0)
+                : nFlags(HandleFlags::NONE)
                 , bMirroredX ( false )
                 , bMirroredY ( false )
                 , bSwitched( false )
diff --git a/svx/source/customshapes/EnhancedCustomShape2d.cxx b/svx/source/customshapes/EnhancedCustomShape2d.cxx
index 8bf41478447d..a015e8c78d5a 100644
--- a/svx/source/customshapes/EnhancedCustomShape2d.cxx
+++ b/svx/source/customshapes/EnhancedCustomShape2d.cxx
@@ -438,7 +438,7 @@ bool EnhancedCustomShape2d::ConvertSequenceToEnhancedCustomShape2dHandle(
     sal_uInt32 i, nProperties = rHandleProperties.getLength();
     if ( nProperties )
     {
-        rDestinationHandle.nFlags = 0;
+        rDestinationHandle.nFlags = HandleFlags::NONE;
         for ( i = 0; i < nProperties; i++ )
         {
             const com::sun::star::beans::PropertyValue& rPropVal = rHandleProperties[ i ];
@@ -454,7 +454,7 @@ bool EnhancedCustomShape2d::ConvertSequenceToEnhancedCustomShape2dHandle(
                 if ( rPropVal.Value >>= bMirroredX )
                 {
                     if ( bMirroredX )
-                        rDestinationHandle.nFlags |= HANDLE_FLAGS_MIRRORED_X;
+                        rDestinationHandle.nFlags |= HandleFlags::MIRRORED_X;
                 }
             }
             else if ( rPropVal.Name == "MirroredY" )
@@ -463,7 +463,7 @@ bool EnhancedCustomShape2d::ConvertSequenceToEnhancedCustomShape2dHandle(
                 if ( rPropVal.Value >>= bMirroredY )
                 {
                     if ( bMirroredY )
-                        rDestinationHandle.nFlags |= HANDLE_FLAGS_MIRRORED_Y;
+                        rDestinationHandle.nFlags |= HandleFlags::MIRRORED_Y;
                 }
             }
             else if ( rPropVal.Name == "Switched" )
@@ -472,63 +472,63 @@ bool EnhancedCustomShape2d::ConvertSequenceToEnhancedCustomShape2dHandle(
                 if ( rPropVal.Value >>= bSwitched )
                 {
                     if ( bSwitched )
-                        rDestinationHandle.nFlags |= HANDLE_FLAGS_SWITCHED;
+                        rDestinationHandle.nFlags |= HandleFlags::SWITCHED;
                 }
             }
             else if ( rPropVal.Name == "Polar" )
             {
                 if ( rPropVal.Value >>= rDestinationHandle.aPolar )
-                    rDestinationHandle.nFlags |= HANDLE_FLAGS_POLAR;
+                    rDestinationHandle.nFlags |= HandleFlags::POLAR;
             }
             else if ( rPropVal.Name == "RefX" )
             {
                 if ( rPropVal.Value >>= rDestinationHandle.nRefX )
-                    rDestinationHandle.nFlags |= HANDLE_FLAGS_REFX;
+                    rDestinationHandle.nFlags |= HandleFlags::REFX;
             }
             else if ( rPropVal.Name == "RefY" )
             {
                 if ( rPropVal.Value >>= rDestinationHandle.nRefY )
-                    rDestinationHandle.nFlags |= HANDLE_FLAGS_REFY;
+                    rDestinationHandle.nFlags |= HandleFlags::REFY;
             }
             else if ( rPropVal.Name == "RefAngle" )
             {
                 if ( rPropVal.Value >>= rDestinationHandle.nRefAngle )
-                    rDestinationHandle.nFlags |= HANDLE_FLAGS_REFANGLE;
+                    rDestinationHandle.nFlags |= HandleFlags::REFANGLE;
             }
             else if ( rPropVal.Name == "RefR" )
             {
                 if ( rPropVal.Value >>= rDestinationHandle.nRefR )
-                    rDestinationHandle.nFlags |= HANDLE_FLAGS_REFR;
+                    rDestinationHandle.nFlags |= HandleFlags::REFR;
             }
             else if ( rPropVal.Name == "RadiusRangeMinimum" )
             {
                 if ( rPropVal.Value >>= rDestinationHandle.aRadiusRangeMinimum )
-                    rDestinationHandle.nFlags |= HANDLE_FLAGS_RADIUS_RANGE_MINIMUM;
+                    rDestinationHandle.nFlags |= HandleFlags::RADIUS_RANGE_MINIMUM;
             }
             else if ( rPropVal.Name == "RadiusRangeMaximum" )
             {
                 if ( rPropVal.Value >>= rDestinationHandle.aRadiusRangeMaximum )
-                    rDestinationHandle.nFlags |= HANDLE_FLAGS_RADIUS_RANGE_MAXIMUM;
+                    rDestinationHandle.nFlags |= HandleFlags::RADIUS_RANGE_MAXIMUM;
             }
             else if ( rPropVal.Name == "RangeXMinimum" )
             {
                 if ( rPropVal.Value >>= rDestinationHandle.aXRangeMinimum )
-                    rDestinationHandle.nFlags |= HANDLE_FLAGS_RANGE_X_MINIMUM;
+                    rDestinationHandle.nFlags |= HandleFlags::RANGE_X_MINIMUM;
             }
             else if ( rPropVal.Name == "RangeXMaximum" )
             {
                 if ( rPropVal.Value >>= rDestinationHandle.aXRangeMaximum )
-                    rDestinationHandle.nFlags |= HANDLE_FLAGS_RANGE_X_MAXIMUM;
+                    rDestinationHandle.nFlags |= HandleFlags::RANGE_X_MAXIMUM;
             }
             else if ( rPropVal.Name == "RangeYMinimum" )
             {
                 if ( rPropVal.Value >>= rDestinationHandle.aYRangeMinimum )
-                    rDestinationHandle.nFlags |= HANDLE_FLAGS_RANGE_Y_MINIMUM;
+                    rDestinationHandle.nFlags |= HandleFlags::RANGE_Y_MINIMUM;
             }
             else if ( rPropVal.Name == "RangeYMaximum" )
             {
                 if ( rPropVal.Value >>= rDestinationHandle.aYRangeMaximum )
-                    rDestinationHandle.nFlags |= HANDLE_FLAGS_RANGE_Y_MAXIMUM;
+                    rDestinationHandle.nFlags |= HandleFlags::RANGE_Y_MAXIMUM;
             }
         }
     }
@@ -1143,7 +1143,7 @@ bool EnhancedCustomShape2d::GetHandlePosition( const sal_uInt32 nIndex, Point& r
         Handle aHandle;
         if ( ConvertSequenceToEnhancedCustomShape2dHandle( seqHandles[ nIndex ], aHandle ) )
         {
-            if ( aHandle.nFlags & HANDLE_FLAGS_POLAR )
+            if ( aHandle.nFlags & HandleFlags::POLAR )
             {
                 Point aReferencePoint( GetPoint( aHandle.aPolar, true, false ) );
 
@@ -1164,7 +1164,7 @@ bool EnhancedCustomShape2d::GetHandlePosition( const sal_uInt32 nIndex, Point& r
             }
             else
             {
-                if ( aHandle.nFlags & HANDLE_FLAGS_SWITCHED )
+                if ( aHandle.nFlags & HandleFlags::SWITCHED )
                 {
                     if ( aLogicRect.GetHeight() > aLogicRect.GetWidth() )
                     {
@@ -1235,7 +1235,7 @@ bool EnhancedCustomShape2d::SetHandleControllerPosition( const sal_uInt32 nIndex
             fPos1 /= fXScale;
             fPos2 /= fYScale;
 
-            if ( aHandle.nFlags & HANDLE_FLAGS_SWITCHED )
+            if ( aHandle.nFlags & HandleFlags::SWITCHED )
             {
                 if ( aLogicRect.GetHeight() > aLogicRect.GetWidth() )
                 {
@@ -1253,7 +1253,7 @@ bool EnhancedCustomShape2d::SetHandleControllerPosition( const sal_uInt32 nIndex
             if ( aHandle.aPosition.Second.Type == EnhancedCustomShapeParameterType::ADJUSTMENT )
                 aHandle.aPosition.Second.Value>>= nSecondAdjustmentValue;
 
-            if ( aHandle.nFlags & HANDLE_FLAGS_POLAR )
+            if ( aHandle.nFlags & HandleFlags::POLAR )
             {
                 double fXRef, fYRef, fAngle;
                 GetParameter( fXRef, aHandle.aPolar.First, false, false );
@@ -1263,14 +1263,14 @@ bool EnhancedCustomShape2d::SetHandleControllerPosition( const sal_uInt32 nIndex
                 double fX = ( fPos1 - fXRef );
                 double fY = ( fPos2 - fYRef );
                 double fRadius = sqrt( fX * fX + fY * fY );
-                if ( aHandle.nFlags & HANDLE_FLAGS_RADIUS_RANGE_MINIMUM )
+                if ( aHandle.nFlags & HandleFlags::RADIUS_RANGE_MINIMUM )
                 {
                     double fMin;
                     GetParameter( fMin,  aHandle.aRadiusRangeMinimum, false, false );
                     if ( fRadius < fMin )
                         fRadius = fMin;
                 }
-                if ( aHandle.nFlags & HANDLE_FLAGS_RADIUS_RANGE_MAXIMUM )
+                if ( aHandle.nFlags & HandleFlags::RADIUS_RANGE_MAXIMUM )
                 {
                     double fMax;
                     GetParameter( fMax, aHandle.aRadiusRangeMaximum, false, false );
@@ -1284,13 +1284,13 @@ bool EnhancedCustomShape2d::SetHandleControllerPosition( const sal_uInt32 nIndex
             }
             else
             {
-                if ( aHandle.nFlags & HANDLE_FLAGS_REFX )
+                if ( aHandle.nFlags & HandleFlags::REFX )
                 {
                     nFirstAdjustmentValue = aHandle.nRefX;
                     fPos1 *= 100000.0;
                     fPos1 /= nCoordWidth;
                 }
-                if ( aHandle.nFlags & HANDLE_FLAGS_REFY )
+                if ( aHandle.nFlags & HandleFlags::REFY )
                 {
                     nSecondAdjustmentValue = aHandle.nRefY;
                     fPos2 *= 100000.0;
@@ -1298,14 +1298,14 @@ bool EnhancedCustomShape2d::SetHandleControllerPosition( const sal_uInt32 nIndex
                 }
                 if ( nFirstAdjustmentValue >= 0 )
                 {
-                    if ( aHandle.nFlags & HANDLE_FLAGS_RANGE_X_MINIMUM )        // check if horizontal handle needs to be within a range
+                    if ( aHandle.nFlags & HandleFlags::RANGE_X_MINIMUM )        // check if horizontal handle needs to be within a range
                     {
                         double fXMin;
                         GetParameter( fXMin, aHandle.aXRangeMinimum, false, false );
                         if ( fPos1 < fXMin )
                             fPos1 = fXMin;
                     }
-                    if ( aHandle.nFlags & HANDLE_FLAGS_RANGE_X_MAXIMUM )        // check if horizontal handle needs to be within a range
+                    if ( aHandle.nFlags & HandleFlags::RANGE_X_MAXIMUM )        // check if horizontal handle needs to be within a range
                     {
                         double fXMax;
                         GetParameter( fXMax, aHandle.aXRangeMaximum, false, false );
@@ -1316,14 +1316,14 @@ bool EnhancedCustomShape2d::SetHandleControllerPosition( const sal_uInt32 nIndex
                 }
                 if ( nSecondAdjustmentValue >= 0 )
                 {
-                    if ( aHandle.nFlags & HANDLE_FLAGS_RANGE_Y_MINIMUM )        // check if vertical handle needs to be within a range
+                    if ( aHandle.nFlags & HandleFlags::RANGE_Y_MINIMUM )        // check if vertical handle needs to be within a range
                     {
                         double fYMin;
                         GetParameter( fYMin, aHandle.aYRangeMinimum, false, false );
                         if ( fPos2 < fYMin )
                             fPos2 = fYMin;
                     }
-                    if ( aHandle.nFlags & HANDLE_FLAGS_RANGE_Y_MAXIMUM )        // check if vertical handle needs to be within a range
+                    if ( aHandle.nFlags & HandleFlags::RANGE_Y_MAXIMUM )        // check if vertical handle needs to be within a range
                     {
                         double fYMax;
                         GetParameter( fYMax, aHandle.aYRangeMaximum, false, false );