tdf#96505 Remove 0L occurences from avmedia and basegfx modules

No compiler warnings on my machine

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

14 files changed, 166 insertions, 166 deletions

diff --git a/basegfx/source/curve/b2dcubicbezier.cxx b/basegfx/source/curve/b2dcubicbezier.cxx
index 612922a99fa6..ffa5a6ec8ea8 100644
--- a/basegfx/source/curve/b2dcubicbezier.cxx
+++ b/basegfx/source/curve/b2dcubicbezier.cxx
@@ -678,10 +678,10 @@ namespace basegfx
 
         // now look for the closest point
         const sal_uInt32 nPointCount(aInitialPolygon.count());
-        B2DVector aVector(rTestPoint - aInitialPolygon.getB2DPoint(0L));
+        B2DVector aVector(rTestPoint - aInitialPolygon.getB2DPoint(0));
         double fQuadDist(aVector.getX() * aVector.getX() + aVector.getY() * aVector.getY());
         double fNewQuadDist;
-        sal_uInt32 nSmallestIndex(0L);
+        sal_uInt32 nSmallestIndex(0);
 
         for(sal_uInt32 a(1L); a < nPointCount; a++)
         {
diff --git a/basegfx/source/polygon/b2dlinegeometry.cxx b/basegfx/source/polygon/b2dlinegeometry.cxx
index 33dd5707a4fb..9d055206b913 100644
--- a/basegfx/source/polygon/b2dlinegeometry.cxx
+++ b/basegfx/source/polygon/b2dlinegeometry.cxx
@@ -47,7 +47,7 @@ namespace basegfx
         {
             B2DPolyPolygon aRetval;
             OSL_ENSURE(rCandidate.count() > 1L, "createAreaGeometryForLineStartEnd: Line polygon has too less points (!)");
-            OSL_ENSURE(rArrow.count() > 0L, "createAreaGeometryForLineStartEnd: Empty arrow tools::PolyPolygon (!)");
+            OSL_ENSURE(rArrow.count() > 0, "createAreaGeometryForLineStartEnd: Empty arrow tools::PolyPolygon (!)");
             OSL_ENSURE(fWidth > 0.0, "createAreaGeometryForLineStartEnd: Width too small (!)");
             OSL_ENSURE(fDockingPosition >= 0.0 && fDockingPosition <= 1.0,
                 "createAreaGeometryForLineStartEnd: fDockingPosition out of range [0.0 .. 1.0] (!)");
@@ -98,7 +98,7 @@ namespace basegfx
 
                 // get the polygon vector we want to plant this arrow on
                 const double fConsumedLength(fArrowYLength * (1.0 - fDockingPosition) - fShift);
-                const B2DVector aHead(rCandidate.getB2DPoint((bStart) ? 0L : rCandidate.count() - 1L));
+                const B2DVector aHead(rCandidate.getB2DPoint((bStart) ? 0 : rCandidate.count() - 1L));
                 const B2DVector aTail(getPositionAbsolute(rCandidate,
                     (bStart) ? fConsumedLength : fCandidateLength - fConsumedLength, fCandidateLength));
 
diff --git a/basegfx/source/polygon/b2dpolygonclipper.cxx b/basegfx/source/polygon/b2dpolygonclipper.cxx
index fcf6fa00642b..d8123edcd881 100644
--- a/basegfx/source/polygon/b2dpolygonclipper.cxx
+++ b/basegfx/source/polygon/b2dpolygonclipper.cxx
@@ -97,7 +97,7 @@ namespace basegfx
                     B2DCubicBezier aEdge;
                     B2DPolygon aRun;
 
-                    for(sal_uInt32 a(0L); a < nEdgeCount; a++)
+                    for(sal_uInt32 a(0); a < nEdgeCount; a++)
                     {
                         aCandidate.getBezierSegment(a, aEdge);
                         const B2DPoint aTestPoint(aEdge.interpolatePoint(0.5));
@@ -169,7 +169,7 @@ namespace basegfx
             const sal_uInt32 nPolygonCount(rCandidate.count());
             B2DPolyPolygon aRetval;
 
-            for(sal_uInt32 a(0L); a < nPolygonCount; a++)
+            for(sal_uInt32 a(0); a < nPolygonCount; a++)
             {
                 const B2DPolyPolygon aClippedPolyPolygon(clipPolygonOnParallelAxis(rCandidate.getB2DPolygon(a), bParallelToXAxis, bAboveAxis, fValueOnOtherAxis, bStroke));
 
@@ -249,7 +249,7 @@ namespace basegfx
                 // against Y-Axis, lower value
                 if(1L == aRetval.count())
                 {
-                    aRetval = clipPolygonOnParallelAxis(aRetval.getB2DPolygon(0L), false, bInside, rRange.getMinX(), bStroke);
+                    aRetval = clipPolygonOnParallelAxis(aRetval.getB2DPolygon(0), false, bInside, rRange.getMinX(), bStroke);
                 }
                 else
                 {
@@ -261,7 +261,7 @@ namespace basegfx
                     // against X-Axis, higher value
                     if(1L == aRetval.count())
                     {
-                        aRetval = clipPolygonOnParallelAxis(aRetval.getB2DPolygon(0L), true, !bInside, rRange.getMaxY(), bStroke);
+                        aRetval = clipPolygonOnParallelAxis(aRetval.getB2DPolygon(0), true, !bInside, rRange.getMaxY(), bStroke);
                     }
                     else
                     {
@@ -273,7 +273,7 @@ namespace basegfx
                         // against Y-Axis, higher value
                         if(1L == aRetval.count())
                         {
-                            aRetval = clipPolygonOnParallelAxis(aRetval.getB2DPolygon(0L), false, !bInside, rRange.getMaxX(), bStroke);
+                            aRetval = clipPolygonOnParallelAxis(aRetval.getB2DPolygon(0), false, !bInside, rRange.getMaxX(), bStroke);
                         }
                         else
                         {
@@ -313,7 +313,7 @@ namespace basegfx
 
             if(bInside)
             {
-                for(sal_uInt32 a(0L); a < nPolygonCount; a++)
+                for(sal_uInt32 a(0); a < nPolygonCount; a++)
                 {
                     const B2DPolyPolygon aClippedPolyPolygon(clipPolygonOnRange(rCandidate.getB2DPolygon(a), rRange, bInside, bStroke));
 
diff --git a/basegfx/source/polygon/b2dpolygoncutandtouch.cxx b/basegfx/source/polygon/b2dpolygoncutandtouch.cxx
index 378c8586ed14..1d4405fac5c8 100644
--- a/basegfx/source/polygon/b2dpolygoncutandtouch.cxx
+++ b/basegfx/source/polygon/b2dpolygoncutandtouch.cxx
@@ -101,12 +101,12 @@ namespace basegfx
 
                     // prepare loop
                     B2DCubicBezier aEdge;
-                    sal_uInt32 nNewInd(0L);
+                    sal_uInt32 nNewInd(0);
 
                     // add start point
                     aRetval.append(rCandidate.getB2DPoint(0));
 
-                    for(sal_uInt32 a(0L); a < nCount; a++)
+                    for(sal_uInt32 a(0); a < nCount; a++)
                     {
                         // get edge
                         rCandidate.getBezierSegment(a, aEdge);
@@ -180,11 +180,11 @@ namespace basegfx
             // cut positions in the polygon to relative cut positions on the original bezier
             // segment.
             const sal_uInt32 nTempPointCount(rPointVector.size());
-            const sal_uInt32 nEdgeCount(rPolygon.count() ? rPolygon.count() - 1L : 0L);
+            const sal_uInt32 nEdgeCount(rPolygon.count() ? rPolygon.count() - 1L : 0);
 
             if(nTempPointCount && nEdgeCount)
             {
-                for(sal_uInt32 a(0L); a < nTempPointCount; a++)
+                for(sal_uInt32 a(0); a < nTempPointCount; a++)
                 {
                     const temporaryPoint& rTempPoint = rPointVector[a];
                     const double fCutPosInPolygon((double)rTempPoint.getIndex() + rTempPoint.getCut());
@@ -283,15 +283,15 @@ namespace basegfx
             {
                 const sal_uInt32 nEdgeCountA(nPointCountA - 1);
                 const sal_uInt32 nEdgeCountB(nPointCountB - 1);
-                B2DPoint aCurrA(rCandidateA.getB2DPoint(0L));
+                B2DPoint aCurrA(rCandidateA.getB2DPoint(0));
 
-                for(sal_uInt32 a(0L); a < nEdgeCountA; a++)
+                for(sal_uInt32 a(0); a < nEdgeCountA; a++)
                 {
                     const B2DPoint aNextA(rCandidateA.getB2DPoint(a + 1L));
                     const B2DRange aRangeA(aCurrA, aNextA);
-                    B2DPoint aCurrB(rCandidateB.getB2DPoint(0L));
+                    B2DPoint aCurrB(rCandidateB.getB2DPoint(0));
 
-                    for(sal_uInt32 b(0L); b < nEdgeCountB; b++)
+                    for(sal_uInt32 b(0); b < nEdgeCountB; b++)
                     {
                         const B2DPoint aNextB(rCandidateB.getB2DPoint(b + 1L));
                         const B2DRange aRangeB(aCurrB, aNextB);
@@ -412,7 +412,7 @@ namespace basegfx
             }
 
             // append remapped tempVector entries for edge to tempPoints for edge
-            for(size_t a(0L); a < aTempPointVectorEdge.size(); a++)
+            for(size_t a(0); a < aTempPointVectorEdge.size(); a++)
             {
                 const temporaryPoint& rTempPoint = aTempPointVectorEdge[a];
                 rTempPointsB.push_back(temporaryPoint(rTempPoint.getPoint(), nIndB, rTempPoint.getCut()));
@@ -508,7 +508,7 @@ namespace basegfx
                         B2DCubicBezier aCubicA;
                         B2DCubicBezier aCubicB;
 
-                        for(sal_uInt32 a(0L); a < nEdgeCount - 1L; a++)
+                        for(sal_uInt32 a(0); a < nEdgeCount - 1L; a++)
                         {
                             rCandidate.getBezierSegment(a, aCubicA);
                             aCubicA.testAndSolveTrivialBezier();
@@ -564,17 +564,17 @@ namespace basegfx
                     }
                     else
                     {
-                        B2DPoint aCurrA(rCandidate.getB2DPoint(0L));
+                        B2DPoint aCurrA(rCandidate.getB2DPoint(0));
 
-                        for(sal_uInt32 a(0L); a < nEdgeCount - 1L; a++)
+                        for(sal_uInt32 a(0); a < nEdgeCount - 1L; a++)
                         {
-                            const B2DPoint aNextA(rCandidate.getB2DPoint(a + 1L == nPointCount ? 0L : a + 1L));
+                            const B2DPoint aNextA(rCandidate.getB2DPoint(a + 1L == nPointCount ? 0 : a + 1L));
                             const B2DRange aRangeA(aCurrA, aNextA);
                             B2DPoint aCurrB(rCandidate.getB2DPoint(a + 1L));
 
                             for(sal_uInt32 b(a + 1L); b < nEdgeCount; b++)
                             {
-                                const B2DPoint aNextB(rCandidate.getB2DPoint(b + 1L == nPointCount ? 0L : b + 1L));
+                                const B2DPoint aNextB(rCandidate.getB2DPoint(b + 1L == nPointCount ? 0 : b + 1L));
                                 const B2DRange aRangeB(aCurrB, aNextB);
 
                                 // consecutive segments touch of course
@@ -622,7 +622,7 @@ namespace basegfx
                 const B2DVector aEdgeVector(rNext - rCurr);
                 bool bTestUsingX(fabs(aEdgeVector.getX()) > fabs(aEdgeVector.getY()));
 
-                for(sal_uInt32 a(0L); a < nPointCount; a++)
+                for(sal_uInt32 a(0); a < nPointCount; a++)
                 {
                     const B2DPoint aTestPoint(rPointPolygon.getB2DPoint(a));
 
@@ -687,7 +687,7 @@ namespace basegfx
                 const sal_uInt32 nEdgeCount(rEdgePolygon.isClosed() ? nEdgePointCount : nEdgePointCount - 1L);
                 B2DPoint aCurr(rEdgePolygon.getB2DPoint(0));
 
-                for(sal_uInt32 a(0L); a < nEdgeCount; a++)
+                for(sal_uInt32 a(0); a < nEdgeCount; a++)
                 {
                     const sal_uInt32 nNextIndex((a + 1) % nEdgePointCount);
                     const B2DPoint aNext(rEdgePolygon.getB2DPoint(nNextIndex));
@@ -751,14 +751,14 @@ namespace basegfx
                         B2DCubicBezier aCubicA;
                         B2DCubicBezier aCubicB;
 
-                        for(sal_uInt32 a(0L); a < nEdgeCountA; a++)
+                        for(sal_uInt32 a(0); a < nEdgeCountA; a++)
                         {
                             rCandidateA.getBezierSegment(a, aCubicA);
                             aCubicA.testAndSolveTrivialBezier();
                             const bool bEdgeAIsCurve(aCubicA.isBezier());
                             const B2DRange aRangeA(aCubicA.getRange());
 
-                            for(sal_uInt32 b(0L); b < nEdgeCountB; b++)
+                            for(sal_uInt32 b(0); b < nEdgeCountB; b++)
                             {
                                 rCandidateB.getBezierSegment(b, aCubicB);
                                 aCubicB.testAndSolveTrivialBezier();
@@ -800,17 +800,17 @@ namespace basegfx
                     }
                     else
                     {
-                        B2DPoint aCurrA(rCandidateA.getB2DPoint(0L));
+                        B2DPoint aCurrA(rCandidateA.getB2DPoint(0));
 
-                        for(sal_uInt32 a(0L); a < nEdgeCountA; a++)
+                        for(sal_uInt32 a(0); a < nEdgeCountA; a++)
                         {
-                            const B2DPoint aNextA(rCandidateA.getB2DPoint(a + 1L == nPointCountA ? 0L : a + 1L));
+                            const B2DPoint aNextA(rCandidateA.getB2DPoint(a + 1L == nPointCountA ? 0 : a + 1L));
                             const B2DRange aRangeA(aCurrA, aNextA);
-                            B2DPoint aCurrB(rCandidateB.getB2DPoint(0L));
+                            B2DPoint aCurrB(rCandidateB.getB2DPoint(0));
 
-                            for(sal_uInt32 b(0L); b < nEdgeCountB; b++)
+                            for(sal_uInt32 b(0); b < nEdgeCountB; b++)
                             {
-                                const B2DPoint aNextB(rCandidateB.getB2DPoint(b + 1L == nPointCountB ? 0L : b + 1L));
+                                const B2DPoint aNextB(rCandidateB.getB2DPoint(b + 1L == nPointCountB ? 0 : b + 1L));
                                 const B2DRange aRangeB(aCurrB, aNextB);
 
                                 // consecutive segments touch of course
@@ -875,7 +875,7 @@ namespace basegfx
                     if(bSelfIntersections)
                     {
                         // remove self intersections
-                        aRetval.append(addPointsAtCutsAndTouches(rCandidate.getB2DPolygon(0L)));
+                        aRetval.append(addPointsAtCutsAndTouches(rCandidate.getB2DPolygon(0)));
                     }
                     else
                     {
@@ -889,7 +889,7 @@ namespace basegfx
                     std::unique_ptr<temporaryPolygonData[]> pTempData(new temporaryPolygonData[nCount]);
                     sal_uInt32 a, b;
 
-                    for(a = 0L; a < nCount; a++)
+                    for(a = 0; a < nCount; a++)
                     {
                         if(bSelfIntersections)
                         {
@@ -904,9 +904,9 @@ namespace basegfx
                     }
 
                     // now cuts and touches between the polygons
-                    for(a = 0L; a < nCount; a++)
+                    for(a = 0; a < nCount; a++)
                     {
-                        for(b = 0L; b < nCount; b++)
+                        for(b = 0; b < nCount; b++)
                         {
                             if(a != b)
                             {
@@ -929,7 +929,7 @@ namespace basegfx
                     }
 
                     // consolidate the result
-                    for(a = 0L; a < nCount; a++)
+                    for(a = 0; a < nCount; a++)
                     {
                         aRetval.append(mergeTemporaryPointsAndPolygon(pTempData[a].getPolygon(), pTempData[a].getTemporaryPointVector()));
                     }
diff --git a/basegfx/source/polygon/b2dpolygontools.cxx b/basegfx/source/polygon/b2dpolygontools.cxx
index 3eee5a5377f9..4ec182ec939b 100644
--- a/basegfx/source/polygon/b2dpolygontools.cxx
+++ b/basegfx/source/polygon/b2dpolygontools.cxx
@@ -128,7 +128,7 @@ namespace basegfx
             }
             else if(nIndex + 1L == rCandidate.count())
             {
-                return 0L;
+                return 0;
             }
             else
             {
@@ -186,7 +186,7 @@ namespace basegfx
                     // add start point (always)
                     aRetval.append(aBezier.getStartPoint());
 
-                    for(sal_uInt32 a(0L); a < nEdgeCount; a++)
+                    for(sal_uInt32 a(0); a < nEdgeCount; a++)
                     {
                         // get next and control points
                         const sal_uInt32 nNextIndex((a + 1) % nPointCount);
@@ -283,7 +283,7 @@ namespace basegfx
                         fAngleBound = 0.1;
                     }
 
-                    for(sal_uInt32 a(0L); a < nEdgeCount; a++)
+                    for(sal_uInt32 a(0); a < nEdgeCount; a++)
                     {
                         // get next and control points
                         const sal_uInt32 nNextIndex((a + 1) % nPointCount);
@@ -343,12 +343,12 @@ namespace basegfx
                     aRetval.append(aBezier.getStartPoint());
 
                     // #i37443# prepare convenient count if none was given
-                    if(0L == nCount)
+                    if(0 == nCount)
                     {
                         nCount = COUNT_SUBDIVIDE_DEFAULT;
                     }
 
-                    for(sal_uInt32 a(0L); a < nEdgeCount; a++)
+                    for(sal_uInt32 a(0); a < nEdgeCount; a++)
                     {
                         // get next and control points
                         const sal_uInt32 nNextIndex((a + 1) % nPointCount);
@@ -404,7 +404,7 @@ namespace basegfx
                 {
                     B2DPoint aCurrentPoint(aCandidate.getB2DPoint(nPointCount - 1L));
 
-                    for(sal_uInt32 a(0L); a < nPointCount; a++)
+                    for(sal_uInt32 a(0); a < nPointCount; a++)
                     {
                         const B2DPoint aPreviousPoint(aCurrentPoint);
                         aCurrentPoint = aCandidate.getB2DPoint(a);
@@ -452,7 +452,7 @@ namespace basegfx
             const B2DPolygon aPolygon(rPolygon.areControlPointsUsed() ? rPolygon.getDefaultAdaptiveSubdivision() : rPolygon);
             const sal_uInt32 nPointCount(aPolygon.count());
 
-            for(sal_uInt32 a(0L); a < nPointCount; a++)
+            for(sal_uInt32 a(0); a < nPointCount; a++)
             {
                 const B2DPoint aTestPoint(aPolygon.getB2DPoint(a));
 
@@ -479,7 +479,7 @@ namespace basegfx
 
             if(nPointCount > 2)
             {
-                for(sal_uInt32 a(0L); a < nPointCount; a++)
+                for(sal_uInt32 a(0); a < nPointCount; a++)
                 {
                     const B2DPoint aPreviousPoint(aCandidate.getB2DPoint((!a) ? nPointCount - 1L : a - 1L));
                     const B2DPoint aCurrentPoint(aCandidate.getB2DPoint(a));
@@ -607,7 +607,7 @@ namespace basegfx
             else if(nPointCount > 1L)
             {
                 const sal_uInt32 nEdgeCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1);
-                sal_uInt32 nIndex(0L);
+                sal_uInt32 nIndex(0);
                 bool bIndexDone(false);
 
                 // get length if not given
@@ -788,7 +788,7 @@ namespace basegfx
                     bool bStartDone(false);
                     bool bEndDone(false);
 
-                    for(sal_uInt32 a(0L); !(bStartDone && bEndDone) && a < nEdgeCount; a++)
+                    for(sal_uInt32 a(0); !(bStartDone && bEndDone) && a < nEdgeCount; a++)
                     {
                         const double fEdgeLength(getEdgeLength(rCandidate, a));
 
@@ -1972,9 +1972,9 @@ namespace basegfx
             if(nPointCount > 2L)
             {
                 B2DPoint aPrevPoint(rCandidate.getB2DPoint(nPointCount - 1L));
-                B2DPoint aCurrPoint(rCandidate.getB2DPoint(0L));
+                B2DPoint aCurrPoint(rCandidate.getB2DPoint(0));
 
-                for(sal_uInt32 a(0L); a < nPointCount; a++)
+                for(sal_uInt32 a(0); a < nPointCount; a++)
                 {
                     const B2DPoint aNextPoint(rCandidate.getB2DPoint((a + 1) % nPointCount));
                     const B2DVector aPrevVec(aPrevPoint - aCurrPoint);
@@ -2005,9 +2005,9 @@ namespace basegfx
                 const sal_uInt32 nPointCount(rCandidate.count());
                 B2DPolygon aRetval;
                 B2DPoint aPrevPoint(rCandidate.getB2DPoint(nPointCount - 1L));
-                B2DPoint aCurrPoint(rCandidate.getB2DPoint(0L));
+                B2DPoint aCurrPoint(rCandidate.getB2DPoint(0));
 
-                for(sal_uInt32 a(0L); a < nPointCount; a++)
+                for(sal_uInt32 a(0); a < nPointCount; a++)
                 {
                     const B2DPoint aNextPoint(rCandidate.getB2DPoint((a + 1) % nPointCount));
                     const B2DVector aPrevVec(aPrevPoint - aCurrPoint);
@@ -2030,9 +2030,9 @@ namespace basegfx
                     }
                 }
 
-                while(aRetval.count() && B2VectorOrientation::Neutral == getOrientationForIndex(aRetval, 0L))
+                while(aRetval.count() && B2VectorOrientation::Neutral == getOrientationForIndex(aRetval, 0))
                 {
-                    aRetval.remove(0L);
+                    aRetval.remove(0);
                 }
 
                 // copy closed state
@@ -2054,11 +2054,11 @@ namespace basegfx
             if(nPointCount > 2L)
             {
                 const B2DPoint aPrevPoint(rCandidate.getB2DPoint(nPointCount - 1L));
-                B2DPoint aCurrPoint(rCandidate.getB2DPoint(0L));
+                B2DPoint aCurrPoint(rCandidate.getB2DPoint(0));
                 B2DVector aCurrVec(aPrevPoint - aCurrPoint);
                 B2VectorOrientation aOrientation(B2VectorOrientation::Neutral);
 
-                for(sal_uInt32 a(0L); a < nPointCount; a++)
+                for(sal_uInt32 a(0); a < nPointCount; a++)
                 {
                     const B2DPoint aNextPoint(rCandidate.getB2DPoint((a + 1) % nPointCount));
                     const B2DVector aNextVec(aNextPoint - aCurrPoint);
@@ -2142,9 +2142,9 @@ namespace basegfx
             if(nPointCount > 1L)
             {
                 const sal_uInt32 nLoopCount(aCandidate.isClosed() ? nPointCount : nPointCount - 1L);
-                B2DPoint aCurrentPoint(aCandidate.getB2DPoint(0L));
+                B2DPoint aCurrentPoint(aCandidate.getB2DPoint(0));
 
-                for(sal_uInt32 a(0L); a < nLoopCount; a++)
+                for(sal_uInt32 a(0); a < nLoopCount; a++)
                 {
                     const B2DPoint aNextPoint(aCandidate.getB2DPoint((a + 1L) % nPointCount));
 
@@ -2158,7 +2158,7 @@ namespace basegfx
             }
             else if(nPointCount && bWithPoints)
             {
-                return rPoint.equal(aCandidate.getB2DPoint(0L));
+                return rPoint.equal(aCandidate.getB2DPoint(0));
             }
 
             return false;
@@ -2214,7 +2214,7 @@ namespace basegfx
 
             if(nCount > 2L)
             {
-                const B2DPoint aStart(rCandidate.getB2DPoint(0L));
+                const B2DPoint aStart(rCandidate.getB2DPoint(0));
                 B2DPoint aLast(rCandidate.getB2DPoint(1L));
 
                 for(sal_uInt32 a(2L); a < nCount; a++)
@@ -2351,7 +2351,7 @@ namespace basegfx
             {
                 B3DPolygon aRetval;
 
-                for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
+                for(sal_uInt32 a(0); a < rCandidate.count(); a++)
                 {
                     B2DPoint aPoint(rCandidate.getB2DPoint(a));
                     aRetval.append(B3DPoint(aPoint.getX(), aPoint.getY(), fZCoordinate));
@@ -2370,7 +2370,7 @@ namespace basegfx
             const sal_uInt32 nCount(rCandidate.count());
             const bool bIsIdentity(rMat.isIdentity());
 
-            for(sal_uInt32 a(0L); a < nCount; a++)
+            for(sal_uInt32 a(0); a < nCount; a++)
             {
                 B3DPoint aCandidate(rCandidate.getB3DPoint(a));
 
@@ -2441,7 +2441,7 @@ namespace basegfx
                 B2DCubicBezier aBezier;
                 aBezier.setStartPoint(rCandidate.getB2DPoint(0));
 
-                for(sal_uInt32 a(0L); a < nEdgeCount; a++)
+                for(sal_uInt32 a(0); a < nEdgeCount; a++)
                 {
                     const sal_uInt32 nNextIndex((a + 1) % nPointCount);
                     aBezier.setEndPoint(rCandidate.getB2DPoint(nNextIndex));
@@ -2535,7 +2535,7 @@ namespace basegfx
             {
                 B2DPolygon aRetval;
 
-                for(sal_uInt32 a(0L); a < nPointCount; a++)
+                for(sal_uInt32 a(0); a < nPointCount; a++)
                 {
                     aRetval.append(distort(rCandidate.getB2DPoint(a), rOriginal, rTopLeft, rTopRight, rBottomLeft, rBottomRight));
 
@@ -2566,7 +2566,7 @@ namespace basegfx
         {
             B2DPolygon aRetval(rCandidate);
 
-            for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
+            for(sal_uInt32 a(0); a < rCandidate.count(); a++)
             {
                 expandToCurveInPoint(aRetval, a);
             }
@@ -2786,11 +2786,11 @@ namespace basegfx
                     if(nPointCount)
                     {
                         B2DPoint aPrev(rCandidate.getB2DPoint(nPointCount - 1L));
-                        B2DPoint aCurrent(rCandidate.getB2DPoint(0L));
+                        B2DPoint aCurrent(rCandidate.getB2DPoint(0));
 
-                        for(sal_uInt32 a(0L); a < nPointCount; a++)
+                        for(sal_uInt32 a(0); a < nPointCount; a++)
                         {
-                            const B2DPoint aNext(rCandidate.getB2DPoint(a + 1L == nPointCount ? 0L : a + 1L));
+                            const B2DPoint aNext(rCandidate.getB2DPoint(a + 1L == nPointCount ? 0 : a + 1L));
                             const B2DVector aBack(aPrev - aCurrent);
                             const B2DVector aForw(aNext - aCurrent);
                             const B2DVector aPerpBack(getNormalizedPerpendicular(aBack));
@@ -2837,7 +2837,7 @@ namespace basegfx
                     const double fLength(getLength(rCandidate));
                     const sal_uInt32 nLoopCount(rCandidate.isClosed() ? nSegments : nSegments + 1L);
 
-                    for(sal_uInt32 a(0L); a < nLoopCount; a++)
+                    for(sal_uInt32 a(0); a < nLoopCount; a++)
                     {
                         const double fRelativePos((double)a / (double)nSegments); // 0.0 .. 1.0
                         const B2DPoint aNewPoint(getPositionRelative(rCandidate, fRelativePos, fLength));
@@ -2870,7 +2870,7 @@ namespace basegfx
                 const bool bInterpolateVectors(rOld1.areControlPointsUsed() || rOld2.areControlPointsUsed());
                 aRetval.setClosed(rOld1.isClosed() && rOld2.isClosed());
 
-                for(sal_uInt32 a(0L); a < rOld1.count(); a++)
+                for(sal_uInt32 a(0); a < rOld1.count(); a++)
                 {
                     aRetval.append(interpolate(rOld1.getB2DPoint(a), rOld2.getB2DPoint(a), t));
 
@@ -2904,7 +2904,7 @@ namespace basegfx
                 // add start point
                 aRetval.append(aBezier.getStartPoint());
 
-                for(sal_uInt32 a(0L); a < nEdgeCount; a++)
+                for(sal_uInt32 a(0); a < nEdgeCount; a++)
                 {
                     // get values for edge
                     const sal_uInt32 nNextIndex((a + 1) % nPointCount);
diff --git a/basegfx/source/polygon/b2dpolygontriangulator.cxx b/basegfx/source/polygon/b2dpolygontriangulator.cxx
index 479d06ebdb34..64d6e875d7ad 100644
--- a/basegfx/source/polygon/b2dpolygontriangulator.cxx
+++ b/basegfx/source/polygon/b2dpolygontriangulator.cxx
@@ -223,7 +223,7 @@ namespace basegfx
             // by Y,X,atan2 when adding nodes
             if(rCandidate.count())
             {
-                for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
+                for(sal_uInt32 a(0); a < rCandidate.count(); a++)
                 {
                     const B2DPolygon aPolygonCandidate(rCandidate.getB2DPolygon(a));
                     const sal_uInt32 nCount(aPolygonCandidate.count());
@@ -232,7 +232,7 @@ namespace basegfx
                     {
                         B2DPoint aPrevPnt(aPolygonCandidate.getB2DPoint(nCount - 1L));
 
-                        for(sal_uInt32 b(0L); b < nCount; b++)
+                        for(sal_uInt32 b(0); b < nCount; b++)
                         {
                             B2DPoint aNextPnt(aPolygonCandidate.getB2DPoint(b));
 
@@ -430,7 +430,7 @@ namespace basegfx
             if(1L == aCandidate.count())
             {
                 // single polygon -> single polygon triangulation
-                const B2DPolygon aSinglePolygon(aCandidate.getB2DPolygon(0L));
+                const B2DPolygon aSinglePolygon(aCandidate.getB2DPolygon(0));
                 aRetval = triangulate(aSinglePolygon);
             }
             else
diff --git a/basegfx/source/polygon/b2dpolypolygon.cxx b/basegfx/source/polygon/b2dpolypolygon.cxx
index 535f7b457684..f58dceca6c7a 100644
--- a/basegfx/source/polygon/b2dpolypolygon.cxx
+++ b/basegfx/source/polygon/b2dpolypolygon.cxx
@@ -105,7 +105,7 @@ public:
 
     void setClosed(bool bNew)
     {
-        for(size_t a(0L); a < maPolygons.size(); a++)
+        for(size_t a(0); a < maPolygons.size(); a++)
         {
             maPolygons[a].setClosed(bNew);
         }
@@ -239,7 +239,7 @@ namespace basegfx
 
     bool B2DPolyPolygon::areControlPointsUsed() const
     {
-        for(sal_uInt32 a(0L); a < mpPolyPolygon->count(); a++)
+        for(sal_uInt32 a(0); a < mpPolyPolygon->count(); a++)
         {
             const B2DPolygon& rPolygon = mpPolyPolygon->getB2DPolygon(a);
 
@@ -270,7 +270,7 @@ namespace basegfx
     {
         B2DPolyPolygon aRetval;
 
-        for(sal_uInt32 a(0L); a < mpPolyPolygon->count(); a++)
+        for(sal_uInt32 a(0); a < mpPolyPolygon->count(); a++)
         {
             aRetval.append(mpPolyPolygon->getB2DPolygon(a).getDefaultAdaptiveSubdivision());
         }
@@ -282,7 +282,7 @@ namespace basegfx
     {
         B2DRange aRetval;
 
-        for(sal_uInt32 a(0L); a < mpPolyPolygon->count(); a++)
+        for(sal_uInt32 a(0); a < mpPolyPolygon->count(); a++)
         {
             aRetval.expand(mpPolyPolygon->getB2DPolygon(a).getB2DRange());
         }
@@ -323,7 +323,7 @@ namespace basegfx
 
         // PolyPOlygon is closed when all contained Polygons are closed or
         // no Polygon exists.
-        for(sal_uInt32 a(0L); bRetval && a < mpPolyPolygon->count(); a++)
+        for(sal_uInt32 a(0); bRetval && a < mpPolyPolygon->count(); a++)
         {
             if(!(mpPolyPolygon->getB2DPolygon(a)).isClosed())
             {
@@ -352,7 +352,7 @@ namespace basegfx
     {
         bool bRetval(false);
 
-        for(sal_uInt32 a(0L); !bRetval && a < mpPolyPolygon->count(); a++)
+        for(sal_uInt32 a(0); !bRetval && a < mpPolyPolygon->count(); a++)
         {
             if((mpPolyPolygon->getB2DPolygon(a)).hasDoublePoints())
             {
diff --git a/basegfx/source/polygon/b2dpolypolygoncutter.cxx b/basegfx/source/polygon/b2dpolypolygoncutter.cxx
index 6cefd12f70e9..3332976e9768 100644
--- a/basegfx/source/polygon/b2dpolypolygoncutter.cxx
+++ b/basegfx/source/polygon/b2dpolypolygoncutter.cxx
@@ -688,7 +688,7 @@ namespace basegfx
 
         B2DPolyPolygon solveCrossovers(const B2DPolyPolygon& rCandidate)
         {
-            if(rCandidate.count() > 0L)
+            if(rCandidate.count() > 0)
             {
                 solver aSolver(rCandidate);
                 return aSolver.getB2DPolyPolygon();
@@ -709,7 +709,7 @@ namespace basegfx
         {
             B2DPolyPolygon aRetval;
 
-            for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
+            for(sal_uInt32 a(0); a < rCandidate.count(); a++)
             {
                 const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
 
@@ -789,7 +789,7 @@ namespace basegfx
                 const B2DPolyPolygon aSource(aCandidate);
                 aCandidate.clear();
 
-                for(a = 0L; a < nCount; a++)
+                for(a = 0; a < nCount; a++)
                 {
                     const StripHelper& rHelper = aHelpers[a];
                     // for contained unequal oriented polygons sum will be 0
@@ -817,7 +817,7 @@ namespace basegfx
             {
                 if(nCount == 1L)
                 {
-                    if(!bKeepAboveZero && B2VectorOrientation::Positive == tools::getOrientation(rCandidate.getB2DPolygon(0L)))
+                    if(!bKeepAboveZero && B2VectorOrientation::Positive == tools::getOrientation(rCandidate.getB2DPolygon(0)))
                     {
                         aRetval = rCandidate;
                     }
@@ -828,16 +828,16 @@ namespace basegfx
                     ::std::vector< StripHelper > aHelpers;
                     aHelpers.resize(nCount);
 
-                    for(a = 0L; a < nCount; a++)
+                    for(a = 0; a < nCount; a++)
                     {
                         const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
                         StripHelper* pNewHelper = &(aHelpers[a]);
                         pNewHelper->maRange = tools::getRange(aCandidate);
                         pNewHelper->meOrinetation = tools::getOrientation(aCandidate);
-                        pNewHelper->mnDepth = (B2VectorOrientation::Negative == pNewHelper->meOrinetation ? -1L : 0L);
+                        pNewHelper->mnDepth = (B2VectorOrientation::Negative == pNewHelper->meOrinetation ? -1L : 0);
                     }
 
-                    for(a = 0L; a < nCount - 1L; a++)
+                    for(a = 0; a < nCount - 1L; a++)
                     {
                         const B2DPolygon aCandA(rCandidate.getB2DPolygon(a));
                         StripHelper& rHelperA = aHelpers[a];
@@ -894,10 +894,10 @@ namespace basegfx
                         }
                     }
 
-                    for(a = 0L; a < nCount; a++)
+                    for(a = 0; a < nCount; a++)
                     {
                         const StripHelper& rHelper = aHelpers[a];
-                        bool bAcceptEntry(bKeepAboveZero ? 1L <= rHelper.mnDepth : 0L == rHelper.mnDepth);
+                        bool bAcceptEntry(bKeepAboveZero ? 1L <= rHelper.mnDepth : 0 == rHelper.mnDepth);
 
                         if(bAcceptEntry)
                         {
diff --git a/basegfx/source/polygon/b2dpolypolygontools.cxx b/basegfx/source/polygon/b2dpolypolygontools.cxx
index 8bc7f580701c..016eb476aa38 100644
--- a/basegfx/source/polygon/b2dpolypolygontools.cxx
+++ b/basegfx/source/polygon/b2dpolypolygontools.cxx
@@ -35,13 +35,13 @@ namespace basegfx
             B2DPolyPolygon aRetval(rCandidate);
             const sal_uInt32 nCount(aRetval.count());
 
-            for(sal_uInt32 a(0L); a < nCount; a++)
+            for(sal_uInt32 a(0); a < nCount; a++)
             {
                 const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
                 const B2VectorOrientation aOrientation(tools::getOrientation(aCandidate));
-                sal_uInt32 nDepth(0L);
+                sal_uInt32 nDepth(0);
 
-                for(sal_uInt32 b(0L); b < nCount; b++)
+                for(sal_uInt32 b(0); b < nCount; b++)
                 {
                     if(b != a)
                     {
@@ -74,12 +74,12 @@ namespace basegfx
 
             if(nCount > 1L)
             {
-                for(sal_uInt32 a(0L); a < nCount; a++)
+                for(sal_uInt32 a(0); a < nCount; a++)
                 {
                     const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
-                    sal_uInt32 nDepth(0L);
+                    sal_uInt32 nDepth(0);
 
-                    for(sal_uInt32 b(0L); b < nCount; b++)
+                    for(sal_uInt32 b(0); b < nCount; b++)
                     {
                         if(b != a)
                         {
@@ -96,11 +96,11 @@ namespace basegfx
                     {
                         B2DPolyPolygon aRetval(rCandidate);
 
-                        if(a != 0L)
+                        if(a != 0)
                         {
-                            // exchange polygon a and polygon 0L
-                            aRetval.setB2DPolygon(0L, aCandidate);
-                            aRetval.setB2DPolygon(a, rCandidate.getB2DPolygon(0L));
+                            // exchange polygon a and polygon 0
+                            aRetval.setB2DPolygon(0, aCandidate);
+                            aRetval.setB2DPolygon(a, rCandidate.getB2DPolygon(0));
                         }
 
                         // exit
@@ -119,7 +119,7 @@ namespace basegfx
                 const sal_uInt32 nPolygonCount(rCandidate.count());
                 B2DPolyPolygon aRetval;
 
-                for(sal_uInt32 a(0L); a < nPolygonCount; a++)
+                for(sal_uInt32 a(0); a < nPolygonCount; a++)
                 {
                     const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
 
@@ -148,7 +148,7 @@ namespace basegfx
                 const sal_uInt32 nPolygonCount(rCandidate.count());
                 B2DPolyPolygon aRetval;
 
-                for(sal_uInt32 a(0L); a < nPolygonCount; a++)
+                for(sal_uInt32 a(0); a < nPolygonCount; a++)
                 {
                     const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
 
@@ -176,13 +176,13 @@ namespace basegfx
 
             if(1L == nPolygonCount)
             {
-                return isInside(rCandidate.getB2DPolygon(0L), rPoint, bWithBorder);
+                return isInside(rCandidate.getB2DPolygon(0), rPoint, bWithBorder);
             }
             else
             {
-                sal_Int32 nInsideCount(0L);
+                sal_Int32 nInsideCount(0);
 
-                for(sal_uInt32 a(0L); a < nPolygonCount; a++)
+                for(sal_uInt32 a(0); a < nPolygonCount; a++)
                 {
                     const B2DPolygon aPolygon(rCandidate.getB2DPolygon(a));
                     const bool bInside(isInside(aPolygon, rPoint, bWithBorder));
@@ -202,7 +202,7 @@ namespace basegfx
             B2DRange aRetval;
             const sal_uInt32 nPolygonCount(rCandidate.count());
 
-            for(sal_uInt32 a(0L); a < nPolygonCount; a++)
+            for(sal_uInt32 a(0); a < nPolygonCount; a++)
             {
                 B2DPolygon aCandidate = rCandidate.getB2DPolygon(a);
                 aRetval.expand(tools::getRange(aCandidate));
@@ -216,7 +216,7 @@ namespace basegfx
             double fRetval(0.0);
             const sal_uInt32 nPolygonCount(rCandidate.count());
 
-            for(sal_uInt32 a(0L); a < nPolygonCount; a++)
+            for(sal_uInt32 a(0); a < nPolygonCount; a++)
             {
                 const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
 
@@ -243,7 +243,7 @@ namespace basegfx
             {
                 B2DPolyPolygon aLineTarget, aGapTarget;
 
-                for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
+                for(sal_uInt32 a(0); a < rCandidate.count(); a++)
                 {
                     const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
 
@@ -271,7 +271,7 @@ namespace basegfx
         {
             const sal_uInt32 nPolygonCount(rCandidate.count());
 
-            for(sal_uInt32 a(0L); a < nPolygonCount; a++)
+            for(sal_uInt32 a(0); a < nPolygonCount; a++)
             {
                 B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
 
@@ -289,7 +289,7 @@ namespace basegfx
             const sal_uInt32 nPolygonCount(rCandidate.count());
             B3DPolyPolygon aRetval;
 
-            for(sal_uInt32 a(0L); a < nPolygonCount; a++)
+            for(sal_uInt32 a(0); a < nPolygonCount; a++)
             {
                 B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
 
@@ -304,7 +304,7 @@ namespace basegfx
             const sal_uInt32 nPolygonCount(rCandidate.count());
             B2DPolyPolygon aRetval;
 
-            for(sal_uInt32 a(0L); a < nPolygonCount; a++)
+            for(sal_uInt32 a(0); a < nPolygonCount; a++)
             {
                 B3DPolygon aCandidate(rCandidate.getB3DPolygon(a));
 
@@ -320,7 +320,7 @@ namespace basegfx
             const double fZero(0.0);
             const sal_uInt32 nPolygonCount(rCandidate.count());
 
-            for(sal_uInt32 a(0L); a < nPolygonCount; a++)
+            for(sal_uInt32 a(0); a < nPolygonCount; a++)
             {
                 const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
                 sal_uInt32 nNewEdgeIndex;
@@ -351,7 +351,7 @@ namespace basegfx
             const sal_uInt32 nPolygonCount(rCandidate.count());
             B2DPolyPolygon aRetval;
 
-            for(sal_uInt32 a(0L); a < nPolygonCount; a++)
+            for(sal_uInt32 a(0); a < nPolygonCount; a++)
             {
                 const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
 
@@ -366,7 +366,7 @@ namespace basegfx
             const sal_uInt32 nPolygonCount(rCandidate.count());
             B2DPolyPolygon aRetval;
 
-            for(sal_uInt32 a(0L); a < nPolygonCount; a++)
+            for(sal_uInt32 a(0); a < nPolygonCount; a++)
             {
                 const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
 
@@ -382,7 +382,7 @@ namespace basegfx
             {
                 B2DPolyPolygon aRetval;
 
-                for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
+                for(sal_uInt32 a(0); a < rCandidate.count(); a++)
                 {
                     aRetval.append(growInNormalDirection(rCandidate.getB2DPolygon(a), fValue));
                 }
@@ -404,7 +404,7 @@ namespace basegfx
         {
             B2DPolyPolygon aRetval;
 
-            for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
+            for(sal_uInt32 a(0); a < rCandidate.count(); a++)
             {
                 aRetval.append(reSegmentPolygon(rCandidate.getB2DPolygon(a), nSegments));
             }
@@ -417,7 +417,7 @@ namespace basegfx
             OSL_ENSURE(rOld1.count() == rOld2.count(), "B2DPolyPolygon interpolate: Different geometry (!)");
             B2DPolyPolygon aRetval;
 
-            for(sal_uInt32 a(0L); a < rOld1.count(); a++)
+            for(sal_uInt32 a(0); a < rOld1.count(); a++)
             {
                 aRetval.append(interpolate(rOld1.getB2DPolygon(a), rOld2.getB2DPolygon(a), t));
             }
@@ -441,7 +441,7 @@ namespace basegfx
             {
                 B2DPolyPolygon aRetval;
 
-                for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
+                for(sal_uInt32 a(0); a < rCandidate.count(); a++)
                 {
                     aRetval.append(simplifyCurveSegments(rCandidate.getB2DPolygon(a)));
                 }
@@ -458,7 +458,7 @@ namespace basegfx
         {
             B2DPolyPolygon aRetval;
 
-            for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
+            for(sal_uInt32 a(0); a < rCandidate.count(); a++)
             {
                 aRetval.append(snapPointsOfHorizontalOrVerticalEdges(rCandidate.getB2DPolygon(a)));
             }
diff --git a/basegfx/source/polygon/b3dpolygon.cxx b/basegfx/source/polygon/b3dpolygon.cxx
index 97efdc25f65d..d607bd65a288 100644
--- a/basegfx/source/polygon/b3dpolygon.cxx
+++ b/basegfx/source/polygon/b3dpolygon.cxx
@@ -255,7 +255,7 @@ class BColorArray
 public:
     explicit BColorArray(sal_uInt32 nCount)
     :   maVector(nCount),
-        mnUsedEntries(0L)
+        mnUsedEntries(0)
     {
     }
 
@@ -267,7 +267,7 @@ public:
 
     BColorArray(const BColorArray& rOriginal, sal_uInt32 nIndex, sal_uInt32 nCount)
     :   maVector(),
-        mnUsedEntries(0L)
+        mnUsedEntries(0)
     {
         BColorDataVector::const_iterator aStart(rOriginal.maVector.begin());
         aStart += nIndex;
@@ -296,7 +296,7 @@ public:
 
     bool isUsed() const
     {
-        return (0L != mnUsedEntries);
+        return (0 != mnUsedEntries);
     }
 
     const ::basegfx::BColor& getBColor(sal_uInt32 nIndex) const
@@ -413,7 +413,7 @@ class NormalsArray3D
 public:
     explicit NormalsArray3D(sal_uInt32 nCount)
     :   maVector(nCount),
-        mnUsedEntries(0L)
+        mnUsedEntries(0)
     {
     }
 
@@ -425,7 +425,7 @@ public:
 
     NormalsArray3D(const NormalsArray3D& rOriginal, sal_uInt32 nIndex, sal_uInt32 nCount)
     :   maVector(),
-        mnUsedEntries(0L)
+        mnUsedEntries(0)
     {
         NormalsData3DVector::const_iterator aStart(rOriginal.maVector.begin());
         aStart += nIndex;
@@ -453,7 +453,7 @@ public:
 
     bool isUsed() const
     {
-        return (0L != mnUsedEntries);
+        return (0 != mnUsedEntries);
     }
 
     const ::basegfx::B3DVector& getNormal(sal_uInt32 nIndex) const
@@ -580,7 +580,7 @@ class TextureCoordinate2D
 public:
     explicit TextureCoordinate2D(sal_uInt32 nCount)
     :   maVector(nCount),
-        mnUsedEntries(0L)
+        mnUsedEntries(0)
     {
     }
 
@@ -592,7 +592,7 @@ public:
 
     TextureCoordinate2D(const TextureCoordinate2D& rOriginal, sal_uInt32 nIndex, sal_uInt32 nCount)
     :   maVector(),
-        mnUsedEntries(0L)
+        mnUsedEntries(0)
     {
         TextureData2DVector::const_iterator aStart(rOriginal.maVector.begin());
         aStart += nIndex;
@@ -620,7 +620,7 @@ public:
 
     bool isUsed() const
     {
-        return (0L != mnUsedEntries);
+        return (0 != mnUsedEntries);
     }
 
     const ::basegfx::B2DPoint& getTextureCoordinate(sal_uInt32 nIndex) const
@@ -778,7 +778,7 @@ public:
     // This constructor is only used from the static identity polygon, thus
     // the RefCount is set to 1 to never 'delete' this static incarnation.
     ImplB3DPolygon()
-    :   maPoints(0L),
+    :   maPoints(0),
         mpBColors(nullptr),
         mpNormals(nullptr),
         mpTextureCoordinates(nullptr),
@@ -1351,17 +1351,17 @@ public:
             // check for same start and end point
             const sal_uInt32 nIndex(maPoints.count() - 1L);
 
-            if(maPoints.getCoordinate(0L) == maPoints.getCoordinate(nIndex))
+            if(maPoints.getCoordinate(0) == maPoints.getCoordinate(nIndex))
             {
-                const bool bBColorEqual(!mpBColors || (mpBColors->getBColor(0L) == mpBColors->getBColor(nIndex)));
+                const bool bBColorEqual(!mpBColors || (mpBColors->getBColor(0) == mpBColors->getBColor(nIndex)));
 
                 if(bBColorEqual)
                 {
-                    const bool bNormalsEqual(!mpNormals || (mpNormals->getNormal(0L) == mpNormals->getNormal(nIndex)));
+                    const bool bNormalsEqual(!mpNormals || (mpNormals->getNormal(0) == mpNormals->getNormal(nIndex)));
 
                     if(bNormalsEqual)
                     {
-                        const bool bTextureCoordinatesEqual(!mpTextureCoordinates || (mpTextureCoordinates->getTextureCoordinate(0L) == mpTextureCoordinates->getTextureCoordinate(nIndex)));
+                        const bool bTextureCoordinatesEqual(!mpTextureCoordinates || (mpTextureCoordinates->getTextureCoordinate(0) == mpTextureCoordinates->getTextureCoordinate(nIndex)));
 
                         if(bTextureCoordinatesEqual)
                         {
@@ -1373,7 +1373,7 @@ public:
         }
 
         // test for range
-        for(sal_uInt32 a(0L); a < maPoints.count() - 1L; a++)
+        for(sal_uInt32 a(0); a < maPoints.count() - 1L; a++)
         {
             if(maPoints.getCoordinate(a) == maPoints.getCoordinate(a + 1L))
             {
@@ -1413,19 +1413,19 @@ public:
                 if(maPoints.count() > 1L)
                 {
                     const sal_uInt32 nIndex(maPoints.count() - 1L);
-                    bRemove = (maPoints.getCoordinate(0L) == maPoints.getCoordinate(nIndex));
+                    bRemove = (maPoints.getCoordinate(0) == maPoints.getCoordinate(nIndex));
 
-                    if(bRemove && mpBColors && !(mpBColors->getBColor(0L) == mpBColors->getBColor(nIndex)))
+                    if(bRemove && mpBColors && !(mpBColors->getBColor(0) == mpBColors->getBColor(nIndex)))
                     {
                         bRemove = false;
                     }
 
-                    if(bRemove && mpNormals && !(mpNormals->getNormal(0L) == mpNormals->getNormal(nIndex)))
+                    if(bRemove && mpNormals && !(mpNormals->getNormal(0) == mpNormals->getNormal(nIndex)))
                     {
                         bRemove = false;
                     }
 
-                    if(bRemove && mpTextureCoordinates && !(mpTextureCoordinates->getTextureCoordinate(0L) == mpTextureCoordinates->getTextureCoordinate(nIndex)))
+                    if(bRemove && mpTextureCoordinates && !(mpTextureCoordinates->getTextureCoordinate(0) == mpTextureCoordinates->getTextureCoordinate(nIndex)))
                     {
                         bRemove = false;
                     }
@@ -1442,7 +1442,7 @@ public:
 
     void removeDoublePointsWholeTrack()
     {
-        sal_uInt32 nIndex(0L);
+        sal_uInt32 nIndex(0);
 
         // test as long as there are at least two points and as long as the index
         // is smaller or equal second last point
@@ -1661,7 +1661,7 @@ namespace basegfx
                 nCount = rPoly.count();
             }
 
-            if(0L == nIndex && nCount == rPoly.count())
+            if(0 == nIndex && nCount == rPoly.count())
             {
                 mpPolygon->insert(mpPolygon->count(), *rPoly.mpPolygon);
             }
diff --git a/basegfx/source/polygon/b3dpolygontools.cxx b/basegfx/source/polygon/b3dpolygontools.cxx
index 279e0ecd36ae..1e739fc4aefe 100644
--- a/basegfx/source/polygon/b3dpolygontools.cxx
+++ b/basegfx/source/polygon/b3dpolygontools.cxx
@@ -37,7 +37,7 @@ namespace basegfx
         void checkClosed(B3DPolygon& rCandidate)
         {
             while(rCandidate.count() > 1L
-                && rCandidate.getB3DPoint(0L).equal(rCandidate.getB3DPoint(rCandidate.count() - 1L)))
+                && rCandidate.getB3DPoint(0).equal(rCandidate.getB3DPoint(rCandidate.count() - 1L)))
             {
                 rCandidate.setClosed(true);
                 rCandidate.remove(rCandidate.count() - 1L);
@@ -54,7 +54,7 @@ namespace basegfx
             }
             else
             {
-                return 0L;
+                return 0;
             }
         }
 
@@ -63,7 +63,7 @@ namespace basegfx
             B3DRange aRetval;
             const sal_uInt32 nPointCount(rCandidate.count());
 
-            for(sal_uInt32 a(0L); a < nPointCount; a++)
+            for(sal_uInt32 a(0); a < nPointCount; a++)
             {
                 const B3DPoint aTestPoint(rCandidate.getB3DPoint(a));
                 aRetval.expand(aTestPoint);
@@ -81,7 +81,7 @@ namespace basegfx
             {
                 const sal_uInt32 nLoopCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1L);
 
-                for(sal_uInt32 a(0L); a < nLoopCount; a++)
+                for(sal_uInt32 a(0); a < nLoopCount; a++)
                 {
                     const sal_uInt32 nNextIndex(getIndexOfSuccessor(a, rCandidate));
                     const B3DPoint aCurrentPoint(rCandidate.getB3DPoint(a));
@@ -270,7 +270,7 @@ namespace basegfx
         {
             B3DPolygon aRetval(rCandidate);
 
-            for(sal_uInt32 a(0L); a < aRetval.count(); a++)
+            for(sal_uInt32 a(0); a < aRetval.count(); a++)
             {
                 B3DVector aVector(aRetval.getB3DPoint(a) - rCenter);
                 aVector.normalize();
@@ -286,7 +286,7 @@ namespace basegfx
 
             if(aRetval.areNormalsUsed())
             {
-                for(sal_uInt32 a(0L); a < aRetval.count(); a++)
+                for(sal_uInt32 a(0); a < aRetval.count(); a++)
                 {
                     aRetval.setNormal(a, -aRetval.getNormal(a));
                 }
@@ -309,7 +309,7 @@ namespace basegfx
                 const bool bHeightSet(!fTools::equalZero(fHeight));
                 const double fOne(1.0);
 
-                for(sal_uInt32 a(0L); a < aRetval.count(); a++)
+                for(sal_uInt32 a(0); a < aRetval.count(); a++)
                 {
                     const B3DPoint aPoint(aRetval.getB3DPoint(a));
                     B2DPoint aTextureCoordinate(aRetval.getTextureCoordinate(a));
@@ -364,7 +364,7 @@ namespace basegfx
                 const B3DPoint aPlaneCenter(aPlaneRange.getCenter() - rCenter);
                 const double fXCenter(fOne - ((atan2(aPlaneCenter.getZ(), aPlaneCenter.getX()) + F_PI) / F_2PI));
 
-                for(a = 0L; a < nPointCount; a++)
+                for(a = 0; a < nPointCount; a++)
                 {
                     const B3DVector aVector(aRetval.getB3DPoint(a) - rCenter);
                     const double fY(fOne - ((atan2(aVector.getY(), aVector.getXZLength()) + F_PI2) / F_PI));
@@ -429,7 +429,7 @@ namespace basegfx
                 {
                     // correct X-texture coordinates if polar points are contained. Those
                     // coordinates cannot be correct, so use prev or next X-coordinate
-                    for(a = 0L; a < nPointCount; a++)
+                    for(a = 0; a < nPointCount; a++)
                     {
                         B2DPoint aTexCoor(aRetval.getTextureCoordinate(a));
 
diff --git a/basegfx/source/polygon/b3dpolypolygon.cxx b/basegfx/source/polygon/b3dpolypolygon.cxx
index feb2a0587c1b..aa7ee1891ac7 100644
--- a/basegfx/source/polygon/b3dpolypolygon.cxx
+++ b/basegfx/source/polygon/b3dpolypolygon.cxx
@@ -251,7 +251,7 @@ namespace basegfx
 
     bool B3DPolyPolygon::areBColorsUsed() const
     {
-        for(sal_uInt32 a(0L); a < mpPolyPolygon->count(); a++)
+        for(sal_uInt32 a(0); a < mpPolyPolygon->count(); a++)
         {
             if((mpPolyPolygon->getB3DPolygon(a)).areBColorsUsed())
             {
@@ -276,7 +276,7 @@ namespace basegfx
 
     bool B3DPolyPolygon::areNormalsUsed() const
     {
-        for(sal_uInt32 a(0L); a < mpPolyPolygon->count(); a++)
+        for(sal_uInt32 a(0); a < mpPolyPolygon->count(); a++)
         {
             if((mpPolyPolygon->getB3DPolygon(a)).areNormalsUsed())
             {
@@ -301,7 +301,7 @@ namespace basegfx
 
     bool B3DPolyPolygon::areTextureCoordinatesUsed() const
     {
-        for(sal_uInt32 a(0L); a < mpPolyPolygon->count(); a++)
+        for(sal_uInt32 a(0); a < mpPolyPolygon->count(); a++)
         {
             if((mpPolyPolygon->getB3DPolygon(a)).areTextureCoordinatesUsed())
             {
@@ -352,7 +352,7 @@ namespace basegfx
     {
         bool bRetval(false);
 
-        for(sal_uInt32 a(0L); !bRetval && a < mpPolyPolygon->count(); a++)
+        for(sal_uInt32 a(0); !bRetval && a < mpPolyPolygon->count(); a++)
         {
             if((mpPolyPolygon->getB3DPolygon(a)).hasDoublePoints())
             {
diff --git a/basegfx/source/polygon/b3dpolypolygontools.cxx b/basegfx/source/polygon/b3dpolypolygontools.cxx
index c04239a26883..bcb0ba5cc58d 100644
--- a/basegfx/source/polygon/b3dpolypolygontools.cxx
+++ b/basegfx/source/polygon/b3dpolypolygontools.cxx
@@ -43,7 +43,7 @@ namespace basegfx
             B3DRange aRetval;
             const sal_uInt32 nPolygonCount(rCandidate.count());
 
-            for(sal_uInt32 a(0L); a < nPolygonCount; a++)
+            for(sal_uInt32 a(0); a < nPolygonCount; a++)
             {
                 B3DPolygon aCandidate = rCandidate.getB3DPolygon(a);
                 aRetval.expand(getRange(aCandidate));
@@ -261,7 +261,7 @@ namespace basegfx
             bool bVerToBottom(fTools::equal(fVerStop, -F_PI2));
 
             // create horizontal rings
-            const sal_uInt32 nLoopVerInit(bVerFromTop ? 1L : 0L);
+            const sal_uInt32 nLoopVerInit(bVerFromTop ? 1L : 0);
             const sal_uInt32 nLoopVerLimit(bVerToBottom ? nVerSeg : nVerSeg + 1L);
             const sal_uInt32 nLoopHorLimit(bHorClosed ? nHorSeg : nHorSeg + 1L);
 
@@ -270,7 +270,7 @@ namespace basegfx
                 const double fVer(fVerStart + ((double)(a) * fVerDiffPerStep));
                 B3DPolygon aNew;
 
-                for(b = 0L; b < nLoopHorLimit; b++)
+                for(b = 0; b < nLoopHorLimit; b++)
                 {
                     const double fHor(fHorStart + ((double)(b) * fHorDiffPerStep));
                     aNew.append(getPointFromCartesian(fHor, fVer));
@@ -281,7 +281,7 @@ namespace basegfx
             }
 
             // create vertical half-rings
-            for(a = 0L; a < nLoopHorLimit; a++)
+            for(a = 0; a < nLoopHorLimit; a++)
             {
                 const double fHor(fHorStart + ((double)(a) * fHorDiffPerStep));
                 B3DPolygon aNew;
@@ -353,13 +353,13 @@ namespace basegfx
             nVerSeg = ::std::min(nMaxSegments, ::std::max(nMinSegments, nVerSeg));
 
             // vertical loop
-            for(sal_uInt32 a(0L); a < nVerSeg; a++)
+            for(sal_uInt32 a(0); a < nVerSeg; a++)
             {
                 const double fVer1(fVerStart + (((fVerStop - fVerStart) * a) / nVerSeg));
                 const double fVer2(fVerStart + (((fVerStop - fVerStart) * (a + 1)) / nVerSeg));
 
                 // horizontal loop
-                for(sal_uInt32 b(0L); b < nHorSeg; b++)
+                for(sal_uInt32 b(0); b < nHorSeg; b++)
                 {
                     const double fHor1(fHorStart + (((fHorStop - fHorStart) * b) / nHorSeg));
                     const double fHor2(fHorStart + (((fHorStop - fHorStart) * (b + 1)) / nHorSeg));
@@ -372,7 +372,7 @@ namespace basegfx
 
                     if(bNormals)
                     {
-                        for(sal_uInt32 c(0L); c < aNew.count(); c++)
+                        for(sal_uInt32 c(0); c < aNew.count(); c++)
                         {
                             aNew.setNormal(c, ::basegfx::B3DVector(aNew.getB3DPoint(c)));
                         }
@@ -411,7 +411,7 @@ namespace basegfx
         {
             B3DPolyPolygon aRetval;
 
-            for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
+            for(sal_uInt32 a(0); a < rCandidate.count(); a++)
             {
                 aRetval.append(applyDefaultNormalsSphere(rCandidate.getB3DPolygon(a), rCenter));
             }
@@ -423,7 +423,7 @@ namespace basegfx
         {
             B3DPolyPolygon aRetval;
 
-            for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
+            for(sal_uInt32 a(0); a < rCandidate.count(); a++)
             {
                 aRetval.append(invertNormals(rCandidate.getB3DPolygon(a)));
             }
@@ -435,7 +435,7 @@ namespace basegfx
         {
             B3DPolyPolygon aRetval;
 
-            for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
+            for(sal_uInt32 a(0); a < rCandidate.count(); a++)
             {
                 aRetval.append(applyDefaultTextureCoordinatesParallel(rCandidate.getB3DPolygon(a), rRange, bChangeX, bChangeY));
             }
@@ -447,7 +447,7 @@ namespace basegfx
         {
             B3DPolyPolygon aRetval;
 
-            for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
+            for(sal_uInt32 a(0); a < rCandidate.count(); a++)
             {
                 aRetval.append(applyDefaultTextureCoordinatesSphere(rCandidate.getB3DPolygon(a), rCenter, bChangeX, bChangeY));
             }
diff --git a/basegfx/source/tools/unotools.cxx b/basegfx/source/tools/unotools.cxx
index f3a4765eb3d0..8fe38a743bb8 100644
--- a/basegfx/source/tools/unotools.cxx
+++ b/basegfx/source/tools/unotools.cxx
@@ -171,7 +171,7 @@ namespace unotools
             const bool bClosed(rPoly.isClosed());
 
             // calculate input vertex count
-            const sal_uInt32 nLoopCount(bClosed ? nCount : (nCount ? nCount - 1L : 0L ));
+            const sal_uInt32 nLoopCount(bClosed ? nCount : (nCount ? nCount - 1L : 0 ));
 
             std::vector<awt::Point> aPoints; aPoints.reserve(nLoopCount);
             std::vector<drawing::PolygonFlags> aFlags; aFlags.reserve(nLoopCount);
@@ -182,7 +182,7 @@ namespace unotools
                 basegfx::B2DCubicBezier aBezier;
                 aBezier.setStartPoint(rPoly.getB2DPoint(0));
 
-                for(sal_uInt32 b(0L); b<nLoopCount; b++)
+                for(sal_uInt32 b(0); b<nLoopCount; b++)
                 {
                     // add current point (always) and remember StartPointIndex for evtl. later corrections
                     const awt::Point aStartPoint(fround(aBezier.getStartPoint().getX()),