convert POINTER constants to scoped enum

Change-Id: Iea29ce5fd6c620535197d3ca8538335078430e19
Reviewed-on: https://gerrit.libreoffice.org/15825
Reviewed-by: Noel Grandin <noelgrandin@gmail.com>
Tested-by: Noel Grandin <noelgrandin@gmail.com>
Signed-off-by: Jan Holesovsky <kendy@collabora.com>

20 files changed, 405 insertions, 412 deletions

diff --git a/vcl/inc/osx/saldata.hxx b/vcl/inc/osx/saldata.hxx
index babb1b44301a..fc8d3e82779a 100644
--- a/vcl/inc/osx/saldata.hxx
+++ b/vcl/inc/osx/saldata.hxx
@@ -39,6 +39,7 @@
 #include <map>
 #include <unordered_set>
 #include <vector>
+#include <o3tl/enumarray.hxx>
 
 #include <cstdio>
 #include <cstdarg>
@@ -83,7 +84,7 @@ public:
     CGColorSpaceRef                               mxRGBSpace;
     CGColorSpaceRef                               mxGraySpace;
 
-    std::vector< NSCursor* >                      maCursors;
+    o3tl::enumarray< PointerStyle, NSCursor* >    maCursors;
     std::vector< NSMenuItem* >                    maFallbackMenu;
     std::map< NSEvent*, bool >                    maKeyEventAnswer;
 
diff --git a/vcl/inc/unx/gtk/gtkdata.hxx b/vcl/inc/unx/gtk/gtkdata.hxx
index 9269132c4502..697fecee0eef 100644
--- a/vcl/inc/unx/gtk/gtkdata.hxx
+++ b/vcl/inc/unx/gtk/gtkdata.hxx
@@ -34,6 +34,7 @@
 #include <vcl/ptrstyle.hxx>
 #include <osl/conditn.h>
 #include "saltimer.hxx"
+#include <o3tl/enumarray.hxx>
 
 #include <list>
 
@@ -134,7 +135,7 @@ class GtkSalDisplay : public SalDisplay
 {
     GtkSalSystem*                   m_pSys;
     GdkDisplay*                     m_pGdkDisplay;
-    GdkCursor                      *m_aCursors[ POINTER_COUNT ];
+    o3tl::enumarray<PointerStyle, GdkCursor*> m_aCursors;
     bool                            m_bStartupCompleted;
     bool                            m_bX11Display;
 
diff --git a/vcl/inc/unx/saldisp.hxx b/vcl/inc/unx/saldisp.hxx
index f4e1fea16b56..a304a4b3718b 100644
--- a/vcl/inc/unx/saldisp.hxx
+++ b/vcl/inc/unx/saldisp.hxx
@@ -38,6 +38,7 @@ class   SalXLib;
 #include <salwtype.hxx>
 #include <generic/gendata.hxx>
 #include <generic/gendisp.hxx>
+#include <o3tl/enumarray.hxx>
 
 #include <vclpluginapi.h>
 
@@ -243,7 +244,7 @@ protected:
 
     // until x bytes
 
-    Cursor          aPointerCache_[POINTER_COUNT];
+    o3tl::enumarray<PointerStyle, Cursor> aPointerCache_;
 
     // Keyboard
     bool            bNumLockFromXS_;    // Num Lock handled by X Server
@@ -303,7 +304,7 @@ public:
                                Status         *pStatus,
                                XIC = NULL ) const;
 
-    Cursor                GetPointer( int ePointerStyle );
+    Cursor                GetPointer( PointerStyle ePointerStyle );
     virtual int           CaptureMouse( SalFrame *pCapture );
 
     void                  Remove( XEvent   *pEvent );
diff --git a/vcl/osx/saldata.cxx b/vcl/osx/saldata.cxx
index 762bc67641be..7008011d4df8 100644
--- a/vcl/osx/saldata.cxx
+++ b/vcl/osx/saldata.cxx
@@ -22,6 +22,7 @@
 #include "osx/saldata.hxx"
 #include "osx/salnsmenu.h"
 #include "osx/salinst.h"
+#include "o3tl/enumarray.hxx"
 
 #import "apple_remote/RemoteMainController.h"
 
@@ -44,7 +45,7 @@ SalData::SalData()
     mpStatusItem( nil ),
     mxRGBSpace( CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB) ),
     mxGraySpace( CGColorSpaceCreateWithName(kCGColorSpaceGenericGray) ),
-    maCursors( POINTER_COUNT, INVALID_CURSOR_PTR ),
+    maCursors(),
     mbIsScrollbarDoubleMax( false ),
 #if !HAVE_FEATURE_MACOSX_SANDBOX
     mpAppleRemoteMainController( NULL ),
@@ -53,6 +54,7 @@ SalData::SalData()
     mnDPIX( 0 ),
     mnDPIY( 0 )
 {
+    maCursors.fill( INVALID_CURSOR_PTR );
     if( s_aAutoReleaseKey == 0 )
         s_aAutoReleaseKey = osl_createThreadKey( releasePool );
 }
@@ -61,9 +63,8 @@ SalData::~SalData()
 {
     CGColorSpaceRelease( mxRGBSpace );
     CGColorSpaceRelease( mxGraySpace );
-    for( unsigned int i = 0; i < maCursors.size(); i++ )
+    for( NSCursor* pCurs : maCursors )
     {
-        NSCursor* pCurs = maCursors[i];
         if( pCurs && pCurs != INVALID_CURSOR_PTR )
             [pCurs release];
     }
@@ -105,114 +106,112 @@ void SalData::ensureThreadAutoreleasePool()
     }
 }
 
-struct curs_ent
+typedef struct
 {
     const char*         pBaseName;
     const NSPoint       aHotSpot;
-}
-const aCursorTab[ POINTER_COUNT ] =
+} curs_ent;
+
+const o3tl::enumarray<PointerStyle, curs_ent> aCursorTab =
 {
-{ NULL, { 0, 0 } }, //POINTER_ARROW
-{ "nullptr", { 16, 16 } }, //POINTER_NULL
-{ "hourglass", { 15, 15 } }, //POINTER_WAIT
-{ NULL, { 0, 0 } }, //POINTER_TEXT
-{ "help", { 0, 0 } }, //POINTER_HELP
-{ NULL, { 0, 0 } }, //POINTER_CROSS
-{ NULL, { 0, 0 } }, //POINTER_MOVE
-{ NULL, { 0, 0 } }, //POINTER_NSIZE
-{ NULL, { 0, 0 } }, //POINTER_SSIZE
-{ NULL, { 0, 0 } }, //POINTER_WSIZE
-{ NULL, { 0, 0 } }, //POINTER_ESIZE
-{ "nwsesize", { 15, 15 } }, //POINTER_NWSIZE
-{ "neswsize", { 15, 15 } }, //POINTER_NESIZE
-{ "neswsize", { 15, 15 } }, //POINTER_SWSIZE
-{ "nwsesize", { 15, 15 } }, //POINTER_SESIZE
-{ NULL, { 0, 0 } }, //POINTER_WINDOW_NSIZE
-{ NULL, { 0, 0 } }, //POINTER_WINDOW_SSIZE
-{ NULL, { 0, 0 } }, //POINTER_WINDOW_WSIZE
-{ NULL, { 0, 0 } }, //POINTER_WINDOW_ESIZE
-{ "nwsesize", { 15, 15 } }, //POINTER_WINDOW_NWSIZE
-{ "neswsize", { 15, 15 } }, //POINTER_WINDOW_NESIZE
-{ "neswsize", { 15, 15 } }, //POINTER_WINDOW_SWSIZE
-{ "nwsesize", { 15, 15 } }, //POINTER_WINDOW_SESIZE
-{ NULL, { 0, 0 } }, //POINTER_HSPLIT
-{ NULL, { 0, 0 } }, //POINTER_VSPLIT
-{ NULL, { 0, 0 } }, //POINTER_HSIZEBAR
-{ NULL, { 0, 0 } }, //POINTER_VSIZEBAR
-{ NULL, { 0, 0 } }, //POINTER_HAND
-{ NULL, { 0, 0 } }, //POINTER_REFHAND
-{ "pen", { 3, 27 } }, //POINTER_PEN
-{ "magnify", { 12, 13 } }, //POINTER_MAGNIFY
-{ "fill", { 10, 22 } }, //POINTER_FILL
-{ "rotate", { 15, 15 } }, //POINTER_ROTATE
-{ "hshear", { 15, 15 } }, //POINTER_HSHEAR
-{ "vshear", { 15, 15 } }, //POINTER_VSHEAR
-{ "mirror", { 14, 12 } }, //POINTER_MIRROR
-{ "crook", { 15, 14 } }, //POINTER_CROOK
-{ "crop", { 9, 9 } }, //POINTER_CROP
-{ "movept", { 0, 0 } }, //POINTER_MOVEPOINT
-{ "movebw", { 0, 0 } }, //POINTER_MOVEBEZIERWEIGHT
-{ "movedata", { 0, 0 } }, //POINTER_MOVEDATA
-{ "copydata", { 0, 0 } }, //POINTER_COPYDATA
-{ "linkdata", { 0, 0 } }, //POINTER_LINKDATA
-{ "movedlnk", { 0, 0 } }, //POINTER_MOVEDATALINK
-{ "copydlnk", { 0, 0 } }, //POINTER_COPYDATALINK
-{ "movef", { 8, 8 } }, //POINTER_MOVEFILE
-{ "copyf", { 8, 8 } }, //POINTER_COPYFILE
-{ "linkf", { 8, 8 } }, //POINTER_LINKFILE
-{ "moveflnk", { 8, 8 } }, //POINTER_MOVEFILELINK
-{ "copyflnk", { 8, 8 } }, //POINTER_COPYFILELINK
-{ "movef2", { 7, 8 } }, //POINTER_MOVEFILES
-{ "copyf2", { 7, 8 } }, //POINTER_COPYFILES
-{ "notallow", { 15, 15 } }, //POINTER_NOTALLOWED
-{ "dline", { 8, 8 } }, //POINTER_DRAW_LINE
-{ "drect", { 8, 8 } }, //POINTER_DRAW_RECT
-{ "dpolygon", { 8, 8 } }, //POINTER_DRAW_POLYGON
-{ "dbezier", { 8, 8 } }, //POINTER_DRAW_BEZIER
-{ "darc", { 8, 8 } }, //POINTER_DRAW_ARC
-{ "dpie", { 8, 8 } }, //POINTER_DRAW_PIE
-{ "dcirccut", { 8, 8 } }, //POINTER_DRAW_CIRCLECUT
-{ "dellipse", { 8, 8 } }, //POINTER_DRAW_ELLIPSE
-{ "dfree", { 8, 8 } }, //POINTER_DRAW_FREEHAND
-{ "dconnect", { 8, 8 } }, //POINTER_DRAW_CONNECT
-{ "dtext", { 8, 8 } }, //POINTER_DRAW_TEXT
-{ "dcapt", { 8, 8 } }, //POINTER_DRAW_CAPTION
-{ "chart", { 15, 16 } }, //POINTER_CHART
-{ "detectiv", { 12, 13 } }, //POINTER_DETECTIVE
-{ "pivotcol", { 7, 5 } }, //POINTER_PIVOT_COL
-{ "pivotrow", { 8, 7 } }, //POINTER_PIVOT_ROW
-{ "pivotfld", { 8, 7 } }, //POINTER_PIVOT_FIELD
-{ "chain", { 0, 2 } }, //POINTER_CHAIN
-{ "chainnot", { 2, 2 } }, //POINTER_CHAIN_NOTALLOWED
-{ "timemove", { 16, 16 } }, //POINTER_TIMEEVENT_MOVE
-{ "timesize", { 16, 17 } }, //POINTER_TIMEEVENT_SIZE
-{ "asn", { 16, 12 } }, //POINTER_AUTOSCROLL_N
-{ "ass", { 15, 19 } }, //POINTER_AUTOSCROLL_S
-{ "asw", { 12, 15 } }, //POINTER_AUTOSCROLL_W
-{ "ase", { 19, 16 } }, //POINTER_AUTOSCROLL_E
-{ "asnw", { 10, 10 } }, //POINTER_AUTOSCROLL_NW
-{ "asne", { 21, 10 } }, //POINTER_AUTOSCROLL_NE
-{ "assw", { 21, 21 } }, //POINTER_AUTOSCROLL_SW
-{ "asse", { 21, 21 } }, //POINTER_AUTOSCROLL_SE
-{ "asns", { 15, 15 } }, //POINTER_AUTOSCROLL_NS
-{ "aswe", { 15, 15 } }, //POINTER_AUTOSCROLL_WE
-{ "asnswe", { 15, 15 } }, //POINTER_AUTOSCROLL_NSWE
-{ "airbrush", { 5, 22 } }, //POINTER_AIRBRUSH
-{ "vtext", { 15, 15 } }, //POINTER_TEXT_VERTICAL
-{ "pivotdel", { 18, 15 } }, //POINTER_PIVOT_DELETE
-{ "tblsels", { 15, 30 } }, //POINTER_TAB_SELECT_S
-{ "tblsele", { 30, 16 } }, //POINTER_TAB_SELECT_E
-{ "tblselse", { 30, 30 } }, //POINTER_TAB_SELECT_SE
-{ "tblselw", { 1, 16 } }, //POINTER_TAB_SELECT_W
-{ "tblselsw", { 1, 30 } }, //POINTER_TAB_SELECT_SW
-{ "pntbrsh", { 9, 16 } }  //POINTER_PAINTBRUSH
+curs_ent{ NULL, { 0, 0 } }, //PointerStyle::Arrow
+{ "nullptr", { 16, 16 } }, //PointerStyle::Null
+{ "hourglass", { 15, 15 } }, //PointerStyle::Wait
+{ NULL, { 0, 0 } }, //PointerStyle::Text
+{ "help", { 0, 0 } }, //PointerStyle::Help
+{ NULL, { 0, 0 } }, //PointerStyle::Cross
+{ NULL, { 0, 0 } }, //PointerStyle::Move
+{ NULL, { 0, 0 } }, //PointerStyle::NSize
+{ NULL, { 0, 0 } }, //PointerStyle::SSize
+{ NULL, { 0, 0 } }, //PointerStyle::WSize
+{ NULL, { 0, 0 } }, //PointerStyle::ESize
+{ "nwsesize", { 15, 15 } }, //PointerStyle::NWSize
+{ "neswsize", { 15, 15 } }, //PointerStyle::NESize
+{ "neswsize", { 15, 15 } }, //PointerStyle::SWSize
+{ "nwsesize", { 15, 15 } }, //PointerStyle::SESize
+{ NULL, { 0, 0 } }, //PointerStyle::WindowNSize
+{ NULL, { 0, 0 } }, //PointerStyle::WindowSSize
+{ NULL, { 0, 0 } }, //PointerStyle::WindowWSize
+{ NULL, { 0, 0 } }, //PointerStyle::WindowESize
+{ "nwsesize", { 15, 15 } }, //PointerStyle::WindowNWSize
+{ "neswsize", { 15, 15 } }, //PointerStyle::WindowNESize
+{ "neswsize", { 15, 15 } }, //PointerStyle::WindowSWSize
+{ "nwsesize", { 15, 15 } }, //PointerStyle::WindowSESize
+{ NULL, { 0, 0 } }, //PointerStyle::HSplit
+{ NULL, { 0, 0 } }, //PointerStyle::VSplit
+{ NULL, { 0, 0 } }, //PointerStyle::HSizeBar
+{ NULL, { 0, 0 } }, //PointerStyle::VSizeBar
+{ NULL, { 0, 0 } }, //PointerStyle::Hand
+{ NULL, { 0, 0 } }, //PointerStyle::RefHand
+{ "pen", { 3, 27 } }, //PointerStyle::Pen
+{ "magnify", { 12, 13 } }, //PointerStyle::Magnify
+{ "fill", { 10, 22 } }, //PointerStyle::Fill
+{ "rotate", { 15, 15 } }, //PointerStyle::Rotate
+{ "hshear", { 15, 15 } }, //PointerStyle::HShear
+{ "vshear", { 15, 15 } }, //PointerStyle::VShear
+{ "mirror", { 14, 12 } }, //PointerStyle::Mirror
+{ "crook", { 15, 14 } }, //PointerStyle::Crook
+{ "crop", { 9, 9 } }, //PointerStyle::Crop
+{ "movept", { 0, 0 } }, //PointerStyle::MovePoint
+{ "movebw", { 0, 0 } }, //PointerStyle::MoveBezierWeight
+{ "movedata", { 0, 0 } }, //PointerStyle::MoveData
+{ "copydata", { 0, 0 } }, //PointerStyle::CopyData
+{ "linkdata", { 0, 0 } }, //PointerStyle::LinkData
+{ "movedlnk", { 0, 0 } }, //PointerStyle::MoveDataLink
+{ "copydlnk", { 0, 0 } }, //PointerStyle::CopyDataLink
+{ "movef", { 8, 8 } }, //PointerStyle::MoveFile
+{ "copyf", { 8, 8 } }, //PointerStyle::CopyFile
+{ "linkf", { 8, 8 } }, //PointerStyle::LinkFile
+{ "moveflnk", { 8, 8 } }, //PointerStyle::MoveFileLink
+{ "copyflnk", { 8, 8 } }, //PointerStyle::CopyFileLink
+{ "movef2", { 7, 8 } }, //PointerStyle::MoveFiles
+{ "copyf2", { 7, 8 } }, //PointerStyle::CopyFiles
+{ "notallow", { 15, 15 } }, //PointerStyle::NotAllowed
+{ "dline", { 8, 8 } }, //PointerStyle::DrawLine
+{ "drect", { 8, 8 } }, //PointerStyle::DrawRect
+{ "dpolygon", { 8, 8 } }, //PointerStyle::DrawPolygon
+{ "dbezier", { 8, 8 } }, //PointerStyle::DrawBezier
+{ "darc", { 8, 8 } }, //PointerStyle::DrawArc
+{ "dpie", { 8, 8 } }, //PointerStyle::DrawPie
+{ "dcirccut", { 8, 8 } }, //PointerStyle::DrawCircleCut
+{ "dellipse", { 8, 8 } }, //PointerStyle::DrawEllipse
+{ "dfree", { 8, 8 } }, //PointerStyle::DrawFreehand
+{ "dconnect", { 8, 8 } }, //PointerStyle::DrawConnect
+{ "dtext", { 8, 8 } }, //PointerStyle::DrawText
+{ "dcapt", { 8, 8 } }, //PointerStyle::DrawCaption
+{ "chart", { 15, 16 } }, //PointerStyle::Chart
+{ "detectiv", { 12, 13 } }, //PointerStyle::Detective
+{ "pivotcol", { 7, 5 } }, //PointerStyle::PivotCol
+{ "pivotrow", { 8, 7 } }, //PointerStyle::PivotRow
+{ "pivotfld", { 8, 7 } }, //PointerStyle::PivotField
+{ "chain", { 0, 2 } }, //PointerStyle::Chain
+{ "chainnot", { 2, 2 } }, //PointerStyle::ChainNotAllowed
+{ "timemove", { 16, 16 } }, //PointerStyle::TimeEventMove
+{ "timesize", { 16, 17 } }, //PointerStyle::TimeEventSize
+{ "asn", { 16, 12 } }, //PointerStyle::AutoScrollN
+{ "ass", { 15, 19 } }, //PointerStyle::AutoScrollS
+{ "asw", { 12, 15 } }, //PointerStyle::AutoScrollW
+{ "ase", { 19, 16 } }, //PointerStyle::AutoScrollE
+{ "asnw", { 10, 10 } }, //PointerStyle::AutoScrollNW
+{ "asne", { 21, 10 } }, //PointerStyle::AutoScrollNE
+{ "assw", { 21, 21 } }, //PointerStyle::AutoScrollSW
+{ "asse", { 21, 21 } }, //PointerStyle::AutoScrollSE
+{ "asns", { 15, 15 } }, //PointerStyle::AutoScrollNS
+{ "aswe", { 15, 15 } }, //PointerStyle::AutoScrollWE
+{ "asnswe", { 15, 15 } }, //PointerStyle::AutoScrollNSWE
+{ "airbrush", { 5, 22 } }, //PointerStyle::Airbrush
+{ "vtext", { 15, 15 } }, //PointerStyle::TextVertical
+{ "pivotdel", { 18, 15 } }, //PointerStyle::PivotDelete
+{ "tblsels", { 15, 30 } }, //PointerStyle::TabSelectS
+{ "tblsele", { 30, 16 } }, //PointerStyle::TabSelectE
+{ "tblselse", { 30, 30 } }, //PointerStyle::TabSelectSE
+{ "tblselw", { 1, 16 } }, //PointerStyle::TabSelectW
+{ "tblselsw", { 1, 30 } }, //PointerStyle::TabSelectSW
+{ "pntbrsh", { 9, 16 } }  //PointerStyle::Paintbrush
 };
 
 NSCursor* SalData::getCursor( PointerStyle i_eStyle )
 {
-    if( i_eStyle >= POINTER_COUNT )
-        return nil;
-
     NSCursor* pCurs = maCursors[ i_eStyle ];
     if( pCurs == INVALID_CURSOR_PTR )
     {
diff --git a/vcl/osx/salframe.cxx b/vcl/osx/salframe.cxx
index 98b49e803ca8..8a41aa769cac 100644
--- a/vcl/osx/salframe.cxx
+++ b/vcl/osx/salframe.cxx
@@ -73,7 +73,7 @@ AquaSalFrame::AquaSalFrame( SalFrame* pParent, sal_uLong salFrameStyle ) :
     mnLastModifierFlags( 0 ),
     mpMenu( NULL ),
     mnExtStyle( 0 ),
-    mePointerStyle( POINTER_ARROW ),
+    mePointerStyle( PointerStyle::Arrow ),
     mnTrackingRectTag( 0 ),
     mrClippingPath( 0 ),
     mnICOptions( InputContextFlags::NONE )
@@ -805,26 +805,26 @@ NSCursor* AquaSalFrame::getCurrentCursor() const
     NSCursor* pCursor = nil;
     switch( mePointerStyle )
     {
-    case POINTER_TEXT:      pCursor = [NSCursor IBeamCursor];           break;
-    case POINTER_CROSS:     pCursor = [NSCursor crosshairCursor];       break;
-    case POINTER_HAND:
-    case POINTER_MOVE:      pCursor = [NSCursor openHandCursor];        break;
-    case POINTER_NSIZE:     pCursor = [NSCursor resizeUpCursor];        break;
-    case POINTER_SSIZE:     pCursor = [NSCursor resizeDownCursor];      break;
-    case POINTER_ESIZE:     pCursor = [NSCursor resizeRightCursor];      break;
-    case POINTER_WSIZE:     pCursor = [NSCursor resizeLeftCursor];     break;
-    case POINTER_ARROW:     pCursor = [NSCursor arrowCursor];           break;
-    case POINTER_VSPLIT:
-    case POINTER_VSIZEBAR:
-    case POINTER_WINDOW_NSIZE:
-    case POINTER_WINDOW_SSIZE:
+    case PointerStyle::Text:      pCursor = [NSCursor IBeamCursor];           break;
+    case PointerStyle::Cross:     pCursor = [NSCursor crosshairCursor];       break;
+    case PointerStyle::Hand:
+    case PointerStyle::Move:      pCursor = [NSCursor openHandCursor];        break;
+    case PointerStyle::NSize:     pCursor = [NSCursor resizeUpCursor];        break;
+    case PointerStyle::SSize:     pCursor = [NSCursor resizeDownCursor];      break;
+    case PointerStyle::ESize:     pCursor = [NSCursor resizeRightCursor];      break;
+    case PointerStyle::WSize:     pCursor = [NSCursor resizeLeftCursor];     break;
+    case PointerStyle::Arrow:     pCursor = [NSCursor arrowCursor];           break;
+    case PointerStyle::VSplit:
+    case PointerStyle::VSizeBar:
+    case PointerStyle::WindowNSize:
+    case PointerStyle::WindowSSize:
                             pCursor = [NSCursor resizeUpDownCursor];    break;
-    case POINTER_HSPLIT:
-    case POINTER_HSIZEBAR:
-    case POINTER_WINDOW_ESIZE:
-    case POINTER_WINDOW_WSIZE:
+    case PointerStyle::HSplit:
+    case PointerStyle::HSizeBar:
+    case PointerStyle::WindowESize:
+    case PointerStyle::WindowWSize:
                             pCursor = [NSCursor resizeLeftRightCursor]; break;
-    case POINTER_REFHAND:   pCursor = [NSCursor pointingHandCursor];    break;
+    case PointerStyle::RefHand:   pCursor = [NSCursor pointingHandCursor];    break;
 
     default:
         pCursor = GetSalData()->getCursor( mePointerStyle );
@@ -846,7 +846,7 @@ void AquaSalFrame::SetPointer( PointerStyle ePointerStyle )
     // #i113170# may not be the main thread if called from UNO API
     SalData::ensureThreadAutoreleasePool();
 
-    if( ePointerStyle >= POINTER_COUNT || ePointerStyle == mePointerStyle )
+    if( ePointerStyle == mePointerStyle )
         return;
     mePointerStyle = ePointerStyle;
 
diff --git a/vcl/source/control/edit.cxx b/vcl/source/control/edit.cxx
index 95267f962c77..5f09d77cc103 100644
--- a/vcl/source/control/edit.cxx
+++ b/vcl/source/control/edit.cxx
@@ -355,7 +355,7 @@ void Edit::ImplInit(vcl::Window* pParent, WinBits nStyle)
 
     SetCursor( new vcl::Cursor );
 
-    SetPointer( Pointer( POINTER_TEXT ) );
+    SetPointer( Pointer( PointerStyle::Text ) );
 
     uno::Reference< datatransfer::dnd::XDragGestureListener> xDGL( mxDnDListener, uno::UNO_QUERY );
     uno::Reference< datatransfer::dnd::XDragGestureRecognizer > xDGR = GetDragGestureRecognizer();
@@ -2712,7 +2712,7 @@ void Edit::SetSubEdit(Edit* pEdit)
 
     if (mpSubEdit)
     {
-        SetPointer(POINTER_ARROW);    // Nur das SubEdit hat den BEAM...
+        SetPointer(PointerStyle::Arrow);    // Nur das SubEdit hat den BEAM...
         mpSubEdit->mbIsSubEdit = true;
 
         mpSubEdit->SetReadOnly(mbReadOnly);
diff --git a/vcl/source/control/fixedhyper.cxx b/vcl/source/control/fixedhyper.cxx
index 74309848605a..4fb5af42c491 100644
--- a/vcl/source/control/fixedhyper.cxx
+++ b/vcl/source/control/fixedhyper.cxx
@@ -68,7 +68,7 @@ void FixedHyperlink::MouseMove( const MouseEvent& rMEvt )
 {
     // changes the pointer if the control is enabled and the mouse is over the text.
     if ( !rMEvt.IsLeaveWindow() && IsEnabled() && ImplIsOverText(GetPointerPosPixel()) )
-        SetPointer( POINTER_REFHAND );
+        SetPointer( PointerStyle::RefHand );
     else
         SetPointer( m_aOldPointer );
 }
diff --git a/vcl/source/edit/vclmedit.cxx b/vcl/source/edit/vclmedit.cxx
index 1dc34783b595..bb9cbf989efe 100644
--- a/vcl/source/edit/vclmedit.cxx
+++ b/vcl/source/edit/vclmedit.cxx
@@ -713,7 +713,7 @@ TextWindow::TextWindow( vcl::Window* pParent ) : Window( pParent )
     mbSelectOnTab = true;
     mbTextSelectable = true;
 
-    SetPointer( Pointer( POINTER_TEXT ) );
+    SetPointer( Pointer( PointerStyle::Text ) );
 
     mpExtTextEngine = new ExtTextEngine;
     mpExtTextEngine->SetMaxTextLen(EDIT_NOLIMIT);
diff --git a/vcl/source/window/brdwin.cxx b/vcl/source/window/brdwin.cxx
index 54ed27695f00..44afe837cfbf 100644
--- a/vcl/source/window/brdwin.cxx
+++ b/vcl/source/window/brdwin.cxx
@@ -296,23 +296,23 @@ bool ImplBorderWindowView::ImplMouseMove( ImplBorderFrameData* pData, const Mous
 
     Point aMousePos = rMEvt.GetPosPixel();
     sal_uInt16 nHitTest = ImplHitTest( pData, aMousePos );
-    PointerStyle ePtrStyle = POINTER_ARROW;
+    PointerStyle ePtrStyle = PointerStyle::Arrow;
     if ( nHitTest & BORDERWINDOW_HITTEST_LEFT )
-        ePtrStyle = POINTER_WINDOW_WSIZE;
+        ePtrStyle = PointerStyle::WindowWSize;
     else if ( nHitTest & BORDERWINDOW_HITTEST_RIGHT )
-        ePtrStyle = POINTER_WINDOW_ESIZE;
+        ePtrStyle = PointerStyle::WindowESize;
     else if ( nHitTest & BORDERWINDOW_HITTEST_TOP )
-        ePtrStyle = POINTER_WINDOW_NSIZE;
+        ePtrStyle = PointerStyle::WindowNSize;
     else if ( nHitTest & BORDERWINDOW_HITTEST_BOTTOM )
-        ePtrStyle = POINTER_WINDOW_SSIZE;
+        ePtrStyle = PointerStyle::WindowSSize;
     else if ( nHitTest & BORDERWINDOW_HITTEST_TOPLEFT )
-        ePtrStyle = POINTER_WINDOW_NWSIZE;
+        ePtrStyle = PointerStyle::WindowNWSize;
     else if ( nHitTest & BORDERWINDOW_HITTEST_BOTTOMRIGHT )
-        ePtrStyle = POINTER_WINDOW_SESIZE;
+        ePtrStyle = PointerStyle::WindowSESize;
     else if ( nHitTest & BORDERWINDOW_HITTEST_TOPRIGHT )
-        ePtrStyle = POINTER_WINDOW_NESIZE;
+        ePtrStyle = PointerStyle::WindowNESize;
     else if ( nHitTest & BORDERWINDOW_HITTEST_BOTTOMLEFT )
-        ePtrStyle = POINTER_WINDOW_SWSIZE;
+        ePtrStyle = PointerStyle::WindowSWSize;
     else if ( nHitTest & BORDERWINDOW_HITTEST_CLOSE )
         pData->mnCloseState |= DrawButtonFlags::Highlight;
     else if ( nHitTest & BORDERWINDOW_HITTEST_MENU )
@@ -745,7 +745,7 @@ bool ImplBorderWindowView::ImplTracking( ImplBorderFrameData* pData, const Track
 
             if ( pData->mnHitTest & BORDERWINDOW_HITTEST_TITLE )
             {
-                pData->mpBorderWindow->SetPointer( Pointer( POINTER_MOVE ) );
+                pData->mpBorderWindow->SetPointer( Pointer( PointerStyle::Move ) );
 
                 Point aPos = pBorderWindow->GetPosPixel();
                 aPos.X() += aMousePos.X();
diff --git a/vcl/source/window/mouse.cxx b/vcl/source/window/mouse.cxx
index cab23bcce7c6..5aeed11a45ab 100644
--- a/vcl/source/window/mouse.cxx
+++ b/vcl/source/window/mouse.cxx
@@ -98,7 +98,7 @@ PointerStyle Window::ImplGetMousePointer() const
     if ( IsEnabled() && IsInputEnabled() && ! IsInModalMode() )
         ePointerStyle = GetPointer().GetStyle();
     else
-        ePointerStyle = POINTER_ARROW;
+        ePointerStyle = PointerStyle::Arrow;
 
     const vcl::Window* pWindow = this;
     do
@@ -106,13 +106,13 @@ PointerStyle Window::ImplGetMousePointer() const
         // when the pointer is not visible stop the search, as
         // this status should not be overwritten
         if ( pWindow->mpWindowImpl->mbNoPtrVisible )
-            return POINTER_NULL;
+            return PointerStyle::Null;
 
         if ( !bWait )
         {
             if ( pWindow->mpWindowImpl->mnWaitCount )
             {
-                ePointerStyle = POINTER_WAIT;
+                ePointerStyle = PointerStyle::Wait;
                 bWait = true;
             }
             else
diff --git a/vcl/source/window/scrwnd.cxx b/vcl/source/window/scrwnd.cxx
index da613bd330ae..8ddc748891e7 100644
--- a/vcl/source/window/scrwnd.cxx
+++ b/vcl/source/window/scrwnd.cxx
@@ -246,11 +246,11 @@ PointerStyle ImplWheelWindow::ImplGetMousePointer( long nDistX, long nDistY )
         if( mnActDist < WHEEL_RADIUS )
         {
             if( bHorz && bVert )
-                eStyle = POINTER_AUTOSCROLL_NSWE;
+                eStyle = PointerStyle::AutoScrollNSWE;
             else if( bHorz )
-                eStyle = POINTER_AUTOSCROLL_WE;
+                eStyle = PointerStyle::AutoScrollWE;
             else
-                eStyle = POINTER_AUTOSCROLL_NS;
+                eStyle = PointerStyle::AutoScrollNS;
         }
         else
         {
@@ -262,40 +262,40 @@ PointerStyle ImplWheelWindow::ImplGetMousePointer( long nDistX, long nDistY )
             if( bHorz && bVert )
             {
                 if( fAngle >= 22.5 && fAngle <= 67.5 )
-                    eStyle = POINTER_AUTOSCROLL_NE;
+                    eStyle = PointerStyle::AutoScrollNE;
                 else if( fAngle >= 67.5 && fAngle <= 112.5 )
-                    eStyle = POINTER_AUTOSCROLL_N;
+                    eStyle = PointerStyle::AutoScrollN;
                 else if( fAngle >= 112.5 && fAngle <= 157.5 )
-                    eStyle = POINTER_AUTOSCROLL_NW;
+                    eStyle = PointerStyle::AutoScrollNW;
                 else if( fAngle >= 157.5 && fAngle <= 202.5 )
-                    eStyle = POINTER_AUTOSCROLL_W;
+                    eStyle = PointerStyle::AutoScrollW;
                 else if( fAngle >= 202.5 && fAngle <= 247.5 )
-                    eStyle = POINTER_AUTOSCROLL_SW;
+                    eStyle = PointerStyle::AutoScrollSW;
                 else if( fAngle >= 247.5 && fAngle <= 292.5 )
-                    eStyle = POINTER_AUTOSCROLL_S;
+                    eStyle = PointerStyle::AutoScrollS;
                 else if( fAngle >= 292.5 && fAngle <= 337.5 )
-                    eStyle = POINTER_AUTOSCROLL_SE;
+                    eStyle = PointerStyle::AutoScrollSE;
                 else
-                    eStyle = POINTER_AUTOSCROLL_E;
+                    eStyle = PointerStyle::AutoScrollE;
             }
             else if( bHorz )
             {
                 if( fAngle >= 270. || fAngle <= 90. )
-                    eStyle = POINTER_AUTOSCROLL_E;
+                    eStyle = PointerStyle::AutoScrollE;
                 else
-                    eStyle = POINTER_AUTOSCROLL_W;
+                    eStyle = PointerStyle::AutoScrollW;
             }
             else
             {
                 if( fAngle >= 0. && fAngle <= 180. )
-                    eStyle = POINTER_AUTOSCROLL_N;
+                    eStyle = PointerStyle::AutoScrollN;
                 else
-                    eStyle = POINTER_AUTOSCROLL_S;
+                    eStyle = PointerStyle::AutoScrollS;
             }
         }
     }
     else
-        eStyle = POINTER_ARROW;
+        eStyle = PointerStyle::Arrow;
 
     return eStyle;
 }
@@ -325,14 +325,14 @@ void ImplWheelWindow::MouseMove( const MouseEvent& rMEvt )
     {
         switch( eActStyle )
         {
-            case( POINTER_AUTOSCROLL_N ):   mnActDeltaX = +0L, mnActDeltaY = +1L; break;
-            case( POINTER_AUTOSCROLL_S ):   mnActDeltaX = +0L, mnActDeltaY = -1L; break;
-            case( POINTER_AUTOSCROLL_W ):   mnActDeltaX = +1L, mnActDeltaY = +0L; break;
-            case( POINTER_AUTOSCROLL_E ):   mnActDeltaX = -1L, mnActDeltaY = +0L; break;
-            case( POINTER_AUTOSCROLL_NW ):  mnActDeltaX = +1L, mnActDeltaY = +1L; break;
-            case( POINTER_AUTOSCROLL_NE ):  mnActDeltaX = -1L, mnActDeltaY = +1L; break;
-            case( POINTER_AUTOSCROLL_SW ):  mnActDeltaX = +1L, mnActDeltaY = -1L; break;
-            case( POINTER_AUTOSCROLL_SE ):  mnActDeltaX = -1L, mnActDeltaY = -1L; break;
+            case( PointerStyle::AutoScrollN ):   mnActDeltaX = +0L, mnActDeltaY = +1L; break;
+            case( PointerStyle::AutoScrollS ):   mnActDeltaX = +0L, mnActDeltaY = -1L; break;
+            case( PointerStyle::AutoScrollW ):   mnActDeltaX = +1L, mnActDeltaY = +0L; break;
+            case( PointerStyle::AutoScrollE ):   mnActDeltaX = -1L, mnActDeltaY = +0L; break;
+            case( PointerStyle::AutoScrollNW ):  mnActDeltaX = +1L, mnActDeltaY = +1L; break;
+            case( PointerStyle::AutoScrollNE ):  mnActDeltaX = -1L, mnActDeltaY = +1L; break;
+            case( PointerStyle::AutoScrollSW ):  mnActDeltaX = +1L, mnActDeltaY = -1L; break;
+            case( PointerStyle::AutoScrollSE ):  mnActDeltaX = -1L, mnActDeltaY = -1L; break;
 
             default:
             break;
diff --git a/vcl/source/window/split.cxx b/vcl/source/window/split.cxx
index 026b40fbbbb2..6c97de76aa5c 100644
--- a/vcl/source/window/split.cxx
+++ b/vcl/source/window/split.cxx
@@ -74,12 +74,12 @@ void Splitter::ImplInitHorVer(bool bNew)
 
     if ( mbHorzSplit )
     {
-        ePointerStyle = POINTER_HSPLIT;
+        ePointerStyle = PointerStyle::HSplit;
         SetSizePixel( Size( rSettings.GetSplitSize(), rSettings.GetScrollBarSize() ) );
     }
     else
     {
-        ePointerStyle = POINTER_VSPLIT;
+        ePointerStyle = PointerStyle::VSplit;
         SetSizePixel( Size( rSettings.GetScrollBarSize(), rSettings.GetSplitSize() ) );
     }
 
diff --git a/vcl/source/window/splitwin.cxx b/vcl/source/window/splitwin.cxx
index 84531924c744..ae529df3ecae 100644
--- a/vcl/source/window/splitwin.cxx
+++ b/vcl/source/window/splitwin.cxx
@@ -2184,11 +2184,11 @@ void SplitWindow::ImplStartSplit( const MouseEvent& rMEvt )
         }
         mnMStartPos = mnMSplitPos;
 
-        PointerStyle eStyle = POINTER_ARROW;
+        PointerStyle eStyle = PointerStyle::Arrow;
         if ( mnSplitTest & SPLIT_HORZ )
-            eStyle = POINTER_HSPLIT;
+            eStyle = PointerStyle::HSplit;
         else if ( mnSplitTest & SPLIT_VERT )
-            eStyle = POINTER_VSPLIT;
+            eStyle = PointerStyle::VSplit;
 
         Pointer aPtr( eStyle );
         SetPointer( aPtr );
@@ -2286,7 +2286,7 @@ void SplitWindow::MouseMove( const MouseEvent& rMEvt )
         ImplSplitSet*   pTempSplitSet;
         sal_uInt16          nTempSplitPos;
         sal_uInt16          nSplitTest = ImplTestSplit( this, aPos, nTemp, &pTempSplitSet, nTempSplitPos );
-        PointerStyle    eStyle = POINTER_ARROW;
+        PointerStyle    eStyle = PointerStyle::Arrow;
         Rectangle       aAutoHideRect;
         Rectangle       aFadeInRect;
         Rectangle       aFadeOutRect;
@@ -2301,9 +2301,9 @@ void SplitWindow::MouseMove( const MouseEvent& rMEvt )
             if ( nSplitTest && !(nSplitTest & SPLIT_NOSPLIT) )
             {
                 if ( nSplitTest & SPLIT_HORZ )
-                    eStyle = POINTER_HSPLIT;
+                    eStyle = PointerStyle::HSplit;
                 else if ( nSplitTest & SPLIT_VERT )
-                    eStyle = POINTER_VSPLIT;
+                    eStyle = PointerStyle::VSplit;
             }
         }
 
diff --git a/vcl/source/window/toolbox.cxx b/vcl/source/window/toolbox.cxx
index 280ac76f335c..cb32d9b3f104 100644
--- a/vcl/source/window/toolbox.cxx
+++ b/vcl/source/window/toolbox.cxx
@@ -1395,7 +1395,7 @@ void ToolBox::ImplInit( vcl::Window* pParent, WinBits nStyle )
     mbChangingHighlight = false;
     meButtonType      = ButtonType::SYMBOLONLY;
     meAlign           = WINDOWALIGN_TOP;
-    meLastStyle       = POINTER_ARROW;
+    meLastStyle       = PointerStyle::Arrow;
     mnWinStyle        = nStyle;
     meLayoutMode      = TBX_LAYOUT_NORMAL;
     mnLastFocusItemId = 0;
@@ -3665,12 +3665,12 @@ void ToolBox::MouseMove( const MouseEvent& rMEvt )
         return;
     }
 
-    PointerStyle eStyle = POINTER_ARROW;
+    PointerStyle eStyle = PointerStyle::Arrow;
 
     // change mouse cursor over drag area
     ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
     if( pWrapper && pWrapper->GetDragArea().IsInside( rMEvt.GetPosPixel() ) )
-        eStyle = POINTER_MOVE;
+        eStyle = PointerStyle::Move;
 
     if ( (mnWinStyle & TB_WBLINESIZING) == TB_WBLINESIZING )
     {
@@ -3680,21 +3680,21 @@ void ToolBox::MouseMove( const MouseEvent& rMEvt )
             if ( nLinePtr & DOCK_LINEHSIZE )
             {
                 if ( meAlign == WINDOWALIGN_LEFT )
-                    eStyle = POINTER_WINDOW_ESIZE;
+                    eStyle = PointerStyle::WindowESize;
                 else
-                    eStyle = POINTER_WINDOW_WSIZE;
+                    eStyle = PointerStyle::WindowWSize;
             }
             else if ( nLinePtr & DOCK_LINEVSIZE )
             {
                 if ( meAlign == WINDOWALIGN_TOP )
-                    eStyle = POINTER_WINDOW_SSIZE;
+                    eStyle = PointerStyle::WindowSSize;
                 else
-                    eStyle = POINTER_WINDOW_NSIZE;
+                    eStyle = PointerStyle::WindowNSize;
             }
         }
     }
 
-    if ( (eStyle == POINTER_ARROW) && mbCustomizeMode )
+    if ( (eStyle == PointerStyle::Arrow) && mbCustomizeMode )
     {
         // search the item which was clicked
         std::vector< ImplToolItem >::const_iterator it = mpData->m_aItems.begin();
@@ -3706,7 +3706,7 @@ void ToolBox::MouseMove( const MouseEvent& rMEvt )
                 if ( it->maRect.IsInside( aMousePos ) )
                 {
                     if ( it->maRect.Right()-TB_RESIZE_OFFSET <= aMousePos.X() )
-                        eStyle = POINTER_HSIZEBAR;
+                        eStyle = PointerStyle::HSizeBar;
                     break;
                 }
             }
diff --git a/vcl/source/window/winproc.cxx b/vcl/source/window/winproc.cxx
index be93192b028e..3291feb8a5a2 100644
--- a/vcl/source/window/winproc.cxx
+++ b/vcl/source/window/winproc.cxx
@@ -86,7 +86,7 @@ static bool ImplHandleMouseFloatMode( vcl::Window* pChild, const Point& rMousePo
             {
                 if ( pSVData->maHelpData.mpHelpWin && !pSVData->maHelpData.mbKeyboardHelp )
                     ImplDestroyHelpWindow( true );
-                pChild->ImplGetFrame()->SetPointer( POINTER_ARROW );
+                pChild->ImplGetFrame()->SetPointer( PointerStyle::Arrow );
                 return true;
             }
         }
@@ -191,7 +191,7 @@ static void ImplSetMousePointer( vcl::Window* pChild )
 {
     ImplSVData* pSVData = ImplGetSVData();
     if ( pSVData->maHelpData.mbExtHelpMode )
-        pChild->ImplGetFrame()->SetPointer( POINTER_HELP );
+        pChild->ImplGetFrame()->SetPointer( PointerStyle::Help );
     else
         pChild->ImplGetFrame()->SetPointer( pChild->ImplGetMousePointer() );
 }
diff --git a/vcl/unx/generic/app/saldisp.cxx b/vcl/unx/generic/app/saldisp.cxx
index eedbadbbfb5d..08106412e268 100644
--- a/vcl/unx/generic/app/saldisp.cxx
+++ b/vcl/unx/generic/app/saldisp.cxx
@@ -335,10 +335,10 @@ void SalDisplay::doDestruct()
             }
         }
 
-        for( size_t i = 0; i < POINTER_COUNT; i++ )
+        for( Cursor & aCsr : aPointerCache_ )
         {
-            if( aPointerCache_[i] )
-                XFreeCursor( pDisp_, aPointerCache_[i] );
+            if( aCsr )
+                XFreeCursor( pDisp_, aCsr );
         }
 
         if( pXLib_ )
@@ -556,8 +556,8 @@ SalDisplay::initScreen( SalX11Screen nXScreen ) const
 
 void SalDisplay::Init()
 {
-    for( size_t i = 0; i < POINTER_COUNT; i++ )
-        aPointerCache_[i] = None;
+    for( Cursor & aCsr : aPointerCache_ )
+        aCsr = None;
 
     mpFactory           = (AttributeProvider*)NULL;
     m_bXinerama         = false;
@@ -1477,11 +1477,8 @@ KeySym SalDisplay::GetKeySym( XKeyEvent        *pEvent,
     nXHot = name##curs_x_hot; \
     nYHot = name##curs_y_hot
 
-Cursor SalDisplay::GetPointer( int ePointerStyle )
+Cursor SalDisplay::GetPointer( PointerStyle ePointerStyle )
 {
-    if( ePointerStyle >= POINTER_COUNT )
-        return 0;
-
     Cursor &aCur = aPointerCache_[ePointerStyle];
 
     if( aCur != None )
@@ -1492,310 +1489,310 @@ Cursor SalDisplay::GetPointer( int ePointerStyle )
 
     switch( ePointerStyle )
     {
-        case POINTER_NULL:
+        case PointerStyle::Null:
             MAKE_CURSOR( null );
             break;
-        case POINTER_ARROW:
+        case PointerStyle::Arrow:
             aCur = XCreateFontCursor( pDisp_, XC_left_ptr );
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_WAIT:
+        case PointerStyle::Wait:
             aCur = XCreateFontCursor( pDisp_, XC_watch );
             break;
-        case POINTER_TEXT:          // Mouse Pointer is a "I" Beam
+        case PointerStyle::Text:          // Mouse Pointer is a "I" Beam
             aCur = XCreateFontCursor( pDisp_, XC_xterm );
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_HELP:
+        case PointerStyle::Help:
             aCur = XCreateFontCursor( pDisp_, XC_question_arrow );
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_CROSS:         // Mouse Pointer is a cross
+        case PointerStyle::Cross:         // Mouse Pointer is a cross
             aCur = XCreateFontCursor( pDisp_, XC_crosshair );
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_NSIZE:
+        case PointerStyle::NSize:
             aCur = XCreateFontCursor( pDisp_, XC_sb_v_double_arrow );
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_SSIZE:
+        case PointerStyle::SSize:
             aCur = XCreateFontCursor( pDisp_, XC_sb_v_double_arrow );
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_WSIZE:
+        case PointerStyle::WSize:
             aCur = XCreateFontCursor( pDisp_, XC_sb_h_double_arrow );
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_ESIZE:
+        case PointerStyle::ESize:
             aCur = XCreateFontCursor( pDisp_, XC_sb_h_double_arrow );
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_WINDOW_NSIZE:
+        case PointerStyle::WindowNSize:
             aCur = XCreateFontCursor( pDisp_, XC_top_side );
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_WINDOW_SSIZE:
+        case PointerStyle::WindowSSize:
             aCur = XCreateFontCursor( pDisp_, XC_bottom_side );
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_WINDOW_WSIZE:
+        case PointerStyle::WindowWSize:
             aCur = XCreateFontCursor( pDisp_, XC_left_side );
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_WINDOW_ESIZE:
+        case PointerStyle::WindowESize:
             aCur = XCreateFontCursor( pDisp_, XC_right_side );
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_NWSIZE:
+        case PointerStyle::NWSize:
             aCur = XCreateFontCursor( pDisp_, XC_top_left_corner );
             break;
-        case POINTER_NESIZE:
+        case PointerStyle::NESize:
             aCur = XCreateFontCursor( pDisp_, XC_top_right_corner );
             break;
-        case POINTER_SWSIZE:
+        case PointerStyle::SWSize:
             aCur = XCreateFontCursor( pDisp_, XC_bottom_left_corner );
             break;
-        case POINTER_SESIZE:
+        case PointerStyle::SESize:
             aCur = XCreateFontCursor( pDisp_, XC_bottom_right_corner );
             break;
-        case POINTER_WINDOW_NWSIZE:
+        case PointerStyle::WindowNWSize:
             aCur = XCreateFontCursor( pDisp_, XC_top_left_corner );
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_WINDOW_NESIZE:
+        case PointerStyle::WindowNESize:
             aCur = XCreateFontCursor( pDisp_, XC_top_right_corner );
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_WINDOW_SWSIZE:
+        case PointerStyle::WindowSWSize:
             aCur = XCreateFontCursor( pDisp_, XC_bottom_left_corner );
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_WINDOW_SESIZE:
+        case PointerStyle::WindowSESize:
             aCur = XCreateFontCursor( pDisp_, XC_bottom_right_corner );
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_HSPLIT:
+        case PointerStyle::HSplit:
             aCur = XCreateFontCursor( pDisp_, XC_sb_h_double_arrow );
             break;
-        case POINTER_VSPLIT:
+        case PointerStyle::VSplit:
             aCur = XCreateFontCursor( pDisp_, XC_sb_v_double_arrow );
             break;
-        case POINTER_HSIZEBAR:
+        case PointerStyle::HSizeBar:
             aCur = XCreateFontCursor( pDisp_, XC_sb_h_double_arrow ); // ???
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_VSIZEBAR:
+        case PointerStyle::VSizeBar:
             aCur = XCreateFontCursor( pDisp_, XC_sb_v_double_arrow ); // ???
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_REFHAND:
+        case PointerStyle::RefHand:
             aCur = XCreateFontCursor( pDisp_, XC_hand1 );
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_HAND:
+        case PointerStyle::Hand:
             aCur = XCreateFontCursor( pDisp_, XC_hand2 );
             break;
-        case POINTER_MAGNIFY:
+        case PointerStyle::Magnify:
             MAKE_CURSOR( magnify_ );
             break;
-        case POINTER_FILL:
+        case PointerStyle::Fill:
             MAKE_CURSOR( fill_ );
             break;
-        case POINTER_MOVE:
+        case PointerStyle::Move:
             aCur = XCreateFontCursor( pDisp_, XC_fleur );
             break;
-        case POINTER_MOVEDATA:
+        case PointerStyle::MoveData:
             MAKE_CURSOR( movedata_ );
             break;
-        case POINTER_COPYDATA:
+        case PointerStyle::CopyData:
             MAKE_CURSOR( copydata_ );
             break;
-        case POINTER_MOVEFILE:
+        case PointerStyle::MoveFile:
             MAKE_CURSOR( movefile_ );
             break;
-        case POINTER_COPYFILE:
+        case PointerStyle::CopyFile:
             MAKE_CURSOR( copyfile_ );
             break;
-        case POINTER_MOVEFILES:
+        case PointerStyle::MoveFiles:
             MAKE_CURSOR( movefiles_ );
             break;
-        case POINTER_COPYFILES:
+        case PointerStyle::CopyFiles:
             MAKE_CURSOR( copyfiles_ );
             break;
-        case POINTER_NOTALLOWED:
+        case PointerStyle::NotAllowed:
             MAKE_CURSOR( nodrop_ );
             break;
-        case POINTER_ROTATE:
+        case PointerStyle::Rotate:
             MAKE_CURSOR( rotate_ );
             break;
-        case POINTER_HSHEAR:
+        case PointerStyle::HShear:
             MAKE_CURSOR( hshear_ );
             break;
-        case POINTER_VSHEAR:
+        case PointerStyle::VShear:
             MAKE_CURSOR( vshear_ );
             break;
-        case POINTER_DRAW_LINE:
+        case PointerStyle::DrawLine:
             MAKE_CURSOR( drawline_ );
             break;
-        case POINTER_DRAW_RECT:
+        case PointerStyle::DrawRect:
             MAKE_CURSOR( drawrect_ );
             break;
-        case POINTER_DRAW_POLYGON:
+        case PointerStyle::DrawPolygon:
             MAKE_CURSOR( drawpolygon_ );
             break;
-        case POINTER_DRAW_BEZIER:
+        case PointerStyle::DrawBezier:
             MAKE_CURSOR( drawbezier_ );
             break;
-        case POINTER_DRAW_ARC:
+        case PointerStyle::DrawArc:
             MAKE_CURSOR( drawarc_ );
             break;
-        case POINTER_DRAW_PIE:
+        case PointerStyle::DrawPie:
             MAKE_CURSOR( drawpie_ );
             break;
-        case POINTER_DRAW_CIRCLECUT:
+        case PointerStyle::DrawCircleCut:
             MAKE_CURSOR( drawcirclecut_ );
             break;
-        case POINTER_DRAW_ELLIPSE:
+        case PointerStyle::DrawEllipse:
             MAKE_CURSOR( drawellipse_ );
             break;
-        case POINTER_DRAW_CONNECT:
+        case PointerStyle::DrawConnect:
             MAKE_CURSOR( drawconnect_ );
             break;
-        case POINTER_DRAW_TEXT:
+        case PointerStyle::DrawText:
             MAKE_CURSOR( drawtext_ );
             break;
-        case POINTER_MIRROR:
+        case PointerStyle::Mirror:
             MAKE_CURSOR( mirror_ );
             break;
-        case POINTER_CROOK:
+        case PointerStyle::Crook:
             MAKE_CURSOR( crook_ );
             break;
-        case POINTER_CROP:
+        case PointerStyle::Crop:
             MAKE_CURSOR( crop_ );
             break;
-        case POINTER_MOVEPOINT:
+        case PointerStyle::MovePoint:
             MAKE_CURSOR( movepoint_ );
             break;
-        case POINTER_MOVEBEZIERWEIGHT:
+        case PointerStyle::MoveBezierWeight:
             MAKE_CURSOR( movebezierweight_ );
             break;
-        case POINTER_DRAW_FREEHAND:
+        case PointerStyle::DrawFreehand:
             MAKE_CURSOR( drawfreehand_ );
             break;
-        case POINTER_DRAW_CAPTION:
+        case PointerStyle::DrawCaption:
             MAKE_CURSOR( drawcaption_ );
             break;
-        case POINTER_PEN:       // Mouse Pointer is a pencil
+        case PointerStyle::Pen:       // Mouse Pointer is a pencil
             aCur = XCreateFontCursor( pDisp_, XC_pencil );
             DBG_ASSERT( aCur != None, "GetPointer: Could not define cursor" );
             break;
-        case POINTER_LINKDATA:
+        case PointerStyle::LinkData:
             MAKE_CURSOR( linkdata_ );
             break;
-        case POINTER_MOVEDATALINK:
+        case PointerStyle::MoveDataLink:
             MAKE_CURSOR( movedlnk_ );
             break;
-        case POINTER_COPYDATALINK:
+        case PointerStyle::CopyDataLink:
             MAKE_CURSOR( copydlnk_ );
             break;
-        case POINTER_LINKFILE:
+        case PointerStyle::LinkFile:
             MAKE_CURSOR( linkfile_ );
             break;
-        case POINTER_MOVEFILELINK:
+        case PointerStyle::MoveFileLink:
             MAKE_CURSOR( moveflnk_ );
             break;
-        case POINTER_COPYFILELINK:
+        case PointerStyle::CopyFileLink:
             MAKE_CURSOR( copyflnk_ );
             break;
-        case POINTER_CHART:
+        case PointerStyle::Chart:
             MAKE_CURSOR( chart_ );
             break;
-        case POINTER_DETECTIVE:
+        case PointerStyle::Detective:
             MAKE_CURSOR( detective_ );
             break;
-        case POINTER_PIVOT_COL:
+        case PointerStyle::PivotCol:
             MAKE_CURSOR( pivotcol_ );
             break;
-        case POINTER_PIVOT_ROW:
+        case PointerStyle::PivotRow:
             MAKE_CURSOR( pivotrow_ );
             break;
-        case POINTER_PIVOT_FIELD:
+        case PointerStyle::PivotField:
             MAKE_CURSOR( pivotfld_ );
             break;
-        case POINTER_PIVOT_DELETE:
+        case PointerStyle::PivotDelete:
             MAKE_CURSOR( pivotdel_ );
             break;
-        case POINTER_CHAIN:
+        case PointerStyle::Chain:
             MAKE_CURSOR( chain_ );
             break;
-        case POINTER_CHAIN_NOTALLOWED:
+        case PointerStyle::ChainNotAllowed:
             MAKE_CURSOR( chainnot_ );
             break;
-        case POINTER_TIMEEVENT_MOVE:
+        case PointerStyle::TimeEventMove:
             MAKE_CURSOR( timemove_ );
             break;
-        case POINTER_TIMEEVENT_SIZE:
+        case PointerStyle::TimeEventSize:
             MAKE_CURSOR( timesize_ );
             break;
-        case POINTER_AUTOSCROLL_N:
+        case PointerStyle::AutoScrollN:
             MAKE_CURSOR(asn_ );
             break;
-        case POINTER_AUTOSCROLL_S:
+        case PointerStyle::AutoScrollS:
             MAKE_CURSOR( ass_ );
             break;
-        case POINTER_AUTOSCROLL_W:
+        case PointerStyle::AutoScrollW:
             MAKE_CURSOR( asw_ );
             break;
-        case POINTER_AUTOSCROLL_E:
+        case PointerStyle::AutoScrollE:
             MAKE_CURSOR( ase_ );
             break;
-        case POINTER_AUTOSCROLL_NW:
+        case PointerStyle::AutoScrollNW:
             MAKE_CURSOR( asnw_ );
             break;
-        case POINTER_AUTOSCROLL_NE:
+        case PointerStyle::AutoScrollNE:
             MAKE_CURSOR( asne_ );
             break;
-        case POINTER_AUTOSCROLL_SW:
+        case PointerStyle::AutoScrollSW:
             MAKE_CURSOR( assw_ );
             break;
-        case POINTER_AUTOSCROLL_SE:
+        case PointerStyle::AutoScrollSE:
             MAKE_CURSOR( asse_ );
             break;
-        case POINTER_AUTOSCROLL_NS:
+        case PointerStyle::AutoScrollNS:
             MAKE_CURSOR( asns_ );
             break;
-        case POINTER_AUTOSCROLL_WE:
+        case PointerStyle::AutoScrollWE:
             MAKE_CURSOR( aswe_ );
             break;
-        case POINTER_AUTOSCROLL_NSWE:
+        case PointerStyle::AutoScrollNSWE:
             MAKE_CURSOR( asnswe_ );
             break;
-        case POINTER_AIRBRUSH:
+        case PointerStyle::Airbrush:
             MAKE_CURSOR( airbrush_ );
             break;
-        case POINTER_TEXT_VERTICAL:
+        case PointerStyle::TextVertical:
             MAKE_CURSOR( vertcurs_ );
             break;
 
         // #i32329# Enhanced table selection
-        case POINTER_TAB_SELECT_S:
+        case PointerStyle::TabSelectS:
             MAKE_CURSOR( tblsels_ );
             break;
-        case POINTER_TAB_SELECT_E:
+        case PointerStyle::TabSelectE:
             MAKE_CURSOR( tblsele_ );
             break;
-        case POINTER_TAB_SELECT_SE:
+        case PointerStyle::TabSelectSE:
             MAKE_CURSOR( tblselse_ );
             break;
-        case POINTER_TAB_SELECT_W:
+        case PointerStyle::TabSelectW:
             MAKE_CURSOR( tblselw_ );
             break;
-        case POINTER_TAB_SELECT_SW:
+        case PointerStyle::TabSelectSW:
             MAKE_CURSOR( tblselsw_ );
             break;
 
         // #i20119# Paintbrush tool
-        case POINTER_PAINTBRUSH :
+        case PointerStyle::Paintbrush :
             MAKE_CURSOR( paintbrush_ );
             break;
 
diff --git a/vcl/unx/generic/window/salframe.cxx b/vcl/unx/generic/window/salframe.cxx
index 4f428dcdec2b..14e11d5be9ef 100644
--- a/vcl/unx/generic/window/salframe.cxx
+++ b/vcl/unx/generic/window/salframe.cxx
@@ -745,7 +745,7 @@ void X11SalFrame::Init( sal_uLong nSalFrameStyle, SalX11Screen nXScreen, SystemP
     m_nWorkArea = GetDisplay()->getWMAdaptor()->getCurrentWorkArea();
 
     // Pointer
-    SetPointer( POINTER_ARROW );
+    SetPointer( PointerStyle::Arrow );
 }
 
 X11SalFrame::X11SalFrame( SalFrame *pParent, sal_uLong nSalFrameStyle,
diff --git a/vcl/unx/gtk/app/gtkdata.cxx b/vcl/unx/gtk/app/gtkdata.cxx
index 0d5aea096127..df1546ac9e43 100644
--- a/vcl/unx/gtk/app/gtkdata.cxx
+++ b/vcl/unx/gtk/app/gtkdata.cxx
@@ -69,8 +69,8 @@ GtkSalDisplay::GtkSalDisplay( GdkDisplay* pDisplay ) :
             m_pGdkDisplay( pDisplay ),
             m_bStartupCompleted( false )
 {
-    for(int i = 0; i < POINTER_COUNT; i++)
-        m_aCursors[ i ] = NULL;
+    for(GdkCursor* & rpCsr : m_aCursors)
+        rpCsr = NULL;
 #if !GTK_CHECK_VERSION(3,0,0)
     m_bUseRandRWrapper = false; // use gdk signal instead
     Init ();
@@ -101,9 +101,9 @@ GtkSalDisplay::~GtkSalDisplay()
     pDisp_ = NULL;
 #endif
 
-    for(int i = 0; i < POINTER_COUNT; i++)
-        if( m_aCursors[ i ] )
-            gdk_cursor_unref( m_aCursors[ i ] );
+    for(GdkCursor* & rpCsr : m_aCursors)
+        if( rpCsr )
+            gdk_cursor_unref( rpCsr );
 }
 
 extern "C" {
@@ -338,125 +338,122 @@ GdkCursor* GtkSalDisplay::getFromXBM( const unsigned char *pBitmap,
 
 GdkCursor *GtkSalDisplay::getCursor( PointerStyle ePointerStyle )
 {
-    if( ePointerStyle >= POINTER_COUNT )
-        return NULL;
-
     if ( !m_aCursors[ ePointerStyle ] )
     {
         GdkCursor *pCursor = NULL;
 
         switch( ePointerStyle )
         {
-            MAP_BUILTIN( POINTER_ARROW, GDK_LEFT_PTR );
-            MAP_BUILTIN( POINTER_TEXT, GDK_XTERM );
-            MAP_BUILTIN( POINTER_HELP, GDK_QUESTION_ARROW );
-            MAP_BUILTIN( POINTER_CROSS, GDK_CROSSHAIR );
-            MAP_BUILTIN( POINTER_WAIT, GDK_WATCH );
-
-            MAP_BUILTIN( POINTER_NSIZE, GDK_SB_V_DOUBLE_ARROW );
-            MAP_BUILTIN( POINTER_SSIZE, GDK_SB_V_DOUBLE_ARROW );
-            MAP_BUILTIN( POINTER_WSIZE, GDK_SB_H_DOUBLE_ARROW );
-            MAP_BUILTIN( POINTER_ESIZE, GDK_SB_H_DOUBLE_ARROW );
-
-            MAP_BUILTIN( POINTER_NWSIZE, GDK_TOP_LEFT_CORNER );
-            MAP_BUILTIN( POINTER_NESIZE, GDK_TOP_RIGHT_CORNER );
-            MAP_BUILTIN( POINTER_SWSIZE, GDK_BOTTOM_LEFT_CORNER );
-            MAP_BUILTIN( POINTER_SESIZE, GDK_BOTTOM_RIGHT_CORNER );
-
-            MAP_BUILTIN( POINTER_WINDOW_NSIZE, GDK_TOP_SIDE );
-            MAP_BUILTIN( POINTER_WINDOW_SSIZE, GDK_BOTTOM_SIDE );
-            MAP_BUILTIN( POINTER_WINDOW_WSIZE, GDK_LEFT_SIDE );
-            MAP_BUILTIN( POINTER_WINDOW_ESIZE, GDK_RIGHT_SIDE );
-
-            MAP_BUILTIN( POINTER_WINDOW_NWSIZE, GDK_TOP_LEFT_CORNER );
-            MAP_BUILTIN( POINTER_WINDOW_NESIZE, GDK_TOP_RIGHT_CORNER );
-            MAP_BUILTIN( POINTER_WINDOW_SWSIZE, GDK_BOTTOM_LEFT_CORNER );
-            MAP_BUILTIN( POINTER_WINDOW_SESIZE, GDK_BOTTOM_RIGHT_CORNER );
-
-            MAP_BUILTIN( POINTER_HSIZEBAR, GDK_SB_H_DOUBLE_ARROW );
-            MAP_BUILTIN( POINTER_VSIZEBAR, GDK_SB_V_DOUBLE_ARROW );
-
-            MAP_BUILTIN( POINTER_REFHAND, GDK_HAND2 );
-            MAP_BUILTIN( POINTER_HAND, GDK_HAND2 );
-            MAP_BUILTIN( POINTER_PEN, GDK_PENCIL );
-
-            MAP_BUILTIN( POINTER_HSPLIT, GDK_SB_H_DOUBLE_ARROW );
-            MAP_BUILTIN( POINTER_VSPLIT, GDK_SB_V_DOUBLE_ARROW );
-
-            MAP_BUILTIN( POINTER_MOVE, GDK_FLEUR );
-
-            MAKE_CURSOR( POINTER_NULL, null );
-            MAKE_CURSOR( POINTER_MAGNIFY, magnify_ );
-            MAKE_CURSOR( POINTER_FILL, fill_ );
-            MAKE_CURSOR( POINTER_MOVEDATA, movedata_ );
-            MAKE_CURSOR( POINTER_COPYDATA, copydata_ );
-            MAKE_CURSOR( POINTER_MOVEFILE, movefile_ );
-            MAKE_CURSOR( POINTER_COPYFILE, copyfile_ );
-            MAKE_CURSOR( POINTER_MOVEFILES, movefiles_ );
-            MAKE_CURSOR( POINTER_COPYFILES, copyfiles_ );
-            MAKE_CURSOR( POINTER_NOTALLOWED, nodrop_ );
-            MAKE_CURSOR( POINTER_ROTATE, rotate_ );
-            MAKE_CURSOR( POINTER_HSHEAR, hshear_ );
-            MAKE_CURSOR( POINTER_VSHEAR, vshear_ );
-            MAKE_CURSOR( POINTER_DRAW_LINE, drawline_ );
-            MAKE_CURSOR( POINTER_DRAW_RECT, drawrect_ );
-            MAKE_CURSOR( POINTER_DRAW_POLYGON, drawpolygon_ );
-            MAKE_CURSOR( POINTER_DRAW_BEZIER, drawbezier_ );
-            MAKE_CURSOR( POINTER_DRAW_ARC, drawarc_ );
-            MAKE_CURSOR( POINTER_DRAW_PIE, drawpie_ );
-            MAKE_CURSOR( POINTER_DRAW_CIRCLECUT, drawcirclecut_ );
-            MAKE_CURSOR( POINTER_DRAW_ELLIPSE, drawellipse_ );
-            MAKE_CURSOR( POINTER_DRAW_CONNECT, drawconnect_ );
-            MAKE_CURSOR( POINTER_DRAW_TEXT, drawtext_ );
-            MAKE_CURSOR( POINTER_MIRROR, mirror_ );
-            MAKE_CURSOR( POINTER_CROOK, crook_ );
-            MAKE_CURSOR( POINTER_CROP, crop_ );
-            MAKE_CURSOR( POINTER_MOVEPOINT, movepoint_ );
-            MAKE_CURSOR( POINTER_MOVEBEZIERWEIGHT, movebezierweight_ );
-            MAKE_CURSOR( POINTER_DRAW_FREEHAND, drawfreehand_ );
-            MAKE_CURSOR( POINTER_DRAW_CAPTION, drawcaption_ );
-            MAKE_CURSOR( POINTER_LINKDATA, linkdata_ );
-            MAKE_CURSOR( POINTER_MOVEDATALINK, movedlnk_ );
-            MAKE_CURSOR( POINTER_COPYDATALINK, copydlnk_ );
-            MAKE_CURSOR( POINTER_LINKFILE, linkfile_ );
-            MAKE_CURSOR( POINTER_MOVEFILELINK, moveflnk_ );
-            MAKE_CURSOR( POINTER_COPYFILELINK, copyflnk_ );
-            MAKE_CURSOR( POINTER_CHART, chart_ );
-            MAKE_CURSOR( POINTER_DETECTIVE, detective_ );
-            MAKE_CURSOR( POINTER_PIVOT_COL, pivotcol_ );
-            MAKE_CURSOR( POINTER_PIVOT_ROW, pivotrow_ );
-            MAKE_CURSOR( POINTER_PIVOT_FIELD, pivotfld_ );
-            MAKE_CURSOR( POINTER_PIVOT_DELETE, pivotdel_ );
-            MAKE_CURSOR( POINTER_CHAIN, chain_ );
-            MAKE_CURSOR( POINTER_CHAIN_NOTALLOWED, chainnot_ );
-            MAKE_CURSOR( POINTER_TIMEEVENT_MOVE, timemove_ );
-            MAKE_CURSOR( POINTER_TIMEEVENT_SIZE, timesize_ );
-            MAKE_CURSOR( POINTER_AUTOSCROLL_N, asn_ );
-            MAKE_CURSOR( POINTER_AUTOSCROLL_S, ass_ );
-            MAKE_CURSOR( POINTER_AUTOSCROLL_W, asw_ );
-            MAKE_CURSOR( POINTER_AUTOSCROLL_E, ase_ );
-            MAKE_CURSOR( POINTER_AUTOSCROLL_NW, asnw_ );
-            MAKE_CURSOR( POINTER_AUTOSCROLL_NE, asne_ );
-            MAKE_CURSOR( POINTER_AUTOSCROLL_SW, assw_ );
-            MAKE_CURSOR( POINTER_AUTOSCROLL_SE, asse_ );
-            MAKE_CURSOR( POINTER_AUTOSCROLL_NS, asns_ );
-            MAKE_CURSOR( POINTER_AUTOSCROLL_WE, aswe_ );
-            MAKE_CURSOR( POINTER_AUTOSCROLL_NSWE, asnswe_ );
-            MAKE_CURSOR( POINTER_AIRBRUSH, airbrush_ );
-            MAKE_CURSOR( POINTER_TEXT_VERTICAL, vertcurs_ );
+            MAP_BUILTIN( PointerStyle::Arrow, GDK_LEFT_PTR );
+            MAP_BUILTIN( PointerStyle::Text, GDK_XTERM );
+            MAP_BUILTIN( PointerStyle::Help, GDK_QUESTION_ARROW );
+            MAP_BUILTIN( PointerStyle::Cross, GDK_CROSSHAIR );
+            MAP_BUILTIN( PointerStyle::Wait, GDK_WATCH );
+
+            MAP_BUILTIN( PointerStyle::NSize, GDK_SB_V_DOUBLE_ARROW );
+            MAP_BUILTIN( PointerStyle::SSize, GDK_SB_V_DOUBLE_ARROW );
+            MAP_BUILTIN( PointerStyle::WSize, GDK_SB_H_DOUBLE_ARROW );
+            MAP_BUILTIN( PointerStyle::ESize, GDK_SB_H_DOUBLE_ARROW );
+
+            MAP_BUILTIN( PointerStyle::NWSize, GDK_TOP_LEFT_CORNER );
+            MAP_BUILTIN( PointerStyle::NESize, GDK_TOP_RIGHT_CORNER );
+            MAP_BUILTIN( PointerStyle::SWSize, GDK_BOTTOM_LEFT_CORNER );
+            MAP_BUILTIN( PointerStyle::SESize, GDK_BOTTOM_RIGHT_CORNER );
+
+            MAP_BUILTIN( PointerStyle::WindowNSize, GDK_TOP_SIDE );
+            MAP_BUILTIN( PointerStyle::WindowSSize, GDK_BOTTOM_SIDE );
+            MAP_BUILTIN( PointerStyle::WindowWSize, GDK_LEFT_SIDE );
+            MAP_BUILTIN( PointerStyle::WindowESize, GDK_RIGHT_SIDE );
+
+            MAP_BUILTIN( PointerStyle::WindowNWSize, GDK_TOP_LEFT_CORNER );
+            MAP_BUILTIN( PointerStyle::WindowNESize, GDK_TOP_RIGHT_CORNER );
+            MAP_BUILTIN( PointerStyle::WindowSWSize, GDK_BOTTOM_LEFT_CORNER );
+            MAP_BUILTIN( PointerStyle::WindowSESize, GDK_BOTTOM_RIGHT_CORNER );
+
+            MAP_BUILTIN( PointerStyle::HSizeBar, GDK_SB_H_DOUBLE_ARROW );
+            MAP_BUILTIN( PointerStyle::VSizeBar, GDK_SB_V_DOUBLE_ARROW );
+
+            MAP_BUILTIN( PointerStyle::RefHand, GDK_HAND2 );
+            MAP_BUILTIN( PointerStyle::Hand, GDK_HAND2 );
+            MAP_BUILTIN( PointerStyle::Pen, GDK_PENCIL );
+
+            MAP_BUILTIN( PointerStyle::HSplit, GDK_SB_H_DOUBLE_ARROW );
+            MAP_BUILTIN( PointerStyle::VSplit, GDK_SB_V_DOUBLE_ARROW );
+
+            MAP_BUILTIN( PointerStyle::Move, GDK_FLEUR );
+
+            MAKE_CURSOR( PointerStyle::Null, null );
+            MAKE_CURSOR( PointerStyle::Magnify, magnify_ );
+            MAKE_CURSOR( PointerStyle::Fill, fill_ );
+            MAKE_CURSOR( PointerStyle::MoveData, movedata_ );
+            MAKE_CURSOR( PointerStyle::CopyData, copydata_ );
+            MAKE_CURSOR( PointerStyle::MoveFile, movefile_ );
+            MAKE_CURSOR( PointerStyle::CopyFile, copyfile_ );
+            MAKE_CURSOR( PointerStyle::MoveFiles, movefiles_ );
+            MAKE_CURSOR( PointerStyle::CopyFiles, copyfiles_ );
+            MAKE_CURSOR( PointerStyle::NotAllowed, nodrop_ );
+            MAKE_CURSOR( PointerStyle::Rotate, rotate_ );
+            MAKE_CURSOR( PointerStyle::HShear, hshear_ );
+            MAKE_CURSOR( PointerStyle::VShear, vshear_ );
+            MAKE_CURSOR( PointerStyle::DrawLine, drawline_ );
+            MAKE_CURSOR( PointerStyle::DrawRect, drawrect_ );
+            MAKE_CURSOR( PointerStyle::DrawPolygon, drawpolygon_ );
+            MAKE_CURSOR( PointerStyle::DrawBezier, drawbezier_ );
+            MAKE_CURSOR( PointerStyle::DrawArc, drawarc_ );
+            MAKE_CURSOR( PointerStyle::DrawPie, drawpie_ );
+            MAKE_CURSOR( PointerStyle::DrawCircleCut, drawcirclecut_ );
+            MAKE_CURSOR( PointerStyle::DrawEllipse, drawellipse_ );
+            MAKE_CURSOR( PointerStyle::DrawConnect, drawconnect_ );
+            MAKE_CURSOR( PointerStyle::DrawText, drawtext_ );
+            MAKE_CURSOR( PointerStyle::Mirror, mirror_ );
+            MAKE_CURSOR( PointerStyle::Crook, crook_ );
+            MAKE_CURSOR( PointerStyle::Crop, crop_ );
+            MAKE_CURSOR( PointerStyle::MovePoint, movepoint_ );
+            MAKE_CURSOR( PointerStyle::MoveBezierWeight, movebezierweight_ );
+            MAKE_CURSOR( PointerStyle::DrawFreehand, drawfreehand_ );
+            MAKE_CURSOR( PointerStyle::DrawCaption, drawcaption_ );
+            MAKE_CURSOR( PointerStyle::LinkData, linkdata_ );
+            MAKE_CURSOR( PointerStyle::MoveDataLink, movedlnk_ );
+            MAKE_CURSOR( PointerStyle::CopyDataLink, copydlnk_ );
+            MAKE_CURSOR( PointerStyle::LinkFile, linkfile_ );
+            MAKE_CURSOR( PointerStyle::MoveFileLink, moveflnk_ );
+            MAKE_CURSOR( PointerStyle::CopyFileLink, copyflnk_ );
+            MAKE_CURSOR( PointerStyle::Chart, chart_ );
+            MAKE_CURSOR( PointerStyle::Detective, detective_ );
+            MAKE_CURSOR( PointerStyle::PivotCol, pivotcol_ );
+            MAKE_CURSOR( PointerStyle::PivotRow, pivotrow_ );
+            MAKE_CURSOR( PointerStyle::PivotField, pivotfld_ );
+            MAKE_CURSOR( PointerStyle::PivotDelete, pivotdel_ );
+            MAKE_CURSOR( PointerStyle::Chain, chain_ );
+            MAKE_CURSOR( PointerStyle::ChainNotAllowed, chainnot_ );
+            MAKE_CURSOR( PointerStyle::TimeEventMove, timemove_ );
+            MAKE_CURSOR( PointerStyle::TimeEventSize, timesize_ );
+            MAKE_CURSOR( PointerStyle::AutoScrollN, asn_ );
+            MAKE_CURSOR( PointerStyle::AutoScrollS, ass_ );
+            MAKE_CURSOR( PointerStyle::AutoScrollW, asw_ );
+            MAKE_CURSOR( PointerStyle::AutoScrollE, ase_ );
+            MAKE_CURSOR( PointerStyle::AutoScrollNW, asnw_ );
+            MAKE_CURSOR( PointerStyle::AutoScrollNE, asne_ );
+            MAKE_CURSOR( PointerStyle::AutoScrollSW, assw_ );
+            MAKE_CURSOR( PointerStyle::AutoScrollSE, asse_ );
+            MAKE_CURSOR( PointerStyle::AutoScrollNS, asns_ );
+            MAKE_CURSOR( PointerStyle::AutoScrollWE, aswe_ );
+            MAKE_CURSOR( PointerStyle::AutoScrollNSWE, asnswe_ );
+            MAKE_CURSOR( PointerStyle::Airbrush, airbrush_ );
+            MAKE_CURSOR( PointerStyle::TextVertical, vertcurs_ );
 
             // #i32329#
-            MAKE_CURSOR( POINTER_TAB_SELECT_S, tblsels_ );
-            MAKE_CURSOR( POINTER_TAB_SELECT_E, tblsele_ );
-            MAKE_CURSOR( POINTER_TAB_SELECT_SE, tblselse_ );
-            MAKE_CURSOR( POINTER_TAB_SELECT_W, tblselw_ );
-            MAKE_CURSOR( POINTER_TAB_SELECT_SW, tblselsw_ );
+            MAKE_CURSOR( PointerStyle::TabSelectS, tblsels_ );
+            MAKE_CURSOR( PointerStyle::TabSelectE, tblsele_ );
+            MAKE_CURSOR( PointerStyle::TabSelectSE, tblselse_ );
+            MAKE_CURSOR( PointerStyle::TabSelectW, tblselw_ );
+            MAKE_CURSOR( PointerStyle::TabSelectSW, tblselsw_ );
 
             // #i20119#
-            MAKE_CURSOR( POINTER_PAINTBRUSH, paintbrush_ );
+            MAKE_CURSOR( PointerStyle::Paintbrush, paintbrush_ );
 
         default:
-            SAL_WARN( "vcl.gtk", "pointer " << ePointerStyle << "not implemented" );
+            SAL_WARN( "vcl.gtk", "pointer " << static_cast<int>(ePointerStyle) << "not implemented" );
             break;
         }
         if( !pCursor )
diff --git a/vcl/unx/gtk/window/gtksalframe.cxx b/vcl/unx/gtk/window/gtksalframe.cxx
index a43bcf80a8d2..3286267b8686 100644
--- a/vcl/unx/gtk/window/gtksalframe.cxx
+++ b/vcl/unx/gtk/window/gtksalframe.cxx
@@ -1037,7 +1037,7 @@ void GtkSalFrame::InitCommon()
     m_nGSMCookie = 0;
     m_nExtStyle         = 0;
     m_pRegion           = NULL;
-    m_ePointerStyle     = 0xffff;
+    m_ePointerStyle     = static_cast<PointerStyle>(0xffff);
     m_bSetFocusOnMap    = false;
     m_pSalMenu          = NULL;
     m_nWatcherId        = 0;
diff --git a/vcl/win/source/window/salframe.cxx b/vcl/win/source/window/salframe.cxx
index 79f4e6ee0dd6..25058c5d2edd 100644
--- a/vcl/win/source/window/salframe.cxx
+++ b/vcl/win/source/window/salframe.cxx
@@ -39,6 +39,7 @@
 #include <osl/module.h>
 
 #include <tools/debug.hxx>
+#include <o3tl/enumarray.hxx>
 
 #include <vcl/sysdata.hxx>
 #include <vcl/timer.hxx>
@@ -2061,9 +2062,9 @@ void WinSalFrame::SetPointer( PointerStyle ePointerStyle )
         UINT            mnOwnId;
     };
 
-    static ImplPtrData aImplPtrTab[POINTER_COUNT] =
+    static o3tl::enumarray<PointerStyle, ImplPtrData> aImplPtrTab =
     {
-    { 0, IDC_ARROW, 0 },                            // POINTER_ARROW
+    ImplPtrData{ 0, IDC_ARROW, 0 },                 // POINTER_ARROW
     { 0, 0, SAL_RESID_POINTER_NULL },               // POINTER_NULL
     { 0, IDC_WAIT, 0 },                             // POINTER_WAIT
     { 0, IDC_IBEAM, 0 },                            // POINTER_TEXT
@@ -2152,22 +2153,18 @@ void WinSalFrame::SetPointer( PointerStyle ePointerStyle )
     { 0, 0, SAL_RESID_POINTER_TEXT_VERTICAL },      // POINTER_TEXT_VERTICAL
     { 0, 0, SAL_RESID_POINTER_PIVOT_DELETE },       // POINTER_PIVOT_DELETE
 
-    // #i32329#
+     // #i32329#
     { 0, 0, SAL_RESID_POINTER_TAB_SELECT_S },       // POINTER_TAB_SELECT_S
     { 0, 0, SAL_RESID_POINTER_TAB_SELECT_E },       // POINTER_TAB_SELECT_E
     { 0, 0, SAL_RESID_POINTER_TAB_SELECT_SE },      // POINTER_TAB_SELECT_SE
     { 0, 0, SAL_RESID_POINTER_TAB_SELECT_W },       // POINTER_TAB_SELECT_W
     { 0, 0, SAL_RESID_POINTER_TAB_SELECT_SW },      // POINTER_TAB_SELECT_SW
 
-    // #i20119#
+     // #i20119#
     { 0, 0, SAL_RESID_POINTER_PAINTBRUSH }          // POINTER_PAINTBRUSH
 
     };
 
-#if POINTER_COUNT != 94
-#error New Pointer must be defined!
-#endif
-
     // Mousepointer loaded ?
     if ( !aImplPtrTab[ePointerStyle].mhCursor )
     {