tdf#96505 - Remove "long" integer literals in vcl/source/gdi/

Removed the "long" integer literals in "vcl/source/gdi/". Some literals are
left to match external methods

Change-Id: I55aa9bd2935bfd82c9c1cc5cd1efcc4b7c3d9346
Reviewed-on: https://gerrit.libreoffice.org/27784
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Michael Stahl <mstahl@redhat.com>

1 files changed, 53 insertions, 53 deletions

diff --git a/vcl/source/gdi/impvect.cxx b/vcl/source/gdi/impvect.cxx
index 7f0559a43209..26a4c6d520d2 100644
--- a/vcl/source/gdi/impvect.cxx
+++ b/vcl/source/gdi/impvect.cxx
@@ -39,7 +39,7 @@
 #define VECT_POLY_OUTLINE_INNER 4UL
 #define VECT_POLY_OUTLINE_OUTER 8UL
 
-#define VECT_MAP( _def_pIn, _def_pOut, _def_nVal )  _def_pOut[_def_nVal]=(_def_pIn[_def_nVal]=((_def_nVal)*4L)+1L)+5L;
+#define VECT_MAP( _def_pIn, _def_pOut, _def_nVal )  _def_pOut[_def_nVal]=(_def_pIn[_def_nVal]=((_def_nVal)*4)+1)+5;
 #define BACK_MAP( _def_nVal )                       ((((_def_nVal)+2)>>2)-1)
 #define VECT_PROGRESS( _def_pProgress, _def_nVal ) \
   if(_def_pProgress)      \
@@ -60,36 +60,36 @@ namespace ImplVectorizer
 struct ChainMove { long nDX; long nDY; };
 
 static const ChainMove aImplMove[ 8 ] =   {
-                                        { 1L, 0L },
-                                        { 0L, -1L },
-                                        { -1L, 0L },
-                                        { 0L, 1L },
-                                        { 1L, -1L },
-                                        { -1, -1L },
-                                        { -1L, 1L },
-                                        { 1L, 1L }
+                                        { 1, 0 },
+                                        { 0, -1 },
+                                        { -1, 0 },
+                                        { 0, 1 },
+                                        { 1, -1 },
+                                        { -1, -1 },
+                                        { -1, 1 },
+                                        { 1, 1 }
                                     };
 
 static const ChainMove aImplMoveInner[ 8 ] =  {
-                                            { 0L, 1L },
-                                            { 1L, 0L },
-                                            { 0L, -1L },
-                                            { -1L, 0L },
-                                            { 0L, 1L },
-                                            { 1L, 0L },
-                                            { 0L, -1L },
-                                            { -1L, 0L }
+                                            { 0, 1 },
+                                            { 1, 0 },
+                                            { 0, -1 },
+                                            { -1, 0 },
+                                            { 0, 1 },
+                                            { 1, 0 },
+                                            { 0, -1 },
+                                            { -1, 0 }
                                         };
 
 static const ChainMove aImplMoveOuter[ 8 ] =  {
-                                            { 0L, -1L },
-                                            { -1L, 0L },
-                                            { 0L, 1L },
-                                            { 1L, 0L },
-                                            { -1L, 0L },
-                                            { 0L, 1L },
-                                            { 1L, 0L },
-                                            { 0L, -1L }
+                                            { 0, -1 },
+                                            { -1, 0 },
+                                            { 0, 1 },
+                                            { 1, 0 },
+                                            { -1, 0 },
+                                            { 0, 1 },
+                                            { 1, 0 },
+                                            { 0, -1 }
                                         };
 
 struct ImplColorSet
@@ -217,14 +217,14 @@ ImplVectMap::ImplVectMap( long nWidth, long nHeight ) :
     mnWidth ( nWidth ),
     mnHeight( nHeight )
 {
-    const long  nWidthAl = ( nWidth >> 2L ) + 1L;
+    const long  nWidthAl = ( nWidth >> 2 ) + 1;
     const long  nSize = nWidthAl * nHeight;
     Scanline    pTmp = mpBuf = static_cast<Scanline>(rtl_allocateMemory( nSize ));
 
     memset( mpBuf, 0, nSize );
     mpScan = static_cast<Scanline*>(rtl_allocateMemory( nHeight * sizeof( Scanline ) ));
 
-    for( long nY = 0L; nY < nHeight; pTmp += nWidthAl )
+    for( long nY = 0; nY < nHeight; pTmp += nWidthAl )
         mpScan[ nY++ ] = pTmp;
 }
 
@@ -437,8 +437,8 @@ void ImplChain::ImplEndAdd( sal_uLong nFlag )
                 }
             }
 
-            aArr[ nPolyPos ].X() = nFirstX + 1L;
-            aArr[ nPolyPos++ ].Y() = nFirstY + 1L;
+            aArr[ nPolyPos ].X() = nFirstX + 1;
+            aArr[ nPolyPos++ ].Y() = nFirstY + 1;
             aArr.ImplSetRealSize( nPolyPos );
         }
         else if( nFlag & VECT_POLY_INLINE_OUTER )
@@ -544,8 +544,8 @@ void ImplChain::ImplEndAdd( sal_uLong nFlag )
                 }
             }
 
-            aArr[ nPolyPos ].X() = nFirstX - 1L;
-            aArr[ nPolyPos++ ].Y() = nFirstY - 1L;
+            aArr[ nPolyPos ].X() = nFirstX - 1;
+            aArr[ nPolyPos++ ].Y() = nFirstY - 1;
             aArr.ImplSetRealSize( nPolyPos );
         }
         else
@@ -662,8 +662,8 @@ bool ImplVectorize( const Bitmap& rColorBmp, GDIMetaFile& rMtf,
             pColorSet[ n ].maColor = pRAcc->GetPaletteColor( n );
         }
 
-        for( long nY = 0L; nY < nHeight; nY++ )
-            for( long nX = 0L; nX < nWidth; nX++ )
+        for( long nY = 0; nY < nHeight; nY++ )
+            for( long nX = 0; nX < nWidth; nX++ )
                 pColorSet[ pRAcc->GetPixel( nY, nX ).GetIndex() ].mbSet = true;
 
         qsort( pColorSet, 256, sizeof( ImplColorSet ), ImplColorSetCmpFnc );
@@ -856,8 +856,8 @@ ImplVectMap* ImplExpand( BitmapReadAccess* pRAcc, const Color& rColor )
     {
         const long          nOldWidth = pRAcc->Width();
         const long          nOldHeight = pRAcc->Height();
-        const long          nNewWidth = ( nOldWidth << 2L ) + 4L;
-        const long          nNewHeight = ( nOldHeight << 2L ) + 4L;
+        const long          nNewWidth = ( nOldWidth << 2 ) + 4;
+        const long          nNewHeight = ( nOldHeight << 2 ) + 4;
         const BitmapColor   aTest( pRAcc->GetBestMatchingColor( rColor ) );
         std::unique_ptr<long[]> pMapIn(new long[ std::max( nOldWidth, nOldHeight ) ]);
         std::unique_ptr<long[]> pMapOut(new long[ std::max( nOldWidth, nOldHeight ) ]);
@@ -865,17 +865,17 @@ ImplVectMap* ImplExpand( BitmapReadAccess* pRAcc, const Color& rColor )
 
         pMap = new ImplVectMap( nNewWidth, nNewHeight );
 
-        for( nX = 0L; nX < nOldWidth; nX++ )
+        for( nX = 0; nX < nOldWidth; nX++ )
             VECT_MAP( pMapIn, pMapOut, nX );
 
-        for( nY = 0L, nTmpY = 5L; nY < nOldHeight; nY++, nTmpY += 4L )
+        for( nY = 0, nTmpY = 5; nY < nOldHeight; nY++, nTmpY += 4 )
         {
-            for( nX = 0L; nX < nOldWidth; )
+            for( nX = 0; nX < nOldWidth; )
             {
                 if( pRAcc->GetPixel( nY, nX ) == aTest )
                 {
                     nTmpX = pMapIn[ nX++ ];
-                    nTmpY -= 3L;
+                    nTmpY -= 3;
 
                     pMap->Set( nTmpY++, nTmpX, VECT_CONT_INDEX );
                     pMap->Set( nTmpY++, nTmpX, VECT_CONT_INDEX );
@@ -885,8 +885,8 @@ ImplVectMap* ImplExpand( BitmapReadAccess* pRAcc, const Color& rColor )
                     while( nX < nOldWidth && pRAcc->GetPixel( nY, nX ) == aTest )
                          nX++;
 
-                    nTmpX = pMapOut[ nX - 1L ];
-                    nTmpY -= 3L;
+                    nTmpX = pMapOut[ nX - 1 ];
+                    nTmpY -= 3;
 
                     pMap->Set( nTmpY++, nTmpX, VECT_CONT_INDEX );
                     pMap->Set( nTmpY++, nTmpX, VECT_CONT_INDEX );
@@ -898,16 +898,16 @@ ImplVectMap* ImplExpand( BitmapReadAccess* pRAcc, const Color& rColor )
             }
         }
 
-        for( nY = 0L; nY < nOldHeight; nY++ )
+        for( nY = 0; nY < nOldHeight; nY++ )
             VECT_MAP( pMapIn, pMapOut, nY );
 
-        for( nX = 0L, nTmpX = 5L; nX < nOldWidth; nX++, nTmpX += 4L )
+        for( nX = 0, nTmpX = 5; nX < nOldWidth; nX++, nTmpX += 4 )
         {
-            for( nY = 0L; nY < nOldHeight; )
+            for( nY = 0; nY < nOldHeight; )
             {
                 if( pRAcc->GetPixel( nY, nX ) == aTest )
                 {
-                    nTmpX -= 3L;
+                    nTmpX -= 3;
                     nTmpY = pMapIn[ nY++ ];
 
                     pMap->Set( nTmpY, nTmpX++, VECT_CONT_INDEX );
@@ -918,8 +918,8 @@ ImplVectMap* ImplExpand( BitmapReadAccess* pRAcc, const Color& rColor )
                     while( nY < nOldHeight && pRAcc->GetPixel( nY, nX ) == aTest )
                         nY++;
 
-                    nTmpX -= 3L;
-                    nTmpY = pMapOut[ nY - 1L ];
+                    nTmpX -= 3;
+                    nTmpY = pMapOut[ nY - 1 ];
 
                     pMap->Set( nTmpY, nTmpX++, VECT_CONT_INDEX );
                     pMap->Set( nTmpY, nTmpX++, VECT_CONT_INDEX );
@@ -939,9 +939,9 @@ void ImplCalculate( ImplVectMap* pMap, tools::PolyPolygon& rPolyPoly, sal_uInt8
 {
     const long nWidth = pMap->Width(), nHeight= pMap->Height();
 
-    for( long nY = 0L; nY < nHeight; nY++ )
+    for( long nY = 0; nY < nHeight; nY++ )
     {
-        long    nX = 0L;
+        long    nX = 0;
         bool    bInner = true;
 
         while( nX < nWidth )
@@ -992,7 +992,7 @@ void ImplCalculate( ImplVectMap* pMap, tools::PolyPolygon& rPolyPoly, sal_uInt8
                 while( pMap->IsDone( nY, nX ) )
                     nX++;
 
-                if( ( ( nX - nStartSegX ) == 1L ) || ( ImplIsUp( pMap, nY, nStartSegX ) != ImplIsUp( pMap, nY, nX - 1L ) ) )
+                if( ( ( nX - nStartSegX ) == 1 ) || ( ImplIsUp( pMap, nY, nStartSegX ) != ImplIsUp( pMap, nY, nX - 1 ) ) )
                     bInner = !bInner;
             }
         }
@@ -1051,11 +1051,11 @@ bool ImplGetChain(  ImplVectMap* pMap, const Point& rStartPt, ImplChain& rChain
 
 bool ImplIsUp( ImplVectMap* pMap, long nY, long nX )
 {
-    if( pMap->IsDone( nY - 1L, nX ) )
+    if( pMap->IsDone( nY - 1, nX ) )
         return true;
-    else if( pMap->IsDone( nY + 1L, nX ) )
+    else if( pMap->IsDone( nY + 1, nX ) )
         return false;
-    else if( pMap->IsDone( nY - 1L, nX - 1L ) || pMap->IsDone( nY - 1L, nX + 1L ) )
+    else if( pMap->IsDone( nY - 1, nX - 1 ) || pMap->IsDone( nY - 1, nX + 1 ) )
         return true;
     else
         return false;