1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_svx.hxx" 26 27 #include <svx/svdmrkv.hxx> 28 #include <svx/svdetc.hxx> 29 #include <svx/svdoedge.hxx> 30 #include "svx/svdglob.hxx" 31 #include <svx/svdpagv.hxx> 32 #include <svx/svdpage.hxx> 33 #include "svddrgm1.hxx" 34 35 //////////////////////////////////////////////////////////////////////////////////////////////////// 36 //////////////////////////////////////////////////////////////////////////////////////////////////// 37 //////////////////////////////////////////////////////////////////////////////////////////////////// 38 // 39 // @@@@@ @@ @@ @@ @@ @@ @@ @@@@@@ @@ @@ @@@@ @@@@@ @@ @@ @@ @@@@@ @@@@@ @@ @@ @@ @@ @@@@ 40 // @@ @@ @@ @@ @@@ @@ @@ @@ @@ @@@ @@@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@@ @@ @@ @@ 41 // @@ @@ @@ @@ @@@@@@ @@ @@ @@ @@@@@@@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@@@@@ @@ 42 // @@@@@ @@ @@ @@@@@@ @@@@ @@ @@@@@@@ @@@@@@ @@@@@ @@@@ @@ @@@@ @@@@@ @@ @@ @@@@@@ @@ @@@ 43 // @@ @@ @@ @@ @@@ @@ @@ @@ @@ @ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@@ @@ @@ 44 // @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ 45 // @@ @@@@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@@@@ @@ @@ @@@@ @@ @@ @@@@@ 46 // 47 //////////////////////////////////////////////////////////////////////////////////////////////////// 48 49 sal_Bool SdrMarkView::HasMarkablePoints() const 50 { 51 ForceUndirtyMrkPnt(); 52 bool bRet=false; 53 if (!ImpIsFrameHandles()) { 54 sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); 55 if (nMarkAnz<=nFrameHandlesLimit) { 56 for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz && !bRet; nMarkNum++) { 57 const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); 58 const SdrObject* pObj=pM->GetMarkedSdrObj(); 59 bRet=pObj->IsPolyObj(); 60 } 61 } 62 } 63 return bRet; 64 } 65 66 sal_uIntPtr SdrMarkView::GetMarkablePointCount() const 67 { 68 ForceUndirtyMrkPnt(); 69 sal_uIntPtr nAnz=0; 70 if (!ImpIsFrameHandles()) { 71 sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); 72 if (nMarkAnz<=nFrameHandlesLimit) { 73 for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz; nMarkNum++) { 74 const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); 75 const SdrObject* pObj=pM->GetMarkedSdrObj(); 76 if (pObj->IsPolyObj()) { 77 nAnz+=pObj->GetPointCount(); 78 } 79 } 80 } 81 } 82 return nAnz; 83 } 84 85 sal_Bool SdrMarkView::HasMarkedPoints() const 86 { 87 ForceUndirtyMrkPnt(); 88 sal_Bool bRet=sal_False; 89 if (!ImpIsFrameHandles()) { 90 sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); 91 if (nMarkAnz<=nFrameHandlesLimit) { 92 for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz && !bRet; nMarkNum++) { 93 const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); 94 const SdrUShortCont* pPts=pM->GetMarkedPoints(); 95 bRet=pPts!=NULL && pPts->GetCount()!=0; 96 } 97 } 98 } 99 return bRet; 100 } 101 102 sal_uIntPtr SdrMarkView::GetMarkedPointCount() const 103 { 104 ForceUndirtyMrkPnt(); 105 sal_uIntPtr nAnz=0; 106 if (!ImpIsFrameHandles()) { 107 sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); 108 if (nMarkAnz<=nFrameHandlesLimit) { 109 for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz; nMarkNum++) { 110 const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); 111 const SdrUShortCont* pPts=pM->GetMarkedPoints(); 112 if (pPts!=NULL) nAnz+=pPts->GetCount(); 113 } 114 } 115 } 116 return nAnz; 117 } 118 119 sal_Bool SdrMarkView::IsPointMarkable(const SdrHdl& rHdl) const 120 { 121 return !ImpIsFrameHandles() && &rHdl!=NULL && !rHdl.IsPlusHdl() && rHdl.GetKind()!=HDL_GLUE && rHdl.GetKind()!=HDL_SMARTTAG && rHdl.GetObj()!=NULL && rHdl.GetObj()->IsPolyObj(); 122 } 123 124 sal_Bool SdrMarkView::MarkPointHelper(SdrHdl* pHdl, SdrMark* pMark, sal_Bool bUnmark) 125 { 126 return ImpMarkPoint( pHdl, pMark, bUnmark ); 127 } 128 129 sal_Bool SdrMarkView::ImpMarkPoint(SdrHdl* pHdl, SdrMark* pMark, sal_Bool bUnmark) 130 { 131 if (pHdl==NULL || pHdl->IsPlusHdl() || pHdl->GetKind()==HDL_GLUE) 132 return sal_False; 133 134 if (pHdl->IsSelected() != bUnmark) 135 return sal_False; 136 137 SdrObject* pObj=pHdl->GetObj(); 138 if (pObj==NULL || !pObj->IsPolyObj()) 139 return sal_False; 140 141 if (pMark==NULL) 142 { 143 sal_uIntPtr nMarkNum=TryToFindMarkedObject(pObj); 144 if (nMarkNum==CONTAINER_ENTRY_NOTFOUND) 145 return sal_False; 146 pMark=GetSdrMarkByIndex(nMarkNum); 147 } 148 const sal_uInt32 nHdlNum(pHdl->GetObjHdlNum()); 149 SdrUShortCont* pPts=pMark->ForceMarkedPoints(); 150 if (!bUnmark) 151 { 152 pPts->Insert((sal_uInt16)nHdlNum); 153 } 154 else 155 { 156 sal_uIntPtr nBla=pPts->GetPos((sal_uInt16)nHdlNum); 157 if (nBla!=CONTAINER_ENTRY_NOTFOUND) 158 { 159 pPts->Remove(nBla); 160 } 161 else 162 { 163 return sal_False; // Fehlerfall! 164 } 165 } 166 167 pHdl->SetSelected(!bUnmark); 168 if (!bPlusHdlAlways) 169 { 170 if (!bUnmark) 171 { 172 sal_uInt32 nAnz(pObj->GetPlusHdlCount(*pHdl)); 173 for (sal_uInt32 i=0; i<nAnz; i++) 174 { 175 SdrHdl* pPlusHdl=pObj->GetPlusHdl(*pHdl,i); 176 if (pPlusHdl!=NULL) 177 { 178 pPlusHdl->SetObj(pObj); 179 pPlusHdl->SetPageView(pMark->GetPageView()); 180 pPlusHdl->SetPlusHdl(sal_True); 181 aHdl.AddHdl(pPlusHdl); 182 } 183 } 184 } 185 else 186 { 187 for (sal_uIntPtr i = aHdl.GetHdlCount(); i>0;) 188 { 189 i--; 190 SdrHdl* pPlusHdl=aHdl.GetHdl(i); 191 if (pPlusHdl->IsPlusHdl() && pPlusHdl->GetSourceHdlNum()==nHdlNum) 192 { 193 aHdl.RemoveHdl(i); 194 delete pPlusHdl; 195 } 196 } 197 } 198 } 199 200 // #97016# II: Sort handles. This was missing in ImpMarkPoint all the time. 201 aHdl.Sort(); 202 203 return sal_True; 204 } 205 206 207 sal_Bool SdrMarkView::MarkPoint(SdrHdl& rHdl, sal_Bool bUnmark) 208 { 209 if (&rHdl==NULL) return sal_False; 210 ForceUndirtyMrkPnt(); 211 sal_Bool bRet=sal_False; 212 const SdrObject* pObj=rHdl.GetObj(); 213 if (IsPointMarkable(rHdl) && rHdl.IsSelected()==bUnmark) { 214 sal_uIntPtr nMarkNum=TryToFindMarkedObject(pObj); 215 if (nMarkNum!=CONTAINER_ENTRY_NOTFOUND) { 216 SdrMark* pM=GetSdrMarkByIndex(nMarkNum); 217 SdrUShortCont* pPts=pM->ForceMarkedPoints(); 218 pPts->ForceSort(); 219 if (ImpMarkPoint(&rHdl,pM,bUnmark)) { 220 pPts->ForceSort(); 221 MarkListHasChanged(); 222 bRet=sal_True; 223 } 224 } 225 } 226 227 return bRet; 228 } 229 230 sal_Bool SdrMarkView::MarkPoints(const Rectangle* pRect, sal_Bool bUnmark) 231 { 232 ForceUndirtyMrkPnt(); 233 sal_Bool bChgd=sal_False; 234 SortMarkedObjects(); 235 const SdrObject* pObj0=NULL; 236 const SdrPageView* pPV0=NULL; 237 SdrMark* pM=NULL; 238 aHdl.Sort(); 239 //HMHBOOL bHideHdl=IsMarkHdlShown() && IsSolidMarkHdl() && !bPlusHdlAlways; 240 sal_uIntPtr nHdlAnz=aHdl.GetHdlCount(); 241 for (sal_uIntPtr nHdlNum=nHdlAnz; nHdlNum>0;) { 242 nHdlNum--; 243 SdrHdl* pHdl=aHdl.GetHdl(nHdlNum); 244 if (IsPointMarkable(*pHdl) && pHdl->IsSelected()==bUnmark) { 245 const SdrObject* pObj=pHdl->GetObj(); 246 const SdrPageView* pPV=pHdl->GetPageView(); 247 if (pObj!=pObj0 || pPV!=pPV0 || pM==NULL) { // Dieser Abschnitt dient zur Optimierung, 248 if (pM!=NULL) { 249 SdrUShortCont* pPts=pM->GetMarkedPoints(); 250 if (pPts!=NULL) pPts->ForceSort(); 251 } 252 sal_uIntPtr nMarkNum=TryToFindMarkedObject(pObj); // damit ImpMarkPoint() nicht staendig das 253 if (nMarkNum!=CONTAINER_ENTRY_NOTFOUND) { // Objekt in der MarkList suchen muss. 254 pM=GetSdrMarkByIndex(nMarkNum); 255 pObj0=pObj; 256 pPV0=pPV; 257 SdrUShortCont* pPts=pM->ForceMarkedPoints(); 258 pPts->ForceSort(); 259 } else { 260 #ifdef DBG_UTIL 261 if (pObj->IsInserted()) { 262 DBG_ERROR("SdrMarkView::MarkPoints(const Rectangle* pRect): Markiertes Objekt nicht gefunden"); 263 } 264 #endif 265 pM=NULL; 266 } 267 } 268 Point aPos(pHdl->GetPos()); 269 if (pM!=NULL && (pRect==NULL || pRect->IsInside(aPos))) { 270 //HMHif (bHideHdl && IsMarkHdlShown() && pHdl->GetObj()!=NULL) { 271 //HMHsal_uInt32 nAnz=pHdl->GetObj()->GetPlusHdlCount(*pHdl); 272 //HMHif (nAnz!=0L) HideMarkHdl(); // #36987# 273 //HMH} 274 if (ImpMarkPoint(pHdl,pM,bUnmark)) bChgd=sal_True; 275 } 276 } 277 } 278 if (pM!=NULL) { // Den zuletzt geaenderten MarkEntry ggf. noch aufraeumen 279 SdrUShortCont* pPts=pM->GetMarkedPoints(); 280 if (pPts!=NULL) pPts->ForceSort(); 281 } 282 //HMHif (bHideHdl) ShowMarkHdl(); // #36987# 283 if (bChgd) { 284 MarkListHasChanged(); 285 } 286 287 return bChgd; 288 } 289 290 sal_Bool SdrMarkView::MarkNextPoint(sal_Bool /*bPrev*/) 291 { 292 ForceUndirtyMrkPnt(); 293 sal_Bool bChgd=sal_False; 294 SortMarkedObjects(); 295 // ... 296 if (bChgd) { 297 MarkListHasChanged(); 298 } 299 return bChgd; 300 } 301 302 sal_Bool SdrMarkView::MarkNextPoint(const Point& /*rPnt*/, sal_Bool /*bPrev*/) 303 { 304 ForceUndirtyMrkPnt(); 305 sal_Bool bChgd=sal_False; 306 SortMarkedObjects(); 307 // ... 308 if (bChgd) { 309 MarkListHasChanged(); 310 } 311 return bChgd; 312 } 313 314 const Rectangle& SdrMarkView::GetMarkedPointsRect() const 315 { 316 ForceUndirtyMrkPnt(); 317 if (bMarkedPointsRectsDirty) ImpSetPointsRects(); 318 return aMarkedPointsRect; 319 } 320 321 void SdrMarkView::SetPlusHandlesAlwaysVisible(sal_Bool bOn) 322 { // HandlePaint optimieren !!!!!!! 323 ForceUndirtyMrkPnt(); 324 if (bOn!=bPlusHdlAlways) { 325 //HMHBOOL bVis=IsMarkHdlShown(); 326 //HMHif (bVis) HideMarkHdl(); 327 bPlusHdlAlways=bOn; 328 SetMarkHandles(); 329 //HMHif (bVis) ShowMarkHdl(); 330 MarkListHasChanged(); 331 } 332 } 333 334 //////////////////////////////////////////////////////////////////////////////////////////////////// 335 // ImpSetPointsRects() ist fuer PolyPoints und GluePoints! 336 //////////////////////////////////////////////////////////////////////////////////////////////////// 337 338 void SdrMarkView::ImpSetPointsRects() const 339 { 340 Rectangle aPnts; 341 Rectangle aGlue; 342 sal_uIntPtr nHdlAnz=aHdl.GetHdlCount(); 343 for (sal_uIntPtr nHdlNum=0; nHdlNum<nHdlAnz; nHdlNum++) { 344 const SdrHdl* pHdl=aHdl.GetHdl(nHdlNum); 345 SdrHdlKind eKind=pHdl->GetKind(); 346 if ((eKind==HDL_POLY && pHdl->IsSelected()) || eKind==HDL_GLUE) { 347 Point aPt(pHdl->GetPos()); 348 Rectangle& rR=eKind==HDL_GLUE ? aGlue : aPnts; 349 if (rR.IsEmpty()) { 350 rR=Rectangle(aPt,aPt); 351 } else { 352 if (aPt.X()<rR.Left ()) rR.Left ()=aPt.X(); 353 if (aPt.X()>rR.Right ()) rR.Right ()=aPt.X(); 354 if (aPt.Y()<rR.Top ()) rR.Top ()=aPt.Y(); 355 if (aPt.Y()>rR.Bottom()) rR.Bottom()=aPt.Y(); 356 } 357 } 358 } 359 ((SdrMarkView*)this)->aMarkedPointsRect=aPnts; 360 ((SdrMarkView*)this)->aMarkedGluePointsRect=aGlue; 361 ((SdrMarkView*)this)->bMarkedPointsRectsDirty=sal_False; 362 } 363 364 //////////////////////////////////////////////////////////////////////////////////////////////////// 365 // UndirtyMrkPnt() ist fuer PolyPoints und GluePoints! 366 //////////////////////////////////////////////////////////////////////////////////////////////////// 367 368 void SdrMarkView::UndirtyMrkPnt() const 369 { 370 sal_Bool bChg=sal_False; 371 sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); 372 for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz; nMarkNum++) { 373 SdrMark* pM=GetSdrMarkByIndex(nMarkNum); 374 const SdrObject* pObj=pM->GetMarkedSdrObj(); 375 // PolyPoints 376 SdrUShortCont* pPts=pM->GetMarkedPoints(); 377 if (pPts!=NULL) { 378 if (pObj->IsPolyObj()) { 379 // Ungueltig markierte Punkte entfernen, also alle 380 // Eintraege die groesser sind als die Punktanzahl des Objekts 381 sal_uInt32 nMax(pObj->GetPointCount()); 382 sal_uInt32 nPtNum(0xffffffff); 383 384 pPts->ForceSort(); 385 386 for (sal_uInt32 nIndex(pPts->GetCount()); nIndex > 0L && nPtNum >= nMax;) 387 { 388 nIndex--; 389 nPtNum = pPts->GetObject(nIndex); 390 391 if(nPtNum >= nMax) 392 { 393 pPts->Remove(nIndex); 394 bChg = sal_True; 395 } 396 } 397 } 398 else 399 { 400 DBG_ERROR("SdrMarkView::UndirtyMrkPnt(): Markierte Punkte an einem Objekt, dass kein PolyObj ist!"); 401 if(pPts && pPts->GetCount()) 402 { 403 pPts->Clear(); 404 bChg = sal_True; 405 } 406 } 407 } 408 409 // GluePoints 410 pPts=pM->GetMarkedGluePoints(); 411 const SdrGluePointList* pGPL=pObj->GetGluePointList(); 412 if (pPts!=NULL) { 413 if (pGPL!=NULL) { 414 // Ungueltig markierte Klebepunkte entfernen, also alle 415 // Eintraege (Id's) die nicht in der GluePointList des 416 // Objekts enthalten sind 417 pPts->ForceSort(); 418 for (sal_uIntPtr nIndex=pPts->GetCount(); nIndex>0;) { 419 nIndex--; 420 sal_uInt16 nId=pPts->GetObject(nIndex); 421 if (pGPL->FindGluePoint(nId)==SDRGLUEPOINT_NOTFOUND) { 422 pPts->Remove(nIndex); 423 bChg=sal_True; 424 } 425 } 426 } else { 427 if (pPts!=NULL && pPts->GetCount()!=0) { 428 pPts->Clear(); // Objekt hat keine Klebepunkte (mehr) 429 bChg=sal_True; 430 } 431 } 432 } 433 } 434 if (bChg) ((SdrMarkView*)this)->bMarkedPointsRectsDirty=sal_True; 435 ((SdrMarkView*)this)->bMrkPntDirty=sal_False; 436 } 437 438 //////////////////////////////////////////////////////////////////////////////////////////////////// 439 //////////////////////////////////////////////////////////////////////////////////////////////////// 440 //////////////////////////////////////////////////////////////////////////////////////////////////// 441 442 sal_Bool SdrMarkView::HasMarkableGluePoints() const 443 { 444 sal_Bool bRet=sal_False; 445 if (IsGluePointEditMode()) { 446 ForceUndirtyMrkPnt(); 447 sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); 448 for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz && !bRet; nMarkNum++) { 449 const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); 450 const SdrObject* pObj=pM->GetMarkedSdrObj(); 451 const SdrGluePointList* pGPL=pObj->GetGluePointList(); 452 453 // #i38892# 454 if(pGPL && pGPL->GetCount()) 455 { 456 for(sal_uInt16 a(0); !bRet && a < pGPL->GetCount(); a++) 457 { 458 if((*pGPL)[a].IsUserDefined()) 459 { 460 bRet = sal_True; 461 } 462 } 463 } 464 } 465 } 466 return bRet; 467 } 468 469 sal_uIntPtr SdrMarkView::GetMarkableGluePointCount() const 470 { 471 sal_uIntPtr nAnz=0; 472 if (IsGluePointEditMode()) { 473 ForceUndirtyMrkPnt(); 474 sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); 475 for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz; nMarkNum++) { 476 const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); 477 const SdrObject* pObj=pM->GetMarkedSdrObj(); 478 const SdrGluePointList* pGPL=pObj->GetGluePointList(); 479 480 // #i38892# 481 if(pGPL && pGPL->GetCount()) 482 { 483 for(sal_uInt16 a(0); a < pGPL->GetCount(); a++) 484 { 485 if((*pGPL)[a].IsUserDefined()) 486 { 487 nAnz++; 488 } 489 } 490 } 491 } 492 } 493 return nAnz; 494 } 495 496 sal_Bool SdrMarkView::HasMarkedGluePoints() const 497 { 498 ForceUndirtyMrkPnt(); 499 sal_Bool bRet=sal_False; 500 sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); 501 for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz && !bRet; nMarkNum++) { 502 const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); 503 const SdrUShortCont* pPts=pM->GetMarkedGluePoints(); 504 bRet=pPts!=NULL && pPts->GetCount()!=0; 505 } 506 return bRet; 507 } 508 509 sal_uIntPtr SdrMarkView::GetMarkedGluePointCount() const 510 { 511 ForceUndirtyMrkPnt(); 512 sal_uIntPtr nAnz=0; 513 sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); 514 for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz; nMarkNum++) { 515 const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); 516 const SdrUShortCont* pPts=pM->GetMarkedGluePoints(); 517 if (pPts!=NULL) nAnz+=pPts->GetCount(); 518 } 519 return nAnz; 520 } 521 522 sal_Bool SdrMarkView::MarkGluePoints(const Rectangle* pRect, sal_Bool bUnmark) 523 { 524 if (!IsGluePointEditMode() && !bUnmark) return sal_False; 525 ForceUndirtyMrkPnt(); 526 sal_Bool bChgd=sal_False; 527 SortMarkedObjects(); 528 sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); 529 for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz; nMarkNum++) { 530 SdrMark* pM=GetSdrMarkByIndex(nMarkNum); 531 const SdrObject* pObj=pM->GetMarkedSdrObj(); 532 const SdrGluePointList* pGPL=pObj->GetGluePointList(); 533 SdrUShortCont* pPts=pM->GetMarkedGluePoints(); 534 if (bUnmark && pRect==NULL) { // UnmarkAll 535 if (pPts!=NULL && pPts->GetCount()!=0) { 536 pPts->Clear(); 537 bChgd=sal_True; 538 } 539 } else { 540 if (pGPL!=NULL && (pPts!=NULL || !bUnmark)) { 541 sal_uInt16 nGPAnz=pGPL->GetCount(); 542 for (sal_uInt16 nGPNum=0; nGPNum<nGPAnz; nGPNum++) { 543 const SdrGluePoint& rGP=(*pGPL)[nGPNum]; 544 545 // #i38892# 546 if(rGP.IsUserDefined()) 547 { 548 Point aPos(rGP.GetAbsolutePos(*pObj)); 549 if (pRect==NULL || pRect->IsInside(aPos)) { 550 if (pPts==NULL) pPts=pM->ForceMarkedGluePoints(); 551 else pPts->ForceSort(); 552 sal_uIntPtr nPos=pPts->GetPos(rGP.GetId()); 553 if (!bUnmark && nPos==CONTAINER_ENTRY_NOTFOUND) { 554 bChgd=sal_True; 555 pPts->Insert(rGP.GetId()); 556 } 557 if (bUnmark && nPos!=CONTAINER_ENTRY_NOTFOUND) { 558 bChgd=sal_True; 559 pPts->Remove(nPos); 560 } 561 } 562 } 563 } 564 } 565 } 566 } 567 if (bChgd) { 568 AdjustMarkHdl(); 569 MarkListHasChanged(); 570 } 571 return bChgd; 572 } 573 574 sal_Bool SdrMarkView::PickGluePoint(const Point& rPnt, SdrObject*& rpObj, sal_uInt16& rnId, SdrPageView*& rpPV, sal_uIntPtr nOptions) const 575 { 576 SdrObject* pObj0=rpObj; 577 //SdrPageView* pPV0=rpPV; 578 sal_uInt16 nId0=rnId; 579 rpObj=NULL; rpPV=NULL; rnId=0; 580 if (!IsGluePointEditMode()) return sal_False; 581 sal_Bool bBack=(nOptions & SDRSEARCH_BACKWARD) !=0; 582 sal_Bool bNext=(nOptions & SDRSEARCH_NEXT) !=0; 583 OutputDevice* pOut=(OutputDevice*)pActualOutDev; 584 if (pOut==NULL) pOut=GetFirstOutputDevice(); //GetWin(0); 585 if (pOut==NULL) return sal_False; 586 SortMarkedObjects(); 587 sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); 588 sal_uIntPtr nMarkNum=bBack ? 0 : nMarkAnz; 589 if (bNext) { 590 nMarkNum=((SdrMarkView*)this)->TryToFindMarkedObject(pObj0); 591 if (nMarkNum==CONTAINER_ENTRY_NOTFOUND) return sal_False; 592 if (!bBack) nMarkNum++; 593 } 594 while (bBack ? nMarkNum<nMarkAnz : nMarkNum>0) { 595 if (!bBack) nMarkNum--; 596 const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); 597 SdrObject* pObj=pM->GetMarkedSdrObj(); 598 SdrPageView* pPV=pM->GetPageView(); 599 const SdrGluePointList* pGPL=pObj->GetGluePointList(); 600 if (pGPL!=NULL) { 601 sal_uInt16 nNum=pGPL->HitTest(rPnt,*pOut,pObj,bBack,bNext,nId0); 602 if (nNum!=SDRGLUEPOINT_NOTFOUND) 603 { 604 // #i38892# 605 const SdrGluePoint& rCandidate = (*pGPL)[nNum]; 606 607 if(rCandidate.IsUserDefined()) 608 { 609 rpObj=pObj; 610 rnId=(*pGPL)[nNum].GetId(); 611 rpPV=pPV; 612 return sal_True; 613 } 614 } 615 } 616 bNext=sal_False; // HitNextGluePoint nur beim ersten Obj 617 if (bBack) nMarkNum++; 618 } 619 return sal_False; 620 } 621 622 sal_Bool SdrMarkView::MarkGluePoint(const SdrObject* pObj, sal_uInt16 nId, const SdrPageView* /*pPV*/, sal_Bool bUnmark) 623 { 624 if (!IsGluePointEditMode()) return sal_False; 625 ForceUndirtyMrkPnt(); 626 sal_Bool bChgd=sal_False; 627 if (pObj!=NULL) { 628 sal_uIntPtr nMarkPos=TryToFindMarkedObject(pObj); 629 if (nMarkPos!=CONTAINER_ENTRY_NOTFOUND) { 630 SdrMark* pM=GetSdrMarkByIndex(nMarkPos); 631 SdrUShortCont* pPts=bUnmark ? pM->GetMarkedGluePoints() : pM->ForceMarkedGluePoints(); 632 if (pPts!=NULL) { 633 sal_uIntPtr nPointPos=pPts->GetPos(nId); 634 if (!bUnmark && nPointPos==CONTAINER_ENTRY_NOTFOUND) { 635 bChgd=sal_True; 636 pPts->Insert(nId); 637 } 638 if (bUnmark && nPointPos!=CONTAINER_ENTRY_NOTFOUND) { 639 bChgd=sal_True; 640 pPts->Remove(nPointPos); 641 } 642 } 643 } else { 644 // Objekt implizit markieren ... 645 // ... fehlende Implementation 646 } 647 } 648 if (bChgd) { 649 AdjustMarkHdl(); 650 MarkListHasChanged(); 651 } 652 return bChgd; 653 } 654 655 sal_Bool SdrMarkView::IsGluePointMarked(const SdrObject* pObj, sal_uInt16 nId) const 656 { 657 ForceUndirtyMrkPnt(); 658 sal_Bool bRet=sal_False; 659 sal_uIntPtr nPos=((SdrMarkView*)this)->TryToFindMarkedObject(pObj); // casting auf NonConst 660 if (nPos!=CONTAINER_ENTRY_NOTFOUND) { 661 const SdrMark* pM=GetSdrMarkByIndex(nPos); 662 const SdrUShortCont* pPts=pM->GetMarkedGluePoints(); 663 if (pPts!=NULL) { 664 bRet=pPts->Exist(nId); 665 } 666 } 667 return bRet; 668 } 669 670 sal_Bool SdrMarkView::UnmarkGluePoint(const SdrHdl& rHdl) 671 { 672 if (&rHdl!=NULL && rHdl.GetKind()==HDL_GLUE && rHdl.GetObj()!=NULL) { 673 return MarkGluePoint(rHdl.GetObj(),(sal_uInt16)rHdl.GetObjHdlNum(),rHdl.GetPageView(),sal_True); 674 } else return sal_False; 675 } 676 677 SdrHdl* SdrMarkView::GetGluePointHdl(const SdrObject* pObj, sal_uInt16 nId) const 678 { 679 ForceUndirtyMrkPnt(); 680 sal_uIntPtr nHdlAnz=aHdl.GetHdlCount(); 681 for (sal_uIntPtr nHdlNum=0; nHdlNum<nHdlAnz; nHdlNum++) { 682 SdrHdl* pHdl=aHdl.GetHdl(nHdlNum); 683 if (pHdl->GetObj()==pObj && 684 pHdl->GetKind()==HDL_GLUE && 685 pHdl->GetObjHdlNum()==nId ) return pHdl; 686 } 687 return NULL; 688 } 689 690 sal_Bool SdrMarkView::MarkNextGluePoint(sal_Bool /*bPrev*/) 691 { 692 ForceUndirtyMrkPnt(); 693 sal_Bool bChgd=sal_False; 694 SortMarkedObjects(); 695 // ... 696 if (bChgd) { 697 MarkListHasChanged(); 698 } 699 return bChgd; 700 } 701 702 sal_Bool SdrMarkView::MarkNextGluePoint(const Point& /*rPnt*/, sal_Bool /*bPrev*/) 703 { 704 ForceUndirtyMrkPnt(); 705 sal_Bool bChgd=sal_False; 706 SortMarkedObjects(); 707 // ... 708 if (bChgd) { 709 MarkListHasChanged(); 710 } 711 return bChgd; 712 } 713 714 const Rectangle& SdrMarkView::GetMarkedGluePointsRect() const 715 { 716 ForceUndirtyMrkPnt(); 717 if (bMarkedPointsRectsDirty) ImpSetPointsRects(); 718 return aMarkedGluePointsRect; 719 } 720 721