INTEGRATION: CWS aw013 (1.3.294); FILE MERGED

2004/06/29 10:10:24 aw 1.3.294.3: #i29181#
2004/06/28 14:55:03 aw 1.3.294.2: #117254#
2004/06/24 09:26:38 aw 1.3.294.1: #i29181#

1 files changed, 575 insertions, 297 deletions

diff --git a/svx/source/svdraw/svdmark.cxx b/svx/source/svdraw/svdmark.cxx
index 5e1e773df7d9..fc1d7cbe6b8e 100644
--- a/svx/source/svdraw/svdmark.cxx
+++ b/svx/source/svdraw/svdmark.cxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: svdmark.cxx,v $
  *
- *  $Revision: 1.3 $
+ *  $Revision: 1.4 $
  *
- *  last change: $Author: rt $ $Date: 2003-11-24 16:55:25 $
+ *  last change: $Author: rt $ $Date: 2004-07-12 14:46:24 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -59,6 +59,8 @@
  *
  ************************************************************************/
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 #include "svdmark.hxx"
 #include "svdetc.hxx"
 #include "svdobj.hxx"
@@ -73,62 +75,93 @@
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+#ifndef _E3D_OBJ3D_HXX //autogen
+#include <obj3d.hxx>
+#endif
+
+#ifndef _E3D_SCENE3D_HXX
+#include <scene3d.hxx>
+#endif
+
+#ifndef _SFXBRDCST_HXX //autogen
+#include <svtools/brdcst.hxx>
+#endif
+
+#ifndef _SVDOEDGE_HXX
+#include <svdoedge.hxx>
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 class ImpSdrUShortContSorter: public ContainerSorter
 {
 public:
-    ImpSdrUShortContSorter(Container& rNewCont): ContainerSorter(rNewCont) {}
+    ImpSdrUShortContSorter(Container& rNewCont)
+    :   ContainerSorter(rNewCont)
+    {}
+
     virtual int Compare(const void* pElem1, const void* pElem2) const;
 };
 
 int ImpSdrUShortContSorter::Compare(const void* pElem1, const void* pElem2) const
 {
-    USHORT n1=USHORT(ULONG(pElem1));
-    USHORT n2=USHORT(ULONG(pElem2));
-    return n1<n2 ? -1 : n1>n2 ? 1 : 0;
+    sal_uInt16 n1((sal_uInt16)((sal_uInt32)pElem1));
+    sal_uInt16 n2((sal_uInt16)((sal_uInt32)pElem2));
+
+    return ((n1 < n2) ? (-1) : (n1 > n2) ? (1) : (0));
 }
 
-void SdrUShortCont::Sort()
+void SdrUShortCont::Sort() const
 {
-    ImpSdrUShortContSorter aSort(aArr);
+    ImpSdrUShortContSorter aSort(*((Container*)(&maArray)));
     aSort.DoSort();
-    bSorted=TRUE;
-    if (bDelDups) {
-        ULONG nNum=GetCount();
-        if (nNum>1) {
+    ((SdrUShortCont*)this)->mbSorted = sal_True;
+
+    sal_uInt32 nNum(GetCount());
+
+    if(nNum > 1)
+    {
+        nNum--;
+        sal_uInt16 nVal0 = GetObject(nNum);
+
+        while(nNum > 0)
+        {
             nNum--;
-            USHORT nVal0=GetObject(nNum);
-            while (nNum>0) {
-                nNum--;
-                USHORT nVal1=GetObject(nNum);
-                if (nVal1==nVal0) {
-                    Remove(nNum);
-                }
-                nVal0=nVal1;
+            sal_uInt16 nVal1 = GetObject(nNum);
+
+            if(nVal1 == nVal0)
+            {
+                ((SdrUShortCont*)this)->Remove(nNum);
             }
+
+            nVal0 = nVal1;
         }
     }
 }
 
-void SdrUShortCont::CheckSort(ULONG nPos)
+void SdrUShortCont::CheckSort(sal_uInt32 nPos)
 {
-    ULONG nAnz=aArr.Count();
-    if (nPos>nAnz) nPos=nAnz;
-    USHORT nAktVal=GetObject(nPos);
-    if (nPos>0) {
-        USHORT nPrevVal=GetObject(nPos-1);
-        if (bDelDups) {
-            if (nPrevVal>=nAktVal) bSorted=FALSE;
-        } else {
-            if (nPrevVal>nAktVal) bSorted=FALSE;
-        }
+    sal_uInt32 nAnz(maArray.Count());
+
+    if(nPos > nAnz)
+        nPos = nAnz;
+
+    sal_uInt16 nAktVal = GetObject(nPos);
+
+    if(nPos > 0)
+    {
+        sal_uInt16 nPrevVal = GetObject(nPos - 1);
+
+        if(nPrevVal >= nAktVal)
+            mbSorted = sal_False;
     }
-    if (nPos<nAnz-1) {
-        USHORT nNextVal=GetObject(nPos+1);
-        if (bDelDups) {
-            if (nNextVal<=nAktVal) bSorted=FALSE;
-        } else {
-            if (nNextVal<nAktVal) bSorted=FALSE;
-        }
+
+    if(nPos < nAnz - 1)
+    {
+        sal_uInt16 nNextVal = GetObject(nPos + 1);
+
+        if(nNextVal <= nAktVal)
+            mbSorted = sal_False;
     }
 }
 
@@ -136,70 +169,108 @@ void SdrUShortCont::CheckSort(ULONG nPos)
 
 SdrMark& SdrMark::operator=(const SdrMark& rMark)
 {
-    pObj=rMark.pObj;
-    pPageView=rMark.pPageView;
-    bCon1=rMark.bCon1;
-    bCon2=rMark.bCon2;
-    nUser=rMark.nUser;
-    if (rMark.pPoints==NULL) {
-        if (pPoints!=NULL) {
-            delete pPoints;
-            pPoints=NULL;
-        }
-    } else {
-        if (pPoints==NULL) {
-            pPoints=new SdrUShortCont(*rMark.pPoints);
-        } else {
-            *pPoints=*rMark.pPoints;
-        }
-    }
-    if (rMark.pLines==NULL) {
-        if (pLines!=NULL) {
-            delete pLines;
-            pLines=NULL;
-        }
-    } else {
-        if (pLines==NULL) {
-            pLines=new SdrUShortCont(*rMark.pLines);
-        } else {
-            *pLines=*rMark.pLines;
-        }
-    }
-    if (rMark.pGluePoints==NULL) {
-        if (pGluePoints!=NULL) {
-            delete pGluePoints;
-            pGluePoints=NULL;
-        }
-    } else {
-        if (pGluePoints==NULL) {
-            pGluePoints=new SdrUShortCont(*rMark.pGluePoints);
-        } else {
-            *pGluePoints=*rMark.pGluePoints;
+    mpObj = rMark.mpObj;
+    mpPageView = rMark.mpPageView;
+    mbCon1 = rMark.mbCon1;
+    mbCon2 = rMark.mbCon2;
+    mnUser = rMark.mnUser;
+
+    if(!rMark.mpPoints)
+    {
+        if(mpPoints)
+        {
+            delete mpPoints;
+            mpPoints = 0L;
+        }
+    }
+    else
+    {
+        if(!mpPoints)
+        {
+            mpPoints = new SdrUShortCont(*rMark.mpPoints);
+        }
+        else
+        {
+            *mpPoints = *rMark.mpPoints;
+        }
+    }
+
+    if(!rMark.mpLines)
+    {
+        if(mpLines)
+        {
+            delete mpLines;
+            mpLines = 0L;
+        }
+    }
+    else
+    {
+        if(!mpLines)
+        {
+            mpLines = new SdrUShortCont(*rMark.mpLines);
+        }
+        else
+        {
+            *mpLines = *rMark.mpLines;
+        }
+    }
+
+    if(!rMark.mpGluePoints)
+    {
+        if(mpGluePoints)
+        {
+            delete mpGluePoints;
+            mpGluePoints = 0L;
+        }
+    }
+    else
+    {
+        if(!mpGluePoints)
+        {
+            mpGluePoints = new SdrUShortCont(*rMark.mpGluePoints);
+        }
+        else
+        {
+            *mpGluePoints = *rMark.mpGluePoints;
         }
     }
+
     return *this;
 }
 
-FASTBOOL SdrMark::operator==(const SdrMark& rMark) const
+sal_Bool SdrMark::operator==(const SdrMark& rMark) const
 {
-    FASTBOOL bRet=pObj==rMark.pObj && pPageView==rMark.pPageView && bCon1==rMark.bCon1 && bCon2==rMark.bCon2 && nUser==rMark.nUser;
-    if ((pPoints!=NULL) != (rMark.pPoints!=NULL)) bRet=FALSE;
-    if ((pLines !=NULL) != (rMark.pLines !=NULL)) bRet=FALSE;
-    if ((pGluePoints!=NULL) != (rMark.pGluePoints!=NULL)) bRet=FALSE;
-    if (bRet && pPoints!=NULL && *pPoints!=*rMark.pPoints) bRet=FALSE;
-    if (bRet && pLines !=NULL && *pLines !=*rMark.pLines ) bRet=FALSE;
-    if (bRet && pGluePoints!=NULL && *pGluePoints!=*rMark.pGluePoints) bRet=FALSE;
+    sal_Bool bRet(mpObj == rMark.mpObj && mpPageView == rMark.mpPageView && mbCon1 == rMark.mbCon1 && mbCon2 == rMark.mbCon2 && mnUser == rMark.mnUser);
+
+    if((mpPoints != 0L) != (rMark.mpPoints != 0L))
+        bRet = sal_False;
+
+    if((mpLines != 0L) != (rMark.mpLines != 0L))
+        bRet = sal_False;
+
+    if((mpGluePoints != 0L) != (rMark.mpGluePoints != 0L))
+        bRet = sal_False;
+
+    if(bRet && mpPoints && *mpPoints != *rMark.mpPoints)
+        bRet = sal_False;
+
+    if(bRet && mpLines && *mpLines != *rMark.mpLines)
+        bRet = sal_False;
+
+    if(bRet && mpGluePoints && *mpGluePoints != *rMark.mpGluePoints)
+        bRet = sal_False;
+
     return bRet;
 }
 
 SdrPage* SdrMark::GetPage() const
 {
-    return (pObj!=NULL ? pObj->GetPage() : NULL);
+    return (mpObj ? mpObj->GetPage() : 0L);
 }
 
 SdrObjList* SdrMark::GetObjList() const
 {
-    return (pObj!=NULL ? pObj->GetObjList() : NULL);
+    return (mpObj ? mpObj->GetObjList() : 0L);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -207,52 +278,83 @@ SdrObjList* SdrMark::GetObjList() const
 class ImpSdrMarkListSorter: public ContainerSorter
 {
 public:
-    ImpSdrMarkListSorter(Container& rNewCont): ContainerSorter(rNewCont) {}
+    ImpSdrMarkListSorter(Container& rNewCont)
+    :   ContainerSorter(rNewCont)
+    {}
+
     virtual int Compare(const void* pElem1, const void* pElem2) const;
 };
 
 int ImpSdrMarkListSorter::Compare(const void* pElem1, const void* pElem2) const
 {
-    const SdrObject* pObj1=((SdrMark*)pElem1)->GetObj();
-    const SdrObject* pObj2=((SdrMark*)pElem2)->GetObj();
-    const SdrObjList* pOL1=pObj1!=NULL ? pObj1->GetObjList() : NULL;
-    const SdrObjList* pOL2=pObj2!=NULL ? pObj2->GetObjList() : NULL;
-    if (pOL1==pOL2) {
-        ULONG nObjOrd1=pObj1!=NULL ? pObj1->GetOrdNum() : 0;
-        ULONG nObjOrd2=pObj2!=NULL ? pObj2->GetOrdNum() : 0;
-        return nObjOrd1<nObjOrd2 ? -1 : 1;
-    } else {
-        return (long)pOL1<(long)pOL2 ? -1 : 1;
+    const SdrObject* pObj1 = ((SdrMark*)pElem1)->GetObj();
+    const SdrObject* pObj2 = ((SdrMark*)pElem2)->GetObj();
+    const SdrObjList* pOL1 = (pObj1) ? pObj1->GetObjList() : 0L;
+    const SdrObjList* pOL2 = (pObj2) ? pObj2->GetObjList() : 0L;
+
+    if(pOL1 == pOL2)
+    {
+        sal_uInt32 nObjOrd1((pObj1) ? pObj1->GetOrdNum() : 0);
+        sal_uInt32 nObjOrd2((pObj2) ? pObj2->GetOrdNum() : 0);
+
+        return (nObjOrd1 < nObjOrd2 ? -1 : 1);
+    }
+    else
+    {
+        return ((long)pOL1 < (long)pOL2) ? -1 : 1;
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void SdrMarkList::ForceSort()
+void SdrMarkList::ForceSort() const
+{
+    if(!mbSorted)
+    {
+        ((SdrMarkList*)this)->ImpForceSort();
+    }
+}
+
+void SdrMarkList::ImpForceSort()
 {
-    if (!bSorted) {
-        bSorted=TRUE;
-        ULONG nAnz=aList.Count();
-        if (nAnz>1) {
-            ImpSdrMarkListSorter aSort(aList);
+    if(!mbSorted)
+    {
+        mbSorted = sal_True;
+        sal_uInt32 nAnz = maList.Count();
+
+        if(nAnz > 1)
+        {
+            ImpSdrMarkListSorter aSort(maList);
             aSort.DoSort();
+
             // und nun doppelte rauswerfen
-            if (aList.Count()>1) {
-                SdrMark* pAkt=(SdrMark*)aList.Last();
-                SdrMark* pCmp=(SdrMark*)aList.Prev();
-                while (pCmp!=NULL) {
-                    if (pAkt->GetObj()==pCmp->GetObj()) {
+            if(maList.Count() > 1)
+            {
+                SdrMark* pAkt = (SdrMark*)maList.Last();
+                SdrMark* pCmp = (SdrMark*)maList.Prev();
+
+                while(pCmp)
+                {
+                    if(pAkt->GetObj() == pCmp->GetObj())
+                    {
                         // Con1/Con2 Merging
-                        if (pCmp->IsCon1()) pAkt->SetCon1(TRUE);
-                        if (pCmp->IsCon2()) pAkt->SetCon2(TRUE);
+                        if(pCmp->IsCon1())
+                            pAkt->SetCon1(sal_True);
+
+                        if(pCmp->IsCon2())
+                            pAkt->SetCon2(sal_True);
+
                         // pCmp loeschen.
-                        aList.Remove();
+                        maList.Remove();
+
                         delete pCmp;
-                        // Aktueller Entry im Container ist nun pAkt!
-                    } else {
-                        pAkt=pCmp;
                     }
-                    pCmp=(SdrMark*)aList.Prev();
+                    else
+                    {
+                        pAkt = pCmp;
+                    }
+
+                    pCmp = (SdrMark*)maList.Prev();
                 }
             }
         }
@@ -261,32 +363,37 @@ void SdrMarkList::ForceSort()
 
 void SdrMarkList::Clear()
 {
-    for (ULONG i=0; i<GetMarkCount(); i++) {
-        SdrMark* pMark=GetMark(i);
+    for(sal_uInt32 i(0L); i < GetMarkCount(); i++)
+    {
+        SdrMark* pMark = GetMark(i);
         delete pMark;
     }
-    aList.Clear();
+
+    maList.Clear();
     SetNameDirty();
 }
 
 void SdrMarkList::operator=(const SdrMarkList& rLst)
 {
     Clear();
-    for (ULONG i=0; i<rLst.GetMarkCount(); i++) {
-        SdrMark* pMark=rLst.GetMark(i);
-        SdrMark* pNeuMark=new SdrMark(*pMark);
-        aList.Insert(pNeuMark,CONTAINER_APPEND);
-    }
-    aMarkName=rLst.aMarkName;
-    bNameOk=rLst.bNameOk;
-    aPointName=rLst.aPointName;
-    bPointNameOk=rLst.bPointNameOk;
-    aGluePointName=rLst.aGluePointName;
-    bGluePointNameOk=rLst.bGluePointNameOk;
-    bSorted=rLst.bSorted;
+
+    for(sal_uInt32 i(0L); i < rLst.GetMarkCount(); i++)
+    {
+        SdrMark* pMark = rLst.GetMark(i);
+        SdrMark* pNeuMark = new SdrMark(*pMark);
+        maList.Insert(pNeuMark, CONTAINER_APPEND);
+    }
+
+    maMarkName = rLst.maMarkName;
+    mbNameOk = rLst.mbNameOk;
+    maPointName = rLst.maPointName;
+    mbPointNameOk = rLst.mbPointNameOk;
+    maGluePointName = rLst.maGluePointName;
+    mbGluePointNameOk = rLst.mbGluePointNameOk;
+    mbSorted = rLst.mbSorted;
 }
 
-ULONG SdrMarkList::FindObject(const SdrObject* pObj)
+sal_uInt32 SdrMarkList::FindObject(const SdrObject* pObj) const
 {
     // #109658#
     //
@@ -294,16 +401,16 @@ ULONG SdrMarkList::FindObject(const SdrObject* pObj)
     // selection may not be inserted in a list if they are e.g. modified ATM, i changed
     // this loop to just look if the object pointer is in the selection.
     //
-    // Problem is that GetOrdNum() which is const, internally casts no non-const and
+    // Problem is that GetOrdNum() which is const, internally casts to non-const and
     // hardly sets the OrdNum member of the object (nOrdNum) to 0 (ZERO) if the object
     // is not inserted in a object list.
     // Since this may be by purpose and necessary somewhere else i decided that it is
     // less dangerous to change this method then changing SdrObject::GetOrdNum().
-    if(pObj && aList.Count())
+    if(pObj && maList.Count())
     {
-        for(sal_uInt32 a(0L); a < aList.Count(); a++)
+        for(sal_uInt32 a(0L); a < maList.Count(); a++)
         {
-            if(((SdrMark*)(aList.GetObject(a)))->GetObj() == pObj)
+            if(((SdrMark*)(maList.GetObject(a)))->GetObj() == pObj)
             {
                 return a;
             }
@@ -311,179 +418,199 @@ ULONG SdrMarkList::FindObject(const SdrObject* pObj)
     }
 
     return CONTAINER_ENTRY_NOTFOUND;
-
-    /*
-    ForceSort();
-    if (pObj==NULL || aList.Count()==0) return CONTAINER_ENTRY_NOTFOUND;
-    const SdrObjList* pOL=pObj->GetObjList();
-    ULONG nObjOrd=pObj->GetOrdNum();
-    ULONG nL=0;
-    ULONG nR=aList.Count();
-    if (GetMark(nL)->GetObj()==pObj) return nL;
-    while (nL+1<nR) { // Der Gesuchte befindet sich zwischen, nicht auf den Grenzen!
-        ULONG nMid=(nL+nR)/2;
-        const SdrObject* pMidObj=GetMark(nMid)->GetObj();
-        if (pMidObj==pObj) return nMid; // Hurra, gefunden!
-        const SdrObjList* pMidOL=pMidObj!=NULL ? pMidObj->GetObjList() : NULL;
-        ULONG nMidObjOrd=pMidObj!=NULL ? pMidObj->GetOrdNum() : 0;
-        if (pMidOL==pOL) {
-            if (nMidObjOrd<nObjOrd) nL=nMid;
-            else if (nMidObjOrd>nObjOrd) nR=nMid;
-            else {
-                DBG_ASSERT(FALSE,"SdrMarkList::FindObject(): Anderes Objekt mit gleicher OrdNum gefunden!");
-                return CONTAINER_ENTRY_NOTFOUND;
-            }
-        } else if ((long)pMidOL<(long)pOL) nL=nMid;
-        else nR=nMid;
-    }
-    return CONTAINER_ENTRY_NOTFOUND;
-    */
 }
 
-void SdrMarkList::InsertEntry(const SdrMark& rMark, FASTBOOL bChkSort)
+void SdrMarkList::InsertEntry(const SdrMark& rMark, sal_Bool bChkSort)
 {
     SetNameDirty();
-    ULONG nAnz=aList.Count();
-    if (!bChkSort || !bSorted || nAnz==0) {
-        if (!bChkSort) bSorted=FALSE;
-        aList.Insert(new SdrMark(rMark),CONTAINER_APPEND);
-    } else {
-        SdrMark* pLast=GetMark(ULONG(nAnz-1));
-        const SdrObject* pLastObj=pLast->GetObj();
-        const SdrObject* pNeuObj=rMark.GetObj();
-        if (pLastObj==pNeuObj) { // Aha, den gibt's schon
+    sal_uInt32 nAnz(maList.Count());
+
+    if(!bChkSort || !mbSorted || nAnz == 0)
+    {
+        if(!bChkSort)
+            mbSorted = sal_False;
+
+        maList.Insert(new SdrMark(rMark), CONTAINER_APPEND);
+    }
+    else
+    {
+        SdrMark* pLast = GetMark(sal_uInt32(nAnz - 1));
+        const SdrObject* pLastObj = pLast->GetObj();
+        const SdrObject* pNeuObj = rMark.GetObj();
+
+        if(pLastObj == pNeuObj)
+        {
+            // Aha, den gibt's schon
             // Con1/Con2 Merging
-            if (rMark.IsCon1()) pLast->SetCon1(TRUE);
-            if (rMark.IsCon2()) pLast->SetCon2(TRUE);
-        } else {
-            SdrMark* pKopie=new SdrMark(rMark);
-            aList.Insert(pKopie,CONTAINER_APPEND);
+            if(rMark.IsCon1())
+                pLast->SetCon1(sal_True);
+
+            if(rMark.IsCon2())
+                pLast->SetCon2(sal_True);
+        }
+        else
+        {
+            SdrMark* pKopie = new SdrMark(rMark);
+            maList.Insert(pKopie, CONTAINER_APPEND);
+
             // und nun checken, ob die Sortierung noch ok ist
-            const SdrObjList* pLastOL=pLastObj!=NULL ? pLastObj->GetObjList() : NULL;
-            const SdrObjList* pNeuOL =pNeuObj !=NULL ? pNeuObj ->GetObjList() : NULL;
-            if (pLastOL==pNeuOL) {
-                ULONG nLastNum=pLastObj!=NULL ? pLastObj->GetOrdNum() : 0;
-                ULONG nNeuNum =pNeuObj !=NULL ? pNeuObj ->GetOrdNum() : 0;
-                if (nNeuNum<nLastNum) {
-                    bSorted=FALSE; // irgendwann muss mal sortiert werden
+            const SdrObjList* pLastOL = pLastObj!=0L ? pLastObj->GetObjList() : 0L;
+            const SdrObjList* pNeuOL = pNeuObj !=0L ? pNeuObj ->GetObjList() : 0L;
+
+            if(pLastOL == pNeuOL)
+            {
+                sal_uInt32 nLastNum(pLastObj!=0L ? pLastObj->GetOrdNum() : 0);
+                sal_uInt32 nNeuNum(pNeuObj !=0L ? pNeuObj ->GetOrdNum() : 0);
+
+                if(nNeuNum < nLastNum)
+                {
+                    // irgendwann muss mal sortiert werden
+                    mbSorted = sal_False;
                 }
-            } else {
-                if ((long)pNeuOL<(long)pLastOL) {
-                    bSorted=FALSE; // irgendwann muss mal sortiert werden
+            }
+            else
+            {
+                if((long)pNeuOL < (long)pLastOL)
+                {
+                    // irgendwann muss mal sortiert werden
+                    mbSorted = sal_False;
                 }
             }
         }
     }
+
     return;
 }
 
-void SdrMarkList::DeleteMark(ULONG nNum)
+void SdrMarkList::DeleteMark(sal_uInt32 nNum)
 {
-    //ForceSort();
-    SdrMark* pMark=GetMark(nNum);
-    DBG_ASSERT(pMark!=NULL,"DeleteMark: MarkEntry nicht gefunden");
-    if (pMark!=NULL) {
-        aList.Remove(nNum);
+    SdrMark* pMark = GetMark(nNum);
+    DBG_ASSERT(pMark!=0L,"DeleteMark: MarkEntry nicht gefunden");
+
+    if(pMark)
+    {
+        maList.Remove(nNum);
         delete pMark;
         SetNameDirty();
     }
 }
 
-void SdrMarkList::ReplaceMark(const SdrMark& rNewMark, ULONG nNum)
+void SdrMarkList::ReplaceMark(const SdrMark& rNewMark, sal_uInt32 nNum)
 {
-    SdrMark* pMark=GetMark(nNum);
-    DBG_ASSERT(pMark!=NULL,"ReplaceMark: MarkEntry nicht gefunden");
-    if (pMark!=NULL) {
+    SdrMark* pMark = GetMark(nNum);
+    DBG_ASSERT(pMark!=0L,"ReplaceMark: MarkEntry nicht gefunden");
+
+    if(pMark)
+    {
         delete pMark;
         SetNameDirty();
-        SdrMark* pKopie=new SdrMark(rNewMark);
-        aList.Replace(pKopie,nNum);
-        bSorted=FALSE;
-        // Checken, ob bSorted wirklich gesetzt werden muss
+        SdrMark* pKopie = new SdrMark(rNewMark);
+        maList.Replace(pKopie, nNum);
+        mbSorted = sal_False;
     }
 }
 
-void SdrMarkList::Merge(const SdrMarkList& rSrcList, FASTBOOL bReverse)
+void SdrMarkList::Merge(const SdrMarkList& rSrcList, sal_Bool bReverse)
 {
-    // Merging ohne ein Sort bei rSrcList zu erzwingen
-    if (rSrcList.bSorted) bReverse=FALSE;
-    ULONG nAnz=rSrcList.aList.Count();
-    if (!bReverse) {
-        for (ULONG i=0; i<nAnz; i++) {
-            SdrMark* pM=(SdrMark*)(rSrcList.aList.GetObject(i));
+    sal_uInt32 nAnz(rSrcList.maList.Count());
+
+    if(rSrcList.mbSorted)
+    {
+        // Merging ohne ein Sort bei rSrcList zu erzwingen
+        bReverse = sal_False;
+    }
+
+    if(!bReverse)
+    {
+        for(sal_uInt32 i(0L); i < nAnz; i++)
+        {
+            SdrMark* pM = (SdrMark*)(rSrcList.maList.GetObject(i));
             InsertEntry(*pM);
         }
-    } else {
-        for (ULONG i=nAnz; i>0;) {
+    }
+    else
+    {
+        for(sal_uInt32 i(nAnz); i > 0;)
+        {
             i--;
-            SdrMark* pM=(SdrMark*)(rSrcList.aList.GetObject(i));
+            SdrMark* pM = (SdrMark*)(rSrcList.maList.GetObject(i));
             InsertEntry(*pM);
         }
     }
 }
 
-FASTBOOL SdrMarkList::DeletePageView(const SdrPageView& rPV)
+sal_Bool SdrMarkList::DeletePageView(const SdrPageView& rPV)
 {
-    FASTBOOL bChgd=FALSE;
-    for (ULONG i=GetMarkCount(); i>0;) {
+    sal_Bool bChgd(sal_False);
+
+    for(sal_uInt32 i(GetMarkCount()); i > 0; )
+    {
         i--;
-        SdrMark* pMark=GetMark(i);
-        if (pMark->GetPageView()==&rPV) {
-            aList.Remove(i);
+        SdrMark* pMark = GetMark(i);
+
+        if(pMark->GetPageView()==&rPV)
+        {
+            maList.Remove(i);
             delete pMark;
             SetNameDirty();
-            bChgd=TRUE;
+            bChgd = sal_True;
         }
     }
+
     return bChgd;
 }
 
-FASTBOOL SdrMarkList::InsertPageView(const SdrPageView& rPV)
+sal_Bool SdrMarkList::InsertPageView(const SdrPageView& rPV)
 {
-    FASTBOOL bChgd=FALSE;
+    sal_Bool bChgd(sal_False);
     DeletePageView(rPV); // erstmal alle raus, dann die ganze Seite hinten dran
     SdrObject* pObj;
-    const SdrObjList* pOL=rPV.GetObjList();
-    ULONG nObjAnz=pOL->GetObjCount();
-    for (ULONG nO=0; nO<nObjAnz; nO++) {
-        pObj=pOL->GetObj(nO);
-        FASTBOOL bDoIt=rPV.IsObjMarkable(pObj);
-        if (bDoIt) {
-            SdrMark* pM=new SdrMark(pObj,(SdrPageView*)&rPV);
-            aList.Insert(pM,CONTAINER_APPEND);
+    const SdrObjList* pOL = rPV.GetObjList();
+    sal_uInt32 nObjAnz(pOL->GetObjCount());
+
+    for(sal_uInt32 nO(0L); nO < nObjAnz; nO++)
+    {
+        pObj = pOL->GetObj(nO);
+        sal_Bool bDoIt(rPV.IsObjMarkable(pObj));
+
+        if(bDoIt)
+        {
+            SdrMark* pM = new SdrMark(pObj, (SdrPageView*)&rPV);
+            maList.Insert(pM, CONTAINER_APPEND);
             SetNameDirty();
-            bChgd=TRUE;
+            bChgd = sal_True;
         }
     }
+
     return bChgd;
 }
 
 const XubString& SdrMarkList::GetMarkDescription() const
 {
-    UINT32 nAnz(GetMarkCount());
+    sal_uInt32 nAnz(GetMarkCount());
 
-    if(bNameOk && nAnz==1)
+    if(mbNameOk && 1L == nAnz)
     {
         // Bei Einfachselektion nur Textrahmen cachen
         SdrObject* pObj = GetMark(0)->GetObj();
-        SdrTextObj* pTextObj = PTR_CAST(SdrTextObj,pObj);
+        SdrTextObj* pTextObj = PTR_CAST(SdrTextObj, pObj);
 
         if(!pTextObj || !pTextObj->IsTextFrame())
         {
-            ((SdrMarkList*)(this))->bNameOk = FALSE;
+            ((SdrMarkList*)(this))->mbNameOk = sal_False;
         }
     }
 
-    if(!bNameOk)
+    if(!mbNameOk)
     {
         SdrMark* pMark = GetMark(0);
         XubString aNam;
 
         if(!nAnz)
         {
-            ((SdrMarkList*)(this))->aMarkName = ImpGetResStr(STR_ObjNameNoObj);
+            ((SdrMarkList*)(this))->maMarkName = ImpGetResStr(STR_ObjNameNoObj);
         }
-        else if(nAnz == 1)
+        else if(1L == nAnz)
         {
             pMark->GetObj()->TakeObjNameSingul(aNam);
         }
@@ -491,9 +618,9 @@ const XubString& SdrMarkList::GetMarkDescription() const
         {
             pMark->GetObj()->TakeObjNamePlural(aNam);
             XubString aStr1;
-            BOOL bEq(TRUE);
+            sal_Bool bEq(sal_True);
 
-            for(UINT32 i = 1; i < GetMarkCount() && bEq; i++)
+            for(sal_uInt32 i = 1; i < GetMarkCount() && bEq; i++)
             {
                 SdrMark* pMark = GetMark(i);
                 pMark->GetObj()->TakeObjNamePlural(aStr1);
@@ -501,49 +628,55 @@ const XubString& SdrMarkList::GetMarkDescription() const
             }
 
             if(!bEq)
+            {
                 aNam = ImpGetResStr(STR_ObjNamePlural);
+            }
 
             aNam.Insert(sal_Unicode(' '), 0);
             aNam.Insert(UniString::CreateFromInt32(nAnz), 0);
         }
 
-        ((SdrMarkList*)(this))->aMarkName = aNam;
-        ((SdrMarkList*)(this))->bNameOk = TRUE;
+        ((SdrMarkList*)(this))->maMarkName = aNam;
+        ((SdrMarkList*)(this))->mbNameOk = sal_True;
     }
 
-    return aMarkName;
+    return maMarkName;
 }
 
-const XubString& SdrMarkList::GetPointMarkDescription(FASTBOOL bGlue) const
+const XubString& SdrMarkList::GetPointMarkDescription(sal_Bool bGlue) const
 {
-    FASTBOOL& rNameOk = (FASTBOOL&)(bGlue ? bGluePointNameOk : bPointNameOk);
-    XubString& rName = (XubString&)(bGlue ? aGluePointName : aPointName);
-    UINT32 nMarkAnz(GetMarkCount());
-    UINT32 nMarkPtAnz(0);
-    UINT32 nMarkPtObjAnz(0);
-    UINT32 n1stMarkNum(0xFFFFFFFF);
-
-    for(UINT32 nMarkNum = 0; nMarkNum < nMarkAnz; nMarkNum++)
+    sal_Bool& rNameOk = (sal_Bool&)(bGlue ? mbGluePointNameOk : mbPointNameOk);
+    XubString& rName = (XubString&)(bGlue ? maGluePointName : maPointName);
+    sal_uInt32 nMarkAnz(GetMarkCount());
+    sal_uInt32 nMarkPtAnz(0L);
+    sal_uInt32 nMarkPtObjAnz(0L);
+    sal_uInt32 n1stMarkNum(0xFFFFFFFF);
+
+    for(sal_uInt32 nMarkNum(0L); nMarkNum < nMarkAnz; nMarkNum++)
     {
         const SdrMark* pMark = GetMark(nMarkNum);
         const SdrUShortCont* pPts = bGlue ? pMark->GetMarkedGluePoints() : pMark->GetMarkedPoints();
-        UINT32 nAnz(pPts ? pPts->GetCount() : 0);
+        sal_uInt32 nAnz(pPts ? pPts->GetCount() : 0);
 
         if(nAnz)
         {
             if(n1stMarkNum == 0xFFFFFFFF)
+            {
                 n1stMarkNum = nMarkNum;
+            }
 
             nMarkPtAnz += nAnz;
             nMarkPtObjAnz++;
         }
 
         if(nMarkPtObjAnz > 1 && rNameOk)
+        {
             // vorzeitige Entscheidung
             return rName;
+        }
     }
 
-    if(rNameOk && nMarkPtObjAnz == 1)
+    if(rNameOk && 1L == nMarkPtObjAnz)
     {
         // Bei Einfachselektion nur Textrahmen cachen
         SdrObject* pObj = GetMark(0)->GetObj();
@@ -551,21 +684,21 @@ const XubString& SdrMarkList::GetPointMarkDescription(FASTBOOL bGlue) const
 
         if(!pTextObj || !pTextObj->IsTextFrame())
         {
-            rNameOk = FALSE;
+            rNameOk = sal_False;
         }
     }
 
     if(!nMarkPtObjAnz)
     {
         rName.Erase();
-        rNameOk = TRUE;
+        rNameOk = sal_True;
     }
     else if(!rNameOk)
     {
         const SdrMark* pMark = GetMark(n1stMarkNum);
         XubString aNam;
 
-        if(nMarkPtObjAnz == 1)
+        if(1L == nMarkPtObjAnz)
         {
             pMark->GetObj()->TakeObjNameSingul(aNam);
         }
@@ -573,9 +706,9 @@ const XubString& SdrMarkList::GetPointMarkDescription(FASTBOOL bGlue) const
         {
             pMark->GetObj()->TakeObjNamePlural(aNam);
             XubString aStr1;
-            BOOL bEq(TRUE);
+            sal_Bool bEq(sal_True);
 
-            for(UINT32 i = n1stMarkNum + 1; i < GetMarkCount() && bEq; i++)
+            for(sal_uInt32 i(n1stMarkNum + 1L); i < GetMarkCount() && bEq; i++)
             {
                 const SdrMark* pMark = GetMark(i);
                 const SdrUShortCont* pPts = bGlue ? pMark->GetMarkedGluePoints() : pMark->GetMarkedPoints();
@@ -588,7 +721,9 @@ const XubString& SdrMarkList::GetPointMarkDescription(FASTBOOL bGlue) const
             }
 
             if(!bEq)
+            {
                 aNam = ImpGetResStr(STR_ObjNamePlural);
+            }
 
             aNam.Insert(sal_Unicode(' '), 0);
             aNam.Insert(UniString::CreateFromInt32(nMarkPtObjAnz), 0);
@@ -596,7 +731,7 @@ const XubString& SdrMarkList::GetPointMarkDescription(FASTBOOL bGlue) const
 
         XubString aStr1;
 
-        if(nMarkPtAnz == 1)
+        if(1L == nMarkPtAnz)
         {
             aStr1 = (ImpGetResStr(bGlue ? STR_ViewMarkedGluePoint : STR_ViewMarkedPoint));
         }
@@ -608,67 +743,210 @@ const XubString& SdrMarkList::GetPointMarkDescription(FASTBOOL bGlue) const
 
         aStr1.SearchAndReplaceAscii("%O", aNam);
         rName = aStr1;
-        rNameOk = TRUE;
+        rNameOk = sal_True;
     }
 
     return rName;
 }
 
-USHORT SdrMarkList::GetPageViewAnz() const
+sal_Bool SdrMarkList::TakeBoundRect(SdrPageView* pPV, Rectangle& rRect) const
 {
-    USHORT nAnz=0;
-    SdrPageView* pPV=NULL;
-    for (ULONG i=0; i<GetMarkCount(); i++) {
-        SdrMark* pMark=GetMark(i);
-        if (pMark->GetPageView()!=pPV) {
-            pPV=pMark->GetPageView();
-            nAnz++;
-        }
-    }
-    return nAnz;
-}
+    sal_Bool bFnd(sal_False);
+    Rectangle aR;
 
-SdrPageView* SdrMarkList::GetPageView(USHORT nNum) const
-{
-  return NULL;
-}
+    for(sal_uInt32 i(0L); i < GetMarkCount(); i++)
+    {
+        SdrMark* pMark = GetMark(i);
 
-FASTBOOL SdrMarkList::TakeBoundRect(SdrPageView* pPV, Rectangle& rRect) const
-{
-    FASTBOOL bFnd=FALSE;
-    Rectangle aR;
+        if(!pPV || pMark->GetPageView() == pPV)
+        {
+            aR = pMark->GetObj()->GetCurrentBoundRect();
 
-    for (ULONG i=0; i<GetMarkCount(); i++) {
-        SdrMark* pMark=GetMark(i);
-        if (pPV==NULL || pMark->GetPageView()==pPV) {
-            aR=pMark->GetObj()->GetCurrentBoundRect();
-            if (bFnd) {
+            if(bFnd)
+            {
                 rRect.Union(aR);
-            } else {
-                rRect=aR;
-                bFnd=TRUE;
+            }
+            else
+            {
+                rRect = aR;
+                bFnd = sal_True;
             }
         }
     }
+
     return bFnd;
 }
 
-FASTBOOL SdrMarkList::TakeSnapRect(SdrPageView* pPV, Rectangle& rRect) const
+sal_Bool SdrMarkList::TakeSnapRect(SdrPageView* pPV, Rectangle& rRect) const
 {
-    FASTBOOL bFnd=FALSE;
+    sal_Bool bFnd(sal_False);
+
+    for(sal_uInt32 i(0L); i < GetMarkCount(); i++)
+    {
+        SdrMark* pMark = GetMark(i);
 
-    for (ULONG i=0; i<GetMarkCount(); i++) {
-        SdrMark* pMark=GetMark(i);
-        if (pPV==NULL || pMark->GetPageView()==pPV) {
+        if(!pPV || pMark->GetPageView() == pPV)
+        {
             Rectangle aR(pMark->GetObj()->GetSnapRect());
-            if (bFnd) {
+
+            if(bFnd)
+            {
                 rRect.Union(aR);
-            } else {
-                rRect=aR;
-                bFnd=TRUE;
+            }
+            else
+            {
+                rRect = aR;
+                bFnd = sal_True;
             }
         }
     }
+
     return bFnd;
 }
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace sdr
+{
+    ViewSelection::ViewSelection()
+    :   mbEdgesOfMarkedNodesDirty(sal_False)
+    {
+    }
+
+    void ViewSelection::SetEdgesOfMarkedNodesDirty()
+    {
+        if(!mbEdgesOfMarkedNodesDirty)
+        {
+            mbEdgesOfMarkedNodesDirty = sal_True;
+            maEdgesOfMarkedNodes.Clear();
+            maMarkedEdgesOfMarkedNodes.Clear();
+            maAllMarkedObjects.Clear();
+        }
+    }
+
+    const SdrMarkList& ViewSelection::GetEdgesOfMarkedNodes() const
+    {
+        if(mbEdgesOfMarkedNodesDirty)
+        {
+            ((ViewSelection*)this)->ImpForceEdgesOfMarkedNodes();
+        }
+
+        return maEdgesOfMarkedNodes;
+    }
+
+    const SdrMarkList& ViewSelection::GetMarkedEdgesOfMarkedNodes() const
+    {
+        if(mbEdgesOfMarkedNodesDirty)
+        {
+            ((ViewSelection*)this)->ImpForceEdgesOfMarkedNodes();
+        }
+
+        return maMarkedEdgesOfMarkedNodes;
+    }
+
+    const List& ViewSelection::GetAllMarkedObjects() const
+    {
+        if(mbEdgesOfMarkedNodesDirty)
+        {
+            ((ViewSelection*)this)->ImpForceEdgesOfMarkedNodes();
+        }
+
+        return maAllMarkedObjects;
+    }
+
+    void ViewSelection::ImplCollectCompleteSelection(SdrObject* pObj)
+    {
+        sal_Bool bIsGroup(pObj->IsGroupObject());
+
+        if(bIsGroup && pObj->ISA(E3dObject) && !pObj->ISA(E3dScene))
+        {
+            bIsGroup = sal_False;
+        }
+
+        if(bIsGroup)
+        {
+            SdrObjList* pList = pObj->GetSubList();
+
+            for(sal_uInt32 a(0L); a < pList->GetObjCount(); a++)
+            {
+                SdrObject* pObj2 = pList->GetObj(a);
+                ImplCollectCompleteSelection(pObj2);
+            }
+        }
+
+        maAllMarkedObjects.Insert(pObj, LIST_APPEND);
+    }
+
+    void ViewSelection::ImpForceEdgesOfMarkedNodes()
+    {
+        if(mbEdgesOfMarkedNodesDirty)
+        {
+            const sal_uInt32 nMarkAnz(maMarkedObjectList.GetMarkCount());
+            sal_uInt32 a;
+
+            maEdgesOfMarkedNodes.Clear();
+            maMarkedEdgesOfMarkedNodes.Clear();
+            maAllMarkedObjects.Clear();
+
+            for(a = 0L; a < nMarkAnz; a++)
+            {
+                SdrObject* pObj = maMarkedObjectList.GetMark(a)->GetObj();
+                ImplCollectCompleteSelection(pObj);
+            }
+
+            mbEdgesOfMarkedNodesDirty = sal_False;
+            maMarkedObjectList.ForceSort();
+
+            for(a = 0L; a < nMarkAnz; a++)
+            {
+                SdrObject* pNode = maMarkedObjectList.GetMark(a)->GetObj();
+                const SfxBroadcaster* pBC = pNode->GetBroadcaster();
+
+                if(pNode->IsNode())
+                {
+                    if(pBC)
+                    {
+                        sal_uInt16 nLstAnz(pBC->GetListenerCount());
+
+                        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() == pNode->GetPage())
+                            {
+                                SdrMark aM(pEdge, maMarkedObjectList.GetMark(a)->GetPageView());
+
+                                if(pEdge->GetConnectedNode(sal_True) == pNode)
+                                {
+                                    aM.SetCon1(sal_True);
+                                }
+
+                                if(pEdge->GetConnectedNode(sal_False) == pNode)
+                                {
+                                    aM.SetCon2(sal_True);
+                                }
+
+                                if(CONTAINER_ENTRY_NOTFOUND == maMarkedObjectList.FindObject(pEdge))
+                                {
+                                    // nachsehen, ob er selbst markiert ist
+                                    maEdgesOfMarkedNodes.InsertEntry(aM);
+                                }
+                                else
+                                {
+                                    maMarkedEdgesOfMarkedNodes.InsertEntry(aM);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            maEdgesOfMarkedNodes.ForceSort();
+            maMarkedEdgesOfMarkedNodes.ForceSort();
+        }
+    }
+} // end of namespace sdr
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// eof