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/svdedtv.hxx> 28 #include <editeng/outliner.hxx> 29 #include <svx/svdundo.hxx> 30 #include <svx/svdogrp.hxx> // fuer's Gruppieren 31 #include <svx/svdovirt.hxx> // fuer VirtualObject-Bundling (Writer) 32 #include <svx/svdopath.hxx> // fuer CombineObjects 33 #include <svx/svdpage.hxx> 34 #include <svx/svdpagv.hxx> 35 #include "svx/svditer.hxx" 36 #include <svx/svdograf.hxx> // fuer Possibilities 37 #include <svx/svdoole2.hxx> // und Mtf-Import 38 #include "svx/svdstr.hrc" // Namen aus der Resource 39 #include "svx/svdglob.hxx" // StringCache 40 #include "svdfmtf.hxx" 41 #include <svx/svdetc.hxx> 42 #include <sfx2/basedlgs.hxx> 43 #include <vcl/msgbox.hxx> 44 #include <editeng/outlobj.hxx> 45 #include <editeng/eeitem.hxx> 46 #include <basegfx/polygon/b2dpolypolygon.hxx> 47 #include <basegfx/polygon/b2dpolypolygontools.hxx> 48 49 #include <svx/svxdlg.hxx> //CHINA001 50 #include <svx/dialogs.hrc> //CHINA001 51 52 // #i37011# 53 #include <svx/svdoashp.hxx> 54 #include <basegfx/polygon/b2dpolypolygoncutter.hxx> 55 56 //////////////////////////////////////////////////////////////////////////////////////////////////// 57 //////////////////////////////////////////////////////////////////////////////////////////////////// 58 //////////////////////////////////////////////////////////////////////////////////////////////////// 59 //////////////////////////////////////////////////////////////////////////////////////////////////// 60 // 61 // @@@@@ @@@@@ @@ @@@@@@ @@ @@ @@ @@@@@ @@ @@ 62 // @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ 63 // @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @ @@ 64 // @@@@ @@ @@ @@ @@ @@@@@ @@ @@@@ @@@@@@@ 65 // @@ @@ @@ @@ @@ @@@ @@ @@ @@@@@@@ 66 // @@ @@ @@ @@ @@ @@@ @@ @@ @@@ @@@ 67 // @@@@@ @@@@@ @@ @@ @ @@ @@@@@ @@ @@ 68 // 69 //////////////////////////////////////////////////////////////////////////////////////////////////// 70 //////////////////////////////////////////////////////////////////////////////////////////////////// 71 72 void SdrEditView::ImpBundleVirtObjOfMarkList() 73 { 74 // ... fehlende Implementation 75 } 76 77 SdrObject* SdrEditView::GetMaxToTopObj(SdrObject* /*pObj*/) const 78 { 79 return NULL; 80 } 81 82 SdrObject* SdrEditView::GetMaxToBtmObj(SdrObject* /*pObj*/) const 83 { 84 return NULL; 85 } 86 87 void SdrEditView::ObjOrderChanged(SdrObject* /*pObj*/, sal_uIntPtr /*nOldPos*/, sal_uIntPtr /*nNewPos*/) 88 { 89 } 90 91 void SdrEditView::MovMarkedToTop() 92 { 93 sal_uIntPtr nAnz=GetMarkedObjectCount(); 94 if (nAnz!=0) 95 { 96 const bool bUndo = IsUndoEnabled(); 97 98 if( bUndo ) 99 BegUndo(ImpGetResStr(STR_EditMovToTop),GetDescriptionOfMarkedObjects(),SDRREPFUNC_OBJ_MOVTOTOP); 100 101 SortMarkedObjects(); 102 sal_uIntPtr nm; 103 for (nm=0; nm<nAnz; nm++) 104 { // Ordnums muessen alle stimmen! 105 GetMarkedObjectByIndex(nm)->GetOrdNum(); 106 } 107 sal_Bool bChg=sal_False; 108 SdrObjList* pOL0=NULL; 109 sal_uIntPtr nNewPos=0; 110 for (nm=nAnz; nm>0;) 111 { 112 nm--; 113 SdrMark* pM=GetSdrMarkByIndex(nm); 114 SdrObject* pObj=pM->GetMarkedSdrObj(); 115 SdrObjList* pOL=pObj->GetObjList(); 116 if (pOL!=pOL0) 117 { 118 nNewPos=sal_uIntPtr(pOL->GetObjCount()-1); 119 pOL0=pOL; 120 } 121 sal_uIntPtr nNowPos=pObj->GetOrdNumDirect(); 122 const Rectangle& rBR=pObj->GetCurrentBoundRect(); 123 sal_uIntPtr nCmpPos=nNowPos+1; 124 SdrObject* pMaxObj=GetMaxToTopObj(pObj); 125 if (pMaxObj!=NULL) 126 { 127 sal_uIntPtr nMaxPos=pMaxObj->GetOrdNum(); 128 if (nMaxPos!=0) 129 nMaxPos--; 130 if (nNewPos>nMaxPos) 131 nNewPos=nMaxPos; // diesen nicht ueberholen. 132 if (nNewPos<nNowPos) 133 nNewPos=nNowPos; // aber dabei auch nicht in die falsche Richtung schieben 134 } 135 sal_Bool bEnd=sal_False; 136 while (nCmpPos<nNewPos && !bEnd) 137 { 138 SdrObject* pCmpObj=pOL->GetObj(nCmpPos); 139 if (pCmpObj==NULL) 140 { 141 DBG_ERROR("MovMarkedToTop(): Vergleichsobjekt nicht gefunden"); 142 bEnd=sal_True; 143 } 144 else if (pCmpObj==pMaxObj) 145 { 146 nNewPos=nCmpPos; 147 nNewPos--; 148 bEnd=sal_True; 149 } 150 else if (rBR.IsOver(pCmpObj->GetCurrentBoundRect())) 151 { 152 nNewPos=nCmpPos; 153 bEnd=sal_True; 154 } 155 else 156 { 157 nCmpPos++; 158 } 159 } 160 if (nNowPos!=nNewPos) 161 { 162 bChg=sal_True; 163 pOL->SetObjectOrdNum(nNowPos,nNewPos); 164 if( bUndo ) 165 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoObjectOrdNum(*pObj,nNowPos,nNewPos)); 166 ObjOrderChanged(pObj,nNowPos,nNewPos); 167 } 168 nNewPos--; 169 } 170 171 if( bUndo ) 172 EndUndo(); 173 174 if (bChg) 175 MarkListHasChanged(); 176 } 177 } 178 179 void SdrEditView::MovMarkedToBtm() 180 { 181 sal_uIntPtr nAnz=GetMarkedObjectCount(); 182 if (nAnz!=0) 183 { 184 const bool bUndo = IsUndoEnabled(); 185 186 if( bUndo ) 187 BegUndo(ImpGetResStr(STR_EditMovToBtm),GetDescriptionOfMarkedObjects(),SDRREPFUNC_OBJ_MOVTOBTM); 188 189 SortMarkedObjects(); 190 sal_uIntPtr nm; 191 for (nm=0; nm<nAnz; nm++) 192 { // Ordnums muessen alle stimmen! 193 GetMarkedObjectByIndex(nm)->GetOrdNum(); 194 } 195 196 sal_Bool bChg=sal_False; 197 SdrObjList* pOL0=NULL; 198 sal_uIntPtr nNewPos=0; 199 for (nm=0; nm<nAnz; nm++) 200 { 201 SdrMark* pM=GetSdrMarkByIndex(nm); 202 SdrObject* pObj=pM->GetMarkedSdrObj(); 203 SdrObjList* pOL=pObj->GetObjList(); 204 if (pOL!=pOL0) 205 { 206 nNewPos=0; 207 pOL0=pOL; 208 } 209 sal_uIntPtr nNowPos=pObj->GetOrdNumDirect(); 210 const Rectangle& rBR=pObj->GetCurrentBoundRect(); 211 sal_uIntPtr nCmpPos=nNowPos; if (nCmpPos>0) nCmpPos--; 212 SdrObject* pMaxObj=GetMaxToBtmObj(pObj); 213 if (pMaxObj!=NULL) 214 { 215 sal_uIntPtr nMinPos=pMaxObj->GetOrdNum()+1; 216 if (nNewPos<nMinPos) 217 nNewPos=nMinPos; // diesen nicht ueberholen. 218 if (nNewPos>nNowPos) 219 nNewPos=nNowPos; // aber dabei auch nicht in die falsche Richtung schieben 220 } 221 sal_Bool bEnd=sal_False; 222 // nNewPos ist an dieser Stelle noch die maximale Position, 223 // an der das Obj hinruecken darf, ohne seinen Vorgaenger 224 // (Mehrfachselektion) zu ueberholen. 225 while (nCmpPos>nNewPos && !bEnd) 226 { 227 SdrObject* pCmpObj=pOL->GetObj(nCmpPos); 228 if (pCmpObj==NULL) 229 { 230 DBG_ERROR("MovMarkedToBtm(): Vergleichsobjekt nicht gefunden"); 231 bEnd=sal_True; 232 } 233 else if (pCmpObj==pMaxObj) 234 { 235 nNewPos=nCmpPos; 236 nNewPos++; 237 bEnd=sal_True; 238 } 239 else if (rBR.IsOver(pCmpObj->GetCurrentBoundRect())) 240 { 241 nNewPos=nCmpPos; 242 bEnd=sal_True; 243 } 244 else 245 { 246 nCmpPos--; 247 } 248 } 249 if (nNowPos!=nNewPos) 250 { 251 bChg=sal_True; 252 pOL->SetObjectOrdNum(nNowPos,nNewPos); 253 if( bUndo ) 254 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoObjectOrdNum(*pObj,nNowPos,nNewPos)); 255 ObjOrderChanged(pObj,nNowPos,nNewPos); 256 } 257 nNewPos++; 258 } 259 260 if(bUndo) 261 EndUndo(); 262 263 if(bChg) 264 MarkListHasChanged(); 265 } 266 } 267 268 void SdrEditView::PutMarkedToTop() 269 { 270 PutMarkedInFrontOfObj(NULL); 271 } 272 273 void SdrEditView::PutMarkedInFrontOfObj(const SdrObject* pRefObj) 274 { 275 sal_uIntPtr nAnz=GetMarkedObjectCount(); 276 if (nAnz!=0) 277 { 278 const bool bUndo = IsUndoEnabled(); 279 if( bUndo ) 280 BegUndo(ImpGetResStr(STR_EditPutToTop),GetDescriptionOfMarkedObjects(),SDRREPFUNC_OBJ_PUTTOTOP); 281 282 SortMarkedObjects(); 283 284 if (pRefObj!=NULL) 285 { 286 // Damit "Vor das Objekt" auch funktioniert wenn die 287 // markierten Objekte bereits vor dem Objekt stehen 288 sal_uIntPtr nRefMark=TryToFindMarkedObject(pRefObj); 289 SdrMark aRefMark; 290 if (nRefMark!=CONTAINER_ENTRY_NOTFOUND) 291 { 292 aRefMark=*GetSdrMarkByIndex(nRefMark); 293 GetMarkedObjectListWriteAccess().DeleteMark(nRefMark); 294 } 295 PutMarkedToBtm(); 296 if (nRefMark!=CONTAINER_ENTRY_NOTFOUND) 297 { 298 GetMarkedObjectListWriteAccess().InsertEntry(aRefMark); 299 SortMarkedObjects(); 300 } 301 } 302 sal_uIntPtr nm; 303 for (nm=0; nm<nAnz; nm++) 304 { // Ordnums muessen alle stimmen! 305 GetMarkedObjectByIndex(nm)->GetOrdNum(); 306 } 307 sal_Bool bChg=sal_False; 308 SdrObjList* pOL0=NULL; 309 sal_uIntPtr nNewPos=0; 310 for (nm=nAnz; nm>0;) 311 { 312 nm--; 313 SdrMark* pM=GetSdrMarkByIndex(nm); 314 SdrObject* pObj=pM->GetMarkedSdrObj(); 315 if (pObj!=pRefObj) 316 { 317 SdrObjList* pOL=pObj->GetObjList(); 318 if (pOL!=pOL0) 319 { 320 nNewPos=sal_uIntPtr(pOL->GetObjCount()-1); 321 pOL0=pOL; 322 } 323 sal_uIntPtr nNowPos=pObj->GetOrdNumDirect(); 324 SdrObject* pMaxObj=GetMaxToTopObj(pObj); 325 if (pMaxObj!=NULL) 326 { 327 sal_uIntPtr nMaxOrd=pMaxObj->GetOrdNum(); // geht leider nicht anders 328 if (nMaxOrd>0) 329 nMaxOrd--; 330 if (nNewPos>nMaxOrd) 331 nNewPos=nMaxOrd; // nicht ueberholen. 332 if (nNewPos<nNowPos) 333 nNewPos=nNowPos; // aber dabei auch nicht in die falsche Richtung schieben 334 } 335 if (pRefObj!=NULL) 336 { 337 if (pRefObj->GetObjList()==pObj->GetObjList()) 338 { 339 sal_uIntPtr nMaxOrd=pRefObj->GetOrdNum(); // geht leider nicht anders 340 if (nNewPos>nMaxOrd) 341 nNewPos=nMaxOrd; // nicht ueberholen. 342 if (nNewPos<nNowPos) 343 nNewPos=nNowPos; // aber dabei auch nicht in die falsche Richtung schieben 344 } 345 else 346 { 347 nNewPos=nNowPos; // andere PageView, also nicht veraendern 348 } 349 } 350 if (nNowPos!=nNewPos) 351 { 352 bChg=sal_True; 353 pOL->SetObjectOrdNum(nNowPos,nNewPos); 354 if( bUndo ) 355 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoObjectOrdNum(*pObj,nNowPos,nNewPos)); 356 ObjOrderChanged(pObj,nNowPos,nNewPos); 357 } 358 nNewPos--; 359 } // if (pObj!=pRefObj) 360 } // for-Schleife ueber alle Markierten Objekte 361 362 if( bUndo ) 363 EndUndo(); 364 365 if(bChg) 366 MarkListHasChanged(); 367 } 368 } 369 370 void SdrEditView::PutMarkedToBtm() 371 { 372 PutMarkedBehindObj(NULL); 373 } 374 375 void SdrEditView::PutMarkedBehindObj(const SdrObject* pRefObj) 376 { 377 sal_uIntPtr nAnz=GetMarkedObjectCount(); 378 if (nAnz!=0) 379 { 380 const bool bUndo = IsUndoEnabled(); 381 382 if( bUndo ) 383 BegUndo(ImpGetResStr(STR_EditPutToBtm),GetDescriptionOfMarkedObjects(),SDRREPFUNC_OBJ_PUTTOBTM); 384 385 SortMarkedObjects(); 386 if (pRefObj!=NULL) 387 { 388 // Damit "Hinter das Objekt" auch funktioniert wenn die 389 // markierten Objekte bereits hinter dem Objekt stehen 390 sal_uIntPtr nRefMark=TryToFindMarkedObject(pRefObj); 391 SdrMark aRefMark; 392 if (nRefMark!=CONTAINER_ENTRY_NOTFOUND) 393 { 394 aRefMark=*GetSdrMarkByIndex(nRefMark); 395 GetMarkedObjectListWriteAccess().DeleteMark(nRefMark); 396 } 397 PutMarkedToTop(); 398 if (nRefMark!=CONTAINER_ENTRY_NOTFOUND) 399 { 400 GetMarkedObjectListWriteAccess().InsertEntry(aRefMark); 401 SortMarkedObjects(); 402 } 403 } 404 sal_uIntPtr nm; 405 for (nm=0; nm<nAnz; nm++) { // Ordnums muessen alle stimmen! 406 GetMarkedObjectByIndex(nm)->GetOrdNum(); 407 } 408 sal_Bool bChg=sal_False; 409 SdrObjList* pOL0=NULL; 410 sal_uIntPtr nNewPos=0; 411 for (nm=0; nm<nAnz; nm++) { 412 SdrMark* pM=GetSdrMarkByIndex(nm); 413 SdrObject* pObj=pM->GetMarkedSdrObj(); 414 if (pObj!=pRefObj) { 415 SdrObjList* pOL=pObj->GetObjList(); 416 if (pOL!=pOL0) { 417 nNewPos=0; 418 pOL0=pOL; 419 } 420 sal_uIntPtr nNowPos=pObj->GetOrdNumDirect(); 421 SdrObject* pMinObj=GetMaxToBtmObj(pObj); 422 if (pMinObj!=NULL) { 423 sal_uIntPtr nMinOrd=pMinObj->GetOrdNum()+1; // geht leider nicht anders 424 if (nNewPos<nMinOrd) nNewPos=nMinOrd; // nicht ueberholen. 425 if (nNewPos>nNowPos) nNewPos=nNowPos; // aber dabei auch nicht in die falsche Richtung schieben 426 } 427 if (pRefObj!=NULL) { 428 if (pRefObj->GetObjList()==pObj->GetObjList()) { 429 sal_uIntPtr nMinOrd=pRefObj->GetOrdNum(); // geht leider nicht anders 430 if (nNewPos<nMinOrd) nNewPos=nMinOrd; // nicht ueberholen. 431 if (nNewPos>nNowPos) nNewPos=nNowPos; // aber dabei auch nicht in die falsche Richtung schieben 432 } else { 433 nNewPos=nNowPos; // andere PageView, also nicht veraendern 434 } 435 } 436 if (nNowPos!=nNewPos) { 437 bChg=sal_True; 438 pOL->SetObjectOrdNum(nNowPos,nNewPos); 439 if( bUndo ) 440 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoObjectOrdNum(*pObj,nNowPos,nNewPos)); 441 ObjOrderChanged(pObj,nNowPos,nNewPos); 442 } 443 nNewPos++; 444 } // if (pObj!=pRefObj) 445 } // for-Schleife ueber alle markierten Objekte 446 447 if(bUndo) 448 EndUndo(); 449 450 if(bChg) 451 MarkListHasChanged(); 452 } 453 } 454 455 void SdrEditView::ReverseOrderOfMarked() 456 { 457 SortMarkedObjects(); 458 sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); 459 if (nMarkAnz>0) 460 { 461 //sal_Bool bNeedBundle=sal_False; 462 sal_Bool bChg=sal_False; 463 464 bool bUndo = IsUndoEnabled(); 465 if( bUndo ) 466 BegUndo(ImpGetResStr(STR_EditRevOrder),GetDescriptionOfMarkedObjects(),SDRREPFUNC_OBJ_REVORDER); 467 468 sal_uIntPtr a=0; 469 do { 470 // Markierung ueber mehrere PageViews berueksichtigen 471 sal_uIntPtr b=a+1; 472 while (b<nMarkAnz && GetSdrPageViewOfMarkedByIndex(b) == GetSdrPageViewOfMarkedByIndex(a)) b++; 473 b--; 474 SdrObjList* pOL=GetSdrPageViewOfMarkedByIndex(a)->GetObjList(); 475 sal_uIntPtr c=b; 476 if (a<c) { // Sicherstellen, dass die OrdNums nicht Dirty sind 477 GetMarkedObjectByIndex(a)->GetOrdNum(); 478 } 479 while (a<c) { 480 SdrObject* pObj1=GetMarkedObjectByIndex(a); 481 SdrObject* pObj2=GetMarkedObjectByIndex(c); 482 sal_uIntPtr nOrd1=pObj1->GetOrdNumDirect(); 483 sal_uIntPtr nOrd2=pObj2->GetOrdNumDirect(); 484 if( bUndo ) 485 { 486 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoObjectOrdNum(*pObj1,nOrd1,nOrd2)); 487 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoObjectOrdNum(*pObj2,nOrd2-1,nOrd1)); 488 } 489 pOL->SetObjectOrdNum(nOrd1,nOrd2); 490 // Obj 2 ist um eine Position nach vorn gerutscht, deshalb nun nOrd2-1 491 pOL->SetObjectOrdNum(nOrd2-1,nOrd1); 492 // Verwendung von Replace statt SetOrdNum wg. Performance (Neuberechnung der Ordnums) 493 a++; c--; 494 bChg=sal_True; 495 } 496 a=b+1; 497 } while (a<nMarkAnz); 498 499 if(bUndo) 500 EndUndo(); 501 502 if(bChg) 503 MarkListHasChanged(); 504 } 505 } 506 507 void SdrEditView::ImpCheckToTopBtmPossible() 508 { 509 sal_uIntPtr nAnz=GetMarkedObjectCount(); 510 if (nAnz==0) 511 return; 512 if (nAnz==1) 513 { // Sonderbehandlung fuer Einzelmarkierung 514 SdrObject* pObj=GetMarkedObjectByIndex(0); 515 SdrObjList* pOL=pObj->GetObjList(); 516 sal_uIntPtr nMax=pOL->GetObjCount(); 517 sal_uIntPtr nMin=0; 518 sal_uIntPtr nObjNum=pObj->GetOrdNum(); 519 SdrObject* pRestrict=GetMaxToTopObj(pObj); 520 if (pRestrict!=NULL) { 521 sal_uIntPtr nRestrict=pRestrict->GetOrdNum(); 522 if (nRestrict<nMax) nMax=nRestrict; 523 } 524 pRestrict=GetMaxToBtmObj(pObj); 525 if (pRestrict!=NULL) { 526 sal_uIntPtr nRestrict=pRestrict->GetOrdNum(); 527 if (nRestrict>nMin) nMin=nRestrict; 528 } 529 bToTopPossible=nObjNum<sal_uIntPtr(nMax-1); 530 bToBtmPossible=nObjNum>nMin; 531 } else { // Mehrfachselektion 532 sal_uIntPtr nm=0; 533 SdrObjList* pOL0=NULL; 534 long nPos0=-1; 535 while (!bToBtmPossible && nm<nAnz) { // 'nach hinten' checken 536 SdrObject* pObj=GetMarkedObjectByIndex(nm); 537 SdrObjList* pOL=pObj->GetObjList(); 538 if (pOL!=pOL0) { 539 nPos0=-1; 540 pOL0=pOL; 541 } 542 sal_uIntPtr nPos=pObj->GetOrdNum(); 543 bToBtmPossible=nPos>sal_uIntPtr(nPos0+1); 544 nPos0=long(nPos); 545 nm++; 546 } 547 nm=nAnz; 548 pOL0=NULL; 549 nPos0=0x7FFFFFFF; 550 while (!bToTopPossible && nm>0) { // 'nach vorn' checken 551 nm--; 552 SdrObject* pObj=GetMarkedObjectByIndex(nm); 553 SdrObjList* pOL=pObj->GetObjList(); 554 if (pOL!=pOL0) { 555 nPos0=pOL->GetObjCount(); 556 pOL0=pOL; 557 } 558 sal_uIntPtr nPos=pObj->GetOrdNum(); 559 bToTopPossible=nPos+1<sal_uIntPtr(nPos0); 560 nPos0=nPos; 561 } 562 } 563 } 564 565 //////////////////////////////////////////////////////////////////////////////////////////////////// 566 // 567 // @@@@ @@@@ @@ @@ @@@@@ @@ @@ @@ @@@@@ 568 // @@ @@ @@ @@ @@@ @@@ @@ @@ @@ @@@ @@ @@ 569 // @@ @@ @@ @@@@@@@ @@ @@ @@ @@@@@@ @@ 570 // @@ @@ @@ @@@@@@@ @@@@@ @@ @@@@@@ @@@@ 571 // @@ @@ @@ @@ @ @@ @@ @@ @@ @@ @@@ @@ 572 // @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ 573 // @@@@ @@@@ @@ @@ @@@@@ @@ @@ @@ @@@@@ 574 // 575 //////////////////////////////////////////////////////////////////////////////////////////////////// 576 577 void SdrEditView::ImpCopyAttributes(const SdrObject* pSource, SdrObject* pDest) const 578 { 579 if (pSource!=NULL) { 580 SdrObjList* pOL=pSource->GetSubList(); 581 if (pOL!=NULL && !pSource->Is3DObj()) { // erstes Nichtgruppenobjekt aus der Gruppe holen 582 SdrObjListIter aIter(*pOL,IM_DEEPNOGROUPS); 583 pSource=aIter.Next(); 584 } 585 } 586 587 if(pSource && pDest) 588 { 589 SfxItemSet aSet(pMod->GetItemPool(), 590 SDRATTR_START, SDRATTR_NOTPERSIST_FIRST-1, 591 SDRATTR_NOTPERSIST_LAST+1, SDRATTR_END, 592 EE_ITEMS_START, EE_ITEMS_END, 593 0, 0); // #52757#, #52762# 594 595 aSet.Put(pSource->GetMergedItemSet()); 596 597 pDest->ClearMergedItem(); 598 pDest->SetMergedItemSet(aSet); 599 600 pDest->NbcSetLayer(pSource->GetLayer()); 601 pDest->NbcSetStyleSheet(pSource->GetStyleSheet(), sal_True); 602 } 603 } 604 605 sal_Bool SdrEditView::ImpCanConvertForCombine1(const SdrObject* pObj) const 606 { 607 // #69711 : new condition IsLine() to be able to combine simple Lines 608 sal_Bool bIsLine(sal_False); 609 610 const SdrPathObj* pPath = PTR_CAST(SdrPathObj,pObj); 611 612 if(pPath) 613 { 614 bIsLine = pPath->IsLine(); 615 } 616 617 SdrObjTransformInfoRec aInfo; 618 pObj->TakeObjInfo(aInfo); 619 620 return (aInfo.bCanConvToPath || aInfo.bCanConvToPoly || bIsLine); 621 } 622 623 sal_Bool SdrEditView::ImpCanConvertForCombine(const SdrObject* pObj) const 624 { 625 SdrObjList* pOL = pObj->GetSubList(); 626 627 if(pOL && !pObj->Is3DObj()) 628 { 629 SdrObjListIter aIter(*pOL, IM_DEEPNOGROUPS); 630 631 while(aIter.IsMore()) 632 { 633 SdrObject* pObj1 = aIter.Next(); 634 635 // Es muessen alle Member einer Gruppe konvertierbar sein 636 if(!ImpCanConvertForCombine1(pObj1)) 637 { 638 return sal_False; 639 } 640 } 641 } 642 else 643 { 644 if(!ImpCanConvertForCombine1(pObj)) 645 { 646 return sal_False; 647 } 648 } 649 650 return sal_True; 651 } 652 653 basegfx::B2DPolyPolygon SdrEditView::ImpGetPolyPolygon1(const SdrObject* pObj, sal_Bool bCombine) const 654 { 655 basegfx::B2DPolyPolygon aRetval; 656 SdrPathObj* pPath = PTR_CAST(SdrPathObj, pObj); 657 658 if(bCombine && pPath && !pObj->GetOutlinerParaObject()) 659 { 660 aRetval = pPath->GetPathPoly(); 661 } 662 else 663 { 664 SdrObject* pConvObj = pObj->ConvertToPolyObj(bCombine, sal_False); 665 666 if(pConvObj) 667 { 668 SdrObjList* pOL = pConvObj->GetSubList(); 669 670 if(pOL) 671 { 672 SdrObjListIter aIter(*pOL, IM_DEEPNOGROUPS); 673 674 while(aIter.IsMore()) 675 { 676 SdrObject* pObj1 = aIter.Next(); 677 pPath = PTR_CAST(SdrPathObj, pObj1); 678 679 if(pPath) 680 { 681 aRetval.append(pPath->GetPathPoly()); 682 } 683 } 684 } 685 else 686 { 687 pPath = PTR_CAST(SdrPathObj, pConvObj); 688 689 if(pPath) 690 { 691 aRetval = pPath->GetPathPoly(); 692 } 693 } 694 695 SdrObject::Free( pConvObj ); 696 } 697 } 698 699 return aRetval; 700 } 701 702 basegfx::B2DPolyPolygon SdrEditView::ImpGetPolyPolygon(const SdrObject* pObj, sal_Bool bCombine) const 703 { 704 SdrObjList* pOL = pObj->GetSubList(); 705 706 if(pOL && !pObj->Is3DObj()) 707 { 708 basegfx::B2DPolyPolygon aRetval; 709 SdrObjListIter aIter(*pOL, IM_DEEPNOGROUPS); 710 711 while(aIter.IsMore()) 712 { 713 SdrObject* pObj1 = aIter.Next(); 714 aRetval.append(ImpGetPolyPolygon1(pObj1, bCombine)); 715 } 716 717 return aRetval; 718 } 719 else 720 { 721 return ImpGetPolyPolygon1(pObj, bCombine); 722 } 723 } 724 725 basegfx::B2DPolygon SdrEditView::ImpCombineToSinglePolygon(const basegfx::B2DPolyPolygon& rPolyPolygon) const 726 { 727 const sal_uInt32 nPolyCount(rPolyPolygon.count()); 728 729 if(0L == nPolyCount) 730 { 731 return basegfx::B2DPolygon(); 732 } 733 else if(1L == nPolyCount) 734 { 735 return rPolyPolygon.getB2DPolygon(0L); 736 } 737 else 738 { 739 basegfx::B2DPolygon aRetval(rPolyPolygon.getB2DPolygon(0L)); 740 741 for(sal_uInt32 a(1L); a < nPolyCount; a++) 742 { 743 basegfx::B2DPolygon aCandidate(rPolyPolygon.getB2DPolygon(a)); 744 745 if(aRetval.count()) 746 { 747 if(aCandidate.count()) 748 { 749 const basegfx::B2DPoint aCA(aCandidate.getB2DPoint(0L)); 750 const basegfx::B2DPoint aCB(aCandidate.getB2DPoint(aCandidate.count() - 1L)); 751 const basegfx::B2DPoint aRA(aRetval.getB2DPoint(0L)); 752 const basegfx::B2DPoint aRB(aRetval.getB2DPoint(aRetval.count() - 1L)); 753 754 const double fRACA(basegfx::B2DVector(aCA - aRA).getLength()); 755 const double fRACB(basegfx::B2DVector(aCB - aRA).getLength()); 756 const double fRBCA(basegfx::B2DVector(aCA - aRB).getLength()); 757 const double fRBCB(basegfx::B2DVector(aCB - aRB).getLength()); 758 759 const double fSmallestRA(fRACA < fRACB ? fRACA : fRACB); 760 const double fSmallestRB(fRBCA < fRBCB ? fRBCA : fRBCB); 761 762 if(fSmallestRA < fSmallestRB) 763 { 764 // flip result 765 aRetval.flip(); 766 } 767 768 const double fSmallestCA(fRACA < fRBCA ? fRACA : fRBCA); 769 const double fSmallestCB(fRACB < fRBCB ? fRACB : fRBCB); 770 771 if(fSmallestCB < fSmallestCA) 772 { 773 // flip candidate 774 aCandidate.flip(); 775 } 776 777 // append candidate to retval 778 aRetval.append(aCandidate); 779 } 780 } 781 else 782 { 783 aRetval = aCandidate; 784 } 785 } 786 787 return aRetval; 788 } 789 } 790 791 // for distribution dialog function 792 struct ImpDistributeEntry 793 { 794 SdrObject* mpObj; 795 sal_Int32 mnPos; 796 sal_Int32 mnLength; 797 }; 798 799 DECLARE_LIST(ImpDistributeEntryList, ImpDistributeEntry*) 800 801 void SdrEditView::DistributeMarkedObjects() 802 { 803 sal_uInt32 nMark(GetMarkedObjectCount()); 804 805 if(nMark > 2) 806 { 807 SfxItemSet aNewAttr(pMod->GetItemPool()); 808 //CHINA001 SvxDistributeDialog* pDlg = new SvxDistributeDialog(NULL, aNewAttr); 809 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); 810 if(pFact) 811 { 812 AbstractSvxDistributeDialog *pDlg = pFact->CreateSvxDistributeDialog(NULL, aNewAttr); 813 DBG_ASSERT(pDlg, "Dialogdiet fail!");//CHINA001 814 815 sal_uInt16 nResult = pDlg->Execute(); 816 817 if(nResult == RET_OK) 818 { 819 SvxDistributeHorizontal eHor = pDlg->GetDistributeHor(); 820 SvxDistributeVertical eVer = pDlg->GetDistributeVer(); 821 ImpDistributeEntryList aEntryList; 822 sal_uInt32 a, nInsPos, nFullLength; 823 824 const bool bUndo = IsUndoEnabled(); 825 if( bUndo ) 826 BegUndo(); 827 828 if(eHor != SvxDistributeHorizontalNone) 829 { 830 // build sorted entry list 831 nFullLength = 0L; 832 833 for(a=0;a<nMark;a++) 834 { 835 SdrMark* pMark = GetSdrMarkByIndex(a); 836 ImpDistributeEntry* pNew = new ImpDistributeEntry; 837 838 pNew->mpObj = pMark->GetMarkedSdrObj(); 839 nInsPos = 0; 840 841 switch(eHor) 842 { 843 case SvxDistributeHorizontalLeft: 844 { 845 pNew->mnPos = pNew->mpObj->GetSnapRect().Left(); 846 break; 847 } 848 case SvxDistributeHorizontalCenter: 849 { 850 pNew->mnPos = (pNew->mpObj->GetSnapRect().Right() + pNew->mpObj->GetSnapRect().Left()) / 2; 851 break; 852 } 853 case SvxDistributeHorizontalDistance: 854 { 855 pNew->mnLength = pNew->mpObj->GetSnapRect().GetWidth() + 1; 856 nFullLength += pNew->mnLength; 857 pNew->mnPos = (pNew->mpObj->GetSnapRect().Right() + pNew->mpObj->GetSnapRect().Left()) / 2; 858 break; 859 } 860 case SvxDistributeHorizontalRight: 861 { 862 pNew->mnPos = pNew->mpObj->GetSnapRect().Right(); 863 break; 864 } 865 default: break; 866 } 867 868 while(nInsPos < aEntryList.Count() && aEntryList.GetObject(nInsPos)->mnPos < pNew->mnPos) 869 nInsPos++; 870 871 aEntryList.Insert(pNew, nInsPos); 872 } 873 874 if(eHor == SvxDistributeHorizontalDistance) 875 { 876 // calc room in-between 877 sal_Int32 nWidth = GetAllMarkedBoundRect().GetWidth() + 1; 878 double fStepWidth = ((double)nWidth - (double)nFullLength) / (double)(aEntryList.Count() - 1); 879 double fStepStart = (double)aEntryList.GetObject(0)->mnPos; 880 fStepStart += fStepWidth + (double)((aEntryList.GetObject(0)->mnLength + aEntryList.GetObject(1)->mnLength) / 2); 881 882 // move entries 1..n-1 883 for(a=1;a<aEntryList.Count()-1;a++) 884 { 885 ImpDistributeEntry* pCurr = aEntryList.GetObject(a); 886 ImpDistributeEntry* pNext = aEntryList.GetObject(a+1); 887 sal_Int32 nDelta = (sal_Int32)(fStepStart + 0.5) - pCurr->mnPos; 888 if( bUndo ) 889 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pCurr->mpObj)); 890 pCurr->mpObj->Move(Size(nDelta, 0)); 891 fStepStart += fStepWidth + (double)((pCurr->mnLength + pNext->mnLength) / 2); 892 } 893 } 894 else 895 { 896 // calc distances 897 sal_Int32 nWidth = aEntryList.GetObject(aEntryList.Count() - 1)->mnPos - aEntryList.GetObject(0)->mnPos; 898 double fStepWidth = (double)nWidth / (double)(aEntryList.Count() - 1); 899 double fStepStart = (double)aEntryList.GetObject(0)->mnPos; 900 fStepStart += fStepWidth; 901 902 // move entries 1..n-1 903 for(a=1;a<aEntryList.Count()-1;a++) 904 { 905 ImpDistributeEntry* pCurr = aEntryList.GetObject(a); 906 sal_Int32 nDelta = (sal_Int32)(fStepStart + 0.5) - pCurr->mnPos; 907 if( bUndo ) 908 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pCurr->mpObj)); 909 pCurr->mpObj->Move(Size(nDelta, 0)); 910 fStepStart += fStepWidth; 911 } 912 } 913 914 // clear list 915 while(aEntryList.Count()) 916 delete aEntryList.Remove((sal_uIntPtr)0L); 917 } 918 919 if(eVer != SvxDistributeVerticalNone) 920 { 921 // build sorted entry list 922 nFullLength = 0L; 923 924 for(a=0;a<nMark;a++) 925 { 926 SdrMark* pMark = GetSdrMarkByIndex(a); 927 ImpDistributeEntry* pNew = new ImpDistributeEntry; 928 929 pNew->mpObj = pMark->GetMarkedSdrObj(); 930 nInsPos = 0; 931 932 switch(eVer) 933 { 934 case SvxDistributeVerticalTop: 935 { 936 pNew->mnPos = pNew->mpObj->GetSnapRect().Top(); 937 break; 938 } 939 case SvxDistributeVerticalCenter: 940 { 941 pNew->mnPos = (pNew->mpObj->GetSnapRect().Bottom() + pNew->mpObj->GetSnapRect().Top()) / 2; 942 break; 943 } 944 case SvxDistributeVerticalDistance: 945 { 946 pNew->mnLength = pNew->mpObj->GetSnapRect().GetHeight() + 1; 947 nFullLength += pNew->mnLength; 948 pNew->mnPos = (pNew->mpObj->GetSnapRect().Bottom() + pNew->mpObj->GetSnapRect().Top()) / 2; 949 break; 950 } 951 case SvxDistributeVerticalBottom: 952 { 953 pNew->mnPos = pNew->mpObj->GetSnapRect().Bottom(); 954 break; 955 } 956 default: break; 957 } 958 959 while(nInsPos < aEntryList.Count() && aEntryList.GetObject(nInsPos)->mnPos < pNew->mnPos) 960 nInsPos++; 961 962 aEntryList.Insert(pNew, nInsPos); 963 } 964 965 if(eVer == SvxDistributeVerticalDistance) 966 { 967 // calc room in-between 968 sal_Int32 nHeight = GetAllMarkedBoundRect().GetHeight() + 1; 969 double fStepWidth = ((double)nHeight - (double)nFullLength) / (double)(aEntryList.Count() - 1); 970 double fStepStart = (double)aEntryList.GetObject(0)->mnPos; 971 fStepStart += fStepWidth + (double)((aEntryList.GetObject(0)->mnLength + aEntryList.GetObject(1)->mnLength) / 2); 972 973 // move entries 1..n-1 974 for(a=1;a<aEntryList.Count()-1;a++) 975 { 976 ImpDistributeEntry* pCurr = aEntryList.GetObject(a); 977 ImpDistributeEntry* pNext = aEntryList.GetObject(a+1); 978 sal_Int32 nDelta = (sal_Int32)(fStepStart + 0.5) - pCurr->mnPos; 979 if( bUndo ) 980 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pCurr->mpObj)); 981 pCurr->mpObj->Move(Size(0, nDelta)); 982 fStepStart += fStepWidth + (double)((pCurr->mnLength + pNext->mnLength) / 2); 983 } 984 } 985 else 986 { 987 // calc distances 988 sal_Int32 nHeight = aEntryList.GetObject(aEntryList.Count() - 1)->mnPos - aEntryList.GetObject(0)->mnPos; 989 double fStepWidth = (double)nHeight / (double)(aEntryList.Count() - 1); 990 double fStepStart = (double)aEntryList.GetObject(0)->mnPos; 991 fStepStart += fStepWidth; 992 993 // move entries 1..n-1 994 for(a=1;a<aEntryList.Count()-1;a++) 995 { 996 ImpDistributeEntry* pCurr = aEntryList.GetObject(a); 997 sal_Int32 nDelta = (sal_Int32)(fStepStart + 0.5) - pCurr->mnPos; 998 if( bUndo ) 999 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pCurr->mpObj)); 1000 pCurr->mpObj->Move(Size(0, nDelta)); 1001 fStepStart += fStepWidth; 1002 } 1003 } 1004 1005 // clear list 1006 while(aEntryList.Count()) 1007 delete aEntryList.Remove((sal_uIntPtr)0L); 1008 } 1009 1010 // UNDO-Comment and end of UNDO 1011 SetUndoComment(ImpGetResStr(STR_DistributeMarkedObjects)); 1012 1013 if( bUndo ) 1014 EndUndo(); 1015 } 1016 1017 delete(pDlg); 1018 } 1019 } 1020 } 1021 1022 void SdrEditView::MergeMarkedObjects(SdrMergeMode eMode) 1023 { 1024 // #i73441# check content 1025 if(AreObjectsMarked()) 1026 { 1027 SdrMarkList aRemove; 1028 SortMarkedObjects(); 1029 1030 const bool bUndo = IsUndoEnabled(); 1031 1032 if( bUndo ) 1033 BegUndo(); 1034 1035 sal_uInt32 nInsPos=0xFFFFFFFF; 1036 const SdrObject* pAttrObj = NULL; 1037 basegfx::B2DPolyPolygon aMergePolyPolygonA; 1038 basegfx::B2DPolyPolygon aMergePolyPolygonB; 1039 1040 SdrObjList* pInsOL = NULL; 1041 SdrPageView* pInsPV = NULL; 1042 sal_Bool bFirstObjectComplete(sal_False); 1043 1044 // make sure selected objects are contour objects 1045 // since now basegfx::tools::adaptiveSubdivide() is used, it is no longer 1046 // necessary to use ConvertMarkedToPolyObj which will subdivide curves using the old 1047 // mechanisms. In a next step the polygon clipper will even be able to clip curves... 1048 // ConvertMarkedToPolyObj(sal_True); 1049 ConvertMarkedToPathObj(sal_True); 1050 OSL_ENSURE(AreObjectsMarked(), "no more objects selected after preparations (!)"); 1051 1052 for(sal_uInt32 a=0;a<GetMarkedObjectCount();a++) 1053 { 1054 SdrMark* pM = GetSdrMarkByIndex(a); 1055 SdrObject* pObj = pM->GetMarkedSdrObj(); 1056 1057 if(ImpCanConvertForCombine(pObj)) 1058 { 1059 if(!pAttrObj) 1060 pAttrObj = pObj; 1061 1062 nInsPos = pObj->GetOrdNum() + 1; 1063 pInsPV = pM->GetPageView(); 1064 pInsOL = pObj->GetObjList(); 1065 1066 // #i76891# use single iter from SJ here whcih works on SdrObjects and takes 1067 // groups into account by itself 1068 SdrObjListIter aIter(*pObj, IM_DEEPWITHGROUPS); 1069 1070 while(aIter.IsMore()) 1071 { 1072 SdrObject* pCandidate = aIter.Next(); 1073 SdrPathObj* pPathObj = PTR_CAST(SdrPathObj, pCandidate); 1074 if(pPathObj) 1075 { 1076 basegfx::B2DPolyPolygon aTmpPoly(pPathObj->GetPathPoly()); 1077 1078 // #i76891# unfortunately ConvertMarkedToPathObj has converted all 1079 // involved polygon data to curve segments, even if not necessary. 1080 // It is better to try to reduce to more simple polygons. 1081 aTmpPoly = basegfx::tools::simplifyCurveSegments(aTmpPoly); 1082 1083 // for each part polygon as preparation, remove self-intersections 1084 // correct orientations and get rid of evtl. neutral polygons. 1085 aTmpPoly = basegfx::tools::prepareForPolygonOperation(aTmpPoly); 1086 1087 if(!bFirstObjectComplete) 1088 { 1089 // #i111987# Also need to collect ORed source shape when more than 1090 // a single polygon is involved 1091 if(aMergePolyPolygonA.count()) 1092 { 1093 aMergePolyPolygonA = basegfx::tools::solvePolygonOperationOr(aMergePolyPolygonA, aTmpPoly); 1094 } 1095 else 1096 { 1097 aMergePolyPolygonA = aTmpPoly; 1098 } 1099 } 1100 else 1101 { 1102 if(aMergePolyPolygonB.count()) 1103 { 1104 // to topologically correctly collect the 2nd polygon 1105 // group it is necessary to OR the parts (each is seen as 1106 // XOR-FillRule polygon and they are drawn over each-other) 1107 aMergePolyPolygonB = basegfx::tools::solvePolygonOperationOr(aMergePolyPolygonB, aTmpPoly); 1108 } 1109 else 1110 { 1111 aMergePolyPolygonB = aTmpPoly; 1112 } 1113 } 1114 } 1115 } 1116 1117 // was there something added to the first poly? 1118 if(!bFirstObjectComplete && aMergePolyPolygonA.count()) 1119 { 1120 bFirstObjectComplete = sal_True; 1121 } 1122 1123 // move object to temporary delete list 1124 aRemove.InsertEntry(SdrMark(pObj, pM->GetPageView())); 1125 } 1126 } 1127 1128 switch(eMode) 1129 { 1130 case SDR_MERGE_MERGE: 1131 { 1132 // merge all contained parts (OR) 1133 static bool bTestXOR(false); 1134 if(bTestXOR) 1135 { 1136 aMergePolyPolygonA = basegfx::tools::solvePolygonOperationXor(aMergePolyPolygonA, aMergePolyPolygonB); 1137 } 1138 else 1139 { 1140 aMergePolyPolygonA = basegfx::tools::solvePolygonOperationOr(aMergePolyPolygonA, aMergePolyPolygonB); 1141 } 1142 break; 1143 } 1144 case SDR_MERGE_SUBSTRACT: 1145 { 1146 // Substract B from A 1147 aMergePolyPolygonA = basegfx::tools::solvePolygonOperationDiff(aMergePolyPolygonA, aMergePolyPolygonB); 1148 break; 1149 } 1150 case SDR_MERGE_INTERSECT: 1151 { 1152 // AND B and A 1153 aMergePolyPolygonA = basegfx::tools::solvePolygonOperationAnd(aMergePolyPolygonA, aMergePolyPolygonB); 1154 break; 1155 } 1156 } 1157 1158 // #i73441# check insert list before taking actions 1159 if(pInsOL) 1160 { 1161 SdrPathObj* pPath = new SdrPathObj(OBJ_PATHFILL, aMergePolyPolygonA); 1162 ImpCopyAttributes(pAttrObj, pPath); 1163 SdrInsertReason aReason(SDRREASON_VIEWCALL, pAttrObj); 1164 pInsOL->InsertObject(pPath, nInsPos, &aReason); 1165 if( bUndo ) 1166 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoNewObject(*pPath)); 1167 MarkObj(pPath, pInsPV, sal_False, sal_True); 1168 } 1169 1170 aRemove.ForceSort(); 1171 switch(eMode) 1172 { 1173 case SDR_MERGE_MERGE: 1174 { 1175 SetUndoComment( 1176 ImpGetResStr(STR_EditMergeMergePoly), 1177 aRemove.GetMarkDescription()); 1178 break; 1179 } 1180 case SDR_MERGE_SUBSTRACT: 1181 { 1182 SetUndoComment( 1183 ImpGetResStr(STR_EditMergeSubstractPoly), 1184 aRemove.GetMarkDescription()); 1185 break; 1186 } 1187 case SDR_MERGE_INTERSECT: 1188 { 1189 SetUndoComment( 1190 ImpGetResStr(STR_EditMergeIntersectPoly), 1191 aRemove.GetMarkDescription()); 1192 break; 1193 } 1194 } 1195 DeleteMarkedList(aRemove); 1196 1197 if( bUndo ) 1198 EndUndo(); 1199 } 1200 } 1201 1202 void SdrEditView::CombineMarkedObjects(sal_Bool bNoPolyPoly) 1203 { 1204 // #105899# Start of Combine-Undo put to front, else ConvertMarkedToPolyObj would 1205 // create a 2nd Undo-action and Undo-Comment. 1206 1207 bool bUndo = IsUndoEnabled(); 1208 1209 // Undo-String will be set later 1210 if( bUndo ) 1211 BegUndo(String(), String(), bNoPolyPoly ? SDRREPFUNC_OBJ_COMBINE_ONEPOLY : SDRREPFUNC_OBJ_COMBINE_POLYPOLY); 1212 1213 // #105899# First, guarantee that all objects are converted to polyobjects, 1214 // especially for SdrGrafObj with bitmap filling this is necessary to not 1215 // loose the bitmap filling. 1216 1217 // #i12392# 1218 // ConvertMarkedToPolyObj was too strong here, it will loose quality and 1219 // information when curve objects are combined. This can be replaced by 1220 // using ConvertMarkedToPathObj without changing the previous fix. 1221 1222 // #i21250# 1223 // Instead of simply passing sal_True as LineToArea, use bNoPolyPoly as info 1224 // if this command is a 'Combine' or a 'Connect' command. On Connect it's sal_True. 1225 // To not concert line segments with a set line width to polygons in that case, 1226 // use this info. Do not convert LineToArea on Connect commands. 1227 // ConvertMarkedToPathObj(!bNoPolyPoly); 1228 1229 // #114310# 1230 // This is used for Combine and Connect. In no case it is necessary to force 1231 // the content to curve, but it is also not good to force to polygons. Thus, 1232 // curve is the less information loosing one. Remember: This place is not 1233 // used for merge. 1234 // LineToArea is never necessary, both commands are able to take over the 1235 // set line style and to display it correctly. Thus, i will use a 1236 // ConvertMarkedToPathObj with a sal_False in any case. Only drawback is that 1237 // simple polygons will be changed to curves, but with no information loss. 1238 ConvertMarkedToPathObj(sal_False /* bLineToArea */); 1239 1240 // continue as before 1241 basegfx::B2DPolyPolygon aPolyPolygon; 1242 SdrObjList* pAktOL = 0L; 1243 SdrMarkList aRemoveMerker; 1244 1245 SortMarkedObjects(); 1246 sal_uInt32 nInsPos(0xFFFFFFFF); 1247 SdrObjList* pInsOL = 0L; 1248 SdrPageView* pInsPV = 0L; 1249 const sal_uInt32 nAnz(GetMarkedObjectCount()); 1250 const SdrObject* pAttrObj = 0L; 1251 1252 for(sal_uInt32 a(nAnz); a > 0L; ) 1253 { 1254 a--; 1255 SdrMark* pM = GetSdrMarkByIndex(a); 1256 SdrObject* pObj = pM->GetMarkedSdrObj(); 1257 SdrObjList* pThisOL = pObj->GetObjList(); 1258 1259 if(pAktOL != pThisOL) 1260 { 1261 pAktOL = pThisOL; 1262 } 1263 1264 if(ImpCanConvertForCombine(pObj)) 1265 { 1266 // Obj merken fuer Attribute kopieren 1267 pAttrObj = pObj; 1268 1269 // unfortunately ConvertMarkedToPathObj has converted all 1270 // involved polygon data to curve segments, even if not necessary. 1271 // It is better to try to reduce to more simple polygons. 1272 basegfx::B2DPolyPolygon aTmpPoly(basegfx::tools::simplifyCurveSegments(ImpGetPolyPolygon(pObj, sal_True))); 1273 aPolyPolygon.insert(0L, aTmpPoly); 1274 1275 if(!pInsOL) 1276 { 1277 nInsPos = pObj->GetOrdNum() + 1L; 1278 pInsPV = pM->GetPageView(); 1279 pInsOL = pObj->GetObjList(); 1280 } 1281 1282 aRemoveMerker.InsertEntry(SdrMark(pObj, pM->GetPageView())); 1283 } 1284 } 1285 1286 if(bNoPolyPoly) 1287 { 1288 basegfx::B2DPolygon aCombinedPolygon(ImpCombineToSinglePolygon(aPolyPolygon)); 1289 aPolyPolygon.clear(); 1290 aPolyPolygon.append(aCombinedPolygon); 1291 } 1292 1293 const sal_uInt32 nPolyCount(aPolyPolygon.count()); 1294 1295 if(nPolyCount) 1296 { 1297 SdrObjKind eKind = OBJ_PATHFILL; 1298 1299 if(nPolyCount > 1L) 1300 { 1301 aPolyPolygon.setClosed(true); 1302 } 1303 else 1304 { 1305 // auf Polyline Checken 1306 const basegfx::B2DPolygon aPolygon(aPolyPolygon.getB2DPolygon(0L)); 1307 const sal_uInt32 nPointCount(aPolygon.count()); 1308 1309 if(nPointCount <= 2L) 1310 { 1311 eKind = OBJ_PATHLINE; 1312 } 1313 else 1314 { 1315 if(!aPolygon.isClosed()) 1316 { 1317 const basegfx::B2DPoint aPointA(aPolygon.getB2DPoint(0L)); 1318 const basegfx::B2DPoint aPointB(aPolygon.getB2DPoint(nPointCount - 1L)); 1319 const double fDistance(basegfx::B2DVector(aPointB - aPointA).getLength()); 1320 const double fJoinTolerance(10.0); 1321 1322 if(fDistance < fJoinTolerance) 1323 { 1324 aPolyPolygon.setClosed(true); 1325 } 1326 else 1327 { 1328 eKind = OBJ_PATHLINE; 1329 } 1330 } 1331 } 1332 } 1333 1334 SdrPathObj* pPath = new SdrPathObj(eKind,aPolyPolygon); 1335 1336 // Attribute des untersten Objekts 1337 ImpCopyAttributes(pAttrObj, pPath); 1338 1339 // #100408# If LineStyle of pAttrObj is XLINE_NONE force to XLINE_SOLID to make visible. 1340 const XLineStyle eLineStyle = ((const XLineStyleItem&)pAttrObj->GetMergedItem(XATTR_LINESTYLE)).GetValue(); 1341 const XFillStyle eFillStyle = ((const XFillStyleItem&)pAttrObj->GetMergedItem(XATTR_FILLSTYLE)).GetValue(); 1342 1343 // #110635# 1344 // Take fill style/closed state of pAttrObj in account when deciding to change the line style 1345 sal_Bool bIsClosedPathObj(pAttrObj->ISA(SdrPathObj) && ((SdrPathObj*)pAttrObj)->IsClosed()); 1346 1347 if(XLINE_NONE == eLineStyle && (XFILL_NONE == eFillStyle || !bIsClosedPathObj)) 1348 { 1349 pPath->SetMergedItem(XLineStyleItem(XLINE_SOLID)); 1350 } 1351 1352 SdrInsertReason aReason(SDRREASON_VIEWCALL,pAttrObj); 1353 pInsOL->InsertObject(pPath,nInsPos,&aReason); 1354 if( bUndo ) 1355 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoNewObject(*pPath)); 1356 1357 // #111111# 1358 // Here was a severe error: Without UnmarkAllObj, the new object was marked 1359 // additionally to the two ones which are deleted below. As long as those are 1360 // in the UNDO there is no problem, but as soon as they get deleted, the 1361 // MarkList will contain deleted objects -> GPF. 1362 UnmarkAllObj(pInsPV); 1363 MarkObj(pPath, pInsPV, sal_False, sal_True); 1364 } 1365 1366 // UndoComment aus den tatsaechlich verwendeten Objekten zusammenbauen 1367 aRemoveMerker.ForceSort(); // wichtig fuer Remove (s.u.) 1368 if( bUndo ) 1369 SetUndoComment(ImpGetResStr(bNoPolyPoly?STR_EditCombine_OnePoly:STR_EditCombine_PolyPoly),aRemoveMerker.GetMarkDescription()); 1370 1371 // die tatsaechlich verwendeten Objekten aus der Liste entfernen 1372 DeleteMarkedList(aRemoveMerker); 1373 if( bUndo ) 1374 EndUndo(); 1375 } 1376 1377 //////////////////////////////////////////////////////////////////////////////////////////////////// 1378 // 1379 // @@@@@ @@ @@@@ @@ @@ @@@@ @@ @@ @@@@@@ @@ @@@@@ 1380 // @@ @@ @@ @@ @@ @@@ @@@ @@ @@ @@@ @@ @@ @@ @@ 1381 // @@ @@ @@ @@ @@@@@@@ @@ @@ @@@@@@ @@ @@ @@ 1382 // @@ @@ @@ @@@@ @@@@@@@ @@@@@@ @@@@@@ @@ @@ @@@@ 1383 // @@ @@ @@ @@ @@ @ @@ @@ @@ @@ @@@ @@ @@ @@ 1384 // @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ 1385 // @@@@@ @@ @@@@ @@ @@ @@ @@ @@ @@ @@ @@@@@ @@@@@ 1386 // 1387 //////////////////////////////////////////////////////////////////////////////////////////////////// 1388 1389 sal_Bool SdrEditView::ImpCanDismantle(const basegfx::B2DPolyPolygon& rPpolyPolygon, sal_Bool bMakeLines) const 1390 { 1391 sal_Bool bCan(sal_False); 1392 const sal_uInt32 nPolygonCount(rPpolyPolygon.count()); 1393 1394 if(nPolygonCount >= 2L) 1395 { 1396 // #i69172# dismantle makes sense with 2 or more polygons in a polyPolygon 1397 bCan = sal_True; 1398 } 1399 else if(bMakeLines && 1L == nPolygonCount) 1400 { 1401 // #i69172# ..or with at least 2 edges (curves or lines) 1402 const basegfx::B2DPolygon aPolygon(rPpolyPolygon.getB2DPolygon(0L)); 1403 const sal_uInt32 nPointCount(aPolygon.count()); 1404 1405 if(nPointCount > 2L) 1406 { 1407 bCan = sal_True; 1408 } 1409 } 1410 1411 return bCan; 1412 } 1413 1414 sal_Bool SdrEditView::ImpCanDismantle(const SdrObject* pObj, sal_Bool bMakeLines) const 1415 { 1416 sal_Bool bOtherObjs(sal_False); // sal_True=andere Objekte ausser PathObj's vorhanden 1417 sal_Bool bMin1PolyPoly(sal_False); // sal_True=mind. 1 PolyPolygon mit mehr als ein Polygon vorhanden 1418 SdrObjList* pOL = pObj->GetSubList(); 1419 1420 if(pOL) 1421 { 1422 // Aha, Gruppenobjekt. Also alle Member ansehen. 1423 // Alle muessen PathObjs sein ! 1424 SdrObjListIter aIter(*pOL, IM_DEEPNOGROUPS); 1425 1426 while(aIter.IsMore() && !bOtherObjs) 1427 { 1428 const SdrObject* pObj1 = aIter.Next(); 1429 const SdrPathObj* pPath = PTR_CAST(SdrPathObj, pObj1); 1430 1431 if(pPath) 1432 { 1433 if(ImpCanDismantle(pPath->GetPathPoly(), bMakeLines)) 1434 { 1435 bMin1PolyPoly = sal_True; 1436 } 1437 1438 SdrObjTransformInfoRec aInfo; 1439 pObj1->TakeObjInfo(aInfo); 1440 1441 if(!aInfo.bCanConvToPath) 1442 { 1443 // Passiert z.B. im Falle Fontwork (Joe, 28-11-95) 1444 bOtherObjs = sal_True; 1445 } 1446 } 1447 else 1448 { 1449 bOtherObjs = sal_True; 1450 } 1451 } 1452 } 1453 else 1454 { 1455 const SdrPathObj* pPath = PTR_CAST(SdrPathObj, pObj); 1456 const SdrObjCustomShape* pCustomShape = PTR_CAST(SdrObjCustomShape, pObj); 1457 1458 // #i37011# 1459 if(pPath) 1460 { 1461 if(ImpCanDismantle(pPath->GetPathPoly(),bMakeLines)) 1462 { 1463 bMin1PolyPoly = sal_True; 1464 } 1465 1466 SdrObjTransformInfoRec aInfo; 1467 pObj->TakeObjInfo(aInfo); 1468 1469 // #69711 : new condition IsLine() to be able to break simple Lines 1470 if(!(aInfo.bCanConvToPath || aInfo.bCanConvToPoly) && !pPath->IsLine()) 1471 { 1472 // Passiert z.B. im Falle Fontwork (Joe, 28-11-95) 1473 bOtherObjs = sal_True; 1474 } 1475 } 1476 else if(pCustomShape) 1477 { 1478 if(bMakeLines) 1479 { 1480 // allow break command 1481 bMin1PolyPoly = sal_True; 1482 } 1483 } 1484 else 1485 { 1486 bOtherObjs = sal_True; 1487 } 1488 } 1489 return bMin1PolyPoly && !bOtherObjs; 1490 } 1491 1492 void SdrEditView::ImpDismantleOneObject(const SdrObject* pObj, SdrObjList& rOL, sal_uIntPtr& rPos, SdrPageView* pPV, sal_Bool bMakeLines) 1493 { 1494 const SdrPathObj* pSrcPath = PTR_CAST(SdrPathObj, pObj); 1495 const SdrObjCustomShape* pCustomShape = PTR_CAST(SdrObjCustomShape, pObj); 1496 1497 const bool bUndo = IsUndoEnabled(); 1498 1499 if(pSrcPath) 1500 { 1501 // #i74631# redesigned due to XpolyPolygon removal and explicit constructors 1502 SdrObject* pLast = 0; // fuer die Zuweisung des OutlinerParaObject 1503 const basegfx::B2DPolyPolygon& rPolyPolygon(pSrcPath->GetPathPoly()); 1504 const sal_uInt32 nPolyCount(rPolyPolygon.count()); 1505 1506 for(sal_uInt32 a(0); a < nPolyCount; a++) 1507 { 1508 const basegfx::B2DPolygon& rCandidate(rPolyPolygon.getB2DPolygon(a)); 1509 const sal_uInt32 nPointCount(rCandidate.count()); 1510 1511 if(!bMakeLines || nPointCount < 2) 1512 { 1513 SdrPathObj* pPath = new SdrPathObj((SdrObjKind)pSrcPath->GetObjIdentifier(), basegfx::B2DPolyPolygon(rCandidate)); 1514 ImpCopyAttributes(pSrcPath, pPath); 1515 pLast = pPath; 1516 SdrInsertReason aReason(SDRREASON_VIEWCALL, pSrcPath); 1517 rOL.InsertObject(pPath, rPos, &aReason); 1518 if( bUndo ) 1519 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoNewObject(*pPath, sal_True)); 1520 MarkObj(pPath, pPV, sal_False, sal_True); 1521 rPos++; 1522 } 1523 else 1524 { 1525 const sal_uInt32 nLoopCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1); 1526 1527 for(sal_uInt32 b(0); b < nLoopCount; b++) 1528 { 1529 SdrObjKind eKind(OBJ_PLIN); 1530 basegfx::B2DPolygon aNewPolygon; 1531 const sal_uInt32 nNextIndex((b + 1) % nPointCount); 1532 1533 aNewPolygon.append(rCandidate.getB2DPoint(b)); 1534 1535 if(rCandidate.areControlPointsUsed()) 1536 { 1537 aNewPolygon.appendBezierSegment( 1538 rCandidate.getNextControlPoint(b), 1539 rCandidate.getPrevControlPoint(nNextIndex), 1540 rCandidate.getB2DPoint(nNextIndex)); 1541 eKind = OBJ_PATHLINE; 1542 } 1543 else 1544 { 1545 aNewPolygon.append(rCandidate.getB2DPoint(nNextIndex)); 1546 } 1547 1548 SdrPathObj* pPath = new SdrPathObj(eKind, basegfx::B2DPolyPolygon(aNewPolygon)); 1549 ImpCopyAttributes(pSrcPath, pPath); 1550 pLast = pPath; 1551 SdrInsertReason aReason(SDRREASON_VIEWCALL, pSrcPath); 1552 rOL.InsertObject(pPath, rPos, &aReason); 1553 if( bUndo ) 1554 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoNewObject(*pPath, sal_True)); 1555 MarkObj(pPath, pPV, sal_False, sal_True); 1556 rPos++; 1557 } 1558 } 1559 } 1560 1561 if(pLast && pSrcPath->GetOutlinerParaObject()) 1562 { 1563 pLast->SetOutlinerParaObject(new OutlinerParaObject(*pSrcPath->GetOutlinerParaObject())); 1564 } 1565 } 1566 else if(pCustomShape) 1567 { 1568 if(bMakeLines) 1569 { 1570 // break up custom shape 1571 const SdrObject* pReplacement = pCustomShape->GetSdrObjectFromCustomShape(); 1572 1573 if(pReplacement) 1574 { 1575 SdrObject* pCandidate = pReplacement->Clone(); 1576 DBG_ASSERT(pCandidate, "SdrEditView::ImpDismantleOneObject: Could not clone SdrObject (!)"); 1577 pCandidate->SetModel(pCustomShape->GetModel()); 1578 1579 if(((SdrShadowItem&)pCustomShape->GetMergedItem(SDRATTR_SHADOW)).GetValue()) 1580 { 1581 if(pReplacement->ISA(SdrObjGroup)) 1582 { 1583 pCandidate->SetMergedItem(SdrShadowItem(sal_True)); 1584 } 1585 } 1586 1587 SdrInsertReason aReason(SDRREASON_VIEWCALL, pCustomShape); 1588 rOL.InsertObject(pCandidate, rPos, &aReason); 1589 if( bUndo ) 1590 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoNewObject(*pCandidate, true)); 1591 MarkObj(pCandidate, pPV, sal_False, sal_True); 1592 1593 if(pCustomShape->HasText() && !pCustomShape->IsTextPath()) 1594 { 1595 // #i37011# also create a text object and add at rPos + 1 1596 SdrTextObj* pTextObj = (SdrTextObj*)SdrObjFactory::MakeNewObject( 1597 pCustomShape->GetObjInventor(), OBJ_TEXT, 0L, pCustomShape->GetModel()); 1598 1599 // Copy text content 1600 OutlinerParaObject* pParaObj = pCustomShape->GetOutlinerParaObject(); 1601 if(pParaObj) 1602 { 1603 pTextObj->NbcSetOutlinerParaObject(new OutlinerParaObject(*pParaObj)); 1604 } 1605 1606 // copy all attributes 1607 SfxItemSet aTargetItemSet(pCustomShape->GetMergedItemSet()); 1608 1609 // clear fill and line style 1610 aTargetItemSet.Put(XLineStyleItem(XLINE_NONE)); 1611 aTargetItemSet.Put(XFillStyleItem(XFILL_NONE)); 1612 1613 // get the text bounds and set at text object 1614 Rectangle aTextBounds = pCustomShape->GetSnapRect(); 1615 if(pCustomShape->GetTextBounds(aTextBounds)) 1616 { 1617 pTextObj->SetSnapRect(aTextBounds); 1618 } 1619 1620 // if rotated, copy GeoStat, too. 1621 const GeoStat& rSourceGeo = pCustomShape->GetGeoStat(); 1622 if(rSourceGeo.nDrehWink) 1623 { 1624 pTextObj->NbcRotate( 1625 pCustomShape->GetSnapRect().Center(), rSourceGeo.nDrehWink, 1626 rSourceGeo.nSin, rSourceGeo.nCos); 1627 } 1628 1629 // set modified ItemSet at text object 1630 pTextObj->SetMergedItemSet(aTargetItemSet); 1631 1632 // insert object 1633 rOL.InsertObject(pTextObj, rPos + 1, &aReason); 1634 if( bUndo ) 1635 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoNewObject(*pTextObj, true)); 1636 MarkObj(pTextObj, pPV, sal_False, sal_True); 1637 } 1638 } 1639 } 1640 } 1641 } 1642 1643 void SdrEditView::DismantleMarkedObjects(sal_Bool bMakeLines) 1644 { 1645 //sal_uInt32 nCnt(0); 1646 // Temporaere Marklist 1647 SdrMarkList aRemoveMerker; 1648 1649 SortMarkedObjects(); 1650 1651 const bool bUndo = IsUndoEnabled(); 1652 1653 if( bUndo ) 1654 { 1655 // Der Comment wird spaeter zusammengebaut 1656 BegUndo(String(), String(), 1657 bMakeLines ? SDRREPFUNC_OBJ_DISMANTLE_LINES : SDRREPFUNC_OBJ_DISMANTLE_POLYS); 1658 } 1659 1660 sal_uIntPtr nm; 1661 sal_uIntPtr nAnz=GetMarkedObjectCount(); 1662 SdrObjList* pOL0=NULL; 1663 for (nm=nAnz; nm>0;) { 1664 nm--; 1665 SdrMark* pM=GetSdrMarkByIndex(nm); 1666 SdrObject* pObj=pM->GetMarkedSdrObj(); 1667 SdrPageView* pPV=pM->GetPageView(); 1668 SdrObjList* pOL=pObj->GetObjList(); 1669 if (pOL!=pOL0) { pOL0=pOL; pObj->GetOrdNum(); } // sicherstellen, dass OrdNums stimmen! 1670 if (ImpCanDismantle(pObj,bMakeLines)) { 1671 aRemoveMerker.InsertEntry(SdrMark(pObj,pM->GetPageView())); 1672 sal_uIntPtr nPos0=pObj->GetOrdNumDirect(); 1673 sal_uIntPtr nPos=nPos0+1; 1674 SdrObjList* pSubList=pObj->GetSubList(); 1675 if (pSubList!=NULL && !pObj->Is3DObj()) { 1676 SdrObjListIter aIter(*pSubList,IM_DEEPNOGROUPS); 1677 while (aIter.IsMore()) { 1678 const SdrObject* pObj1=aIter.Next(); 1679 ImpDismantleOneObject(pObj1,*pOL,nPos,pPV,bMakeLines); 1680 } 1681 } else { 1682 ImpDismantleOneObject(pObj,*pOL,nPos,pPV,bMakeLines); 1683 } 1684 if( bUndo ) 1685 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pObj,sal_True)); 1686 pOL->RemoveObject(nPos0); 1687 1688 if( !bUndo ) 1689 SdrObject::Free(pObj); 1690 } 1691 } 1692 1693 if( bUndo ) 1694 { 1695 // UndoComment aus den tatsaechlich verwendeten Objekten zusammenbauen 1696 SetUndoComment(ImpGetResStr(bMakeLines?STR_EditDismantle_Lines:STR_EditDismantle_Polys),aRemoveMerker.GetMarkDescription()); 1697 // die tatsaechlich verwendeten Objekten aus der Liste entfernen 1698 EndUndo(); 1699 } 1700 } 1701 1702 //////////////////////////////////////////////////////////////////////////////////////////////////// 1703 // 1704 // #### #### ### # # #### 1705 // # # # # # # # # # 1706 // # ## #### # # # # #### 1707 // # # # # # # # # # 1708 // #### # # ### ### # 1709 // 1710 //////////////////////////////////////////////////////////////////////////////////////////////////// 1711 1712 void SdrEditView::GroupMarked(const SdrObject* pUserGrp) 1713 { 1714 if (AreObjectsMarked()) 1715 { 1716 SortMarkedObjects(); 1717 1718 const bool bUndo = IsUndoEnabled(); 1719 if( bUndo ) 1720 { 1721 BegUndo(ImpGetResStr(STR_EditGroup),GetDescriptionOfMarkedObjects(),SDRREPFUNC_OBJ_GROUP); 1722 1723 const sal_uIntPtr nAnz = GetMarkedObjectCount(); 1724 for(sal_uIntPtr nm = nAnz; nm>0; ) 1725 { 1726 // UndoActions fuer alle betroffenen Objekte anlegen 1727 nm--; 1728 SdrMark* pM=GetSdrMarkByIndex(nm); 1729 SdrObject* pObj = pM->GetMarkedSdrObj(); 1730 std::vector< SdrUndoAction* > vConnectorUndoActions( CreateConnectorUndo( *pObj ) ); 1731 AddUndoActions( vConnectorUndoActions ); 1732 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoRemoveObject( *pObj )); 1733 } 1734 } 1735 1736 SdrMarkList aNewMark; 1737 SdrPageView* pPV = GetSdrPageView(); 1738 1739 if(pPV) 1740 { 1741 SdrObjList* pAktLst=pPV->GetObjList(); 1742 SdrObjList* pSrcLst=pAktLst; 1743 SdrObjList* pSrcLst0=pSrcLst; 1744 SdrPage* pPage=pPV->GetPage(); 1745 // sicherstellen, dass die OrdNums stimmen 1746 if (pSrcLst->IsObjOrdNumsDirty()) 1747 pSrcLst->RecalcObjOrdNums(); 1748 SdrObject* pGrp=NULL; 1749 SdrObject* pRefObj=NULL; // Referenz fuer InsertReason (-> rumankern im Writer) 1750 SdrObject* pRefObj1=NULL; // Referenz fuer InsertReason (-> rumankern im Writer) 1751 SdrObjList* pDstLst=NULL; 1752 // Falls alle markierten Objekte aus Fremden Obj-Listen 1753 // kommen, kommt das Gruppenobjekt an das Ende der Liste. 1754 sal_uIntPtr nInsPos=pSrcLst->GetObjCount(); 1755 sal_Bool bNeedInsPos=sal_True; 1756 for (sal_uIntPtr nm=GetMarkedObjectCount(); nm>0;) 1757 { 1758 nm--; 1759 SdrMark* pM=GetSdrMarkByIndex(nm); 1760 if (pM->GetPageView()==pPV) 1761 { 1762 if (pGrp==NULL) 1763 { 1764 if (pUserGrp!=NULL) 1765 pGrp=pUserGrp->Clone(); 1766 if (pGrp==NULL) 1767 pGrp=new SdrObjGroup; 1768 pDstLst=pGrp->GetSubList(); 1769 DBG_ASSERT(pDstLst!=NULL,"Angebliches Gruppenobjekt liefert keine Objektliste"); 1770 } 1771 SdrObject* pObj=pM->GetMarkedSdrObj(); 1772 pSrcLst=pObj->GetObjList(); 1773 if (pSrcLst!=pSrcLst0) 1774 { 1775 if (pSrcLst->IsObjOrdNumsDirty()) 1776 pSrcLst->RecalcObjOrdNums(); 1777 } 1778 sal_Bool bForeignList=pSrcLst!=pAktLst; 1779 sal_Bool bGrouped=pSrcLst!=pPage; 1780 if (!bForeignList && bNeedInsPos) 1781 { 1782 nInsPos=pObj->GetOrdNum(); // ua, damit sind alle ObjOrdNum der Page gesetzt 1783 nInsPos++; 1784 bNeedInsPos=sal_False; 1785 } 1786 pSrcLst->RemoveObject(pObj->GetOrdNumDirect()); 1787 if (!bForeignList) 1788 nInsPos--; // InsertPos korregieren 1789 SdrInsertReason aReason(SDRREASON_VIEWCALL); 1790 pDstLst->InsertObject(pObj,0,&aReason); 1791 GetMarkedObjectListWriteAccess().DeleteMark(nm); 1792 if (pRefObj1==NULL) 1793 pRefObj1=pObj; // Das oberste sichtbare Objekt 1794 if (!bGrouped) 1795 { 1796 if (pRefObj==NULL) 1797 pRefObj=pObj; // Das oberste sichtbare nicht gruppierte Objekt 1798 } 1799 pSrcLst0=pSrcLst; 1800 } 1801 } 1802 if (pRefObj==NULL) 1803 pRefObj=pRefObj1; 1804 if (pGrp!=NULL) 1805 { 1806 aNewMark.InsertEntry(SdrMark(pGrp,pPV)); 1807 sal_uIntPtr nAnz=pDstLst->GetObjCount(); 1808 SdrInsertReason aReason(SDRREASON_VIEWCALL,pRefObj); 1809 pAktLst->InsertObject(pGrp,nInsPos,&aReason); 1810 if( bUndo ) 1811 { 1812 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoNewObject(*pGrp,true)); // Kein Recalc! 1813 for (sal_uIntPtr no=0; no<nAnz; no++) 1814 { 1815 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoInsertObject(*pDstLst->GetObj(no))); 1816 } 1817 } 1818 } 1819 } 1820 GetMarkedObjectListWriteAccess().Merge(aNewMark); 1821 MarkListHasChanged(); 1822 1823 if( bUndo ) 1824 EndUndo(); 1825 } 1826 } 1827 1828 //////////////////////////////////////////////////////////////////////////////////////////////////// 1829 // 1830 // # # # # #### #### ### # # #### 1831 // # # ## # # # # # # # # # # 1832 // # # # # # # ## #### # # # # #### 1833 // # # # ## # # # # # # # # # 1834 // ### # # #### # # ### ### # 1835 // 1836 //////////////////////////////////////////////////////////////////////////////////////////////////// 1837 1838 void SdrEditView::UnGroupMarked() 1839 { 1840 SdrMarkList aNewMark; 1841 1842 const bool bUndo = IsUndoEnabled(); 1843 if( bUndo ) 1844 BegUndo(String(), String(), SDRREPFUNC_OBJ_UNGROUP); 1845 1846 sal_uIntPtr nCount=0; 1847 XubString aName1; 1848 XubString aName; 1849 sal_Bool bNameOk=sal_False; 1850 for (sal_uIntPtr nm=GetMarkedObjectCount(); nm>0;) { 1851 nm--; 1852 SdrMark* pM=GetSdrMarkByIndex(nm); 1853 SdrObject* pGrp=pM->GetMarkedSdrObj(); 1854 SdrObjList* pSrcLst=pGrp->GetSubList(); 1855 if (pSrcLst!=NULL) { 1856 nCount++; 1857 if (nCount==1) { 1858 pGrp->TakeObjNameSingul(aName); // Bezeichnung der Gruppe holen 1859 pGrp->TakeObjNamePlural(aName1); // Bezeichnung der Gruppe holen 1860 bNameOk=sal_True; 1861 } else { 1862 if (nCount==2) aName=aName1; // Pluralname setzen 1863 if (bNameOk) { 1864 XubString aStr; 1865 pGrp->TakeObjNamePlural(aStr); // Bezeichnung der Gruppe holen 1866 1867 if(!aStr.Equals(aName)) 1868 bNameOk = sal_False; 1869 } 1870 } 1871 sal_uIntPtr nDstCnt=pGrp->GetOrdNum(); 1872 SdrObjList* pDstLst=pM->GetPageView()->GetObjList(); 1873 1874 // FIRST move contained objects to parent of group, so that 1875 // the contained objects are NOT migrated to the UNDO-ItemPool 1876 // when AddUndo(new SdrUndoDelObj(*pGrp)) is called. 1877 sal_uIntPtr nAnz=pSrcLst->GetObjCount(); 1878 sal_uIntPtr no; 1879 1880 if( bUndo ) 1881 { 1882 for (no=nAnz; no>0;) 1883 { 1884 no--; 1885 SdrObject* pObj=pSrcLst->GetObj(no); 1886 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoRemoveObject(*pObj)); 1887 } 1888 } 1889 for (no=0; no<nAnz; no++) 1890 { 1891 SdrObject* pObj=pSrcLst->RemoveObject(0); 1892 SdrInsertReason aReason(SDRREASON_VIEWCALL,pGrp); 1893 pDstLst->InsertObject(pObj,nDstCnt,&aReason); 1894 if( bUndo ) 1895 AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoInsertObject(*pObj,true)); 1896 nDstCnt++; 1897 // Kein SortCheck beim einfuegen in die MarkList, denn das 1898 // wuerde wg. pObj->GetOrdNum() jedesmal ein RecalcOrdNums() 1899 // provozieren: 1900 aNewMark.InsertEntry(SdrMark(pObj,pM->GetPageView()),sal_False); 1901 } 1902 1903 if( bUndo ) 1904 { 1905 // Now it is safe to add the delete-UNDO which trigers the 1906 // MigrateItemPool now only for itself, not for the subobjects. 1907 // nDstCnt is right, because previous inserts move group 1908 // object deeper and increase nDstCnt. 1909 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pGrp)); 1910 } 1911 pDstLst->RemoveObject(nDstCnt); 1912 1913 if( !bUndo ) 1914 SdrObject::Free(pGrp); 1915 1916 GetMarkedObjectListWriteAccess().DeleteMark(nm); 1917 } 1918 } 1919 if (nCount!=0) 1920 { 1921 if (!bNameOk) 1922 aName=ImpGetResStr(STR_ObjNamePluralGRUP); // Oberbegriff Gruppenobjekte verwenden, wenn verschiedene Objekte. 1923 SetUndoComment(ImpGetResStr(STR_EditUngroup),aName); 1924 } 1925 1926 if( bUndo ) 1927 EndUndo(); 1928 1929 if (nCount!=0) 1930 { 1931 GetMarkedObjectListWriteAccess().Merge(aNewMark,sal_True); // Durch das obige Einsortieren ist aNewMark genau verkehrtherum 1932 MarkListHasChanged(); 1933 } 1934 } 1935 1936 //////////////////////////////////////////////////////////////////////////////////////////////////// 1937 // 1938 // ### ### # # # # ##### #### ##### ##### ### #### ### # # # 1939 // # # # # ## # # # # # # # # # # # # # # # # # 1940 // # # # # # # # # #### #### # # # # #### # # # # 1941 // # # # # # ## # # # # # # # # # # # # # # 1942 // ### ### # # # ##### # # # # ### # ### #### # 1943 // 1944 //////////////////////////////////////////////////////////////////////////////////////////////////// 1945 1946 SdrObject* SdrEditView::ImpConvertOneObj(SdrObject* pObj, sal_Bool bPath, sal_Bool bLineToArea) 1947 { 1948 SdrObject* pNewObj = pObj->ConvertToPolyObj(bPath, bLineToArea); 1949 if (pNewObj!=NULL) 1950 { 1951 SdrObjList* pOL=pObj->GetObjList(); 1952 DBG_ASSERT(pOL!=NULL,"ConvertTo: Obj liefert keine ObjList"); 1953 if (pOL!=NULL) 1954 { 1955 const bool bUndo = IsUndoEnabled(); 1956 if( bUndo ) 1957 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoReplaceObject(*pObj,*pNewObj)); 1958 1959 pOL->ReplaceObject(pNewObj,pObj->GetOrdNum()); 1960 1961 if( !bUndo ) 1962 SdrObject::Free(pObj); 1963 } 1964 } 1965 return pNewObj; 1966 } 1967 1968 void SdrEditView::ImpConvertTo(sal_Bool bPath, sal_Bool bLineToArea) 1969 { 1970 sal_Bool bMrkChg=sal_False; 1971 sal_Bool bModChg=sal_False; 1972 if (AreObjectsMarked()) { 1973 sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); 1974 sal_uInt16 nDscrID=0; 1975 if(bLineToArea) 1976 { 1977 if(nMarkAnz == 1) 1978 nDscrID = STR_EditConvToContour; 1979 else 1980 nDscrID = STR_EditConvToContours; 1981 1982 BegUndo(ImpGetResStr(nDscrID), GetDescriptionOfMarkedObjects()); 1983 } 1984 else 1985 { 1986 if (bPath) { 1987 if (nMarkAnz==1) nDscrID=STR_EditConvToCurve; 1988 else nDscrID=STR_EditConvToCurves; 1989 BegUndo(ImpGetResStr(nDscrID),GetDescriptionOfMarkedObjects(),SDRREPFUNC_OBJ_CONVERTTOPATH); 1990 } else { 1991 if (nMarkAnz==1) nDscrID=STR_EditConvToPoly; 1992 else nDscrID=STR_EditConvToPolys; 1993 BegUndo(ImpGetResStr(nDscrID),GetDescriptionOfMarkedObjects(),SDRREPFUNC_OBJ_CONVERTTOPOLY); 1994 } 1995 } 1996 for (sal_uIntPtr nm=nMarkAnz; nm>0;) { 1997 nm--; 1998 SdrMark* pM=GetSdrMarkByIndex(nm); 1999 SdrObject* pObj=pM->GetMarkedSdrObj(); 2000 SdrPageView* pPV=pM->GetPageView(); 2001 if (pObj->IsGroupObject() && !pObj->Is3DObj()) { 2002 SdrObject* pGrp=pObj; 2003 SdrObjListIter aIter(*pGrp,IM_DEEPNOGROUPS); 2004 while (aIter.IsMore()) { 2005 pObj=aIter.Next(); 2006 if (ImpConvertOneObj(pObj,bPath,bLineToArea)) bModChg=sal_True; 2007 } 2008 } else { 2009 SdrObject* pNewObj=ImpConvertOneObj(pObj,bPath,bLineToArea); 2010 if (pNewObj!=NULL) { 2011 bModChg=sal_True; 2012 bMrkChg=sal_True; 2013 GetMarkedObjectListWriteAccess().ReplaceMark(SdrMark(pNewObj,pPV),nm); 2014 } 2015 } 2016 } 2017 EndUndo(); 2018 if (bMrkChg) AdjustMarkHdl(); 2019 if (bMrkChg) MarkListHasChanged(); 2020 } 2021 } 2022 2023 void SdrEditView::ConvertMarkedToPathObj(sal_Bool bLineToArea) 2024 { 2025 ImpConvertTo(sal_True, bLineToArea); 2026 } 2027 2028 void SdrEditView::ConvertMarkedToPolyObj(sal_Bool bLineToArea) 2029 { 2030 ImpConvertTo(sal_False, bLineToArea); 2031 } 2032 2033 //////////////////////////////////////////////////////////////////////////////////////////////////// 2034 // 2035 // # # ##### ##### ### ##### # # ##### # # # #### ### #### ##### 2036 // ## ## # # # # # # # # # ## ## # # # # # # # 2037 // # # # #### # ##### ### # # #### ### # # # # #### # # #### # 2038 // # # # # # # # # # # # # # # # # # # # 2039 // # # ##### # # # # # #### ##### # # # # ### # # # 2040 // 2041 //////////////////////////////////////////////////////////////////////////////////////////////////// 2042 2043 void SdrEditView::DoImportMarkedMtf(SvdProgressInfo *pProgrInfo) 2044 { 2045 const bool bUndo = IsUndoEnabled(); 2046 2047 if( bUndo ) 2048 BegUndo(String(), String(), SDRREPFUNC_OBJ_IMPORTMTF); 2049 2050 SortMarkedObjects(); 2051 SdrMarkList aForTheDescription; 2052 SdrMarkList aNewMarked; 2053 sal_uIntPtr nAnz=GetMarkedObjectCount(); 2054 2055 for (sal_uIntPtr nm=nAnz; nm>0;) 2056 { // Undo Objekte fuer alle neuen Objekte erzeugen 2057 // zwischen den Metafiles auf Abbruch testen 2058 if( pProgrInfo != NULL ) 2059 { 2060 pProgrInfo->SetNextObject(); 2061 if(!pProgrInfo->ReportActions(0)) 2062 break; 2063 } 2064 2065 nm--; 2066 SdrMark* pM=GetSdrMarkByIndex(nm); 2067 SdrObject* pObj=pM->GetMarkedSdrObj(); 2068 SdrPageView* pPV=pM->GetPageView(); 2069 SdrObjList* pOL=pObj->GetObjList(); 2070 sal_uIntPtr nInsPos=pObj->GetOrdNum()+1; 2071 SdrGrafObj* pGraf=PTR_CAST(SdrGrafObj,pObj); 2072 SdrOle2Obj* pOle2=PTR_CAST(SdrOle2Obj,pObj); 2073 sal_uIntPtr nInsAnz=0; 2074 Rectangle aLogicRect; 2075 2076 if(pGraf && (pGraf->HasGDIMetaFile() || pGraf->isEmbeddedSvg())) 2077 { 2078 GDIMetaFile aMetaFile; 2079 2080 if(pGraf->HasGDIMetaFile()) 2081 { 2082 aMetaFile = pGraf->GetTransformedGraphic( 2083 SDRGRAFOBJ_TRANSFORMATTR_COLOR|SDRGRAFOBJ_TRANSFORMATTR_MIRROR).GetGDIMetaFile(); 2084 } 2085 else if(pGraf->isEmbeddedSvg()) 2086 { 2087 aMetaFile = pGraf->getMetafileFromEmbeddedSvg(); 2088 } 2089 2090 if(aMetaFile.GetActionCount()) 2091 { 2092 ImpSdrGDIMetaFileImport aFilter(*pMod); 2093 2094 aLogicRect = pGraf->GetLogicRect(); 2095 aFilter.SetScaleRect(aLogicRect); 2096 aFilter.SetLayer(pObj->GetLayer()); 2097 2098 nInsAnz = aFilter.DoImport(aMetaFile, *pOL, nInsPos, pProgrInfo); 2099 } 2100 } 2101 if ( pOle2!=NULL && pOle2->GetGraphic() ) 2102 { 2103 //const GDIMetaFile* pMtf=pOle2->GetGDIMetaFile(); 2104 ImpSdrGDIMetaFileImport aFilter(*pMod); 2105 2106 aLogicRect = pOle2->GetLogicRect(); 2107 aFilter.SetScaleRect(aLogicRect); 2108 aFilter.SetLayer(pObj->GetLayer()); 2109 2110 nInsAnz=aFilter.DoImport(pOle2->GetGraphic()->GetGDIMetaFile(),*pOL,nInsPos,pProgrInfo); 2111 } 2112 if (nInsAnz!=0) 2113 { 2114 // transformation 2115 GeoStat aGeoStat(pGraf ? pGraf->GetGeoStat() : pOle2->GetGeoStat()); 2116 sal_uIntPtr nObj=nInsPos; 2117 2118 if(aGeoStat.nShearWink) 2119 { 2120 aGeoStat.RecalcTan(); 2121 } 2122 2123 if(aGeoStat.nDrehWink) 2124 { 2125 aGeoStat.RecalcSinCos(); 2126 } 2127 2128 for (sal_uIntPtr i=0; i<nInsAnz; i++) 2129 { 2130 if( bUndo ) 2131 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoNewObject(*pOL->GetObj(nObj))); 2132 2133 // Neue MarkList pflegen 2134 SdrObject* pCandidate = pOL->GetObj(nObj); 2135 2136 // apply original transformation 2137 if(aGeoStat.nShearWink) 2138 { 2139 pCandidate->NbcShear(aLogicRect.TopLeft(), aGeoStat.nShearWink, aGeoStat.nTan, false); 2140 } 2141 2142 if(aGeoStat.nDrehWink) 2143 { 2144 pCandidate->NbcRotate(aLogicRect.TopLeft(), aGeoStat.nDrehWink, aGeoStat.nSin, aGeoStat.nCos); 2145 } 2146 2147 SdrMark aNewMark(pCandidate, pPV); 2148 aNewMarked.InsertEntry(aNewMark); 2149 2150 nObj++; 2151 } 2152 aForTheDescription.InsertEntry(*pM); 2153 2154 if( bUndo ) 2155 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pObj)); 2156 2157 // Objekt aus selektion loesen und loeschen 2158 GetMarkedObjectListWriteAccess().DeleteMark(TryToFindMarkedObject(pObj)); 2159 pOL->RemoveObject(nInsPos-1); 2160 2161 if( !bUndo ) 2162 SdrObject::Free(pObj); 2163 } 2164 } 2165 2166 // MarkObj... fehlt... jetzt nicht mehr (AW) 2167 if(aNewMarked.GetMarkCount()) 2168 { 2169 // Neue Selektion bilden 2170 for(sal_uIntPtr a(0); a < aNewMarked.GetMarkCount(); a++) 2171 { 2172 GetMarkedObjectListWriteAccess().InsertEntry(*aNewMarked.GetMark(a)); 2173 } 2174 2175 SortMarkedObjects(); 2176 } 2177 2178 if( bUndo ) 2179 { 2180 SetUndoComment(ImpGetResStr(STR_EditImportMtf),aForTheDescription.GetMarkDescription()); 2181 EndUndo(); 2182 } 2183 } 2184 2185