rename Neu->New in svx

Change-Id: I77a49d55dd49b0fd41f5335ac30a5484ac130250
Reviewed-on: https://gerrit.libreoffice.org/53050
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>

9 files changed, 127 insertions, 127 deletions

diff --git a/svx/source/svdraw/svddrgmt.cxx b/svx/source/svdraw/svddrgmt.cxx
index 1cb2f5aa8bd3..7492063bd766 100644
--- a/svx/source/svdraw/svddrgmt.cxx
+++ b/svx/source/svdraw/svddrgmt.cxx
@@ -1976,29 +1976,29 @@ void SdrDragResize::MoveSdrDrag(const Point& rNoSnapPnt)
         }
     }
 
-    Fraction aNeuXFact(nXMul,nXDiv);
-    Fraction aNeuYFact(nYMul,nYDiv);
+    Fraction aNewXFact(nXMul,nXDiv);
+    Fraction aNewYFact(nYMul,nYDiv);
 
     if (bOrtho)
     {
-        if (aNeuXFact>aMaxFact)
+        if (aNewXFact>aMaxFact)
         {
-            aNeuXFact=aMaxFact;
-            aNeuYFact=aMaxFact;
+            aNewXFact=aMaxFact;
+            aNewYFact=aMaxFact;
         }
 
-        if (aNeuYFact>aMaxFact)
+        if (aNewYFact>aMaxFact)
         {
-            aNeuXFact=aMaxFact;
-            aNeuYFact=aMaxFact;
+            aNewXFact=aMaxFact;
+            aNewYFact=aMaxFact;
         }
     }
 
     if (bXNeg)
-        aNeuXFact=Fraction(-aNeuXFact.GetNumerator(),aNeuXFact.GetDenominator());
+        aNewXFact=Fraction(-aNewXFact.GetNumerator(),aNewXFact.GetDenominator());
 
     if (bYNeg)
-        aNeuYFact=Fraction(-aNeuYFact.GetNumerator(),aNeuYFact.GetDenominator());
+        aNewYFact=Fraction(-aNewYFact.GetNumerator(),aNewYFact.GetDenominator());
 
     if (DragStat().CheckMinMoved(aPnt))
     {
@@ -2007,8 +2007,8 @@ void SdrDragResize::MoveSdrDrag(const Point& rNoSnapPnt)
         {
             Hide();
             DragStat().NextMove(aPnt);
-            aXFact=aNeuXFact;
-            aYFact=aNeuYFact;
+            aXFact=aNewXFact;
+            aYFact=aNewYFact;
             Show();
         }
     }
@@ -2294,7 +2294,7 @@ void SdrDragShear::MoveSdrDrag(const Point& rPnt)
 
     Point aP0(DragStat().GetStart());
     Point aPnt(rPnt);
-    Fraction aNeuFact(1,1);
+    Fraction aNewFract(1,1);
 
     // if angle snapping not activated, snap to raster (except when using slant)
     if (nSA==0 && !bSlant)
@@ -2339,11 +2339,11 @@ void SdrDragShear::MoveSdrDrag(const Point& rPnt)
 
             if (bVertical)
             {
-                aNeuFact=Fraction(aPt2.X()-aRef.X(),aP0.X()-aRef.X());
+                aNewFract=Fraction(aPt2.X()-aRef.X(),aP0.X()-aRef.X());
             }
             else
             {
-                aNeuFact=Fraction(aPt2.Y()-aRef.Y(),aP0.Y()-aRef.Y());
+                aNewFract=Fraction(aPt2.Y()-aRef.Y(),aP0.Y()-aRef.Y());
             }
         }
     }
@@ -2370,7 +2370,7 @@ void SdrDragShear::MoveSdrDrag(const Point& rPnt)
         if (bUpSideDown) nNewAngle-=18000;
         if (bNeg) nTmpAngle=-nTmpAngle;
         bResize=true;
-        aNeuFact = cos(nTmpAngle*nPi180);
+        aNewFract = cos(nTmpAngle*nPi180);
         aFact.ReduceInaccurate(10); // three decimals should be enough
     }
 
@@ -2380,10 +2380,10 @@ void SdrDragShear::MoveSdrDrag(const Point& rPnt)
     if (bNeg)
         nNewAngle=-nNewAngle;
 
-    if (nAngle!=nNewAngle || aFact!=aNeuFact)
+    if (nAngle!=nNewAngle || aFact!=aNewFract)
     {
         nAngle=nNewAngle;
-        aFact=aNeuFact;
+        aFact=aNewFract;
         double a=nAngle*nPi180;
         double nTan1=tan(a); // calculate now, so as little time as possible passes between Hide() and Show()
         Hide();
@@ -2567,13 +2567,13 @@ void SdrDragMirror::MoveSdrDrag(const Point& rPnt)
 {
     if (DragStat().CheckMinMoved(rPnt))
     {
-        bool bNeuSide=ImpCheckSide(rPnt);
-        bool bNeuMirr=bSide0!=bNeuSide;
+        bool bNewSide=ImpCheckSide(rPnt);
+        bool bNewMirrored=bSide0!=bNewSide;
 
-        if (bMirrored!=bNeuMirr)
+        if (bMirrored!=bNewMirrored)
         {
             Hide();
-            bMirrored=bNeuMirr;
+            bMirrored=bNewMirrored;
             DragStat().NextMove(rPnt);
             Show();
         }
@@ -3087,44 +3087,44 @@ void SdrDragCrook::MoveSdrDrag(const Point& rPnt)
     if (!DragStat().CheckMinMoved(rPnt))
         return;
 
-    bool bNeuMoveOnly=getSdrDragView().IsMoveOnlyDragging();
+    bool bNewMoveOnly=getSdrDragView().IsMoveOnlyDragging();
     bAtCenter=false;
-    SdrCrookMode eNeuMode=getSdrDragView().GetCrookMode();
-    bool bNeuContortion=!bNeuMoveOnly && ((bContortionAllowed && !getSdrDragView().IsCrookNoContortion()) || !bNoContortionAllowed);
-    bResize=!getSdrDragView().IsOrtho() && bResizeAllowed && !bNeuMoveOnly;
-    bool bNeuRotate=bRotateAllowed && !bNeuContortion && !bNeuMoveOnly && eNeuMode==SdrCrookMode::Rotate;
+    SdrCrookMode eNewMode=getSdrDragView().GetCrookMode();
+    bool bNewContortion=!bNewMoveOnly && ((bContortionAllowed && !getSdrDragView().IsCrookNoContortion()) || !bNoContortionAllowed);
+    bResize=!getSdrDragView().IsOrtho() && bResizeAllowed && !bNewMoveOnly;
+    bool bNewRotate=bRotateAllowed && !bNewContortion && !bNewMoveOnly && eNewMode==SdrCrookMode::Rotate;
 
     Point aPnt(GetSnapPos(rPnt));
 
-    Point aNeuCenter(aMarkCenter.X(),aStart.Y());
+    Point aNewCenter(aMarkCenter.X(),aStart.Y());
 
     if (bVertical)
     {
-        aNeuCenter.setX(aStart.X() );
-        aNeuCenter.setY(aMarkCenter.Y() );
+        aNewCenter.setX(aStart.X() );
+        aNewCenter.setY(aMarkCenter.Y() );
     }
 
     if (!getSdrDragView().IsCrookAtCenter())
     {
         switch (GetDragHdlKind())
         {
-            case SdrHdlKind::UpperLeft: aNeuCenter.setX(aMarkRect.Right() );  bLft=true; break;
-            case SdrHdlKind::Upper: aNeuCenter.setY(aMarkRect.Bottom() ); bUpr=true; break;
-            case SdrHdlKind::UpperRight: aNeuCenter.setX(aMarkRect.Left() );   bRgt=true; break;
-            case SdrHdlKind::Left : aNeuCenter.setX(aMarkRect.Right() );  bLft=true; break;
-            case SdrHdlKind::Right: aNeuCenter.setX(aMarkRect.Left() );   bRgt=true; break;
-            case SdrHdlKind::LowerLeft: aNeuCenter.setX(aMarkRect.Right() );  bLft=true; break;
-            case SdrHdlKind::Lower: aNeuCenter.setY(aMarkRect.Top() );    bLwr=true; break;
-            case SdrHdlKind::LowerRight: aNeuCenter.setX(aMarkRect.Left() );   bRgt=true; break;
+            case SdrHdlKind::UpperLeft: aNewCenter.setX(aMarkRect.Right() );  bLft=true; break;
+            case SdrHdlKind::Upper: aNewCenter.setY(aMarkRect.Bottom() ); bUpr=true; break;
+            case SdrHdlKind::UpperRight: aNewCenter.setX(aMarkRect.Left() );   bRgt=true; break;
+            case SdrHdlKind::Left : aNewCenter.setX(aMarkRect.Right() );  bLft=true; break;
+            case SdrHdlKind::Right: aNewCenter.setX(aMarkRect.Left() );   bRgt=true; break;
+            case SdrHdlKind::LowerLeft: aNewCenter.setX(aMarkRect.Right() );  bLft=true; break;
+            case SdrHdlKind::Lower: aNewCenter.setY(aMarkRect.Top() );    bLwr=true; break;
+            case SdrHdlKind::LowerRight: aNewCenter.setX(aMarkRect.Left() );   bRgt=true; break;
             default: bAtCenter=true;
         }
     }
     else
         bAtCenter=true;
 
-    Fraction aNeuFact(1,1);
-    long dx1=aPnt.X()-aNeuCenter.X();
-    long dy1=aPnt.Y()-aNeuCenter.Y();
+    Fraction aNewFract(1,1);
+    long dx1=aPnt.X()-aNewCenter.X();
+    long dy1=aPnt.Y()-aNewCenter.Y();
     bValid=bVertical ? dx1!=0 : dy1!=0;
 
     if (bValid)
@@ -3135,7 +3135,7 @@ void SdrDragCrook::MoveSdrDrag(const Point& rPnt)
             bValid = std::abs(dy1)*100>std::abs(dx1);
     }
 
-    long nNeuRad=0;
+    long nNewRad=0;
     nAngle=0;
 
     if (bValid)
@@ -3146,21 +3146,21 @@ void SdrDragCrook::MoveSdrDrag(const Point& rPnt)
         if (bVertical)
         {
             a=static_cast<double>(dy1)/static_cast<double>(dx1); // slope of the radius
-            nNeuRad=(static_cast<long>(dy1*a)+dx1) /2;
-            aNeuCenter.AdjustX(nNeuRad );
-            nPntWink=GetAngle(aPnt-aNeuCenter);
+            nNewRad=(static_cast<long>(dy1*a)+dx1) /2;
+            aNewCenter.AdjustX(nNewRad );
+            nPntWink=GetAngle(aPnt-aNewCenter);
         }
         else
         {
             a=static_cast<double>(dx1)/static_cast<double>(dy1); // slope of the radius
-            nNeuRad=(static_cast<long>(dx1*a)+dy1) /2;
-            aNeuCenter.AdjustY(nNeuRad );
-            nPntWink=GetAngle(aPnt-aNeuCenter)-9000;
+            nNewRad=(static_cast<long>(dx1*a)+dy1) /2;
+            aNewCenter.AdjustY(nNewRad );
+            nPntWink=GetAngle(aPnt-aNewCenter)-9000;
         }
 
         if (!bAtCenter)
         {
-            if (nNeuRad<0)
+            if (nNewRad<0)
             {
                 if (bRgt) nPntWink+=18000;
                 if (bLft) nPntWink=18000-nPntWink;
@@ -3177,13 +3177,13 @@ void SdrDragCrook::MoveSdrDrag(const Point& rPnt)
         }
         else
         {
-            if (nNeuRad<0) nPntWink+=18000;
+            if (nNewRad<0) nPntWink+=18000;
             if (bVertical) nPntWink=18000-nPntWink;
             nPntWink=NormAngle180(nPntWink);
             nPntWink = std::abs(nPntWink);
         }
 
-        double nUmfang = 2 * std::abs(nNeuRad)*nPi;
+        double nUmfang = 2 * std::abs(nNewRad)*nPi;
 
         if (bResize)
         {
@@ -3192,7 +3192,7 @@ void SdrDragCrook::MoveSdrDrag(const Point& rPnt)
             if (bAtCenter)
                 nMul*=2;
 
-            aNeuFact=Fraction(nMul,nMarkSize);
+            aNewFract=Fraction(nMul,nMarkSize);
             nAngle=nPntWink;
         }
         else
@@ -3204,11 +3204,11 @@ void SdrDragCrook::MoveSdrDrag(const Point& rPnt)
         }
     }
 
-    if (nAngle==0 || nNeuRad==0)
+    if (nAngle==0 || nNewRad==0)
         bValid=false;
 
     if (!bValid)
-        nNeuRad=0;
+        nNewRad=0;
 
     if (!bValid && bResize)
     {
@@ -3225,21 +3225,21 @@ void SdrDragCrook::MoveSdrDrag(const Point& rPnt)
             nMul = std::abs(nMul);
         }
 
-        aNeuFact=Fraction(nMul,nDiv);
+        aNewFract=Fraction(nMul,nDiv);
     }
 
-    if (aNeuCenter==aCenter && bNeuContortion==bContortion && aNeuFact==aFact &&
-        bNeuMoveOnly == getMoveOnly() && bNeuRotate==bRotate && eNeuMode==eMode)
+    if (aNewCenter==aCenter && bNewContortion==bContortion && aNewFract==aFact &&
+        bNewMoveOnly == getMoveOnly() && bNewRotate==bRotate && eNewMode==eMode)
         return;
 
     Hide();
-    setMoveOnly(bNeuMoveOnly);
-    bRotate=bNeuRotate;
-    eMode=eNeuMode;
-    bContortion=bNeuContortion;
-    aCenter=aNeuCenter;
-    aFact=aNeuFact;
-    aRad=Point(nNeuRad,nNeuRad);
+    setMoveOnly(bNewMoveOnly);
+    bRotate=bNewRotate;
+    eMode=eNewMode;
+    bContortion=bNewContortion;
+    aCenter=aNewCenter;
+    aFact=aNewFract;
+    aRad=Point(nNewRad,nNewRad);
     bResize=aFact!=Fraction(1,1) && aFact.GetDenominator()!=0 && aFact.IsValid();
     DragStat().NextMove(aPnt);
     Show();
@@ -3488,13 +3488,13 @@ void SdrDragDistort::MoveSdrDrag(const Point& rPnt)
         if (getSdrDragView().IsOrtho())
             OrthoDistance8(DragStat().GetStart(),aPnt,getSdrDragView().IsBigOrtho());
 
-        bool bNeuContortion=(bContortionAllowed && !getSdrDragView().IsCrookNoContortion()) || !bNoContortionAllowed;
+        bool bNewContortion=(bContortionAllowed && !getSdrDragView().IsCrookNoContortion()) || !bNoContortionAllowed;
 
-        if (bNeuContortion!=bContortion || aDistortedRect[nPolyPt]!=aPnt)
+        if (bNewContortion!=bContortion || aDistortedRect[nPolyPt]!=aPnt)
         {
             Hide();
             aDistortedRect[nPolyPt]=aPnt;
-            bContortion=bNeuContortion;
+            bContortion=bNewContortion;
             DragStat().NextMove(aPnt);
             Show();
         }
diff --git a/svx/source/svdraw/svdlayer.cxx b/svx/source/svdraw/svdlayer.cxx
index e3dcf0c57928..72cba8e5d3fa 100644
--- a/svx/source/svdraw/svdlayer.cxx
+++ b/svx/source/svdraw/svdlayer.cxx
@@ -172,14 +172,14 @@ SdrLayerAdmin& SdrLayerAdmin::operator=(const SdrLayerAdmin& rSrcLayerAdmin)
     return *this;
 }
 
-void SdrLayerAdmin::SetModel(SdrModel* pNewModel)
+void SdrLayerAdmin::SetModel(SdrModel* pNewModelel)
 {
-    if (pNewModel!=pModel) {
-        pModel=pNewModel;
+    if (pNewModelel!=pModel) {
+        pModel=pNewModelel;
         sal_uInt16 nCount=GetLayerCount();
         sal_uInt16 i;
         for (i=0; i<nCount; i++) {
-            GetLayer(i)->SetModel(pNewModel);
+            GetLayer(i)->SetModel(pNewModelel);
         }
     }
 }
diff --git a/svx/source/svdraw/svdmodel.cxx b/svx/source/svdraw/svdmodel.cxx
index a4fa78c362ec..531a1a4cc98e 100644
--- a/svx/source/svdraw/svdmodel.cxx
+++ b/svx/source/svdraw/svdmodel.cxx
@@ -1740,9 +1740,9 @@ void SdrModel::setLock( bool bLock )
 }
 
 
-void SdrModel::MigrateItemSet( const SfxItemSet* pSourceSet, SfxItemSet* pDestSet, SdrModel* pNewModel )
+void SdrModel::MigrateItemSet( const SfxItemSet* pSourceSet, SfxItemSet* pDestSet, SdrModel* pNewModelel )
 {
-    assert(pNewModel != nullptr);
+    assert(pNewModelel != nullptr);
     if( pSourceSet && pDestSet && (pSourceSet != pDestSet ) )
     {
         SfxWhichIter aWhichIter(*pSourceSet);
@@ -1758,26 +1758,26 @@ void SdrModel::MigrateItemSet( const SfxItemSet* pSourceSet, SfxItemSet* pDestSe
                 switch( nWhich )
                 {
                 case XATTR_FILLBITMAP:
-                    pResultItem = static_cast<const XFillBitmapItem*>(pPoolItem)->checkForUniqueItem( pNewModel );
+                    pResultItem = static_cast<const XFillBitmapItem*>(pPoolItem)->checkForUniqueItem( pNewModelel );
                     break;
                 case XATTR_LINEDASH:
-                    pResultItem = static_cast<const XLineDashItem*>(pPoolItem)->checkForUniqueItem( pNewModel );
+                    pResultItem = static_cast<const XLineDashItem*>(pPoolItem)->checkForUniqueItem( pNewModelel );
                     break;
                 case XATTR_LINESTART:
-                    pResultItem = static_cast<const XLineStartItem*>(pPoolItem)->checkForUniqueItem( pNewModel );
+                    pResultItem = static_cast<const XLineStartItem*>(pPoolItem)->checkForUniqueItem( pNewModelel );
                     break;
                 case XATTR_LINEEND:
-                    pResultItem = static_cast<const XLineEndItem*>(pPoolItem)->checkForUniqueItem( pNewModel );
+                    pResultItem = static_cast<const XLineEndItem*>(pPoolItem)->checkForUniqueItem( pNewModelel );
                     break;
                 case XATTR_FILLGRADIENT:
-                    pResultItem = static_cast<const XFillGradientItem*>(pPoolItem)->checkForUniqueItem( pNewModel );
+                    pResultItem = static_cast<const XFillGradientItem*>(pPoolItem)->checkForUniqueItem( pNewModelel );
                     break;
                 case XATTR_FILLFLOATTRANSPARENCE:
                     // allow all kinds of XFillFloatTransparenceItem to be set
-                    pResultItem = static_cast<const XFillFloatTransparenceItem*>(pPoolItem)->checkForUniqueItem( pNewModel );
+                    pResultItem = static_cast<const XFillFloatTransparenceItem*>(pPoolItem)->checkForUniqueItem( pNewModelel );
                     break;
                 case XATTR_FILLHATCH:
-                    pResultItem = static_cast<const XFillHatchItem*>(pPoolItem)->checkForUniqueItem( pNewModel );
+                    pResultItem = static_cast<const XFillHatchItem*>(pPoolItem)->checkForUniqueItem( pNewModelel );
                     break;
                 }
 
diff --git a/svx/source/svdraw/svdobjplusdata.cxx b/svx/source/svdraw/svdobjplusdata.cxx
index 45d8bf97c487..3057b38a57e5 100644
--- a/svx/source/svdraw/svdobjplusdata.cxx
+++ b/svx/source/svdraw/svdobjplusdata.cxx
@@ -30,31 +30,31 @@ SdrObjPlusData::~SdrObjPlusData()
 
 SdrObjPlusData* SdrObjPlusData::Clone(SdrObject* pObj1) const
 {
-    SdrObjPlusData* pNeuPlusData=new SdrObjPlusData;
+    SdrObjPlusData* pNewPlusData=new SdrObjPlusData;
     if (pUserDataList!=nullptr) {
         sal_uInt16 nCount=pUserDataList->GetUserDataCount();
         if (nCount!=0) {
-            pNeuPlusData->pUserDataList.reset(new SdrObjUserDataList);
+            pNewPlusData->pUserDataList.reset(new SdrObjUserDataList);
             for (sal_uInt16 i=0; i<nCount; i++) {
                 std::unique_ptr<SdrObjUserData> pNewUserData=pUserDataList->GetUserData(i).Clone(pObj1);
                 if (pNewUserData!=nullptr) {
-                    pNeuPlusData->pUserDataList->AppendUserData(std::move(pNewUserData));
+                    pNewPlusData->pUserDataList->AppendUserData(std::move(pNewUserData));
                 } else {
                     OSL_FAIL("SdrObjPlusData::Clone(): UserData.Clone() returns NULL.");
                 }
             }
         }
     }
-    if (pGluePoints!=nullptr) pNeuPlusData->pGluePoints.reset(new SdrGluePointList(*pGluePoints));
+    if (pGluePoints!=nullptr) pNewPlusData->pGluePoints.reset(new SdrGluePointList(*pGluePoints));
     // MtfAnimator isn't copied either
 
     // #i68101#
     // copy object name, title and description
-    pNeuPlusData->aObjName = aObjName;
-    pNeuPlusData->aObjTitle = aObjTitle;
-    pNeuPlusData->aObjDescription = aObjDescription;
+    pNewPlusData->aObjName = aObjName;
+    pNewPlusData->aObjTitle = aObjTitle;
+    pNewPlusData->aObjDescription = aObjDescription;
 
-    return pNeuPlusData;
+    return pNewPlusData;
 }
 
 void SdrObjPlusData::SetGluePoints(const SdrGluePointList& rPts)
diff --git a/svx/source/svdraw/svdopath.cxx b/svx/source/svdraw/svdopath.cxx
index fc991ab478c3..81b70bc17fa0 100644
--- a/svx/source/svdraw/svdopath.cxx
+++ b/svx/source/svdraw/svdopath.cxx
@@ -668,7 +668,7 @@ bool ImpPathForDragAndCreate::movePathDrag( SdrDragStat& rDrag ) const
             Point  aPos(rDrag.GetNow());      // current position
             Point  aPnt(mpSdrPathDragData->aXP[nPnt]);      // the dragged point
             sal_uInt16 nPnt1=0xFFFF,nPnt2=0xFFFF; // its neighboring points
-            Point  aNeuPos1,aNeuPos2;         // new alternative for aPos
+            Point  aNewPos1,aNewPos2;         // new alternative for aPos
             bool bPnt1 = false, bPnt2 = false; // are these valid alternatives?
             if (!bClosed && mpSdrPathDragData->nPointCount>=2) { // minimum of 2 points for lines
                 if (!bBegPnt) nPnt1=nPrevPnt;
@@ -694,9 +694,9 @@ bool ImpPathForDragAndCreate::movePathDrag( SdrDragStat& rDrag ) const
                     bool bVer=bVLin || (!bHLin && (nXFact<=nYFact)==bBigOrtho);
                     if (bHor) ndy=long(ndy0*nXFact);
                     if (bVer) ndx=long(ndx0*nYFact);
-                    aNeuPos1=aPnt1;
-                    aNeuPos1.AdjustX(ndx );
-                    aNeuPos1.AdjustY(ndy );
+                    aNewPos1=aPnt1;
+                    aNewPos1.AdjustX(ndx );
+                    aNewPos1.AdjustY(ndy );
                 }
             }
             if (nPnt2!=0xFFFF && !bNextIsControl) {
@@ -715,23 +715,23 @@ bool ImpPathForDragAndCreate::movePathDrag( SdrDragStat& rDrag ) const
                     bool bVer=bVLin || (!bHLin && (nXFact<=nYFact)==bBigOrtho);
                     if (bHor) ndy=long(ndy0*nXFact);
                     if (bVer) ndx=long(ndx0*nYFact);
-                    aNeuPos2=aPnt2;
-                    aNeuPos2.AdjustX(ndx );
-                    aNeuPos2.AdjustY(ndy );
+                    aNewPos2=aPnt2;
+                    aNewPos2.AdjustX(ndx );
+                    aNewPos2.AdjustY(ndy );
                 }
             }
             if (bPnt1 && bPnt2) { // both alternatives exist (and compete)
-                BigInt nX1(aNeuPos1.X()-aPos.X()); nX1*=nX1;
-                BigInt nY1(aNeuPos1.Y()-aPos.Y()); nY1*=nY1;
-                BigInt nX2(aNeuPos2.X()-aPos.X()); nX2*=nX2;
-                BigInt nY2(aNeuPos2.Y()-aPos.Y()); nY2*=nY2;
+                BigInt nX1(aNewPos1.X()-aPos.X()); nX1*=nX1;
+                BigInt nY1(aNewPos1.Y()-aPos.Y()); nY1*=nY1;
+                BigInt nX2(aNewPos2.X()-aPos.X()); nX2*=nX2;
+                BigInt nY2(aNewPos2.Y()-aPos.Y()); nY2*=nY2;
                 nX1+=nY1; // correction distance to square
                 nX2+=nY2; // correction distance to square
                 // let the alternative that allows fewer correction win
                 if (nX1<nX2) bPnt2=false; else bPnt1=false;
             }
-            if (bPnt1) rDrag.SetNow(aNeuPos1);
-            if (bPnt2) rDrag.SetNow(aNeuPos2);
+            if (bPnt1) rDrag.SetNow(aNewPos1);
+            if (bPnt2) rDrag.SetNow(aNewPos2);
         }
         rDrag.SetActionRect(tools::Rectangle(rDrag.GetNow(),rDrag.GetNow()));
 
diff --git a/svx/source/svdraw/svdorect.cxx b/svx/source/svdraw/svdorect.cxx
index e68b38ce3205..576800fdbe19 100644
--- a/svx/source/svdraw/svdorect.cxx
+++ b/svx/source/svdraw/svdorect.cxx
@@ -116,19 +116,19 @@ XPolygon SdrRectObj::ImpCalcXPoly(const tools::Rectangle& rRect1, long nRad1) co
 {
     XPolygon aXPoly(rRect1,nRad1,nRad1);
     const sal_uInt16 nPointCnt(aXPoly.GetPointCount());
-    XPolygon aNeuPoly(nPointCnt+1);
+    XPolygon aNewPoly(nPointCnt+1);
     sal_uInt16 nShift=nPointCnt-2;
     if (nRad1!=0) nShift=nPointCnt-5;
     sal_uInt16 j=nShift;
     for (sal_uInt16 i=1; i<nPointCnt; i++) {
-        aNeuPoly[i]=aXPoly[j];
-        aNeuPoly.SetFlags(i,aXPoly.GetFlags(j));
+        aNewPoly[i]=aXPoly[j];
+        aNewPoly.SetFlags(i,aXPoly.GetFlags(j));
         j++;
         if (j>=nPointCnt) j=1;
     }
-    aNeuPoly[0]=rRect1.BottomCenter();
-    aNeuPoly[nPointCnt]=aNeuPoly[0];
-    aXPoly=aNeuPoly;
+    aNewPoly[0]=rRect1.BottomCenter();
+    aNewPoly[nPointCnt]=aNewPoly[0];
+    aXPoly=aNewPoly;
 
     // these angles always relate to the top left corner of aRect
     if (aGeo.nShearAngle!=0) ShearXPoly(aXPoly,maRect.TopLeft(),aGeo.nTan);
diff --git a/svx/source/svdraw/svdotxat.cxx b/svx/source/svdraw/svdotxat.cxx
index e88e55519930..a28a5a698a3c 100644
--- a/svx/source/svdraw/svdotxat.cxx
+++ b/svx/source/svdraw/svdotxat.cxx
@@ -271,11 +271,11 @@ bool SdrTextObj::NbcAdjustTextFrameWidthAndHeight(bool bHgt, bool bWdt)
 
 bool SdrTextObj::AdjustTextFrameWidthAndHeight()
 {
-    tools::Rectangle aNeuRect(maRect);
-    bool bRet=AdjustTextFrameWidthAndHeight(aNeuRect);
+    tools::Rectangle aNewRect(maRect);
+    bool bRet=AdjustTextFrameWidthAndHeight(aNewRect);
     if (bRet) {
         tools::Rectangle aBoundRect0; if (pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
-        maRect = aNeuRect;
+        maRect = aNewRect;
         SetRectsDirty();
         if (dynamic_cast<const SdrRectObj *>(this) != nullptr) { // this is a hack
             static_cast<SdrRectObj*>(this)->SetXPolyDirty();
diff --git a/svx/source/svdraw/svdpage.cxx b/svx/source/svdraw/svdpage.cxx
index 5d143e34f0e2..1532ee47cd3d 100644
--- a/svx/source/svdraw/svdpage.cxx
+++ b/svx/source/svdraw/svdpage.cxx
@@ -89,22 +89,22 @@ SdrObjList::~SdrObjList()
     Clear(); // delete contents of container
 }
 
-SdrObjList* SdrObjList::CloneSdrObjList(SdrModel* pNewModel) const
+SdrObjList* SdrObjList::CloneSdrObjList(SdrModel* pNewModelel) const
 {
     SdrObjList* pObjList = new SdrObjList();
-    pObjList->copyDataFromSdrObjList(*this, pNewModel);
+    pObjList->copyDataFromSdrObjList(*this, pNewModelel);
     return pObjList;
 }
 
-void SdrObjList::copyDataFromSdrObjList(const SdrObjList& rSrcList, SdrModel* pNewModel)
+void SdrObjList::copyDataFromSdrObjList(const SdrObjList& rSrcList, SdrModel* pNewModelel)
 {
     // this function is only supposed to be called once, right after construction
     assert(maList.empty());
     eListKind=rSrcList.eListKind;
-    CopyObjects(rSrcList, pNewModel);
+    CopyObjects(rSrcList, pNewModelel);
 }
 
-void SdrObjList::CopyObjects(const SdrObjList& rSrcList, SdrModel* pNewModel)
+void SdrObjList::CopyObjects(const SdrObjList& rSrcList, SdrModel* pNewModelel)
 {
     Clear();
     bObjOrdNumsDirty = false;
@@ -115,7 +115,7 @@ void SdrObjList::CopyObjects(const SdrObjList& rSrcList, SdrModel* pNewModel)
     for (size_t no(0); no < nCount; ++no)
     {
         SdrObject* pSO(rSrcList.GetObj(no));
-        SdrObject* pDO(pSO->Clone(pNewModel));
+        SdrObject* pDO(pSO->Clone(pNewModelel));
 
         if(nullptr != pDO)
         {
@@ -1219,9 +1219,9 @@ void SdrPage::lateInit(const SdrPage& rSrcPage)
     eListKind = (mbMaster) ? SdrObjListKind::MasterPage : SdrObjListKind::DrawPage;
 }
 
-SdrPage* SdrPage::Clone(SdrModel* pNewModel) const
+SdrPage* SdrPage::Clone(SdrModel* pNewModelel) const
 {
-    SdrPage* pClonedPage(new SdrPage(nullptr == pNewModel ? getSdrModelFromSdrPage() : *pNewModel));
+    SdrPage* pClonedPage(new SdrPage(nullptr == pNewModelel ? getSdrModelFromSdrPage() : *pNewModelel));
     pClonedPage->lateInit(*this);
     return pClonedPage;
 }
diff --git a/svx/source/svdraw/svdxcgv.cxx b/svx/source/svdraw/svdxcgv.cxx
index d6a807414286..5b4031e631b6 100644
--- a/svx/source/svdraw/svdxcgv.cxx
+++ b/svx/source/svdraw/svdxcgv.cxx
@@ -714,11 +714,11 @@ SdrModel* SdrExchangeView::GetMarkedObjModel() const
     // Sorting the MarkList here might be problematic in the future, so
     // use a copy.
     SortMarkedObjects();
-    SdrModel* pNeuMod=mpModel->AllocModel();
-    SdrPage* pNeuPag=pNeuMod->AllocPage(false);
-    pNeuMod->InsertPage(pNeuPag);
+    SdrModel* pNewModel=mpModel->AllocModel();
+    SdrPage* pnewPage=pNewModel->AllocPage(false);
+    pNewModel->InsertPage(pnewPage);
 
-    if( !mxSelectionController.is() || !mxSelectionController->GetMarkedObjModel( pNeuPag ) )
+    if( !mxSelectionController.is() || !mxSelectionController->GetMarkedObjModel( pnewPage ) )
     {
         ::std::vector< SdrObject* > aSdrObjects(GetMarkedObjects());
 
@@ -735,18 +735,18 @@ SdrModel* SdrExchangeView::GetMarkedObjModel() const
                 // convert SdrPageObj's to a graphic representation, because
                 // virtual connection to referenced page gets lost in new model
                 pNewObj = new SdrGrafObj(
-                    *pNeuMod,
+                    *pNewModel,
                     GetObjGraphic(*pObj),
                     pObj->GetLogicRect());
-                pNewObj->SetPage( pNeuPag );
+                pNewObj->SetPage( pnewPage );
             }
             else
             {
                 pNewObj = pObj->Clone();
-                pNewObj->SetPage( pNeuPag );
+                pNewObj->SetPage( pnewPage );
             }
 
-            pNeuPag->InsertObject(pNewObj, SAL_MAX_SIZE);
+            pnewPage->InsertObject(pNewObj, SAL_MAX_SIZE);
 
             // #i13033#
             aCloneList.AddPair(pObj, pNewObj);
@@ -757,7 +757,7 @@ SdrModel* SdrExchangeView::GetMarkedObjModel() const
         aCloneList.CopyConnections();
     }
 
-    return pNeuMod;
+    return pNewModel;
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */