svx/source/svdraw/svdmrkv1.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29
  30 #include <svx/svdmrkv.hxx>
  31 #include <svx/svdetc.hxx>
  32 #include <svx/svdoedge.hxx>
  33 #include "svx/svdglob.hxx"
  34 #include <svx/svdpagv.hxx>
  35 #include <svx/svdpage.hxx>
  36 #include "svddrgm1.hxx"
  37
  38 ////////////////////////////////////////////////////////////////////////////////////////////////////
  39 // Point Selection
  40 ////////////////////////////////////////////////////////////////////////////////////////////////////
  41
  42 sal_Bool SdrMarkView::HasMarkablePoints() const
  43 {
  44     ForceUndirtyMrkPnt();
  45     bool bRet=false;
  46     if (!ImpIsFrameHandles()) {
  47         sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
  48         if (nMarkAnz<=nFrameHandlesLimit) {
  49             for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz && !bRet; nMarkNum++) {
  50                 const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
  51                 const SdrObject* pObj=pM->GetMarkedSdrObj();
  52                 bRet=pObj->IsPolyObj();
  53             }
  54         }
  55     }
  56     return bRet;
  57 }
  58
  59 sal_uIntPtr SdrMarkView::GetMarkablePointCount() const
  60 {
  61     ForceUndirtyMrkPnt();
  62     sal_uIntPtr nAnz=0;
  63     if (!ImpIsFrameHandles()) {
  64         sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
  65         if (nMarkAnz<=nFrameHandlesLimit) {
  66             for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz; nMarkNum++) {
  67                 const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
  68                 const SdrObject* pObj=pM->GetMarkedSdrObj();
  69                 if (pObj->IsPolyObj()) {
  70                     nAnz+=pObj->GetPointCount();
  71                 }
  72             }
  73         }
  74     }
  75     return nAnz;
  76 }
  77
  78 sal_Bool SdrMarkView::HasMarkedPoints() const
  79 {
  80     ForceUndirtyMrkPnt();
  81     sal_Bool bRet=sal_False;
  82     if (!ImpIsFrameHandles()) {
  83         sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
  84         if (nMarkAnz<=nFrameHandlesLimit) {
  85             for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz && !bRet; nMarkNum++) {
  86                 const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
  87                 const SdrUShortCont* pPts=pM->GetMarkedPoints();
  88                 bRet=pPts!=NULL && pPts->GetCount()!=0;
  89             }
  90         }
  91     }
  92     return bRet;
  93 }
  94
  95 sal_uIntPtr SdrMarkView::GetMarkedPointCount() const
  96 {
  97     ForceUndirtyMrkPnt();
  98     sal_uIntPtr nAnz=0;
  99     if (!ImpIsFrameHandles()) {
 100         sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
 101         if (nMarkAnz<=nFrameHandlesLimit) {
 102             for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz; nMarkNum++) {
 103                 const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
 104                 const SdrUShortCont* pPts=pM->GetMarkedPoints();
 105                 if (pPts!=NULL) nAnz+=pPts->GetCount();
 106             }
 107         }
 108     }
 109     return nAnz;
 110 }
 111
 112 sal_Bool SdrMarkView::IsPointMarkable(const SdrHdl& rHdl) const
 113 {
 114     return !ImpIsFrameHandles() && &rHdl!=NULL && !rHdl.IsPlusHdl() && rHdl.GetKind()!=HDL_GLUE && rHdl.GetKind()!=HDL_SMARTTAG && rHdl.GetObj()!=NULL && rHdl.GetObj()->IsPolyObj();
 115 }
 116
 117 sal_Bool SdrMarkView::MarkPointHelper(SdrHdl* pHdl, SdrMark* pMark, sal_Bool bUnmark)
 118 {
 119     return ImpMarkPoint( pHdl, pMark, bUnmark );
 120 }
 121
 122 sal_Bool SdrMarkView::ImpMarkPoint(SdrHdl* pHdl, SdrMark* pMark, sal_Bool bUnmark)
 123 {
 124     if (pHdl==NULL || pHdl->IsPlusHdl() || pHdl->GetKind()==HDL_GLUE)
 125         return sal_False;
 126
 127     if (pHdl->IsSelected() != bUnmark)
 128         return sal_False;
 129
 130     SdrObject* pObj=pHdl->GetObj();
 131     if (pObj==NULL || !pObj->IsPolyObj())
 132         return sal_False;
 133
 134     if (pMark==NULL)
 135     {
 136         sal_uIntPtr nMarkNum=TryToFindMarkedObject(pObj);
 137         if (nMarkNum==CONTAINER_ENTRY_NOTFOUND)
 138             return sal_False;
 139         pMark=GetSdrMarkByIndex(nMarkNum);
 140     }
 141     const sal_uInt32 nHdlNum(pHdl->GetObjHdlNum());
 142     SdrUShortCont* pPts=pMark->ForceMarkedPoints();
 143     if (!bUnmark)
 144     {
 145         pPts->Insert((sal_uInt16)nHdlNum);
 146     }
 147     else
 148     {
 149         sal_uIntPtr nBla=pPts->GetPos((sal_uInt16)nHdlNum);
 150         if (nBla!=CONTAINER_ENTRY_NOTFOUND)
 151         {
 152             pPts->Remove(nBla);
 153         }
 154         else
 155         {
 156             return sal_False; // error case!
 157         }
 158     }
 159
 160     pHdl->SetSelected(!bUnmark);
 161     if (!bPlusHdlAlways)
 162     {
 163         if (!bUnmark)
 164         {
 165             sal_uInt32 nAnz(pObj->GetPlusHdlCount(*pHdl));
 166             for (sal_uInt32 i=0; i<nAnz; i++)
 167             {
 168                 SdrHdl* pPlusHdl=pObj->GetPlusHdl(*pHdl,i);
 169                 if (pPlusHdl!=NULL)
 170                 {
 171                     pPlusHdl->SetObj(pObj);
 172                     pPlusHdl->SetPageView(pMark->GetPageView());
 173                     pPlusHdl->SetPlusHdl(sal_True);
 174                     aHdl.AddHdl(pPlusHdl);
 175                 }
 176             }
 177         }
 178         else
 179         {
 180             for (sal_uIntPtr i = aHdl.GetHdlCount(); i>0;)
 181             {
 182                 i--;
 183                 SdrHdl* pPlusHdl=aHdl.GetHdl(i);
 184                 if (pPlusHdl->IsPlusHdl() && pPlusHdl->GetSourceHdlNum()==nHdlNum)
 185                 {
 186                     aHdl.RemoveHdl(i);
 187                     delete pPlusHdl;
 188                 }
 189             }
 190         }
 191     }
 192
 193     aHdl.Sort();
 194
 195     return sal_True;
 196 }
 197
 198
 199 sal_Bool SdrMarkView::MarkPoint(SdrHdl& rHdl, sal_Bool bUnmark)
 200 {
 201     if (&rHdl==NULL) return sal_False;
 202     ForceUndirtyMrkPnt();
 203     sal_Bool bRet=sal_False;
 204     const SdrObject* pObj=rHdl.GetObj();
 205     if (IsPointMarkable(rHdl) && rHdl.IsSelected()==bUnmark) {
 206         sal_uIntPtr nMarkNum=TryToFindMarkedObject(pObj);
 207         if (nMarkNum!=CONTAINER_ENTRY_NOTFOUND) {
 208             SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
 209             SdrUShortCont* pPts=pM->ForceMarkedPoints();
 210             pPts->ForceSort();
 211             if (ImpMarkPoint(&rHdl,pM,bUnmark)) {
 212                 pPts->ForceSort();
 213                 MarkListHasChanged();
 214                 bRet=sal_True;
 215             }
 216         }
 217     }
 218
 219     return bRet;
 220 }
 221
 222 sal_Bool SdrMarkView::MarkPoints(const Rectangle* pRect, sal_Bool bUnmark)
 223 {
 224     ForceUndirtyMrkPnt();
 225     sal_Bool bChgd=sal_False;
 226     SortMarkedObjects();
 227     const SdrObject* pObj0=NULL;
 228     const SdrPageView* pPV0=NULL;
 229     SdrMark* pM=NULL;
 230     aHdl.Sort();
 231     sal_uIntPtr nHdlAnz=aHdl.GetHdlCount();
 232     for (sal_uIntPtr nHdlNum=nHdlAnz; nHdlNum>0;) {
 233         nHdlNum--;
 234         SdrHdl* pHdl=aHdl.GetHdl(nHdlNum);
 235         if (IsPointMarkable(*pHdl) && pHdl->IsSelected()==bUnmark) {
 236             const SdrObject* pObj=pHdl->GetObj();
 237             const SdrPageView* pPV=pHdl->GetPageView();
 238             if (pObj!=pObj0 || pPV!=pPV0 || pM==NULL) { // This section is for optimization,
 239                 if (pM!=NULL) {
 240                     SdrUShortCont* pPts=pM->GetMarkedPoints();
 241                     if (pPts!=NULL) pPts->ForceSort();
 242                 }
 243                 sal_uIntPtr nMarkNum=TryToFindMarkedObject(pObj);  // so ImpMarkPoint() doesn't always
 244                 if (nMarkNum!=CONTAINER_ENTRY_NOTFOUND) { // have to search the object in the MarkList.
 245                     pM=GetSdrMarkByIndex(nMarkNum);
 246                     pObj0=pObj;
 247                     pPV0=pPV;
 248                     SdrUShortCont* pPts=pM->ForceMarkedPoints();
 249                     pPts->ForceSort();
 250                 } else {
 251 #ifdef DBG_UTIL
 252                     if (pObj->IsInserted()) {
 253                         OSL_FAIL("SdrMarkView::MarkPoints(const Rectangle* pRect): Selected object not found.");
 254                     }
 255 #endif
 256                     pM=NULL;
 257                 }
 258             }
 259             Point aPos(pHdl->GetPos());
 260             if (pM!=NULL && (pRect==NULL || pRect->IsInside(aPos))) {
 261                 if (ImpMarkPoint(pHdl,pM,bUnmark)) bChgd=sal_True;
 262             }
 263         }
 264     }
 265     if (pM!=NULL) { // Clean up the last selected MarkEntry, if necessary
 266         SdrUShortCont* pPts=pM->GetMarkedPoints();
 267         if (pPts!=NULL) pPts->ForceSort();
 268     }
 269     if (bChgd) {
 270         MarkListHasChanged();
 271     }
 272
 273     return bChgd;
 274 }
 275
 276 sal_Bool SdrMarkView::MarkNextPoint(const Point& /*rPnt*/, sal_Bool /*bPrev*/)
 277 {
 278     ForceUndirtyMrkPnt();
 279     sal_Bool bChgd=sal_False;
 280     SortMarkedObjects();
 281     // ...
 282     if (bChgd) {
 283         MarkListHasChanged();
 284     }
 285     return bChgd;
 286 }
 287
 288 const Rectangle& SdrMarkView::GetMarkedPointsRect() const
 289 {
 290     ForceUndirtyMrkPnt();
 291     if (bMarkedPointsRectsDirty) ImpSetPointsRects();
 292     return aMarkedPointsRect;
 293 }
 294
 295 void SdrMarkView::SetPlusHandlesAlwaysVisible(sal_Bool bOn)
 296 { // TODO: Optimize HandlePaint!
 297     ForceUndirtyMrkPnt();
 298     if (bOn!=bPlusHdlAlways) {
 299         bPlusHdlAlways=bOn;
 300         SetMarkHandles();
 301         MarkListHasChanged();
 302     }
 303 }
 304
 305 ////////////////////////////////////////////////////////////////////////////////////////////////////
 306 // ImpSetPointsRects() is for PolyPoints and GluePoints!
 307 ////////////////////////////////////////////////////////////////////////////////////////////////////
 308
 309 void SdrMarkView::ImpSetPointsRects() const
 310 {
 311     Rectangle aPnts;
 312     Rectangle aGlue;
 313     sal_uIntPtr nHdlAnz=aHdl.GetHdlCount();
 314     for (sal_uIntPtr nHdlNum=0; nHdlNum<nHdlAnz; nHdlNum++) {
 315         const SdrHdl* pHdl=aHdl.GetHdl(nHdlNum);
 316         SdrHdlKind eKind=pHdl->GetKind();
 317         if ((eKind==HDL_POLY && pHdl->IsSelected()) || eKind==HDL_GLUE) {
 318             Point aPt(pHdl->GetPos());
 319             Rectangle& rR=eKind==HDL_GLUE ? aGlue : aPnts;
 320             if (rR.IsEmpty()) {
 321                 rR=Rectangle(aPt,aPt);
 322             } else {
 323                 if (aPt.X()<rR.Left  ()) rR.Left  ()=aPt.X();
 324                 if (aPt.X()>rR.Right ()) rR.Right ()=aPt.X();
 325                 if (aPt.Y()<rR.Top   ()) rR.Top   ()=aPt.Y();
 326                 if (aPt.Y()>rR.Bottom()) rR.Bottom()=aPt.Y();
 327             }
 328         }
 329     }
 330     ((SdrMarkView*)this)->aMarkedPointsRect=aPnts;
 331     ((SdrMarkView*)this)->aMarkedGluePointsRect=aGlue;
 332     ((SdrMarkView*)this)->bMarkedPointsRectsDirty=sal_False;
 333 }
 334
 335 ////////////////////////////////////////////////////////////////////////////////////////////////////
 336 // UndirtyMrkPnt() is for PolyPoints and GluePoints!
 337 ////////////////////////////////////////////////////////////////////////////////////////////////////
 338
 339 void SdrMarkView::UndirtyMrkPnt() const
 340 {
 341     sal_Bool bChg=sal_False;
 342     sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
 343     for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz; nMarkNum++) {
 344         SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
 345         const SdrObject* pObj=pM->GetMarkedSdrObj();
 346         // PolyPoints
 347         SdrUShortCont* pPts=pM->GetMarkedPoints();
 348         if (pPts!=NULL) {
 349             if (pObj->IsPolyObj()) {
 350                 // Remove invalid selected points, that is, all
 351                 // entries above the number of points in the object.
 352                 sal_uInt32 nMax(pObj->GetPointCount());
 353                 sal_uInt32 nPtNum(0xffffffff);
 354
 355                 pPts->ForceSort();
 356
 357                 for (sal_uInt32 nIndex(pPts->GetCount()); nIndex > 0L && nPtNum >= nMax;)
 358                 {
 359                     nIndex--;
 360                     nPtNum = pPts->GetObject(nIndex);
 361
 362                     if(nPtNum >= nMax)
 363                     {
 364                         pPts->Remove(nIndex);
 365                         bChg = sal_True;
 366                     }
 367                 }
 368             }
 369             else
 370             {
 371                 OSL_FAIL("SdrMarkView::UndirtyMrkPnt(): Selected points on an object that is not a PolyObj!");
 372                 if(pPts && pPts->GetCount())
 373                 {
 374                     pPts->Clear();
 375                     bChg = sal_True;
 376                 }
 377             }
 378         }
 379
 380         // GluePoints
 381         pPts=pM->GetMarkedGluePoints();
 382         const SdrGluePointList* pGPL=pObj->GetGluePointList();
 383         if (pPts!=NULL) {
 384             if (pGPL!=NULL) {
 385                 // Remove invalid selected glue points, that is, all entries
 386                 // (IDs) that aren't contained in the GluePointList of the
 387                 // object
 388                 pPts->ForceSort();
 389                 for (sal_uIntPtr nIndex=pPts->GetCount(); nIndex>0;) {
 390                     nIndex--;
 391                     sal_uInt16 nId=pPts->GetObject(nIndex);
 392                     if (pGPL->FindGluePoint(nId)==SDRGLUEPOINT_NOTFOUND) {
 393                         pPts->Remove(nIndex);
 394                         bChg=sal_True;
 395                     }
 396                 }
 397             } else {
 398                 if (pPts!=NULL && pPts->GetCount()!=0) {
 399                     pPts->Clear(); // object doesn't have any glue points (any more)
 400                     bChg=sal_True;
 401                 }
 402             }
 403         }
 404     }
 405     if (bChg) ((SdrMarkView*)this)->bMarkedPointsRectsDirty=sal_True;
 406     ((SdrMarkView*)this)->bMrkPntDirty=sal_False;
 407 }
 408
 409 ////////////////////////////////////////////////////////////////////////////////////////////////////
 410
 411 sal_Bool SdrMarkView::HasMarkableGluePoints() const
 412 {
 413     sal_Bool bRet=sal_False;
 414     if (IsGluePointEditMode()) {
 415         ForceUndirtyMrkPnt();
 416         sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
 417         for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz && !bRet; nMarkNum++) {
 418             const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
 419             const SdrObject* pObj=pM->GetMarkedSdrObj();
 420             const SdrGluePointList* pGPL=pObj->GetGluePointList();
 421
 422             // #i38892#
 423             if(pGPL && pGPL->GetCount())
 424             {
 425                 for(sal_uInt16 a(0); !bRet && a < pGPL->GetCount(); a++)
 426                 {
 427                     if((*pGPL)[a].IsUserDefined())
 428                     {
 429                         bRet = sal_True;
 430                     }
 431                 }
 432             }
 433         }
 434     }
 435     return bRet;
 436 }
 437
 438 sal_Bool SdrMarkView::HasMarkedGluePoints() const
 439 {
 440     ForceUndirtyMrkPnt();
 441     sal_Bool bRet=sal_False;
 442     sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
 443     for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz && !bRet; nMarkNum++) {
 444         const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
 445         const SdrUShortCont* pPts=pM->GetMarkedGluePoints();
 446         bRet=pPts!=NULL && pPts->GetCount()!=0;
 447     }
 448     return bRet;
 449 }
 450
 451 sal_Bool SdrMarkView::MarkGluePoints(const Rectangle* pRect, sal_Bool bUnmark)
 452 {
 453     if (!IsGluePointEditMode() && !bUnmark) return sal_False;
 454     ForceUndirtyMrkPnt();
 455     sal_Bool bChgd=sal_False;
 456     SortMarkedObjects();
 457     sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
 458     for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz; nMarkNum++) {
 459         SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
 460         const SdrObject* pObj=pM->GetMarkedSdrObj();
 461         const SdrGluePointList* pGPL=pObj->GetGluePointList();
 462         SdrUShortCont* pPts=pM->GetMarkedGluePoints();
 463         if (bUnmark && pRect==NULL) { // UnmarkAll
 464             if (pPts!=NULL && pPts->GetCount()!=0) {
 465                 pPts->Clear();
 466                 bChgd=sal_True;
 467             }
 468         } else {
 469             if (pGPL!=NULL && (pPts!=NULL || !bUnmark)) {
 470                 sal_uInt16 nGPAnz=pGPL->GetCount();
 471                 for (sal_uInt16 nGPNum=0; nGPNum<nGPAnz; nGPNum++) {
 472                     const SdrGluePoint& rGP=(*pGPL)[nGPNum];
 473
 474                     // #i38892#
 475                     if(rGP.IsUserDefined())
 476                     {
 477                         Point aPos(rGP.GetAbsolutePos(*pObj));
 478                         if (pRect==NULL || pRect->IsInside(aPos)) {
 479                             if (pPts==NULL) pPts=pM->ForceMarkedGluePoints();
 480                             else pPts->ForceSort();
 481                             sal_uIntPtr nPos=pPts->GetPos(rGP.GetId());
 482                             if (!bUnmark && nPos==CONTAINER_ENTRY_NOTFOUND) {
 483                                 bChgd=sal_True;
 484                                 pPts->Insert(rGP.GetId());
 485                             }
 486                             if (bUnmark && nPos!=CONTAINER_ENTRY_NOTFOUND) {
 487                                 bChgd=sal_True;
 488                                 pPts->Remove(nPos);
 489                             }
 490                         }
 491                     }
 492                 }
 493             }
 494         }
 495     }
 496     if (bChgd) {
 497         AdjustMarkHdl();
 498         MarkListHasChanged();
 499     }
 500     return bChgd;
 501 }
 502
 503 sal_Bool SdrMarkView::PickGluePoint(const Point& rPnt, SdrObject*& rpObj, sal_uInt16& rnId, SdrPageView*& rpPV, sal_uIntPtr nOptions) const
 504 {
 505     SdrObject* pObj0=rpObj;
 506     sal_uInt16 nId0=rnId;
 507     rpObj=NULL; rpPV=NULL; rnId=0;
 508     if (!IsGluePointEditMode()) return sal_False;
 509     sal_Bool bBack=(nOptions & SDRSEARCH_BACKWARD) !=0;
 510     sal_Bool bNext=(nOptions & SDRSEARCH_NEXT) !=0;
 511     OutputDevice* pOut=(OutputDevice*)pActualOutDev;
 512     if (pOut==NULL) pOut=GetFirstOutputDevice();
 513     if (pOut==NULL) return sal_False;
 514     SortMarkedObjects();
 515     sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
 516     sal_uIntPtr nMarkNum=bBack ? 0 : nMarkAnz;
 517     if (bNext) {
 518         nMarkNum=((SdrMarkView*)this)->TryToFindMarkedObject(pObj0);
 519         if (nMarkNum==CONTAINER_ENTRY_NOTFOUND) return sal_False;
 520         if (!bBack) nMarkNum++;
 521     }
 522     while (bBack ? nMarkNum<nMarkAnz : nMarkNum>0) {
 523         if (!bBack) nMarkNum--;
 524         const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
 525         SdrObject* pObj=pM->GetMarkedSdrObj();
 526         SdrPageView* pPV=pM->GetPageView();
 527         const SdrGluePointList* pGPL=pObj->GetGluePointList();
 528         if (pGPL!=NULL) {
 529             sal_uInt16 nNum=pGPL->HitTest(rPnt,*pOut,pObj,bBack,bNext,nId0);
 530             if (nNum!=SDRGLUEPOINT_NOTFOUND)
 531             {
 532                 // #i38892#
 533                 const SdrGluePoint& rCandidate = (*pGPL)[nNum];
 534
 535                 if(rCandidate.IsUserDefined())
 536                 {
 537                     rpObj=pObj;
 538                     rnId=(*pGPL)[nNum].GetId();
 539                     rpPV=pPV;
 540                     return sal_True;
 541                 }
 542             }
 543         }
 544         bNext=sal_False; // HitNextGluePoint only for the first Obj
 545         if (bBack) nMarkNum++;
 546     }
 547     return sal_False;
 548 }
 549
 550 sal_Bool SdrMarkView::MarkGluePoint(const SdrObject* pObj, sal_uInt16 nId, const SdrPageView* /*pPV*/, sal_Bool bUnmark)
 551 {
 552     if (!IsGluePointEditMode()) return sal_False;
 553     ForceUndirtyMrkPnt();
 554     sal_Bool bChgd=sal_False;
 555     if (pObj!=NULL) {
 556         sal_uIntPtr nMarkPos=TryToFindMarkedObject(pObj);
 557         if (nMarkPos!=CONTAINER_ENTRY_NOTFOUND) {
 558             SdrMark* pM=GetSdrMarkByIndex(nMarkPos);
 559             SdrUShortCont* pPts=bUnmark ? pM->GetMarkedGluePoints() : pM->ForceMarkedGluePoints();
 560             if (pPts!=NULL) {
 561                 sal_uIntPtr nPointPos=pPts->GetPos(nId);
 562                 if (!bUnmark && nPointPos==CONTAINER_ENTRY_NOTFOUND) {
 563                     bChgd=sal_True;
 564                     pPts->Insert(nId);
 565                 }
 566                 if (bUnmark && nPointPos!=CONTAINER_ENTRY_NOTFOUND) {
 567                     bChgd=sal_True;
 568                     pPts->Remove(nPointPos);
 569                 }
 570             }
 571         } else {
 572             // TODO: implement implicit selection of objects
 573         }
 574     }
 575     if (bChgd) {
 576         AdjustMarkHdl();
 577         MarkListHasChanged();
 578     }
 579     return bChgd;
 580 }
 581
 582 sal_Bool SdrMarkView::IsGluePointMarked(const SdrObject* pObj, sal_uInt16 nId) const
 583 {
 584     ForceUndirtyMrkPnt();
 585     sal_Bool bRet=sal_False;
 586     sal_uIntPtr nPos=((SdrMarkView*)this)->TryToFindMarkedObject(pObj); // casting to NonConst
 587     if (nPos!=CONTAINER_ENTRY_NOTFOUND) {
 588         const SdrMark* pM=GetSdrMarkByIndex(nPos);
 589         const SdrUShortCont* pPts=pM->GetMarkedGluePoints();
 590         if (pPts!=NULL) {
 591             bRet=pPts->Exist(nId);
 592         }
 593     }
 594     return bRet;
 595 }
 596
 597 SdrHdl* SdrMarkView::GetGluePointHdl(const SdrObject* pObj, sal_uInt16 nId) const
 598 {
 599     ForceUndirtyMrkPnt();
 600     sal_uIntPtr nHdlAnz=aHdl.GetHdlCount();
 601     for (sal_uIntPtr nHdlNum=0; nHdlNum<nHdlAnz; nHdlNum++) {
 602         SdrHdl* pHdl=aHdl.GetHdl(nHdlNum);
 603         if (pHdl->GetObj()==pObj &&
 604             pHdl->GetKind()==HDL_GLUE &&
 605             pHdl->GetObjHdlNum()==nId ) return pHdl;
 606     }
 607     return NULL;
 608 }
 609
 610 sal_Bool SdrMarkView::MarkNextGluePoint(const Point& /*rPnt*/, sal_Bool /*bPrev*/)
 611 {
 612     ForceUndirtyMrkPnt();
 613     sal_Bool bChgd=sal_False;
 614     SortMarkedObjects();
 615     // ...
 616     if (bChgd) {
 617         MarkListHasChanged();
 618     }
 619     return bChgd;
 620 }
 621
 622 const Rectangle& SdrMarkView::GetMarkedGluePointsRect() const
 623 {
 624     ForceUndirtyMrkPnt();
 625     if (bMarkedPointsRectsDirty) ImpSetPointsRects();
 626     return aMarkedGluePointsRect;
 627 }
 628
 629 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */