You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@openoffice.apache.org by ms...@apache.org on 2025/03/19 17:21:39 UTC

(openoffice) branch AOO42X updated: Translate German (Neu -> New), cleanup

This is an automated email from the ASF dual-hosted git repository.

mseidel pushed a commit to branch AOO42X
in repository https://gitbox.apache.org/repos/asf/openoffice.git


The following commit(s) were added to refs/heads/AOO42X by this push:
     new 73124a93eb Translate German (Neu -> New), cleanup
73124a93eb is described below

commit 73124a93ebab317677887145a94eac31184536d7
Author: mseidel <ms...@apache.org>
AuthorDate: Wed Mar 19 18:20:33 2025 +0100

    Translate German (Neu -> New), cleanup
    
    (cherry picked from commit e536e65896e21ed4da44ced2cfb8810efcaf5c9b)
---
 main/svx/source/svdraw/svdmark.cxx  | 424 ++++++++++++++++++------------------
 main/svx/source/svdraw/svdmodel.cxx |  10 +-
 2 files changed, 213 insertions(+), 221 deletions(-)

diff --git a/main/svx/source/svdraw/svdmark.cxx b/main/svx/source/svdraw/svdmark.cxx
index e5de23298e..8eaf785e4a 100644
--- a/main/svx/source/svdraw/svdmark.cxx
+++ b/main/svx/source/svdraw/svdmark.cxx
@@ -1,5 +1,5 @@
 /**************************************************************
- * 
+ *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
@@ -7,25 +7,21 @@
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
- * 
+ *
  *   http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
- * 
+ *
  *************************************************************/
 
-
-
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_svx.hxx"
 
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
 #include <svx/svdmark.hxx>
 #include <svx/svdetc.hxx>
 #include <svx/svdobj.hxx>
@@ -33,26 +29,23 @@
 #include "svx/svditer.hxx"
 #include <svx/svdpagv.hxx>
 #include <svx/svdopath.hxx> // zur Abschaltung
-#include <svx/svdogrp.hxx>  // des Cache bei
+#include <svx/svdogrp.hxx> // des Cache bei
 #include <svx/svdorect.hxx> // GetMarkDescription
-#include "svx/svdstr.hrc"   // Namen aus der Resource
-#include "svx/svdglob.hxx"  // StringCache
+#include "svx/svdstr.hrc" // Name from resource
+#include "svx/svdglob.hxx" // StringCache
 
-////////////////////////////////////////////////////////////////////////////////////////////////////
 #include <svx/obj3d.hxx>
 #include <svx/scene3d.hxx>
 #include <svl/brdcst.hxx>
 #include <svx/svdoedge.hxx>
 
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
 class ImpSdrUShortContSorter: public ContainerSorter
 {
 public:
 	ImpSdrUShortContSorter(Container& rNewCont)
-	:	ContainerSorter(rNewCont) 
+	:	ContainerSorter(rNewCont)
 	{}
-	
+
 	virtual int Compare(const void* pElem1, const void* pElem2) const;
 };
 
@@ -72,17 +65,17 @@ void SdrUShortCont::Sort() const
 
 	sal_uLong nNum(GetCount());
 
-	if(nNum > 1) 
+	if(nNum > 1)
 	{
 		nNum--;
 		sal_uInt16 nVal0 = GetObject(nNum);
 
-		while(nNum > 0) 
+		while(nNum > 0)
 		{
 			nNum--;
 			sal_uInt16 nVal1 = GetObject(nNum);
 
-			if(nVal1 == nVal0) 
+			if(nVal1 == nVal0)
 			{
 				((SdrUShortCont*)this)->Remove(nNum);
 			}
@@ -96,24 +89,24 @@ void SdrUShortCont::CheckSort(sal_uLong nPos)
 {
 	sal_uLong nAnz(maArray.Count());
 
-	if(nPos > nAnz) 
+	if(nPos > nAnz)
 		nPos = nAnz;
 
 	sal_uInt16 nAktVal = GetObject(nPos);
 
-	if(nPos > 0) 
+	if(nPos > 0)
 	{
 		sal_uInt16 nPrevVal = GetObject(nPos - 1);
 
-		if(nPrevVal >= nAktVal) 
+		if(nPrevVal >= nAktVal)
 			mbSorted = sal_False;
 	}
 
-	if(nPos < nAnz - 1) 
+	if(nPos < nAnz - 1)
 	{
 		sal_uInt16 nNextVal = GetObject(nPos + 1);
-		
-		if(nNextVal <= nAktVal) 
+
+		if(nNextVal <= nAktVal)
 			mbSorted = sal_False;
 	}
 }
@@ -132,84 +125,84 @@ std::set< sal_uInt16 > SdrUShortCont::getContainer()
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 SdrMark::SdrMark(SdrObject* pNewObj, SdrPageView* pNewPageView)
-:	mpSelectedSdrObject(pNewObj), 
-	mpPageView(pNewPageView), 
-	mpPoints(0L), 
-	mpLines(0L), 
-	mpGluePoints(0L), 
-	mbCon1(sal_False), 
-	mbCon2(sal_False), 
-	mnUser(0) 
+:	mpSelectedSdrObject(pNewObj),
+	mpPageView(pNewPageView),
+	mpPoints(0L),
+	mpLines(0L),
+	mpGluePoints(0L),
+	mbCon1(sal_False),
+	mbCon2(sal_False),
+	mnUser(0)
 {
 	if(mpSelectedSdrObject)
 	{
-		mpSelectedSdrObject->AddObjectUser( *this ); 
+		mpSelectedSdrObject->AddObjectUser( *this );
 	}
 }
 
 SdrMark::SdrMark(const SdrMark& rMark)
 :	ObjectUser(),
-    mpSelectedSdrObject(0L), 
-	mpPageView(0L), 
-	mpPoints(0L), 
-	mpLines(0L), 
-	mpGluePoints(0L), 
-	mbCon1(sal_False), 
-	mbCon2(sal_False), 
-	mnUser(0) 
-{ 
-	*this = rMark; 
+	mpSelectedSdrObject(0L),
+	mpPageView(0L),
+	mpPoints(0L),
+	mpLines(0L),
+	mpGluePoints(0L),
+	mbCon1(sal_False),
+	mbCon2(sal_False),
+	mnUser(0)
+{
+	*this = rMark;
 }
 
 SdrMark::~SdrMark()
-{ 
+{
 	if(mpSelectedSdrObject)
 	{
-		mpSelectedSdrObject->RemoveObjectUser( *this ); 
+		mpSelectedSdrObject->RemoveObjectUser( *this );
 	}
 
-	if(mpPoints) 
+	if(mpPoints)
 	{
-		delete mpPoints; 
+		delete mpPoints;
 	}
-	
-	if(mpLines) 
+
+	if(mpLines)
 	{
-		delete mpLines; 
+		delete mpLines;
 	}
-	
-	if(mpGluePoints) 
+
+	if(mpGluePoints)
 	{
-		delete mpGluePoints; 
+		delete mpGluePoints;
 	}
 }
 
 void SdrMark::ObjectInDestruction(const SdrObject& rObject)
 {
-    (void) rObject; // avoid warnings
+	(void) rObject; // avoid warnings
 	OSL_ENSURE(mpSelectedSdrObject && mpSelectedSdrObject == &rObject, "SdrMark::ObjectInDestruction: called form object different from hosted one (!)");
 	OSL_ENSURE(mpSelectedSdrObject, "SdrMark::ObjectInDestruction: still seleceted SdrObject is deleted, deselect first (!)");
 	mpSelectedSdrObject = 0L;
 }
 
 void SdrMark::SetMarkedSdrObj(SdrObject* pNewObj)
-{ 
+{
 	if(mpSelectedSdrObject)
 	{
-		mpSelectedSdrObject->RemoveObjectUser( *this ); 
+		mpSelectedSdrObject->RemoveObjectUser( *this );
 	}
 
 	mpSelectedSdrObject = pNewObj;
 
 	if(mpSelectedSdrObject)
 	{
-		mpSelectedSdrObject->AddObjectUser( *this ); 
+		mpSelectedSdrObject->AddObjectUser( *this );
 	}
 }
 
 SdrObject* SdrMark::GetMarkedSdrObj() const
-{ 
-	return mpSelectedSdrObject; 
+{
+	return mpSelectedSdrObject;
 }
 
 SdrMark& SdrMark::operator=(const SdrMark& rMark)
@@ -220,61 +213,61 @@ SdrMark& SdrMark::operator=(const SdrMark& rMark)
 	mbCon2 = rMark.mbCon2;
 	mnUser = rMark.mnUser;
 
-	if(!rMark.mpPoints) 
+	if(!rMark.mpPoints)
 	{
-		if(mpPoints) 
+		if(mpPoints)
 		{
 			delete mpPoints;
 			mpPoints = 0L;
 		}
-	} 
-	else 
+	}
+	else
 	{
-		if(!mpPoints) 
+		if(!mpPoints)
 		{
 			mpPoints = new SdrUShortCont(*rMark.mpPoints);
-		} 
-		else 
+		}
+		else
 		{
 			*mpPoints = *rMark.mpPoints;
 		}
 	}
 
-	if(!rMark.mpLines) 
+	if(!rMark.mpLines)
 	{
-		if(mpLines) 
+		if(mpLines)
 		{
 			delete mpLines;
 			mpLines = 0L;
 		}
-	} 
-	else 
+	}
+	else
 	{
-		if(!mpLines) 
+		if(!mpLines)
 		{
 			mpLines = new SdrUShortCont(*rMark.mpLines);
-		} 
-		else 
+		}
+		else
 		{
 			*mpLines = *rMark.mpLines;
 		}
 	}
 
-	if(!rMark.mpGluePoints) 
+	if(!rMark.mpGluePoints)
 	{
-		if(mpGluePoints) 
+		if(mpGluePoints)
 		{
 			delete mpGluePoints;
 			mpGluePoints = 0L;
 		}
-	} 
-	else 
+	}
+	else
 	{
-		if(!mpGluePoints) 
+		if(!mpGluePoints)
 		{
 			mpGluePoints = new SdrUShortCont(*rMark.mpGluePoints);
-		} 
-		else 
+		}
+		else
 		{
 			*mpGluePoints = *rMark.mpGluePoints;
 		}
@@ -287,22 +280,22 @@ sal_Bool SdrMark::operator==(const SdrMark& rMark) const
 {
 	sal_Bool bRet(mpSelectedSdrObject == rMark.mpSelectedSdrObject && mpPageView == rMark.mpPageView && mbCon1 == rMark.mbCon1 && mbCon2 == rMark.mbCon2 && mnUser == rMark.mnUser);
 
-	if((mpPoints != 0L) != (rMark.mpPoints != 0L)) 
+	if((mpPoints != 0L) != (rMark.mpPoints != 0L))
 		bRet = sal_False;
 
-	if((mpLines != 0L) != (rMark.mpLines != 0L)) 
+	if((mpLines != 0L) != (rMark.mpLines != 0L))
 		bRet = sal_False;
 
-	if((mpGluePoints != 0L) != (rMark.mpGluePoints != 0L)) 
+	if((mpGluePoints != 0L) != (rMark.mpGluePoints != 0L))
 		bRet = sal_False;
 
-	if(bRet && mpPoints && *mpPoints != *rMark.mpPoints) 
+	if(bRet && mpPoints && *mpPoints != *rMark.mpPoints)
 		bRet = sal_False;
 
-	if(bRet && mpLines && *mpLines != *rMark.mpLines) 
+	if(bRet && mpLines && *mpLines != *rMark.mpLines)
 		bRet = sal_False;
 
-	if(bRet && mpGluePoints && *mpGluePoints != *rMark.mpGluePoints) 
+	if(bRet && mpGluePoints && *mpGluePoints != *rMark.mpGluePoints)
 		bRet = sal_False;
 
 	return bRet;
@@ -324,9 +317,9 @@ class ImpSdrMarkListSorter: public ContainerSorter
 {
 public:
 	ImpSdrMarkListSorter(Container& rNewCont)
-        :	ContainerSorter(rNewCont)
+		:	ContainerSorter(rNewCont)
 	{}
-	
+
 	virtual int Compare(const void* pElem1, const void* pElem2) const;
 };
 
@@ -337,17 +330,17 @@ int ImpSdrMarkListSorter::Compare(const void* pElem1, const void* pElem2) const
 	SdrObjList* pOL1 = (pObj1) ? pObj1->GetObjList() : 0L;
 	SdrObjList* pOL2 = (pObj2) ? pObj2->GetObjList() : 0L;
 
-	if (pOL1 == pOL2) 
-    {
-        // AF: Note that I reverted a change from sal_uInt32 to sal_uLong (made
-        // for 64bit compliance, #i78198#) because internally in SdrObject
-        // both nOrdNum and mnNavigationPosition are stored as sal_uInt32.
-        sal_uInt32 nObjOrd1((pObj1) ? pObj1->GetNavigationPosition() : 0);
-        sal_uInt32 nObjOrd2((pObj2) ? pObj2->GetNavigationPosition() : 0);
-            
-        return (nObjOrd1 < nObjOrd2 ? -1 : 1);
-    }
-	else 
+	if (pOL1 == pOL2)
+	{
+		// AF: Note that I reverted a change from sal_uInt32 to sal_uLong (made
+		// for 64bit compliance, #i78198#) because internally in SdrObject
+		// both nOrdNum and mnNavigationPosition are stored as sal_uInt32.
+		sal_uInt32 nObjOrd1((pObj1) ? pObj1->GetNavigationPosition() : 0);
+		sal_uInt32 nObjOrd2((pObj2) ? pObj2->GetNavigationPosition() : 0);
+
+		return (nObjOrd1 < nObjOrd2 ? -1 : 1);
+	}
+	else
 	{
 		return ((long)pOL1 < (long)pOL2) ? -1 : 1;
 	}
@@ -365,7 +358,7 @@ void SdrMarkList::ForceSort() const
 
 void SdrMarkList::ImpForceSort()
 {
-	if(!mbSorted) 
+	if(!mbSorted)
 	{
 		mbSorted = sal_True;
 		sal_uLong nAnz = maList.Count();
@@ -378,7 +371,7 @@ void SdrMarkList::ImpForceSort()
 			{
 				if(pAkt->GetMarkedSdrObj() == 0)
 				{
-					maList.Remove();					
+					maList.Remove();
 					delete pAkt;
 				}
 				pAkt= (SdrMark*)maList.Next();
@@ -386,34 +379,34 @@ void SdrMarkList::ImpForceSort()
 			nAnz = maList.Count();
 		}
 
-		if(nAnz > 1) 
+		if(nAnz > 1)
 		{
 			ImpSdrMarkListSorter aSort(maList);
 			aSort.DoSort();
-		
+
 			// remove duplicates
-			if(maList.Count() > 1) 
+			if(maList.Count() > 1)
 			{
 				SdrMark* pAkt = (SdrMark*)maList.Last();
 				SdrMark* pCmp = (SdrMark*)maList.Prev();
 
-				while(pCmp) 
+				while(pCmp)
 				{
 					if(pAkt->GetMarkedSdrObj() == pCmp->GetMarkedSdrObj() && pAkt->GetMarkedSdrObj())
 					{
 						// Con1/Con2 Merging
-						if(pCmp->IsCon1()) 
+						if(pCmp->IsCon1())
 							pAkt->SetCon1(sal_True);
 
-						if(pCmp->IsCon2()) 
+						if(pCmp->IsCon2())
 							pAkt->SetCon2(sal_True);
-						
+
 						// pCmp loeschen.
 						maList.Remove();
-						
+
 						delete pCmp;
-					} 
-					else 
+					}
+					else
 					{
 						pAkt = pCmp;
 					}
@@ -427,7 +420,7 @@ void SdrMarkList::ImpForceSort()
 
 void SdrMarkList::Clear()
 {
-	for(sal_uLong i(0L); i < GetMarkCount(); i++) 
+	for(sal_uLong i(0L); i < GetMarkCount(); i++)
 	{
 		SdrMark* pMark = GetMark(i);
 		delete pMark;
@@ -441,7 +434,7 @@ void SdrMarkList::operator=(const SdrMarkList& rLst)
 {
 	Clear();
 
-	for(sal_uLong i(0L); i < rLst.GetMarkCount(); i++) 
+	for(sal_uLong i(0L); i < rLst.GetMarkCount(); i++)
 	{
 		SdrMark* pMark = rLst.GetMark(i);
 		SdrMark* pNeuMark = new SdrMark(*pMark);
@@ -489,30 +482,30 @@ void SdrMarkList::InsertEntry(const SdrMark& rMark, sal_Bool bChkSort)
 	SetNameDirty();
 	sal_uLong nAnz(maList.Count());
 
-	if(!bChkSort || !mbSorted || nAnz == 0) 
+	if(!bChkSort || !mbSorted || nAnz == 0)
 	{
-		if(!bChkSort) 
+		if(!bChkSort)
 			mbSorted = sal_False;
 
 		maList.Insert(new SdrMark(rMark), CONTAINER_APPEND);
-	} 
-	else 
+	}
+	else
 	{
 		SdrMark* pLast = GetMark(sal_uLong(nAnz - 1));
 		const SdrObject* pLastObj = pLast->GetMarkedSdrObj();
 		const SdrObject* pNeuObj = rMark.GetMarkedSdrObj();
 
-		if(pLastObj == pNeuObj) 
-		{ 
-			// Aha, den gibt's schon
+		if(pLastObj == pNeuObj)
+		{
+			// Aha, den gibt es schon
 			// Con1/Con2 Merging
-			if(rMark.IsCon1()) 
+			if(rMark.IsCon1())
 				pLast->SetCon1(sal_True);
 
-			if(rMark.IsCon2()) 
+			if(rMark.IsCon2())
 				pLast->SetCon2(sal_True);
-		} 
-		else 
+		}
+		else
 		{
 			SdrMark* pKopie = new SdrMark(rMark);
 			maList.Insert(pKopie, CONTAINER_APPEND);
@@ -521,21 +514,21 @@ void SdrMarkList::InsertEntry(const SdrMark& rMark, sal_Bool bChkSort)
 			const SdrObjList* pLastOL = pLastObj!=0L ? pLastObj->GetObjList() : 0L;
 			const SdrObjList* pNeuOL = pNeuObj !=0L ? pNeuObj ->GetObjList() : 0L;
 
-			if(pLastOL == pNeuOL) 
+			if(pLastOL == pNeuOL)
 			{
 				const sal_uLong nLastNum(pLastObj!=0L ? pLastObj->GetOrdNum() : 0);
-				const sal_uLong nNeuNum(pNeuObj !=0L ? pNeuObj ->GetOrdNum() : 0);
+				const sal_uLong nNewNum(pNeuObj !=0L ? pNeuObj ->GetOrdNum() : 0);
 
-				if(nNeuNum < nLastNum) 
+				if(nNewNum < nLastNum)
 				{
 					// irgendwann muss mal sortiert werden
-					mbSorted = sal_False; 
+					mbSorted = sal_False;
 				}
-			} 
-			else 
+			}
+			else
 			{
 				// irgendwann muss mal sortiert werden
-				mbSorted = sal_False; 
+				mbSorted = sal_False;
 			}
 		}
 	}
@@ -548,7 +541,7 @@ void SdrMarkList::DeleteMark(sal_uLong nNum)
 	SdrMark* pMark = GetMark(nNum);
 	DBG_ASSERT(pMark!=0L,"DeleteMark: MarkEntry nicht gefunden");
 
-	if(pMark) 
+	if(pMark)
 	{
 		maList.Remove(nNum);
 		delete pMark;
@@ -559,9 +552,9 @@ void SdrMarkList::DeleteMark(sal_uLong nNum)
 void SdrMarkList::ReplaceMark(const SdrMark& rNewMark, sal_uLong nNum)
 {
 	SdrMark* pMark = GetMark(nNum);
-	DBG_ASSERT(pMark!=0L,"ReplaceMark: MarkEntry nicht gefunden");
+	DBG_ASSERT(pMark!=0L,"ReplaceMark: MarkEntry not found");
 
-	if(pMark) 
+	if(pMark)
 	{
 		delete pMark;
 		SetNameDirty();
@@ -575,7 +568,7 @@ void SdrMarkList::Merge(const SdrMarkList& rSrcList, sal_Bool bReverse)
 {
 	sal_uLong nAnz(rSrcList.maList.Count());
 
-	if(rSrcList.mbSorted) 
+	if(rSrcList.mbSorted)
 	{
 		// Merging ohne ein Sort bei rSrcList zu erzwingen
 		bReverse = sal_False;
@@ -583,7 +576,7 @@ void SdrMarkList::Merge(const SdrMarkList& rSrcList, sal_Bool bReverse)
 
 	if(!bReverse)
 	{
-		for(sal_uLong i(0L); i < nAnz; i++) 
+		for(sal_uLong i(0L); i < nAnz; i++)
 		{
 			SdrMark* pM = (SdrMark*)(rSrcList.maList.GetObject(i));
 			InsertEntry(*pM);
@@ -591,7 +584,7 @@ void SdrMarkList::Merge(const SdrMarkList& rSrcList, sal_Bool bReverse)
 	}
 	else
 	{
-		for(sal_uLong i(nAnz); i > 0;) 
+		for(sal_uLong i(nAnz); i > 0;)
 		{
 			i--;
 			SdrMark* pM = (SdrMark*)(rSrcList.maList.GetObject(i));
@@ -604,12 +597,12 @@ sal_Bool SdrMarkList::DeletePageView(const SdrPageView& rPV)
 {
 	sal_Bool bChgd(sal_False);
 
-	for(sal_uLong i(GetMarkCount()); i > 0; ) 
+	for(sal_uLong i(GetMarkCount()); i > 0; )
 	{
 		i--;
 		SdrMark* pMark = GetMark(i);
 
-		if(pMark->GetPageView()==&rPV) 
+		if(pMark->GetPageView()==&rPV)
 		{
 			maList.Remove(i);
 			delete pMark;
@@ -629,12 +622,12 @@ sal_Bool SdrMarkList::InsertPageView(const SdrPageView& rPV)
 	const SdrObjList* pOL = rPV.GetObjList();
 	sal_uLong nObjAnz(pOL->GetObjCount());
 
-	for(sal_uLong nO(0L); nO < nObjAnz; nO++) 
+	for(sal_uLong nO(0L); nO < nObjAnz; nO++)
 	{
 		pObj = pOL->GetObj(nO);
 		sal_Bool bDoIt(rPV.IsObjMarkable(pObj));
 
-		if(bDoIt) 
+		if(bDoIt)
 		{
 			SdrMark* pM = new SdrMark(pObj, (SdrPageView*)&rPV);
 			maList.Insert(pM, CONTAINER_APPEND);
@@ -649,44 +642,44 @@ sal_Bool SdrMarkList::InsertPageView(const SdrPageView& rPV)
 const XubString& SdrMarkList::GetMarkDescription() const
 {
 	sal_uLong nAnz(GetMarkCount());
-	
-	if(mbNameOk && 1L == nAnz) 
+
+	if(mbNameOk && 1L == nAnz)
 	{
 		// Bei Einfachselektion nur Textrahmen cachen
 		const SdrObject* pObj = GetMark(0)->GetMarkedSdrObj();
 		const SdrTextObj* pTextObj = PTR_CAST(SdrTextObj, pObj);
 
-		if(!pTextObj || !pTextObj->IsTextFrame()) 
+		if(!pTextObj || !pTextObj->IsTextFrame())
 		{
 			((SdrMarkList*)(this))->mbNameOk = sal_False;
 		}
 	}
-	
-	if(!mbNameOk) 
+
+	if(!mbNameOk)
 	{
 		SdrMark* pMark = GetMark(0);
 		XubString aNam;
-		
-		if(!nAnz) 
+
+		if(!nAnz)
 		{
 			((SdrMarkList*)(this))->maMarkName = ImpGetResStr(STR_ObjNameNoObj);
-		} 
-		else if(1L == nAnz) 
+		}
+		else if(1L == nAnz)
 		{
 			if(pMark->GetMarkedSdrObj())
 			{
 				pMark->GetMarkedSdrObj()->TakeObjNameSingul(aNam);
 			}
-		} 
-		else 
+		}
+		else
 		{
 			if(pMark->GetMarkedSdrObj())
 			{
 				pMark->GetMarkedSdrObj()->TakeObjNamePlural(aNam);
 				XubString aStr1;
 				sal_Bool bEq(sal_True);
-				
-				for(sal_uLong i = 1; i < GetMarkCount() && bEq; i++) 
+
+				for(sal_uLong i = 1; i < GetMarkCount() && bEq; i++)
 				{
 					SdrMark* pMark2 = GetMark(i);
 					pMark2->GetMarkedSdrObj()->TakeObjNamePlural(aStr1);
@@ -718,61 +711,61 @@ const XubString& SdrMarkList::GetPointMarkDescription(sal_Bool bGlue) const
 	sal_uLong nMarkPtAnz(0L);
 	sal_uLong nMarkPtObjAnz(0L);
 	sal_uLong n1stMarkNum(ULONG_MAX);
-	
-	for(sal_uLong nMarkNum(0L); nMarkNum < nMarkAnz; nMarkNum++) 
+
+	for(sal_uLong nMarkNum(0L); nMarkNum < nMarkAnz; nMarkNum++)
 	{
 		const SdrMark* pMark = GetMark(nMarkNum);
 		const SdrUShortCont* pPts = bGlue ? pMark->GetMarkedGluePoints() : pMark->GetMarkedPoints();
 		sal_uLong nAnz(pPts ? pPts->GetCount() : 0);
-		
-		if(nAnz) 
+
+		if(nAnz)
 		{
-			if(n1stMarkNum == ULONG_MAX) 
+			if(n1stMarkNum == ULONG_MAX)
 			{
 				n1stMarkNum = nMarkNum;
 			}
-			
+
 			nMarkPtAnz += nAnz;
 			nMarkPtObjAnz++;
 		}
 
-		if(nMarkPtObjAnz > 1 && rNameOk) 
+		if(nMarkPtObjAnz > 1 && rNameOk)
 		{
 			// vorzeitige Entscheidung
-			return rName; 
+			return rName;
 		}
 	}
 
-	if(rNameOk && 1L == nMarkPtObjAnz) 
+	if(rNameOk && 1L == nMarkPtObjAnz)
 	{
 		// Bei Einfachselektion nur Textrahmen cachen
 		const SdrObject* pObj = GetMark(0)->GetMarkedSdrObj();
 		const SdrTextObj* pTextObj = PTR_CAST(SdrTextObj,pObj);
-		
-		if(!pTextObj || !pTextObj->IsTextFrame()) 
+
+		if(!pTextObj || !pTextObj->IsTextFrame())
 		{
 			rNameOk = sal_False;
 		}
 	}
 
-	if(!nMarkPtObjAnz) 
+	if(!nMarkPtObjAnz)
 	{
 		rName.Erase();
 		rNameOk = sal_True;
-	} 
-	else if(!rNameOk) 
+	}
+	else if(!rNameOk)
 	{
 		const SdrMark* pMark = GetMark(n1stMarkNum);
 		XubString aNam;
 
-		if(1L == nMarkPtObjAnz) 
+		if(1L == nMarkPtObjAnz)
 		{
 			if(pMark->GetMarkedSdrObj())
 			{
 				pMark->GetMarkedSdrObj()->TakeObjNameSingul(aNam);
 			}
-		} 
-		else 
+		}
+		else
 		{
 			if(pMark->GetMarkedSdrObj())
 			{
@@ -781,35 +774,35 @@ const XubString& SdrMarkList::GetPointMarkDescription(sal_Bool bGlue) const
 
 			XubString aStr1;
 			sal_Bool bEq(sal_True);
-			
-			for(sal_uLong i(n1stMarkNum + 1L); i < GetMarkCount() && bEq; i++) 
+
+			for(sal_uLong i(n1stMarkNum + 1L); i < GetMarkCount() && bEq; i++)
 			{
 				const SdrMark* pMark2 = GetMark(i);
 				const SdrUShortCont* pPts = bGlue ? pMark2->GetMarkedGluePoints() : pMark2->GetMarkedPoints();
-				
-				if(pPts && pPts->GetCount() && pMark2->GetMarkedSdrObj()) 
+
+				if(pPts && pPts->GetCount() && pMark2->GetMarkedSdrObj())
 				{
 					pMark2->GetMarkedSdrObj()->TakeObjNamePlural(aStr1);
 					bEq = aNam.Equals(aStr1);
 				}
 			}
-	
-			if(!bEq) 
+
+			if(!bEq)
 			{
 				aNam = ImpGetResStr(STR_ObjNamePlural);
 			}
-			
+
 			aNam.Insert(sal_Unicode(' '), 0);
 			aNam.Insert(UniString::CreateFromInt32(nMarkPtObjAnz), 0);
 		}
 
 		XubString aStr1;
-		
-		if(1L == nMarkPtAnz) 
+
+		if(1L == nMarkPtAnz)
 		{
 			aStr1 = (ImpGetResStr(bGlue ? STR_ViewMarkedGluePoint : STR_ViewMarkedPoint));
-		} 
-		else 
+		}
+		else
 		{
 			aStr1 = (ImpGetResStr(bGlue ? STR_ViewMarkedGluePoints : STR_ViewMarkedPoints));
 			aStr1.SearchAndReplaceAscii("%2", UniString::CreateFromInt32(nMarkPtAnz));
@@ -828,21 +821,21 @@ sal_Bool SdrMarkList::TakeBoundRect(SdrPageView* pPV, Rectangle& rRect) const
 	sal_Bool bFnd(sal_False);
 	Rectangle aR;
 
-	for(sal_uLong i(0L); i < GetMarkCount(); i++) 
+	for(sal_uLong i(0L); i < GetMarkCount(); i++)
 	{
 		SdrMark* pMark = GetMark(i);
 
-		if(!pPV || pMark->GetPageView() == pPV) 
+		if(!pPV || pMark->GetPageView() == pPV)
 		{
 			if(pMark->GetMarkedSdrObj())
 			{
 				aR = pMark->GetMarkedSdrObj()->GetCurrentBoundRect();
 
-				if(bFnd) 
+				if(bFnd)
 				{
 					rRect.Union(aR);
-				} 
-				else 
+				}
+				else
 				{
 					rRect = aR;
 					bFnd = sal_True;
@@ -858,21 +851,21 @@ sal_Bool SdrMarkList::TakeSnapRect(SdrPageView* pPV, Rectangle& rRect) const
 {
 	sal_Bool bFnd(sal_False);
 
-	for(sal_uLong i(0L); i < GetMarkCount(); i++) 
+	for(sal_uLong i(0L); i < GetMarkCount(); i++)
 	{
 		SdrMark* pMark = GetMark(i);
 
-		if(!pPV || pMark->GetPageView() == pPV) 
+		if(!pPV || pMark->GetPageView() == pPV)
 		{
 			if(pMark->GetMarkedSdrObj())
 			{
 				Rectangle aR(pMark->GetMarkedSdrObj()->GetSnapRect());
 
-				if(bFnd) 
+				if(bFnd)
 				{
 					rRect.Union(aR);
-				} 
-				else 
+				}
+				else
 				{
 					rRect = aR;
 					bFnd = sal_True;
@@ -893,11 +886,11 @@ namespace sdr
 	{
 	}
 
-	void ViewSelection::SetEdgesOfMarkedNodesDirty() 
-	{ 
+	void ViewSelection::SetEdgesOfMarkedNodesDirty()
+	{
 		if(!mbEdgesOfMarkedNodesDirty)
 		{
-			mbEdgesOfMarkedNodesDirty = sal_True; 
+			mbEdgesOfMarkedNodesDirty = sal_True;
 			maEdgesOfMarkedNodes.Clear();
 			maMarkedEdgesOfMarkedNodes.Clear();
 			maAllMarkedObjects.Clear();
@@ -905,33 +898,33 @@ namespace sdr
 	}
 
 	const SdrMarkList& ViewSelection::GetEdgesOfMarkedNodes() const
-	{ 
+	{
 		if(mbEdgesOfMarkedNodesDirty)
 		{
 			((ViewSelection*)this)->ImpForceEdgesOfMarkedNodes();
 		}
 
-		return maEdgesOfMarkedNodes; 
+		return maEdgesOfMarkedNodes;
 	}
 
-	const SdrMarkList& ViewSelection::GetMarkedEdgesOfMarkedNodes() const 
-	{ 
+	const SdrMarkList& ViewSelection::GetMarkedEdgesOfMarkedNodes() const
+	{
 		if(mbEdgesOfMarkedNodesDirty)
 		{
 			((ViewSelection*)this)->ImpForceEdgesOfMarkedNodes();
 		}
 
-		return maMarkedEdgesOfMarkedNodes; 
+		return maMarkedEdgesOfMarkedNodes;
 	}
 
-	const List& ViewSelection::GetAllMarkedObjects() const 
-	{ 
+	const List& ViewSelection::GetAllMarkedObjects() const
+	{
 		if(mbEdgesOfMarkedNodesDirty)
 		{
 			((ViewSelection*)this)->ImpForceEdgesOfMarkedNodes();
 		}
 
-		return maAllMarkedObjects; 
+		return maAllMarkedObjects;
 	}
 
 	void ViewSelection::ImplCollectCompleteSelection(SdrObject* pObj)
@@ -962,7 +955,7 @@ namespace sdr
 
 	void ViewSelection::ImpForceEdgesOfMarkedNodes()
 	{
-		if(mbEdgesOfMarkedNodesDirty) 
+		if(mbEdgesOfMarkedNodesDirty)
 		{
 			mbEdgesOfMarkedNodesDirty = sal_False;
 			maMarkedObjectList.ForceSort();
@@ -987,35 +980,35 @@ namespace sdr
 						// travel over broadcaster/listener to access edges connected to the selected object
 						const SfxBroadcaster* pBC = pCandidate->GetBroadcaster();
 
-						if(pBC) 
+						if(pBC)
 						{
 							sal_uInt16 nLstAnz(pBC->GetListenerCount());
 
-							for(sal_uInt16 nl(0); nl < nLstAnz; nl++) 
+							for(sal_uInt16 nl(0); nl < nLstAnz; nl++)
 							{
 								SfxListener* pLst = pBC->GetListener(nl);
 								SdrEdgeObj* pEdge = PTR_CAST(SdrEdgeObj, pLst);
 
-								if(pEdge && pEdge->IsInserted() && pEdge->GetPage() == pCandidate->GetPage()) 
+								if(pEdge && pEdge->IsInserted() && pEdge->GetPage() == pCandidate->GetPage())
 								{
 									SdrMark aM(pEdge, maMarkedObjectList.GetMark(a)->GetPageView());
-									
-									if(pEdge->GetConnectedNode(sal_True) == pCandidate) 
+
+									if(pEdge->GetConnectedNode(sal_True) == pCandidate)
 									{
 										aM.SetCon1(sal_True);
 									}
 
-									if(pEdge->GetConnectedNode(sal_False) == pCandidate) 
+									if(pEdge->GetConnectedNode(sal_False) == pCandidate)
 									{
 										aM.SetCon2(sal_True);
 									}
 
 									if(CONTAINER_ENTRY_NOTFOUND == maMarkedObjectList.FindObject(pEdge))
-									{ 
+									{
 										// nachsehen, ob er selbst markiert ist
 										maEdgesOfMarkedNodes.InsertEntry(aM);
-									} 
-									else 
+									}
+									else
 									{
 										maMarkedEdgesOfMarkedNodes.InsertEntry(aM);
 									}
@@ -1032,5 +1025,4 @@ namespace sdr
 	}
 } // end of namespace sdr
 
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// eof
+/* vim: set noet sw=4 ts=4: */
diff --git a/main/svx/source/svdraw/svdmodel.cxx b/main/svx/source/svdraw/svdmodel.cxx
index a209cb749d..e33ca5fe77 100644
--- a/main/svx/source/svdraw/svdmodel.cxx
+++ b/main/svx/source/svdraw/svdmodel.cxx
@@ -1754,23 +1754,23 @@ void SdrModel::Merge(SdrModel& rSourceModel,
 
 					if (bMergeMasterPages)
 					{
-						sal_uInt16 nNeuNum(0xFFFF);
+						sal_uInt16 nNewNum(0xFFFF);
 
 						if(pMasterMap)
 						{
-							nNeuNum = pMasterMap[nMaPgNum];
+							nNewNum = pMasterMap[nMaPgNum];
 						}
 
-						if(nNeuNum != 0xFFFF)
+						if(nNewNum != 0xFFFF)
 						{
 							if(bUndo)
 							{
 								AddUndo(GetSdrUndoFactory().CreateUndoPageChangeMasterPage(*pPg));
 							}
 
-							pPg->TRG_SetMasterPage(*GetMasterPage(nNeuNum));
+							pPg->TRG_SetMasterPage(*GetMasterPage(nNewNum));
 						}
-						DBG_ASSERT(nNeuNum!=0xFFFF,"SdrModel::Merge(): Irgendwas ist krumm beim Mappen der MasterPages");
+						DBG_ASSERT(nNewNum!=0xFFFF,"SdrModel::Merge(): Irgendwas ist krumm beim Mappen der MasterPages");
 					} else {
 						if (nMaPgNum>=nDstMasterPageAnz) {
 							// Aha, die ist ausserbalb des ursprünglichen Bereichs der Masterpages des DstModel