convert SDR*ALIGN constants to scoped enum

Change-Id: I29b7b4fe1181133cbbb0bb43a1835941cf12210d

2 files changed, 49 insertions, 38 deletions

diff --git a/svx/source/svdraw/svdglev.cxx b/svx/source/svdraw/svdglev.cxx
index 3492f47e076c..7f2faba3fa0e 100644
--- a/svx/source/svdraw/svdglev.cxx
+++ b/svx/source/svdraw/svdglev.cxx
@@ -169,11 +169,11 @@ void SdrGlueEditView::SetMarkedGluePointsPercent(bool bOn)
 
 static void ImpGetAlign(SdrGluePoint& rGP, const SdrObject* /*pObj*/, const void* pbFirst, const void* pbDontCare, const void* pbVert, const void* pnRet, const void*)
 {
-    sal_uInt16& nRet=*const_cast<sal_uInt16 *>(static_cast<sal_uInt16 const *>(pnRet));
+    SdrAlign& nRet=*const_cast<SdrAlign *>(static_cast<SdrAlign const *>(pnRet));
     bool& bDontCare=*const_cast<bool *>(static_cast<bool const *>(pbDontCare));
     bool bVert=*static_cast<bool const *>(pbVert);
     if (!bDontCare) {
-        sal_uInt16 nAlg=0;
+        SdrAlign nAlg=SdrAlign::NONE;
         if (bVert) {
             nAlg=rGP.GetVertAlign();
         } else {
@@ -183,21 +183,21 @@ static void ImpGetAlign(SdrGluePoint& rGP, const SdrObject* /*pObj*/, const void
         if (bFirst) { nRet=nAlg; bFirst=false; }
         else if (nRet!=nAlg) {
             if (bVert) {
-                nRet=SDRVERTALIGN_DONTCARE;
+                nRet=SdrAlign::VERT_DONTCARE;
             } else {
-                nRet=SDRHORZALIGN_DONTCARE;
+                nRet=SdrAlign::HORZ_DONTCARE;
             }
             bDontCare=true;
         }
     }
 }
 
-sal_uInt16 SdrGlueEditView::GetMarkedGluePointsAlign(bool bVert) const
+SdrAlign SdrGlueEditView::GetMarkedGluePointsAlign(bool bVert) const
 {
     ForceUndirtyMrkPnt();
     bool bFirst=true;
     bool bDontCare=false;
-    sal_uInt16 nRet=0;
+    SdrAlign nRet=SdrAlign::NONE;
     const_cast<SdrGlueEditView*>(this)->ImpDoMarkedGluePoints(ImpGetAlign,true,&bFirst,&bDontCare,&bVert,&nRet);
     return nRet;
 }
@@ -206,14 +206,14 @@ static void ImpSetAlign(SdrGluePoint& rGP, const SdrObject* pObj, const void* pb
 {
     Point aPos(rGP.GetAbsolutePos(*pObj));
     if (*static_cast<bool const *>(pbVert)) { // bVert?
-        rGP.SetVertAlign(*static_cast<sal_uInt16 const *>(pnAlign));
+        rGP.SetVertAlign(*static_cast<SdrAlign const *>(pnAlign));
     } else {
-        rGP.SetHorzAlign(*static_cast<sal_uInt16 const *>(pnAlign));
+        rGP.SetHorzAlign(*static_cast<SdrAlign const *>(pnAlign));
     }
     rGP.SetAbsolutePos(aPos,*pObj);
 }
 
-void SdrGlueEditView::SetMarkedGluePointsAlign(bool bVert, sal_uInt16 nAlign)
+void SdrGlueEditView::SetMarkedGluePointsAlign(bool bVert, SdrAlign nAlign)
 {
     ForceUndirtyMrkPnt();
     BegUndo(ImpGetResStr(STR_EditSetGlueAlign),GetDescriptionOfMarkedGluePoints());
diff --git a/svx/source/svdraw/svdglue.cxx b/svx/source/svdraw/svdglue.cxx
index ad7b1f3d0d86..cbfc3f58cb9f 100644
--- a/svx/source/svdraw/svdglue.cxx
+++ b/svx/source/svdraw/svdglue.cxx
@@ -52,12 +52,14 @@ Point SdrGluePoint::GetAbsolutePos(const SdrObject& rObj) const
 
     Point aOfs(aSnap.Center());
     switch (GetHorzAlign()) {
-        case SDRHORZALIGN_LEFT  : aOfs.X()=aSnap.Left(); break;
-        case SDRHORZALIGN_RIGHT : aOfs.X()=aSnap.Right(); break;
+        case SdrAlign::HORZ_LEFT  : aOfs.X()=aSnap.Left(); break;
+        case SdrAlign::HORZ_RIGHT : aOfs.X()=aSnap.Right(); break;
+        default: break;
     }
     switch (GetVertAlign()) {
-        case SDRVERTALIGN_TOP   : aOfs.Y()=aSnap.Top(); break;
-        case SDRVERTALIGN_BOTTOM: aOfs.Y()=aSnap.Bottom(); break;
+        case SdrAlign::VERT_TOP   : aOfs.Y()=aSnap.Top(); break;
+        case SdrAlign::VERT_BOTTOM: aOfs.Y()=aSnap.Bottom(); break;
+        default: break;
     }
     if (!bNoPercent) {
         long nXMul=aSnap.Right()-aSnap.Left();
@@ -93,12 +95,14 @@ void SdrGluePoint::SetAbsolutePos(const Point& rNewPos, const SdrObject& rObj)
 
     Point aOfs(aSnap.Center());
     switch (GetHorzAlign()) {
-        case SDRHORZALIGN_LEFT  : aOfs.X()=aSnap.Left(); break;
-        case SDRHORZALIGN_RIGHT : aOfs.X()=aSnap.Right(); break;
+        case SdrAlign::HORZ_LEFT  : aOfs.X()=aSnap.Left(); break;
+        case SdrAlign::HORZ_RIGHT : aOfs.X()=aSnap.Right(); break;
+        default: break;
     }
     switch (GetVertAlign()) {
-        case SDRVERTALIGN_TOP   : aOfs.Y()=aSnap.Top(); break;
-        case SDRVERTALIGN_BOTTOM: aOfs.Y()=aSnap.Bottom(); break;
+        case SdrAlign::VERT_TOP   : aOfs.Y()=aSnap.Top(); break;
+        case SdrAlign::VERT_BOTTOM: aOfs.Y()=aSnap.Bottom(); break;
+        default: break;
     }
     aPt-=aOfs;
     if (!bNoPercent) {
@@ -122,31 +126,38 @@ void SdrGluePoint::SetAbsolutePos(const Point& rNewPos, const SdrObject& rObj)
 
 long SdrGluePoint::GetAlignAngle() const
 {
-    switch (nAlign) {
-        case SDRHORZALIGN_CENTER|SDRVERTALIGN_CENTER: return 0; // Invalid!
-        case SDRHORZALIGN_RIGHT |SDRVERTALIGN_CENTER: return 0;
-        case SDRHORZALIGN_RIGHT |SDRVERTALIGN_TOP   : return 4500;
-        case SDRHORZALIGN_CENTER|SDRVERTALIGN_TOP   : return 9000;
-        case SDRHORZALIGN_LEFT  |SDRVERTALIGN_TOP   : return 13500;
-        case SDRHORZALIGN_LEFT  |SDRVERTALIGN_CENTER: return 18000;
-        case SDRHORZALIGN_LEFT  |SDRVERTALIGN_BOTTOM: return 22500;
-        case SDRHORZALIGN_CENTER|SDRVERTALIGN_BOTTOM: return 27000;
-        case SDRHORZALIGN_RIGHT |SDRVERTALIGN_BOTTOM: return 31500;
-    } // switch
+    if (nAlign == (SdrAlign::HORZ_CENTER|SdrAlign::VERT_CENTER))
+        return 0; // Invalid!
+    else if (nAlign == (SdrAlign::HORZ_RIGHT |SdrAlign::VERT_CENTER))
+        return 0;
+    else if (nAlign == (SdrAlign::HORZ_RIGHT |SdrAlign::VERT_TOP))
+        return 4500;
+    else if (nAlign == (SdrAlign::HORZ_CENTER|SdrAlign::VERT_TOP))
+        return 9000;
+    else if (nAlign == (SdrAlign::HORZ_LEFT  |SdrAlign::VERT_TOP))
+        return 13500;
+    else if (nAlign == (SdrAlign::HORZ_LEFT  |SdrAlign::VERT_CENTER))
+        return 18000;
+    else if (nAlign == (SdrAlign::HORZ_LEFT  |SdrAlign::VERT_BOTTOM))
+        return 22500;
+    else if (nAlign == (SdrAlign::HORZ_CENTER|SdrAlign::VERT_BOTTOM))
+        return 27000;
+    else if (nAlign == (SdrAlign::HORZ_RIGHT |SdrAlign::VERT_BOTTOM))
+        return 31500;
     return 0;
 }
 
 void SdrGluePoint::SetAlignAngle(long nAngle)
 {
     nAngle=NormAngle360(nAngle);
-    if (nAngle>=33750 || nAngle<2250) nAlign=SDRHORZALIGN_RIGHT |SDRVERTALIGN_CENTER;
-    else if (nAngle< 6750) nAlign=SDRHORZALIGN_RIGHT |SDRVERTALIGN_TOP   ;
-    else if (nAngle<11250) nAlign=SDRHORZALIGN_CENTER|SDRVERTALIGN_TOP   ;
-    else if (nAngle<15750) nAlign=SDRHORZALIGN_LEFT  |SDRVERTALIGN_TOP   ;
-    else if (nAngle<20250) nAlign=SDRHORZALIGN_LEFT  |SDRVERTALIGN_CENTER;
-    else if (nAngle<24750) nAlign=SDRHORZALIGN_LEFT  |SDRVERTALIGN_BOTTOM;
-    else if (nAngle<29250) nAlign=SDRHORZALIGN_CENTER|SDRVERTALIGN_BOTTOM;
-    else if (nAngle<33750) nAlign=SDRHORZALIGN_RIGHT |SDRVERTALIGN_BOTTOM;
+    if (nAngle>=33750 || nAngle<2250) nAlign=SdrAlign::HORZ_RIGHT |SdrAlign::VERT_CENTER;
+    else if (nAngle< 6750) nAlign=SdrAlign::HORZ_RIGHT |SdrAlign::VERT_TOP   ;
+    else if (nAngle<11250) nAlign=SdrAlign::HORZ_CENTER|SdrAlign::VERT_TOP   ;
+    else if (nAngle<15750) nAlign=SdrAlign::HORZ_LEFT  |SdrAlign::VERT_TOP   ;
+    else if (nAngle<20250) nAlign=SdrAlign::HORZ_LEFT  |SdrAlign::VERT_CENTER;
+    else if (nAngle<24750) nAlign=SdrAlign::HORZ_LEFT  |SdrAlign::VERT_BOTTOM;
+    else if (nAngle<29250) nAlign=SdrAlign::HORZ_CENTER|SdrAlign::VERT_BOTTOM;
+    else if (nAngle<33750) nAlign=SdrAlign::HORZ_RIGHT |SdrAlign::VERT_BOTTOM;
 }
 
 long SdrGluePoint::EscDirToAngle(SdrEscapeDirection nEsc)
@@ -179,7 +190,7 @@ void SdrGluePoint::Rotate(const Point& rRef, long nAngle, double sn, double cs,
     Point aPt(pObj!=NULL ? GetAbsolutePos(*pObj) : GetPos());
     RotatePoint(aPt,rRef,sn,cs);
     // rotate reference edge
-    if(nAlign != (SDRHORZALIGN_CENTER|SDRVERTALIGN_CENTER))
+    if(nAlign != (SdrAlign::HORZ_CENTER|SdrAlign::VERT_CENTER))
     {
         SetAlignAngle(GetAlignAngle()+nAngle);
     }
@@ -199,7 +210,7 @@ void SdrGluePoint::Mirror(const Point& rRef1, const Point& rRef2, long nAngle, c
     Point aPt(pObj!=NULL ? GetAbsolutePos(*pObj) : GetPos());
     MirrorPoint(aPt,rRef1,rRef2);
     // mirror reference edge
-    if(nAlign != (SDRHORZALIGN_CENTER|SDRVERTALIGN_CENTER))
+    if(nAlign != (SdrAlign::HORZ_CENTER|SdrAlign::VERT_CENTER))
     {
         long nAW=GetAlignAngle();
         nAW+=2*(nAngle-nAW);