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 // MARKER(update_precomp.py): autogen include statement, do not remove 23 #include "precompiled_svx.hxx" 24 25 #include <com/sun/star/i18n/WordType.hpp> 26 #include <svtools/accessibilityoptions.hxx> 27 #include <svx/svdedxv.hxx> 28 #include <svl/solar.hrc> 29 #include <svl/itemiter.hxx> 30 #include <vcl/msgbox.hxx> 31 #include <vcl/hatch.hxx> 32 #include <svl/whiter.hxx> 33 #include <svl/style.hxx> 34 #include <editeng/editstat.hxx> 35 #include <tools/config.hxx> 36 #include <vcl/cursor.hxx> 37 #include <editeng/unotext.hxx> 38 #include <editeng/editeng.hxx> 39 #include <editeng/editobj.hxx> 40 #include <editeng/outlobj.hxx> 41 #include <editeng/scripttypeitem.hxx> 42 #include "svx/svditext.hxx" 43 #include <svx/svdoutl.hxx> 44 #include <svx/sdtfchim.hxx> 45 #include <svx/svdotext.hxx> 46 #include <svx/svdundo.hxx> 47 #include "svx/svditer.hxx" 48 #include "svx/svdpagv.hxx" 49 #include "svx/svdpage.hxx" 50 #include "svx/svdetc.hxx" 51 #include "svx/svdotable.hxx" 52 #include <svx/selectioncontroller.hxx> 53 #ifdef DBG_UTIL 54 #include <svdibrow.hxx> 55 #endif 56 #include <svx/svdoutl.hxx> 57 #include <svx/svddrgv.hxx> 58 #include "svx/svdstr.hrc" 59 #include "svx/svdglob.hxx" 60 #include "svx/globl3d.hxx" 61 #include <editeng/outliner.hxx> 62 #include <editeng/adjitem.hxx> 63 #include <svtools/colorcfg.hxx> 64 #include <vcl/svapp.hxx> 65 #include <svx/sdrpaintwindow.hxx> 66 #include <svx/sdrundomanager.hxx> 67 #include <svx/sdr/overlay/overlaytools.hxx> 68 #include <drawinglayer/processor2d/processor2dtools.hxx> 69 70 //////////////////////////////////////////////////////////////////////////////////////////////////// 71 72 void SdrObjEditView::ImpClearVars() 73 { 74 bQuickTextEditMode=sal_True; 75 bMacroMode=sal_True; 76 pTextEditOutliner=NULL; 77 pTextEditOutlinerView=NULL; 78 pTextEditPV=NULL; 79 pTextEditWin=NULL; 80 pTextEditCursorMerker=NULL; 81 pEditPara=NULL; 82 bTextEditNewObj=sal_False; 83 bMacroDown=sal_False; 84 pMacroObj=NULL; 85 pMacroPV=NULL; 86 pMacroWin=NULL; 87 nMacroTol=0; 88 bTextEditDontDelete=sal_False; 89 bTextEditOnlyOneView=sal_False; 90 } 91 92 SdrObjEditView::SdrObjEditView(SdrModel* pModel1, OutputDevice* pOut): 93 SdrGlueEditView(pModel1,pOut), 94 mpOldTextEditUndoManager(0) 95 { 96 ImpClearVars(); 97 } 98 99 SdrObjEditView::~SdrObjEditView() 100 { 101 pTextEditWin = NULL; // Damit es in SdrEndTextEdit kein ShowCursor gibt 102 if (IsTextEdit()) SdrEndTextEdit(); 103 if (pTextEditOutliner!=NULL) { 104 delete pTextEditOutliner; 105 } 106 107 if(mpOldTextEditUndoManager) 108 { 109 delete mpOldTextEditUndoManager; 110 } 111 } 112 113 //////////////////////////////////////////////////////////////////////////////////////////////////// 114 115 sal_Bool SdrObjEditView::IsAction() const 116 { 117 return IsMacroObj() || SdrGlueEditView::IsAction(); 118 } 119 120 void SdrObjEditView::MovAction(const Point& rPnt) 121 { 122 if (IsMacroObj()) MovMacroObj(rPnt); 123 SdrGlueEditView::MovAction(rPnt); 124 } 125 126 void SdrObjEditView::EndAction() 127 { 128 if (IsMacroObj()) EndMacroObj(); 129 SdrGlueEditView::EndAction(); 130 } 131 132 void SdrObjEditView::BckAction() 133 { 134 BrkMacroObj(); 135 SdrGlueEditView::BckAction(); 136 } 137 138 void SdrObjEditView::BrkAction() 139 { 140 BrkMacroObj(); 141 SdrGlueEditView::BrkAction(); 142 } 143 144 void SdrObjEditView::TakeActionRect(Rectangle& rRect) const 145 { 146 if (IsMacroObj()) { 147 rRect=pMacroObj->GetCurrentBoundRect(); 148 } else { 149 SdrGlueEditView::TakeActionRect(rRect); 150 } 151 } 152 153 void __EXPORT SdrObjEditView::Notify(SfxBroadcaster& rBC, const SfxHint& rHint) 154 { 155 SdrGlueEditView::Notify(rBC,rHint); 156 // Printerwechsel waerend des Editierens 157 SdrHint* pSdrHint=PTR_CAST(SdrHint,&rHint); 158 if (pSdrHint!=NULL && pTextEditOutliner!=NULL) { 159 SdrHintKind eKind=pSdrHint->GetKind(); 160 if (eKind==HINT_REFDEVICECHG) { 161 pTextEditOutliner->SetRefDevice(pMod->GetRefDevice()); 162 } 163 if (eKind==HINT_DEFAULTTABCHG) { 164 pTextEditOutliner->SetDefTab(pMod->GetDefaultTabulator()); 165 } 166 if (eKind==HINT_DEFFONTHGTCHG) { 167 // ... 168 } 169 if (eKind==HINT_MODELSAVED) { // #43095# 170 pTextEditOutliner->ClearModifyFlag(); 171 } 172 } 173 } 174 175 void SdrObjEditView::ModelHasChanged() 176 { 177 SdrGlueEditView::ModelHasChanged(); 178 if (mxTextEditObj.is() && !mxTextEditObj->IsInserted()) SdrEndTextEdit(); // Objekt geloescht 179 // TextEditObj geaendert? 180 if (IsTextEdit()) { 181 SdrTextObj* pTextObj=dynamic_cast<SdrTextObj*>( mxTextEditObj.get() ); 182 if (pTextObj!=NULL) { 183 sal_uIntPtr nOutlViewAnz=pTextEditOutliner->GetViewCount(); 184 sal_Bool bAreaChg=sal_False; 185 sal_Bool bAnchorChg=sal_False; 186 sal_Bool bColorChg=sal_False; 187 bool bContourFrame=pTextObj->IsContourTextFrame(); 188 EVAnchorMode eNewAnchor(ANCHOR_VCENTER_HCENTER); 189 Rectangle aOldArea(aMinTextEditArea); 190 aOldArea.Union(aTextEditArea); 191 Color aNewColor; 192 { // Area Checken 193 Size aPaperMin1; 194 Size aPaperMax1; 195 Rectangle aEditArea1; 196 Rectangle aMinArea1; 197 pTextObj->TakeTextEditArea(&aPaperMin1,&aPaperMax1,&aEditArea1,&aMinArea1); 198 199 // #108784# 200 Point aPvOfs(pTextObj->GetTextEditOffset()); 201 202 aEditArea1.Move(aPvOfs.X(),aPvOfs.Y()); 203 aMinArea1.Move(aPvOfs.X(),aPvOfs.Y()); 204 Rectangle aNewArea(aMinArea1); 205 aNewArea.Union(aEditArea1); 206 207 if (aNewArea!=aOldArea || aEditArea1!=aTextEditArea || aMinArea1!=aMinTextEditArea || 208 pTextEditOutliner->GetMinAutoPaperSize()!=aPaperMin1 || pTextEditOutliner->GetMaxAutoPaperSize()!=aPaperMax1) { 209 aTextEditArea=aEditArea1; 210 aMinTextEditArea=aMinArea1; 211 pTextEditOutliner->SetUpdateMode(sal_False); 212 pTextEditOutliner->SetMinAutoPaperSize(aPaperMin1); 213 pTextEditOutliner->SetMaxAutoPaperSize(aPaperMax1); 214 pTextEditOutliner->SetPaperSize(Size(0,0)); // Damit der Outliner neu formatiert 215 if (!bContourFrame) { 216 pTextEditOutliner->ClearPolygon(); 217 sal_uIntPtr nStat=pTextEditOutliner->GetControlWord(); 218 nStat|=EE_CNTRL_AUTOPAGESIZE; 219 pTextEditOutliner->SetControlWord(nStat); 220 } else { 221 sal_uIntPtr nStat=pTextEditOutliner->GetControlWord(); 222 nStat&=~EE_CNTRL_AUTOPAGESIZE; 223 pTextEditOutliner->SetControlWord(nStat); 224 Rectangle aAnchorRect; 225 pTextObj->TakeTextAnchorRect(aAnchorRect); 226 pTextObj->ImpSetContourPolygon(*pTextEditOutliner,aAnchorRect, sal_True); 227 } 228 for (sal_uIntPtr nOV=0; nOV<nOutlViewAnz; nOV++) { 229 OutlinerView* pOLV=pTextEditOutliner->GetView(nOV); 230 sal_uIntPtr nStat0=pOLV->GetControlWord(); 231 sal_uIntPtr nStat=nStat0; 232 // AutoViewSize nur wenn nicht KontourFrame. 233 if (!bContourFrame) nStat|=EV_CNTRL_AUTOSIZE; 234 else nStat&=~EV_CNTRL_AUTOSIZE; 235 if (nStat!=nStat0) pOLV->SetControlWord(nStat); 236 } 237 pTextEditOutliner->SetUpdateMode(sal_True); 238 bAreaChg=sal_True; 239 } 240 } 241 if (pTextEditOutlinerView!=NULL) { // Fuellfarbe und Anker checken 242 EVAnchorMode eOldAnchor=pTextEditOutlinerView->GetAnchorMode(); 243 eNewAnchor=(EVAnchorMode)pTextObj->GetOutlinerViewAnchorMode(); 244 bAnchorChg=eOldAnchor!=eNewAnchor; 245 Color aOldColor(pTextEditOutlinerView->GetBackgroundColor()); 246 aNewColor = GetTextEditBackgroundColor(*this); 247 bColorChg=aOldColor!=aNewColor; 248 } 249 // #104082# refresh always when it's a contour frame. That 250 // refresh is necessary since it triggers the repaint 251 // which makes the Handles visible. Changes at TakeTextRect() 252 // seem to have resulted in a case where no refresh is executed. 253 // Before that, a refresh must have been always executed 254 // (else this error would have happend earlier), thus i 255 // even think here a refresh should be done always. 256 // Since follow-up problems cannot even be guessed I only 257 // add this one more case to the if below. 258 // BTW: It's VERY bad style that here, inside ModelHasChanged() 259 // the outliner is again massively changed for the text object 260 // in text edit mode. Normally, all necessary data should be 261 // set at SdrBeginTextEdit(). Some changes and value assigns in 262 // SdrBeginTextEdit() are completely useless since they are set here 263 // again on ModelHasChanged(). 264 if (bContourFrame || bAreaChg || bAnchorChg || bColorChg) 265 { 266 for (sal_uIntPtr nOV=0; nOV<nOutlViewAnz; nOV++) 267 { 268 OutlinerView* pOLV=pTextEditOutliner->GetView(nOV); 269 { // Alten OutlinerView-Bereich invalidieren 270 Window* pWin=pOLV->GetWindow(); 271 Rectangle aTmpRect(aOldArea); 272 sal_uInt16 nPixSiz=pOLV->GetInvalidateMore()+1; 273 Size aMore(pWin->PixelToLogic(Size(nPixSiz,nPixSiz))); 274 aTmpRect.Left()-=aMore.Width(); 275 aTmpRect.Right()+=aMore.Width(); 276 aTmpRect.Top()-=aMore.Height(); 277 aTmpRect.Bottom()+=aMore.Height(); 278 InvalidateOneWin(*pWin,aTmpRect); 279 } 280 if (bAnchorChg) 281 pOLV->SetAnchorMode(eNewAnchor); 282 if (bColorChg) 283 pOLV->SetBackgroundColor( aNewColor ); 284 285 pOLV->SetOutputArea(aTextEditArea); // weil sonst scheinbar nicht richtig umgeankert wird 286 ImpInvalidateOutlinerView(*pOLV); 287 } 288 pTextEditOutlinerView->ShowCursor(); 289 } 290 } 291 ImpMakeTextCursorAreaVisible(); 292 } 293 } 294 295 //////////////////////////////////////////////////////////////////////////////////////////////////// 296 // 297 // @@@@@@ @@@@@ @@ @@ @@@@@@ @@@@@ @@@@@ @@ @@@@@@ 298 // @@ @@ @@@ @@@ @@ @@ @@ @@ @@ @@ 299 // @@ @@ @@@@@ @@ @@ @@ @@ @@ @@ 300 // @@ @@@@ @@@ @@ @@@@ @@ @@ @@ @@ 301 // @@ @@ @@@@@ @@ @@ @@ @@ @@ @@ 302 // @@ @@ @@@ @@@ @@ @@ @@ @@ @@ @@ 303 // @@ @@@@@ @@ @@ @@ @@@@@ @@@@@ @@ @@ 304 // 305 //////////////////////////////////////////////////////////////////////////////////////////////////// 306 307 void SdrObjEditView::TextEditDrawing(SdrPaintWindow& rPaintWindow) const 308 { 309 // draw old text edit stuff 310 if(IsTextEdit()) 311 { 312 const SdrOutliner* pActiveOutliner = GetTextEditOutliner(); 313 314 if(pActiveOutliner) 315 { 316 const sal_uInt32 nViewAnz(pActiveOutliner->GetViewCount()); 317 318 if(nViewAnz) 319 { 320 const Region& rRedrawRegion = rPaintWindow.GetRedrawRegion(); 321 const Rectangle aCheckRect(rRedrawRegion.GetBoundRect()); 322 323 for(sal_uInt32 i(0); i < nViewAnz; i++) 324 { 325 OutlinerView* pOLV = pActiveOutliner->GetView(i); 326 327 if(pOLV->GetWindow() == &rPaintWindow.GetOutputDevice()) 328 { 329 ImpPaintOutlinerView(*pOLV, aCheckRect, rPaintWindow.GetTargetOutputDevice()); 330 return; 331 } 332 } 333 } 334 } 335 } 336 } 337 338 void SdrObjEditView::ImpPaintOutlinerView(OutlinerView& rOutlView, const Rectangle& rRect, OutputDevice& rTargetDevice) const 339 { 340 const SdrTextObj* pText = PTR_CAST(SdrTextObj,GetTextEditObject()); 341 bool bTextFrame(pText && pText->IsTextFrame()); 342 bool bFitToSize(0 != (pTextEditOutliner->GetControlWord() & EE_CNTRL_STRETCHING)); 343 bool bModifyMerk(pTextEditOutliner->IsModified()); // #43095# 344 Rectangle aBlankRect(rOutlView.GetOutputArea()); 345 aBlankRect.Union(aMinTextEditArea); 346 Rectangle aPixRect(rTargetDevice.LogicToPixel(aBlankRect)); 347 aBlankRect.Intersection(rRect); 348 rOutlView.GetOutliner()->SetUpdateMode(sal_True); // Bugfix #22596# 349 rOutlView.Paint(aBlankRect, &rTargetDevice); 350 351 if(!bModifyMerk) 352 { 353 // #43095# 354 pTextEditOutliner->ClearModifyFlag(); 355 } 356 357 if(bTextFrame && !bFitToSize) 358 { 359 // completely reworked to use primitives; this ensures same look and functionality 360 const drawinglayer::geometry::ViewInformation2D aViewInformation2D; 361 drawinglayer::processor2d::BaseProcessor2D* pProcessor = drawinglayer::processor2d::createProcessor2DFromOutputDevice( 362 rTargetDevice, 363 aViewInformation2D); 364 365 if(pProcessor) 366 { 367 const bool bMerk(rTargetDevice.IsMapModeEnabled()); 368 const basegfx::B2DRange aRange(aPixRect.Left(), aPixRect.Top(), aPixRect.Right(), aPixRect.Bottom()); 369 const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer; 370 const Color aHilightColor(aSvtOptionsDrawinglayer.getHilightColor()); 371 const double fTransparence(aSvtOptionsDrawinglayer.GetTransparentSelectionPercent() * 0.01); 372 const sal_uInt16 nPixSiz(rOutlView.GetInvalidateMore() - 1); 373 const drawinglayer::primitive2d::Primitive2DReference xReference( 374 new drawinglayer::primitive2d::OverlayRectanglePrimitive( 375 aRange, 376 aHilightColor.getBColor(), 377 fTransparence, 378 std::max(6, nPixSiz - 2), // grow 379 0.0, // shrink 380 0.0)); 381 const drawinglayer::primitive2d::Primitive2DSequence aSequence(&xReference, 1); 382 383 rTargetDevice.EnableMapMode(false); 384 pProcessor->process(aSequence); 385 rTargetDevice.EnableMapMode(bMerk); 386 delete pProcessor; 387 } 388 } 389 390 rOutlView.ShowCursor(); 391 } 392 393 void SdrObjEditView::ImpInvalidateOutlinerView(OutlinerView& rOutlView) const 394 { 395 Window* pWin = rOutlView.GetWindow(); 396 397 if(pWin) 398 { 399 const SdrTextObj* pText = PTR_CAST(SdrTextObj,GetTextEditObject()); 400 bool bTextFrame(pText && pText->IsTextFrame()); 401 bool bFitToSize(0 != (pTextEditOutliner->GetControlWord() & EE_CNTRL_STRETCHING)); 402 403 if(bTextFrame && !bFitToSize) 404 { 405 Rectangle aBlankRect(rOutlView.GetOutputArea()); 406 aBlankRect.Union(aMinTextEditArea); 407 Rectangle aPixRect(pWin->LogicToPixel(aBlankRect)); 408 sal_uInt16 nPixSiz(rOutlView.GetInvalidateMore() - 1); 409 410 aPixRect.Left()--; 411 aPixRect.Top()--; 412 aPixRect.Right()++; 413 aPixRect.Bottom()++; 414 415 { 416 // xPixRect Begrenzen, wegen Treiberproblem bei zu weit hinausragenden Pixelkoordinaten 417 Size aMaxXY(pWin->GetOutputSizePixel()); 418 long a(2 * nPixSiz); 419 long nMaxX(aMaxXY.Width() + a); 420 long nMaxY(aMaxXY.Height() + a); 421 422 if (aPixRect.Left ()<-a) aPixRect.Left()=-a; 423 if (aPixRect.Top ()<-a) aPixRect.Top ()=-a; 424 if (aPixRect.Right ()>nMaxX) aPixRect.Right ()=nMaxX; 425 if (aPixRect.Bottom()>nMaxY) aPixRect.Bottom()=nMaxY; 426 } 427 428 Rectangle aOuterPix(aPixRect); 429 aOuterPix.Left()-=nPixSiz; 430 aOuterPix.Top()-=nPixSiz; 431 aOuterPix.Right()+=nPixSiz; 432 aOuterPix.Bottom()+=nPixSiz; 433 434 bool bMerk(pWin->IsMapModeEnabled()); 435 pWin->EnableMapMode(sal_False); 436 pWin->Invalidate(aOuterPix); 437 pWin->EnableMapMode(bMerk); 438 } 439 } 440 } 441 442 OutlinerView* SdrObjEditView::ImpMakeOutlinerView(Window* pWin, sal_Bool /*bNoPaint*/, OutlinerView* pGivenView) const 443 { 444 // Hintergrund 445 Color aBackground(GetTextEditBackgroundColor(*this)); 446 SdrTextObj* pText = dynamic_cast< SdrTextObj * >( mxTextEditObj.get() ); 447 sal_Bool bTextFrame=pText!=NULL && pText->IsTextFrame(); 448 sal_Bool bContourFrame=pText!=NULL && pText->IsContourTextFrame(); 449 // OutlinerView erzeugen 450 OutlinerView* pOutlView=pGivenView; 451 pTextEditOutliner->SetUpdateMode(sal_False); 452 if (pOutlView==NULL) pOutlView=new OutlinerView(pTextEditOutliner,pWin); 453 else pOutlView->SetWindow(pWin); 454 // Scrollen verbieten 455 sal_uIntPtr nStat=pOutlView->GetControlWord(); 456 nStat&=~EV_CNTRL_AUTOSCROLL; 457 // AutoViewSize nur wenn nicht KontourFrame. 458 if (!bContourFrame) nStat|=EV_CNTRL_AUTOSIZE; 459 if (bTextFrame) { 460 sal_uInt16 nPixSiz=aHdl.GetHdlSize()*2+1; 461 nStat|=EV_CNTRL_INVONEMORE; 462 pOutlView->SetInvalidateMore(nPixSiz); 463 } 464 pOutlView->SetControlWord(nStat); 465 pOutlView->SetBackgroundColor( aBackground ); 466 if (pText!=NULL) 467 { 468 pOutlView->SetAnchorMode((EVAnchorMode)(pText->GetOutlinerViewAnchorMode())); 469 pTextEditOutliner->SetFixedCellHeight(((const SdrTextFixedCellHeightItem&)pText->GetMergedItem(SDRATTR_TEXT_USEFIXEDCELLHEIGHT)).GetValue()); 470 } 471 pOutlView->SetOutputArea(aTextEditArea); 472 pTextEditOutliner->SetUpdateMode(sal_True); 473 ImpInvalidateOutlinerView(*pOutlView); 474 return pOutlView; 475 } 476 477 sal_Bool SdrObjEditView::IsTextEditFrame() const 478 { 479 SdrTextObj* pText = dynamic_cast< SdrTextObj* >( mxTextEditObj.get() ); 480 return pText!=NULL && pText->IsTextFrame(); 481 } 482 483 IMPL_LINK(SdrObjEditView,ImpOutlinerStatusEventHdl,EditStatus*,pEditStat) 484 { 485 if(pTextEditOutliner ) 486 { 487 SdrTextObj* pTextObj = dynamic_cast< SdrTextObj * >( mxTextEditObj.get() ); 488 if( pTextObj ) 489 { 490 pTextObj->onEditOutlinerStatusEvent( pEditStat ); 491 } 492 } 493 return 0; 494 } 495 496 IMPL_LINK(SdrObjEditView,ImpOutlinerCalcFieldValueHdl,EditFieldInfo*,pFI) 497 { 498 bool bOk=false; 499 String& rStr=pFI->GetRepresentation(); 500 rStr.Erase(); 501 SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( mxTextEditObj.get() ); 502 if (pTextObj!=NULL) { 503 Color* pTxtCol=NULL; 504 Color* pFldCol=NULL; 505 bOk=pTextObj->CalcFieldValue(pFI->GetField(),pFI->GetPara(),pFI->GetPos(),sal_True,pTxtCol,pFldCol,rStr); 506 if (bOk) { 507 if (pTxtCol!=NULL) { 508 pFI->SetTxtColor(*pTxtCol); 509 delete pTxtCol; 510 } 511 if (pFldCol!=NULL) { 512 pFI->SetFldColor(*pFldCol); 513 delete pFldCol; 514 } else { 515 pFI->SetFldColor(Color(COL_LIGHTGRAY)); // kann spaeter (357) raus 516 } 517 } 518 } 519 Outliner& rDrawOutl=pMod->GetDrawOutliner(pTextObj); 520 Link aDrawOutlLink=rDrawOutl.GetCalcFieldValueHdl(); 521 if (!bOk && aDrawOutlLink.IsSet()) { 522 aDrawOutlLink.Call(pFI); 523 bOk = (sal_Bool)rStr.Len(); 524 } 525 if (!bOk && aOldCalcFieldValueLink.IsSet()) { 526 return aOldCalcFieldValueLink.Call(pFI); 527 } 528 return 0; 529 } 530 531 IMPL_LINK(SdrObjEditView, EndTextEditHdl, SdrUndoManager*, /*pUndoManager*/) 532 { 533 SdrEndTextEdit(); 534 return 0; 535 } 536 537 SdrUndoManager* SdrObjEditView::getSdrUndoManagerForEnhancedTextEdit() const 538 { 539 // default returns registered UndoManager 540 return GetModel() ? dynamic_cast< SdrUndoManager* >(GetModel()->GetSdrUndoManager()) : 0; 541 } 542 543 sal_Bool SdrObjEditView::SdrBeginTextEdit( 544 SdrObject* pObj, SdrPageView* pPV, Window* pWin, 545 sal_Bool bIsNewObj, SdrOutliner* pGivenOutliner, 546 OutlinerView* pGivenOutlinerView, 547 sal_Bool bDontDeleteOutliner, sal_Bool bOnlyOneView, 548 sal_Bool bGrabFocus) 549 { 550 SdrEndTextEdit(); 551 552 if( dynamic_cast< SdrTextObj* >( pObj ) == 0 ) 553 return sal_False; // currently only possible with text objects 554 555 if(bGrabFocus && pWin) 556 { 557 // attetion, this call may cause an EndTextEdit() call to this view 558 pWin->GrabFocus(); // to force the cursor into the edit view 559 } 560 561 bTextEditDontDelete=bDontDeleteOutliner && pGivenOutliner!=NULL; 562 bTextEditOnlyOneView=bOnlyOneView; 563 bTextEditNewObj=bIsNewObj; 564 const sal_uInt32 nWinAnz(PaintWindowCount()); 565 sal_uInt32 i; 566 sal_Bool bBrk(sal_False); 567 // Abbruch, wenn kein Objekt angegeben. 568 569 if(!pObj) 570 { 571 bBrk = sal_True; 572 } 573 574 if(!bBrk && !pWin) 575 { 576 for(i = 0L; i < nWinAnz && !pWin; i++) 577 { 578 SdrPaintWindow* pPaintWindow = GetPaintWindow(i); 579 580 if(OUTDEV_WINDOW == pPaintWindow->GetOutputDevice().GetOutDevType()) 581 { 582 pWin = (Window*)(&pPaintWindow->GetOutputDevice()); 583 } 584 } 585 586 // Abbruch, wenn kein Window da. 587 if(!pWin) 588 { 589 bBrk = sal_True; 590 } 591 } 592 593 if(!bBrk && !pPV) 594 { 595 pPV = GetSdrPageView(); 596 597 // Abbruch, wenn keine PageView zu dem Objekt vorhanden. 598 if(!pPV) 599 { 600 bBrk = sal_True; 601 } 602 } 603 604 if(pObj && pPV) 605 { 606 // Kein TextEdit an Objekten im gesperrten Layer 607 if(pPV->GetLockedLayers().IsSet(pObj->GetLayer())) 608 { 609 bBrk = sal_True; 610 } 611 } 612 613 if(pTextEditOutliner) 614 { 615 DBG_ERROR("SdrObjEditView::SdrBeginTextEdit() da stand noch ein alter Outliner rum"); 616 delete pTextEditOutliner; 617 pTextEditOutliner = 0L; 618 } 619 620 if(!bBrk) 621 { 622 pTextEditWin=pWin; 623 pTextEditPV=pPV; 624 mxTextEditObj.reset( pObj ); 625 pTextEditOutliner=pGivenOutliner; 626 if (pTextEditOutliner==NULL) 627 pTextEditOutliner = SdrMakeOutliner( OUTLINERMODE_TEXTOBJECT, mxTextEditObj->GetModel() ); 628 629 { 630 SvtAccessibilityOptions aOptions; 631 pTextEditOutliner->ForceAutoColor( aOptions.GetIsAutomaticFontColor() ); 632 } 633 634 sal_Bool bEmpty = mxTextEditObj->GetOutlinerParaObject()==NULL; 635 636 aOldCalcFieldValueLink=pTextEditOutliner->GetCalcFieldValueHdl(); 637 // Der FieldHdl muss von SdrBeginTextEdit gesetzt sein, da dor ein UpdateFields gerufen wird. 638 pTextEditOutliner->SetCalcFieldValueHdl(LINK(this,SdrObjEditView,ImpOutlinerCalcFieldValueHdl)); 639 pTextEditOutliner->SetBeginPasteOrDropHdl(LINK(this,SdrObjEditView,BeginPasteOrDropHdl)); 640 pTextEditOutliner->SetEndPasteOrDropHdl(LINK(this,SdrObjEditView, EndPasteOrDropHdl)); 641 642 // It is just necessary to make the visualized page known. Set it. 643 pTextEditOutliner->setVisualizedPage(pPV ? pPV->GetPage() : 0); 644 645 pTextEditOutliner->SetTextObjNoInit( dynamic_cast< SdrTextObj* >( mxTextEditObj.get() ) ); 646 647 if(mxTextEditObj->BegTextEdit(*pTextEditOutliner)) 648 { 649 SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( mxTextEditObj.get() ); 650 DBG_ASSERT( pTextObj, "svx::SdrObjEditView::BegTextEdit(), no text object?" ); 651 if( !pTextObj ) 652 return sal_False; 653 654 // #111096# Switch off evtl. running TextAnimation 655 pTextObj->SetTextAnimationAllowed(sal_False); 656 657 // alten Cursor merken 658 if (pTextEditOutliner->GetViewCount()!=0) 659 { 660 OutlinerView* pTmpOLV=pTextEditOutliner->RemoveView(sal_uIntPtr(0)); 661 if(pTmpOLV!=NULL && pTmpOLV!=pGivenOutlinerView) 662 delete pTmpOLV; 663 } 664 665 // EditArea ueberTakeTextEditArea bestimmen 666 // Das koennte eigentlich entfallen, da TakeTextRect() die Berechnung der aTextEditArea vornimmt 667 // Die aMinTextEditArea muss jedoch wohl auch erfolgen (darum bleibt es voerst drinnen) 668 pTextObj->TakeTextEditArea(NULL,NULL,&aTextEditArea,&aMinTextEditArea); 669 670 Rectangle aTextRect; 671 Rectangle aAnchorRect; 672 pTextObj->TakeTextRect(*pTextEditOutliner, aTextRect, sal_True, 673 &aAnchorRect /* #97097# Give sal_True here, not sal_False */); 674 675 if ( !pTextObj->IsContourTextFrame() ) 676 { 677 // FitToSize erstmal nicht mit ContourFrame 678 SdrFitToSizeType eFit = pTextObj->GetFitToSize(); 679 if (eFit==SDRTEXTFIT_PROPORTIONAL || eFit==SDRTEXTFIT_ALLLINES) 680 aTextRect = aAnchorRect; 681 } 682 683 aTextEditArea = aTextRect; 684 685 // #108784# 686 Point aPvOfs(pTextObj->GetTextEditOffset()); 687 688 aTextEditArea.Move(aPvOfs.X(),aPvOfs.Y()); 689 aMinTextEditArea.Move(aPvOfs.X(),aPvOfs.Y()); 690 pTextEditCursorMerker=pWin->GetCursor(); 691 692 aHdl.SetMoveOutside(sal_True); 693 694 // #i72757# 695 // Since IsMarkHdlWhenTextEdit() is ignored, it is necessary 696 // to call AdjustMarkHdl() always. 697 AdjustMarkHdl(); 698 699 pTextEditOutlinerView=ImpMakeOutlinerView(pWin,!bEmpty,pGivenOutlinerView); 700 701 // check if this view is already inserted 702 sal_uIntPtr i2,nCount = pTextEditOutliner->GetViewCount(); 703 for( i2 = 0; i2 < nCount; i2++ ) 704 { 705 if( pTextEditOutliner->GetView(i2) == pTextEditOutlinerView ) 706 break; 707 } 708 709 if( i2 == nCount ) 710 pTextEditOutliner->InsertView(pTextEditOutlinerView,0); 711 712 aHdl.SetMoveOutside(sal_False); 713 aHdl.SetMoveOutside(sal_True); 714 //OLMRefreshAllIAOManagers(); 715 716 // alle Wins als OutlinerView beim Outliner anmelden 717 if(!bOnlyOneView) 718 { 719 for(i = 0L; i < nWinAnz; i++) 720 { 721 SdrPaintWindow* pPaintWindow = GetPaintWindow(i); 722 OutputDevice& rOutDev = pPaintWindow->GetOutputDevice(); 723 724 if(&rOutDev != pWin && OUTDEV_WINDOW == rOutDev.GetOutDevType()) 725 { 726 OutlinerView* pOutlView = ImpMakeOutlinerView((Window*)(&rOutDev), !bEmpty, 0L); 727 pTextEditOutliner->InsertView(pOutlView, (sal_uInt16)i); 728 } 729 } 730 } 731 732 pTextEditOutlinerView->ShowCursor(); 733 pTextEditOutliner->SetStatusEventHdl(LINK(this,SdrObjEditView,ImpOutlinerStatusEventHdl)); 734 #ifdef DBG_UTIL 735 if (pItemBrowser!=NULL) pItemBrowser->SetDirty(); 736 #endif 737 pTextEditOutliner->ClearModifyFlag(); 738 739 // #71519#, #91453# 740 if(pWin) 741 { 742 sal_Bool bExtraInvalidate(sal_False); 743 744 // #71519# 745 if(!bExtraInvalidate) 746 { 747 SdrFitToSizeType eFit = pTextObj->GetFitToSize(); 748 if(eFit == SDRTEXTFIT_PROPORTIONAL || eFit == SDRTEXTFIT_ALLLINES) 749 bExtraInvalidate = sal_True; 750 } 751 752 if(bExtraInvalidate) 753 { 754 pWin->Invalidate(aTextEditArea); 755 } 756 } 757 758 // send HINT_BEGEDIT #99840# 759 if( GetModel() ) 760 { 761 SdrHint aHint(*pTextObj); 762 aHint.SetKind(HINT_BEGEDIT); 763 GetModel()->Broadcast(aHint); 764 } 765 766 pTextEditOutliner->setVisualizedPage(0); 767 768 if( mxSelectionController.is() ) 769 mxSelectionController->onSelectionHasChanged(); 770 771 if(IsUndoEnabled()) 772 { 773 SdrUndoManager* pSdrUndoManager = getSdrUndoManagerForEnhancedTextEdit(); 774 775 if(pSdrUndoManager) 776 { 777 // we have an outliner, undo manager and it's an EditUndoManager, exchange 778 // the document undo manager and the default one from the outliner and tell 779 // it that text edit starts by setting a callback if it needs to end text edit mode. 780 if(mpOldTextEditUndoManager) 781 { 782 // should not happen, delete it since it was probably forgotten somewhere 783 OSL_ENSURE(false, "Deleting forgotten old TextEditUndoManager, should be checked (!)"); 784 delete mpOldTextEditUndoManager; 785 mpOldTextEditUndoManager = 0; 786 } 787 788 mpOldTextEditUndoManager = pTextEditOutliner->SetUndoManager(pSdrUndoManager); 789 pSdrUndoManager->SetEndTextEditHdl(LINK(this, SdrObjEditView, EndTextEditHdl)); 790 } 791 else 792 { 793 OSL_ENSURE(false, "The document undo manager is not derived from SdrUndoManager (!)"); 794 } 795 } 796 797 return sal_True; // Gut gelaufen, TextEdit laeuft nun 798 } 799 else 800 { 801 bBrk = sal_True; 802 pTextEditOutliner->SetCalcFieldValueHdl(aOldCalcFieldValueLink); 803 pTextEditOutliner->SetBeginPasteOrDropHdl(Link()); 804 pTextEditOutliner->SetEndPasteOrDropHdl(Link()); 805 806 } 807 } 808 if (pTextEditOutliner != NULL) 809 { 810 pTextEditOutliner->setVisualizedPage(0); 811 } 812 813 // wenn hier angekommen, dann ist irgendwas schief gelaufen 814 if(!bDontDeleteOutliner) 815 { 816 if(pGivenOutliner!=NULL) 817 { 818 delete pGivenOutliner; 819 pTextEditOutliner = NULL; 820 } 821 if(pGivenOutlinerView!=NULL) 822 { 823 delete pGivenOutlinerView; 824 pGivenOutlinerView = NULL; 825 } 826 } 827 if( pTextEditOutliner!=NULL ) 828 { 829 delete pTextEditOutliner; 830 } 831 832 pTextEditOutliner=NULL; 833 pTextEditOutlinerView=NULL; 834 mxTextEditObj.reset(0); 835 pTextEditPV=NULL; 836 pTextEditWin=NULL; 837 //HMHif (bMarkHdlWhenTextEdit) { 838 //HMH HideMarkHdl(); 839 //HMH} 840 aHdl.SetMoveOutside(sal_False); 841 //HMHShowMarkHdl(); 842 843 return sal_False; 844 } 845 846 SdrEndTextEditKind SdrObjEditView::SdrEndTextEdit(sal_Bool bDontDeleteReally) 847 { 848 SdrEndTextEditKind eRet=SDRENDTEXTEDIT_UNCHANGED; 849 SdrTextObj* pTEObj = dynamic_cast< SdrTextObj* >( mxTextEditObj.get() ); 850 Window* pTEWin =pTextEditWin; 851 SdrOutliner* pTEOutliner =pTextEditOutliner; 852 OutlinerView* pTEOutlinerView=pTextEditOutlinerView; 853 Cursor* pTECursorMerker=pTextEditCursorMerker; 854 SdrUndoManager* pUndoEditUndoManager = 0; 855 bool bNeedToUndoSavedRedoTextEdit(false); 856 857 if(IsUndoEnabled() && GetModel() && pTEObj && pTEOutliner) 858 { 859 // change back the UndoManager to the remembered original one 860 ::svl::IUndoManager* pOriginal = pTEOutliner->SetUndoManager(mpOldTextEditUndoManager); 861 mpOldTextEditUndoManager = 0; 862 863 if(pOriginal) 864 { 865 // check if we got back our document undo manager 866 SdrUndoManager* pSdrUndoManager = getSdrUndoManagerForEnhancedTextEdit(); 867 868 if(pSdrUndoManager && dynamic_cast< SdrUndoManager* >(pOriginal) == pSdrUndoManager) 869 { 870 if(pSdrUndoManager->isEndTextEditTriggeredFromUndo()) 871 { 872 // remember the UndoManager where missing Undos have to be triggered after end 873 // text edit. When the undo had triggered the end text edit, the original action 874 // which had to be undone originally is not yet undone. 875 pUndoEditUndoManager = pSdrUndoManager; 876 877 // We are ending text edit; if text edit was triggered from undo, execute all redos 878 // to create a complete text change undo action for the redo buffer. Also mark this 879 // state when at least one redo was executed; the created extra TextChange needs to 880 // be undone in addition to the first real undo outside the text edit changes 881 while(pSdrUndoManager->GetRedoActionCount()) 882 { 883 bNeedToUndoSavedRedoTextEdit = true; 884 pSdrUndoManager->Redo(); 885 } 886 } 887 888 // reset the callback link and let the undo manager cleanup all text edit 889 // undo actions to get the stack back to the form before the text edit 890 pSdrUndoManager->SetEndTextEditHdl(Link()); 891 } 892 else 893 { 894 OSL_ENSURE(false, "�Got UndoManager back in SdrEndTextEdit which is NOT the expected document UndoManager (!)"); 895 delete pOriginal; 896 } 897 } 898 } 899 900 // send HINT_ENDEDIT #99840# 901 if( GetModel() && mxTextEditObj.is() ) 902 { 903 SdrHint aHint(*mxTextEditObj.get()); 904 aHint.SetKind(HINT_ENDEDIT); 905 GetModel()->Broadcast(aHint); 906 } 907 908 mxTextEditObj.reset(0); 909 pTextEditPV=NULL; 910 pTextEditWin=NULL; 911 pTextEditOutliner=NULL; 912 pTextEditOutlinerView=NULL; 913 pTextEditCursorMerker=NULL; 914 aTextEditArea=Rectangle(); 915 916 if (pTEOutliner!=NULL) 917 { 918 sal_Bool bModified=pTEOutliner->IsModified(); 919 if (pTEOutlinerView!=NULL) 920 { 921 pTEOutlinerView->HideCursor(); 922 } 923 if (pTEObj!=NULL) 924 { 925 pTEOutliner->CompleteOnlineSpelling(); 926 927 SdrUndoObjSetText* pTxtUndo = 0; 928 929 if( bModified ) 930 { 931 sal_Int32 nText; 932 for( nText = 0; nText < pTEObj->getTextCount(); ++nText ) 933 if( pTEObj->getText( nText ) == pTEObj->getActiveText() ) 934 break; 935 936 pTxtUndo = dynamic_cast< SdrUndoObjSetText* >( GetModel()->GetSdrUndoFactory().CreateUndoObjectSetText(*pTEObj, nText ) ); 937 } 938 DBG_ASSERT( !bModified || pTxtUndo, "svx::SdrObjEditView::EndTextEdit(), could not create undo action!" ); 939 // Den alten CalcFieldValue-Handler wieder setzen 940 // Muss vor Obj::EndTextEdit() geschehen, da dort ein UpdateFields() gemacht wird. 941 pTEOutliner->SetCalcFieldValueHdl(aOldCalcFieldValueLink); 942 pTEOutliner->SetBeginPasteOrDropHdl(Link()); 943 pTEOutliner->SetEndPasteOrDropHdl(Link()); 944 945 const bool bUndo = IsUndoEnabled(); 946 if( bUndo ) 947 { 948 XubString aObjName; 949 pTEObj->TakeObjNameSingul(aObjName); 950 BegUndo(ImpGetResStr(STR_UndoObjSetText),aObjName); 951 } 952 953 pTEObj->EndTextEdit(*pTEOutliner); 954 955 if( (pTEObj->GetRotateAngle() != 0) || (pTEObj && pTEObj->ISA(SdrTextObj) && ((SdrTextObj*)pTEObj)->IsFontwork()) ) 956 { 957 // obviously a repaint 958 pTEObj->ActionChanged(); 959 } 960 961 if (pTxtUndo!=NULL) 962 { 963 pTxtUndo->AfterSetText(); 964 if (!pTxtUndo->IsDifferent()) 965 { 966 delete pTxtUndo; 967 pTxtUndo=NULL; 968 } 969 } 970 // Loeschung des gesamten TextObj checken 971 SdrUndoAction* pDelUndo=NULL; 972 sal_Bool bDelObj=sal_False; 973 SdrTextObj* pTextObj=PTR_CAST(SdrTextObj,pTEObj); 974 if (pTextObj!=NULL && bTextEditNewObj) 975 { 976 bDelObj=pTextObj->IsTextFrame() && 977 !pTextObj->HasText() && 978 !pTextObj->IsEmptyPresObj() && 979 !pTextObj->HasFill() && 980 !pTextObj->HasLine(); 981 982 if(pTEObj->IsInserted() && bDelObj && pTextObj->GetObjInventor()==SdrInventor && !bDontDeleteReally) 983 { 984 SdrObjKind eIdent=(SdrObjKind)pTextObj->GetObjIdentifier(); 985 if(eIdent==OBJ_TEXT || eIdent==OBJ_TEXTEXT) 986 { 987 pDelUndo= GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pTEObj); 988 } 989 } 990 } 991 if (pTxtUndo!=NULL) 992 { 993 if( bUndo ) 994 AddUndo(pTxtUndo); 995 eRet=SDRENDTEXTEDIT_CHANGED; 996 } 997 if (pDelUndo!=NULL) 998 { 999 if( bUndo ) 1000 { 1001 AddUndo(pDelUndo); 1002 } 1003 else 1004 { 1005 delete pDelUndo; 1006 } 1007 eRet=SDRENDTEXTEDIT_DELETED; 1008 DBG_ASSERT(pTEObj->GetObjList()!=NULL,"SdrObjEditView::SdrEndTextEdit(): Fatal: Editiertes Objekt hat keine ObjList!"); 1009 if (pTEObj->GetObjList()!=NULL) 1010 { 1011 pTEObj->GetObjList()->RemoveObject(pTEObj->GetOrdNum()); 1012 CheckMarked(); // und gleich die Maekierung entfernen... 1013 } 1014 } 1015 else if (bDelObj) 1016 { // Fuer den Writer: Loeschen muss die App nachholen. 1017 eRet=SDRENDTEXTEDIT_SHOULDBEDELETED; 1018 } 1019 1020 if( bUndo ) 1021 EndUndo(); // EndUndo hinter Remove, falls der UndoStack gleich weggehaun' wird 1022 1023 // #111096# 1024 // Switch on evtl. TextAnimation again after TextEdit 1025 if(pTEObj->ISA(SdrTextObj)) 1026 { 1027 ((SdrTextObj*)pTEObj)->SetTextAnimationAllowed(sal_True); 1028 } 1029 1030 // #i72757# 1031 // Since IsMarkHdlWhenTextEdit() is ignored, it is necessary 1032 // to call AdjustMarkHdl() always. 1033 AdjustMarkHdl(); 1034 } 1035 // alle OutlinerViews loeschen 1036 for (sal_uIntPtr i=pTEOutliner->GetViewCount(); i>0;) 1037 { 1038 i--; 1039 OutlinerView* pOLV=pTEOutliner->GetView(i); 1040 sal_uInt16 nMorePix=pOLV->GetInvalidateMore() + 10; // solaris aw033 test #i# 1041 Window* pWin=pOLV->GetWindow(); 1042 Rectangle aRect(pOLV->GetOutputArea()); 1043 pTEOutliner->RemoveView(i); 1044 if (!bTextEditDontDelete || i!=0) 1045 { 1046 // die nullte gehoert mir u.U. nicht. 1047 delete pOLV; 1048 } 1049 aRect.Union(aTextEditArea); 1050 aRect.Union(aMinTextEditArea); 1051 aRect=pWin->LogicToPixel(aRect); 1052 aRect.Left()-=nMorePix; 1053 aRect.Top()-=nMorePix; 1054 aRect.Right()+=nMorePix; 1055 aRect.Bottom()+=nMorePix; 1056 aRect=pWin->PixelToLogic(aRect); 1057 InvalidateOneWin(*pWin,aRect); 1058 // pWin->Invalidate(INVALIDATE_UPDATE); 1059 1060 // pWin->Update(); 1061 // pWin->Flush(); 1062 pWin->SetFillColor(); 1063 pWin->SetLineColor(COL_BLACK); 1064 pWin->DrawPixel(aRect.TopLeft()); 1065 pWin->DrawPixel(aRect.TopRight()); 1066 pWin->DrawPixel(aRect.BottomLeft()); 1067 pWin->DrawPixel(aRect.BottomRight()); 1068 //pWin->DrawRect(aRect); 1069 } 1070 // und auch den Outliner selbst 1071 if (!bTextEditDontDelete) delete pTEOutliner; 1072 else pTEOutliner->Clear(); 1073 if (pTEWin!=NULL) { 1074 pTEWin->SetCursor(pTECursorMerker); 1075 } 1076 //HMH if (bMarkHdlWhenTextEdit) { 1077 //HMH HideMarkHdl(); 1078 //HMH } 1079 aHdl.SetMoveOutside(sal_False); 1080 if (eRet!=SDRENDTEXTEDIT_UNCHANGED) 1081 //HMH { 1082 //HMH ShowMarkHdl(); // Handles kommen ansonsten via Broadcast 1083 //HMH } 1084 //HMH else 1085 { 1086 GetMarkedObjectListWriteAccess().SetNameDirty(); 1087 } 1088 #ifdef DBG_UTIL 1089 if (pItemBrowser) 1090 { 1091 GetMarkedObjectListWriteAccess().SetNameDirty(); 1092 pItemBrowser->SetDirty(); 1093 } 1094 #endif 1095 } 1096 1097 // #108784# 1098 if( pTEObj && 1099 pTEObj->GetModel() && 1100 !pTEObj->GetModel()->isLocked() && 1101 pTEObj->GetBroadcaster()) 1102 { 1103 SdrHint aHint(HINT_ENDEDIT); 1104 aHint.SetObject(pTEObj); 1105 ((SfxBroadcaster*)pTEObj->GetBroadcaster())->Broadcast(aHint); 1106 } 1107 1108 if(pUndoEditUndoManager) 1109 { 1110 if(bNeedToUndoSavedRedoTextEdit) 1111 { 1112 // undo the text edit action since it was created as part of an EndTextEdit 1113 // callback from undo itself. This needs to be done after the call to 1114 // FmFormView::SdrEndTextEdit since it gets created there 1115 pUndoEditUndoManager->Undo(); 1116 } 1117 1118 // trigger the Undo which was not executed, but lead to this 1119 // end text edit 1120 pUndoEditUndoManager->Undo(); 1121 } 1122 1123 return eRet; 1124 } 1125 1126 //////////////////////////////////////////////////////////////////////////////////////////////////// 1127 // info about TextEdit. Default is sal_False. 1128 bool SdrObjEditView::IsTextEdit() const 1129 { 1130 return mxTextEditObj.is(); 1131 } 1132 1133 // info about TextEditPageView. Default is 0L. 1134 SdrPageView* SdrObjEditView::GetTextEditPageView() const 1135 { 1136 return pTextEditPV; 1137 } 1138 1139 //////////////////////////////////////////////////////////////////////////////////////////////////// 1140 1141 OutlinerView* SdrObjEditView::ImpFindOutlinerView(Window* pWin) const 1142 { 1143 if (pWin==NULL) return NULL; 1144 if (pTextEditOutliner==NULL) return NULL; 1145 OutlinerView* pNewView=NULL; 1146 sal_uIntPtr nWinAnz=pTextEditOutliner->GetViewCount(); 1147 for (sal_uIntPtr i=0; i<nWinAnz && pNewView==NULL; i++) { 1148 OutlinerView* pView=pTextEditOutliner->GetView(i); 1149 if (pView->GetWindow()==pWin) pNewView=pView; 1150 } 1151 return pNewView; 1152 } 1153 1154 void SdrObjEditView::SetTextEditWin(Window* pWin) 1155 { 1156 if(mxTextEditObj.is() && pWin!=NULL && pWin!=pTextEditWin) 1157 { 1158 OutlinerView* pNewView=ImpFindOutlinerView(pWin); 1159 if (pNewView!=NULL && pNewView!=pTextEditOutlinerView) 1160 { 1161 if (pTextEditOutlinerView!=NULL) 1162 { 1163 pTextEditOutlinerView->HideCursor(); 1164 } 1165 pTextEditOutlinerView=pNewView; 1166 pTextEditWin=pWin; 1167 pWin->GrabFocus(); // Damit der Cursor hier auch blinkt 1168 pNewView->ShowCursor(); 1169 ImpMakeTextCursorAreaVisible(); 1170 } 1171 } 1172 } 1173 1174 sal_Bool SdrObjEditView::IsTextEditHit(const Point& rHit, short nTol) const 1175 { 1176 sal_Bool bOk=sal_False; 1177 if(mxTextEditObj.is()) 1178 { 1179 nTol=ImpGetHitTolLogic(nTol,NULL); 1180 // nur drittel Toleranz hier, damit die Handles 1181 // noch vernuenftig getroffen werden koennen 1182 nTol=nTol/3; 1183 nTol=0; // Joe am 6.3.1997: Keine Hittoleranz mehr hier 1184 if (!bOk) 1185 { 1186 Rectangle aEditArea; 1187 OutlinerView* pOLV=pTextEditOutliner->GetView(0); 1188 if (pOLV!=NULL) 1189 { 1190 aEditArea.Union(pOLV->GetOutputArea()); 1191 } 1192 aEditArea.Left()-=nTol; 1193 aEditArea.Top()-=nTol; 1194 aEditArea.Right()+=nTol; 1195 aEditArea.Bottom()+=nTol; 1196 bOk=aEditArea.IsInside(rHit); 1197 if (bOk) 1198 { // Nun noch checken, ob auch wirklich Buchstaben getroffen wurden 1199 Point aPnt(rHit); aPnt-=aEditArea.TopLeft(); 1200 long nHitTol = 2000; 1201 OutputDevice* pRef = pTextEditOutliner->GetRefDevice(); 1202 if( pRef ) 1203 nHitTol = pRef->LogicToLogic( nHitTol, MAP_100TH_MM, pRef->GetMapMode().GetMapUnit() ); 1204 1205 bOk = pTextEditOutliner->IsTextPos( aPnt, (sal_uInt16)nHitTol ); 1206 } 1207 } 1208 } 1209 return bOk; 1210 } 1211 1212 sal_Bool SdrObjEditView::IsTextEditFrameHit(const Point& rHit) const 1213 { 1214 sal_Bool bOk=sal_False; 1215 if(mxTextEditObj.is()) 1216 { 1217 SdrTextObj* pText= dynamic_cast<SdrTextObj*>(mxTextEditObj.get()); 1218 OutlinerView* pOLV=pTextEditOutliner->GetView(0); 1219 if( pOLV ) 1220 { 1221 Window* pWin=pOLV->GetWindow(); 1222 if (pText!=NULL && pText->IsTextFrame() && pOLV!=NULL && pWin!=NULL) { 1223 sal_uInt16 nPixSiz=pOLV->GetInvalidateMore(); 1224 Rectangle aEditArea(aMinTextEditArea); 1225 aEditArea.Union(pOLV->GetOutputArea()); 1226 if (!aEditArea.IsInside(rHit)) { 1227 Size aSiz(pWin->PixelToLogic(Size(nPixSiz,nPixSiz))); 1228 aEditArea.Left()-=aSiz.Width(); 1229 aEditArea.Top()-=aSiz.Height(); 1230 aEditArea.Right()+=aSiz.Width(); 1231 aEditArea.Bottom()+=aSiz.Height(); 1232 bOk=aEditArea.IsInside(rHit); 1233 } 1234 } 1235 } 1236 } 1237 return bOk; 1238 } 1239 1240 void SdrObjEditView::AddTextEditOfs(MouseEvent& rMEvt) const 1241 { 1242 if(mxTextEditObj.is()) 1243 { 1244 Point aPvOfs; 1245 SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( mxTextEditObj.get() ); 1246 1247 if( pTextObj ) 1248 { 1249 // #108784# 1250 aPvOfs += pTextObj->GetTextEditOffset(); 1251 } 1252 1253 Point aObjOfs(mxTextEditObj->GetLogicRect().TopLeft()); 1254 (Point&)(rMEvt.GetPosPixel())+=aPvOfs+aObjOfs; 1255 } 1256 } 1257 1258 //////////////////////////////////////////////////////////////////////////////////////////////////// 1259 1260 sal_Bool SdrObjEditView::KeyInput(const KeyEvent& rKEvt, Window* pWin) 1261 { 1262 if(pTextEditOutlinerView) 1263 { 1264 #ifdef DBG_UTIL 1265 if(rKEvt.GetKeyCode().GetCode() == KEY_RETURN && pTextEditOutliner->GetParagraphCount() == 1) 1266 { 1267 ByteString aLine( 1268 pTextEditOutliner->GetText(pTextEditOutliner->GetParagraph( 0 ), 1), 1269 gsl_getSystemTextEncoding()); 1270 aLine = aLine.ToUpperAscii(); 1271 1272 if(aLine == "HELLO JOE, PLEASE SHOW THE ITEMBROWSER") 1273 ShowItemBrowser(); 1274 } 1275 #endif 1276 if (pTextEditOutlinerView->PostKeyEvent(rKEvt)) 1277 { 1278 if( pMod /* && !pMod->IsChanged() */ ) 1279 { 1280 if( pTextEditOutliner && pTextEditOutliner->IsModified() ) 1281 pMod->SetChanged( sal_True ); 1282 } 1283 1284 if (pWin!=NULL && pWin!=pTextEditWin) SetTextEditWin(pWin); 1285 #ifdef DBG_UTIL 1286 if (pItemBrowser!=NULL) pItemBrowser->SetDirty(); 1287 #endif 1288 ImpMakeTextCursorAreaVisible(); 1289 return sal_True; 1290 } 1291 } 1292 return SdrGlueEditView::KeyInput(rKEvt,pWin); 1293 } 1294 1295 sal_Bool SdrObjEditView::MouseButtonDown(const MouseEvent& rMEvt, Window* pWin) 1296 { 1297 if (pTextEditOutlinerView!=NULL) { 1298 sal_Bool bPostIt=pTextEditOutliner->IsInSelectionMode(); 1299 if (!bPostIt) { 1300 Point aPt(rMEvt.GetPosPixel()); 1301 if (pWin!=NULL) aPt=pWin->PixelToLogic(aPt); 1302 else if (pTextEditWin!=NULL) aPt=pTextEditWin->PixelToLogic(aPt); 1303 bPostIt=IsTextEditHit(aPt,nHitTolLog); 1304 } 1305 if (bPostIt) { 1306 Point aPixPos(rMEvt.GetPosPixel()); 1307 Rectangle aR(pWin->LogicToPixel(pTextEditOutlinerView->GetOutputArea())); 1308 if (aPixPos.X()<aR.Left ()) aPixPos.X()=aR.Left (); 1309 if (aPixPos.X()>aR.Right ()) aPixPos.X()=aR.Right (); 1310 if (aPixPos.Y()<aR.Top ()) aPixPos.Y()=aR.Top (); 1311 if (aPixPos.Y()>aR.Bottom()) aPixPos.Y()=aR.Bottom(); 1312 MouseEvent aMEvt(aPixPos,rMEvt.GetClicks(),rMEvt.GetMode(), 1313 rMEvt.GetButtons(),rMEvt.GetModifier()); 1314 if (pTextEditOutlinerView->MouseButtonDown(aMEvt)) { 1315 if (pWin!=NULL && pWin!=pTextEditWin) SetTextEditWin(pWin); 1316 #ifdef DBG_UTIL 1317 if (pItemBrowser!=NULL) pItemBrowser->SetDirty(); 1318 #endif 1319 ImpMakeTextCursorAreaVisible(); 1320 return sal_True; 1321 } 1322 } 1323 } 1324 return SdrGlueEditView::MouseButtonDown(rMEvt,pWin); 1325 } 1326 1327 sal_Bool SdrObjEditView::MouseButtonUp(const MouseEvent& rMEvt, Window* pWin) 1328 { 1329 if (pTextEditOutlinerView!=NULL) { 1330 sal_Bool bPostIt=pTextEditOutliner->IsInSelectionMode(); 1331 if (!bPostIt) { 1332 Point aPt(rMEvt.GetPosPixel()); 1333 if (pWin!=NULL) aPt=pWin->PixelToLogic(aPt); 1334 else if (pTextEditWin!=NULL) aPt=pTextEditWin->PixelToLogic(aPt); 1335 bPostIt=IsTextEditHit(aPt,nHitTolLog); 1336 } 1337 if (bPostIt) { 1338 Point aPixPos(rMEvt.GetPosPixel()); 1339 Rectangle aR(pWin->LogicToPixel(pTextEditOutlinerView->GetOutputArea())); 1340 if (aPixPos.X()<aR.Left ()) aPixPos.X()=aR.Left (); 1341 if (aPixPos.X()>aR.Right ()) aPixPos.X()=aR.Right (); 1342 if (aPixPos.Y()<aR.Top ()) aPixPos.Y()=aR.Top (); 1343 if (aPixPos.Y()>aR.Bottom()) aPixPos.Y()=aR.Bottom(); 1344 MouseEvent aMEvt(aPixPos,rMEvt.GetClicks(),rMEvt.GetMode(), 1345 rMEvt.GetButtons(),rMEvt.GetModifier()); 1346 if (pTextEditOutlinerView->MouseButtonUp(aMEvt)) { 1347 #ifdef DBG_UTIL 1348 if (pItemBrowser!=NULL) pItemBrowser->SetDirty(); 1349 #endif 1350 ImpMakeTextCursorAreaVisible(); 1351 return sal_True; 1352 } 1353 } 1354 } 1355 return SdrGlueEditView::MouseButtonUp(rMEvt,pWin); 1356 } 1357 1358 sal_Bool SdrObjEditView::MouseMove(const MouseEvent& rMEvt, Window* pWin) 1359 { 1360 if (pTextEditOutlinerView!=NULL) { 1361 sal_Bool bSelMode=pTextEditOutliner->IsInSelectionMode(); 1362 sal_Bool bPostIt=bSelMode; 1363 if (!bPostIt) { 1364 Point aPt(rMEvt.GetPosPixel()); 1365 if (pWin!=NULL) aPt=pWin->PixelToLogic(aPt); 1366 else if (pTextEditWin!=NULL) aPt=pTextEditWin->PixelToLogic(aPt); 1367 bPostIt=IsTextEditHit(aPt,nHitTolLog); 1368 } 1369 if (bPostIt) { 1370 Point aPixPos(rMEvt.GetPosPixel()); 1371 Rectangle aR(pWin->LogicToPixel(pTextEditOutlinerView->GetOutputArea())); 1372 if (aPixPos.X()<aR.Left ()) aPixPos.X()=aR.Left (); 1373 if (aPixPos.X()>aR.Right ()) aPixPos.X()=aR.Right (); 1374 if (aPixPos.Y()<aR.Top ()) aPixPos.Y()=aR.Top (); 1375 if (aPixPos.Y()>aR.Bottom()) aPixPos.Y()=aR.Bottom(); 1376 MouseEvent aMEvt(aPixPos,rMEvt.GetClicks(),rMEvt.GetMode(), 1377 rMEvt.GetButtons(),rMEvt.GetModifier()); 1378 if (pTextEditOutlinerView->MouseMove(aMEvt) && bSelMode) { 1379 #ifdef DBG_UTIL 1380 if (pItemBrowser!=NULL) pItemBrowser->SetDirty(); 1381 #endif 1382 ImpMakeTextCursorAreaVisible(); 1383 return sal_True; 1384 } 1385 } 1386 } 1387 return SdrGlueEditView::MouseMove(rMEvt,pWin); 1388 } 1389 1390 sal_Bool SdrObjEditView::Command(const CommandEvent& rCEvt, Window* pWin) 1391 { 1392 // solange bis die OutlinerView einen sal_Bool zurueckliefert 1393 // bekommt sie nur COMMAND_STARTDRAG 1394 if (pTextEditOutlinerView!=NULL) 1395 { 1396 if (rCEvt.GetCommand()==COMMAND_STARTDRAG) { 1397 sal_Bool bPostIt=pTextEditOutliner->IsInSelectionMode() || !rCEvt.IsMouseEvent(); 1398 if (!bPostIt && rCEvt.IsMouseEvent()) { 1399 Point aPt(rCEvt.GetMousePosPixel()); 1400 if (pWin!=NULL) aPt=pWin->PixelToLogic(aPt); 1401 else if (pTextEditWin!=NULL) aPt=pTextEditWin->PixelToLogic(aPt); 1402 bPostIt=IsTextEditHit(aPt,nHitTolLog); 1403 } 1404 if (bPostIt) { 1405 Point aPixPos(rCEvt.GetMousePosPixel()); 1406 if (rCEvt.IsMouseEvent()) { 1407 Rectangle aR(pWin->LogicToPixel(pTextEditOutlinerView->GetOutputArea())); 1408 if (aPixPos.X()<aR.Left ()) aPixPos.X()=aR.Left (); 1409 if (aPixPos.X()>aR.Right ()) aPixPos.X()=aR.Right (); 1410 if (aPixPos.Y()<aR.Top ()) aPixPos.Y()=aR.Top (); 1411 if (aPixPos.Y()>aR.Bottom()) aPixPos.Y()=aR.Bottom(); 1412 } 1413 CommandEvent aCEvt(aPixPos,rCEvt.GetCommand(),rCEvt.IsMouseEvent()); 1414 // Command ist an der OutlinerView leider void 1415 pTextEditOutlinerView->Command(aCEvt); 1416 if (pWin!=NULL && pWin!=pTextEditWin) SetTextEditWin(pWin); 1417 #ifdef DBG_UTIL 1418 if (pItemBrowser!=NULL) pItemBrowser->SetDirty(); 1419 #endif 1420 ImpMakeTextCursorAreaVisible(); 1421 return sal_True; 1422 } 1423 } 1424 else // if (rCEvt.GetCommand() == COMMAND_VOICE ) 1425 { 1426 pTextEditOutlinerView->Command(rCEvt); 1427 return sal_True; 1428 } 1429 } 1430 return SdrGlueEditView::Command(rCEvt,pWin); 1431 } 1432 1433 sal_Bool SdrObjEditView::Cut(sal_uIntPtr nFormat) 1434 { 1435 if (pTextEditOutliner!=NULL) { 1436 pTextEditOutlinerView->Cut(); 1437 #ifdef DBG_UTIL 1438 if (pItemBrowser!=NULL) pItemBrowser->SetDirty(); 1439 #endif 1440 ImpMakeTextCursorAreaVisible(); 1441 return sal_True; 1442 } else { 1443 return SdrGlueEditView::Cut(nFormat); 1444 } 1445 } 1446 1447 sal_Bool SdrObjEditView::Yank(sal_uIntPtr nFormat) 1448 { 1449 if (pTextEditOutliner!=NULL) { 1450 pTextEditOutlinerView->Copy(); 1451 return sal_True; 1452 } else { 1453 return SdrGlueEditView::Yank(nFormat); 1454 } 1455 } 1456 1457 sal_Bool SdrObjEditView::Paste(Window* pWin, sal_uIntPtr nFormat) 1458 { 1459 if (pTextEditOutliner!=NULL) { 1460 if (pWin!=NULL) { 1461 OutlinerView* pNewView=ImpFindOutlinerView(pWin); 1462 if (pNewView!=NULL) { 1463 pNewView->Paste(); 1464 } 1465 } else { 1466 pTextEditOutlinerView->Paste(); 1467 } 1468 #ifdef DBG_UTIL 1469 if (pItemBrowser!=NULL) pItemBrowser->SetDirty(); 1470 #endif 1471 ImpMakeTextCursorAreaVisible(); 1472 return sal_True; 1473 } else { 1474 return SdrGlueEditView::Paste(pWin,nFormat); 1475 } 1476 } 1477 1478 //////////////////////////////////////////////////////////////////////////////////////////////////// 1479 1480 sal_Bool SdrObjEditView::ImpIsTextEditAllSelected() const 1481 { 1482 sal_Bool bRet=sal_False; 1483 if (pTextEditOutliner!=NULL && pTextEditOutlinerView!=NULL) 1484 { 1485 if(SdrTextObj::HasTextImpl( pTextEditOutliner ) ) 1486 { 1487 const sal_uInt32 nParaAnz=pTextEditOutliner->GetParagraphCount(); 1488 Paragraph* pLastPara=pTextEditOutliner->GetParagraph( nParaAnz > 1 ? nParaAnz - 1 : 0 ); 1489 1490 ESelection aESel(pTextEditOutlinerView->GetSelection()); 1491 if (aESel.nStartPara==0 && aESel.nStartPos==0 && aESel.nEndPara==sal_uInt16(nParaAnz-1)) 1492 { 1493 XubString aStr(pTextEditOutliner->GetText(pLastPara)); 1494 1495 if(aStr.Len() == aESel.nEndPos) 1496 bRet = sal_True; 1497 } 1498 // und nun auch noch fuer den Fall, das rueckwaerts selektiert wurde 1499 if (!bRet && aESel.nEndPara==0 && aESel.nEndPos==0 && aESel.nStartPara==sal_uInt16(nParaAnz-1)) 1500 { 1501 XubString aStr(pTextEditOutliner->GetText(pLastPara)); 1502 1503 if(aStr.Len() == aESel.nStartPos) 1504 bRet = sal_True; 1505 } 1506 } 1507 else 1508 { 1509 bRet=sal_True; 1510 } 1511 } 1512 return bRet; 1513 } 1514 1515 void SdrObjEditView::ImpMakeTextCursorAreaVisible() 1516 { 1517 if (pTextEditOutlinerView!=NULL && pTextEditWin!=NULL) { 1518 Cursor* pCsr=pTextEditWin->GetCursor(); 1519 if (pCsr!=NULL) { 1520 Size aSiz(pCsr->GetSize()); 1521 if (aSiz.Width()!=0 && aSiz.Height()!=0) { // #38450# 1522 MakeVisible(Rectangle(pCsr->GetPos(),aSiz),*pTextEditWin); 1523 } 1524 } 1525 } 1526 } 1527 1528 sal_uInt16 SdrObjEditView::GetScriptType() const 1529 { 1530 sal_uInt16 nScriptType = 0; 1531 1532 if( IsTextEdit() ) 1533 { 1534 if( mxTextEditObj->GetOutlinerParaObject() ) 1535 nScriptType = mxTextEditObj->GetOutlinerParaObject()->GetTextObject().GetScriptType(); 1536 1537 if( pTextEditOutlinerView ) 1538 nScriptType = pTextEditOutlinerView->GetSelectedScriptType(); 1539 } 1540 else 1541 { 1542 sal_uInt32 nMarkCount( GetMarkedObjectCount() ); 1543 1544 for( sal_uInt32 i = 0; i < nMarkCount; i++ ) 1545 { 1546 OutlinerParaObject* pParaObj = GetMarkedObjectByIndex( i )->GetOutlinerParaObject(); 1547 1548 if( pParaObj ) 1549 { 1550 nScriptType |= pParaObj->GetTextObject().GetScriptType(); 1551 } 1552 } 1553 } 1554 1555 if( nScriptType == 0 ) 1556 nScriptType = SCRIPTTYPE_LATIN; 1557 1558 return nScriptType; 1559 } 1560 1561 /* new interface src537 */ 1562 sal_Bool SdrObjEditView::GetAttributes(SfxItemSet& rTargetSet, sal_Bool bOnlyHardAttr) const 1563 { 1564 if( mxSelectionController.is() ) 1565 if( mxSelectionController->GetAttributes( rTargetSet, bOnlyHardAttr ) ) 1566 return sal_True; 1567 1568 if(IsTextEdit()) 1569 { 1570 DBG_ASSERT(pTextEditOutlinerView!=NULL,"SdrObjEditView::GetAttributes(): pTextEditOutlinerView=NULL"); 1571 DBG_ASSERT(pTextEditOutliner!=NULL,"SdrObjEditView::GetAttributes(): pTextEditOutliner=NULL"); 1572 1573 // #92389# take care of bOnlyHardAttr(!) 1574 if(!bOnlyHardAttr && mxTextEditObj->GetStyleSheet()) 1575 rTargetSet.Put(mxTextEditObj->GetStyleSheet()->GetItemSet()); 1576 1577 // add object attributes 1578 rTargetSet.Put( mxTextEditObj->GetMergedItemSet() ); 1579 1580 if( mxTextEditObj->GetOutlinerParaObject() ) 1581 rTargetSet.Put( SvxScriptTypeItem( mxTextEditObj->GetOutlinerParaObject()->GetTextObject().GetScriptType() ) ); 1582 1583 if(pTextEditOutlinerView) 1584 { 1585 // FALSE= InvalidItems nicht al Default, sondern als "Loecher" betrachten 1586 rTargetSet.Put(pTextEditOutlinerView->GetAttribs(), sal_False); 1587 rTargetSet.Put( SvxScriptTypeItem( pTextEditOutlinerView->GetSelectedScriptType() ), sal_False ); 1588 } 1589 1590 if(GetMarkedObjectCount()==1 && GetMarkedObjectByIndex(0)==mxTextEditObj.get()) 1591 { 1592 MergeNotPersistAttrFromMarked(rTargetSet, bOnlyHardAttr); 1593 } 1594 1595 return sal_True; 1596 } 1597 else 1598 { 1599 return SdrGlueEditView::GetAttributes(rTargetSet, bOnlyHardAttr); 1600 } 1601 } 1602 1603 sal_Bool SdrObjEditView::SetAttributes(const SfxItemSet& rSet, sal_Bool bReplaceAll) 1604 { 1605 sal_Bool bRet=sal_False; 1606 sal_Bool bTextEdit=pTextEditOutlinerView!=NULL && mxTextEditObj.is(); 1607 sal_Bool bAllTextSelected=ImpIsTextEditAllSelected(); 1608 SfxItemSet* pModifiedSet=NULL; 1609 const SfxItemSet* pSet=&rSet; 1610 //const SvxAdjustItem* pParaJust=NULL; 1611 1612 if (!bTextEdit) 1613 { 1614 // Kein TextEdit aktiv -> alle Items ans Zeichenobjekt 1615 if( mxSelectionController.is() ) 1616 bRet=mxSelectionController->SetAttributes(*pSet,bReplaceAll ); 1617 1618 if( !bRet ) 1619 { 1620 bRet=SdrGlueEditView::SetAttributes(*pSet,bReplaceAll); 1621 } 1622 } 1623 else 1624 { 1625 #ifdef DBG_UTIL 1626 { 1627 sal_Bool bHasEEFeatureItems=sal_False; 1628 SfxItemIter aIter(rSet); 1629 const SfxPoolItem* pItem=aIter.FirstItem(); 1630 while (!bHasEEFeatureItems && pItem!=NULL) 1631 { 1632 if (!IsInvalidItem(pItem)) 1633 { 1634 sal_uInt16 nW=pItem->Which(); 1635 if (nW>=EE_FEATURE_START && nW<=EE_FEATURE_END) 1636 bHasEEFeatureItems=sal_True; 1637 } 1638 1639 pItem=aIter.NextItem(); 1640 } 1641 1642 if(bHasEEFeatureItems) 1643 { 1644 String aMessage; 1645 aMessage.AppendAscii("SdrObjEditView::SetAttributes(): Das setzen von EE_FEATURE-Items an der SdrView macht keinen Sinn! Es fuehrt nur zu Overhead und nicht mehr lesbaren Dokumenten."); 1646 InfoBox(NULL, aMessage).Execute(); 1647 } 1648 } 1649 #endif 1650 1651 sal_Bool bOnlyEEItems; 1652 sal_Bool bNoEEItems=!SearchOutlinerItems(*pSet,bReplaceAll,&bOnlyEEItems); 1653 // alles selektiert? -> Attrs auch an den Rahmen 1654 // und falls keine EEItems, dann Attrs nur an den Rahmen 1655 if (bAllTextSelected || bNoEEItems) 1656 { 1657 if( mxSelectionController.is() ) 1658 bRet=mxSelectionController->SetAttributes(*pSet,bReplaceAll ); 1659 1660 if( !bRet ) 1661 { 1662 const bool bUndo = IsUndoEnabled(); 1663 1664 if( bUndo ) 1665 { 1666 String aStr; 1667 ImpTakeDescriptionStr(STR_EditSetAttributes,aStr); 1668 BegUndo(aStr); 1669 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*mxTextEditObj.get())); 1670 1671 // #i43537# 1672 // If this is a text object also rescue the OutlinerParaObject since 1673 // applying attributes to the object may change text layout when 1674 // multiple portions exist with multiple formats. If a OutlinerParaObject 1675 // really exists and needs to be rescued is evaluated in the undo 1676 // implementation itself. 1677 bool bRescueText = dynamic_cast< SdrTextObj* >(mxTextEditObj.get()); 1678 1679 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoAttrObject(*mxTextEditObj.get(),false,!bNoEEItems || bRescueText)); 1680 EndUndo(); 1681 } 1682 1683 mxTextEditObj->SetMergedItemSetAndBroadcast(*pSet, bReplaceAll); 1684 1685 FlushComeBackTimer(); // Damit ModeHasChanged sofort kommt 1686 bRet=sal_True; 1687 } 1688 } 1689 else if (!bOnlyEEItems) 1690 { 1691 // sonst Set ggf. splitten 1692 // Es wird nun ein ItemSet aSet gemacht, in den die EE_Items von 1693 // *pSet nicht enhalten ist (ansonsten ist es eine Kopie). 1694 sal_uInt16* pNewWhichTable=RemoveWhichRange(pSet->GetRanges(),EE_ITEMS_START,EE_ITEMS_END); 1695 SfxItemSet aSet(pMod->GetItemPool(),pNewWhichTable); 1696 /*90353*/ delete[] pNewWhichTable; 1697 SfxWhichIter aIter(aSet); 1698 sal_uInt16 nWhich=aIter.FirstWhich(); 1699 while (nWhich!=0) 1700 { 1701 const SfxPoolItem* pItem; 1702 SfxItemState eState=pSet->GetItemState(nWhich,sal_False,&pItem); 1703 if (eState==SFX_ITEM_SET) aSet.Put(*pItem); 1704 nWhich=aIter.NextWhich(); 1705 } 1706 1707 1708 if( mxSelectionController.is() ) 1709 bRet=mxSelectionController->SetAttributes(aSet,bReplaceAll ); 1710 1711 if( !bRet ) 1712 { 1713 if( IsUndoEnabled() ) 1714 { 1715 String aStr; 1716 ImpTakeDescriptionStr(STR_EditSetAttributes,aStr); 1717 BegUndo(aStr); 1718 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*mxTextEditObj.get())); 1719 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoAttrObject(*mxTextEditObj.get(),false,false)); 1720 EndUndo(); 1721 } 1722 1723 mxTextEditObj->SetMergedItemSetAndBroadcast(aSet, bReplaceAll); 1724 1725 if (GetMarkedObjectCount()==1 && GetMarkedObjectByIndex(0)==mxTextEditObj.get()) 1726 { 1727 SetNotPersistAttrToMarked(aSet,bReplaceAll); 1728 } 1729 } 1730 FlushComeBackTimer(); 1731 bRet=sal_True; 1732 } 1733 if(!bNoEEItems) 1734 { 1735 // und nun die Attribute auch noch an die EditEngine 1736 if (bReplaceAll) { 1737 // Am Outliner kann man leider nur alle Attribute platthauen 1738 pTextEditOutlinerView->RemoveAttribs( sal_True ); 1739 } 1740 pTextEditOutlinerView->SetAttribs(rSet); 1741 1742 #ifdef DBG_UTIL 1743 if (pItemBrowser!=NULL) 1744 pItemBrowser->SetDirty(); 1745 #endif 1746 1747 ImpMakeTextCursorAreaVisible(); 1748 } 1749 bRet=sal_True; 1750 } 1751 if (pModifiedSet!=NULL) 1752 delete pModifiedSet; 1753 return bRet; 1754 } 1755 1756 SfxStyleSheet* SdrObjEditView::GetStyleSheet() const 1757 { 1758 SfxStyleSheet* pSheet = 0; 1759 1760 if( mxSelectionController.is() ) 1761 { 1762 if( mxSelectionController->GetStyleSheet( pSheet ) ) 1763 return pSheet; 1764 } 1765 1766 if ( pTextEditOutlinerView ) 1767 { 1768 pSheet = pTextEditOutlinerView->GetStyleSheet(); 1769 } 1770 else 1771 { 1772 pSheet = SdrGlueEditView::GetStyleSheet(); 1773 } 1774 return pSheet; 1775 } 1776 1777 sal_Bool SdrObjEditView::SetStyleSheet(SfxStyleSheet* pStyleSheet, sal_Bool bDontRemoveHardAttr) 1778 { 1779 if( mxSelectionController.is() ) 1780 { 1781 if( mxSelectionController->SetStyleSheet( pStyleSheet, bDontRemoveHardAttr ) ) 1782 return sal_True; 1783 } 1784 1785 // if we are currently in edit mode we must also set the stylesheet 1786 // on all paragraphs in the Outliner for the edit view 1787 // #92191# 1788 if( NULL != pTextEditOutlinerView ) 1789 { 1790 Outliner* pOutliner = pTextEditOutlinerView->GetOutliner(); 1791 1792 const sal_uIntPtr nParaCount = pOutliner->GetParagraphCount(); 1793 sal_uIntPtr nPara; 1794 for( nPara = 0; nPara < nParaCount; nPara++ ) 1795 { 1796 pOutliner->SetStyleSheet( nPara, pStyleSheet ); 1797 } 1798 } 1799 1800 return SdrGlueEditView::SetStyleSheet(pStyleSheet,bDontRemoveHardAttr); 1801 } 1802 1803 //////////////////////////////////////////////////////////////////////////////////////////////////// 1804 1805 void SdrObjEditView::AddWindowToPaintView(OutputDevice* pNewWin) 1806 { 1807 SdrGlueEditView::AddWindowToPaintView(pNewWin); 1808 1809 if(mxTextEditObj.is() && !bTextEditOnlyOneView && pNewWin->GetOutDevType()==OUTDEV_WINDOW) 1810 { 1811 OutlinerView* pOutlView=ImpMakeOutlinerView((Window*)pNewWin,sal_False,NULL); 1812 pTextEditOutliner->InsertView(pOutlView); 1813 } 1814 } 1815 1816 void SdrObjEditView::DeleteWindowFromPaintView(OutputDevice* pOldWin) 1817 { 1818 SdrGlueEditView::DeleteWindowFromPaintView(pOldWin); 1819 1820 if(mxTextEditObj.is() && !bTextEditOnlyOneView && pOldWin->GetOutDevType()==OUTDEV_WINDOW) 1821 { 1822 for (sal_uIntPtr i=pTextEditOutliner->GetViewCount(); i>0;) { 1823 i--; 1824 OutlinerView* pOLV=pTextEditOutliner->GetView(i); 1825 if (pOLV && pOLV->GetWindow()==(Window*)pOldWin) { 1826 delete pTextEditOutliner->RemoveView(i); 1827 } 1828 } 1829 } 1830 } 1831 1832 sal_Bool SdrObjEditView::IsTextEditInSelectionMode() const 1833 { 1834 return pTextEditOutliner!=NULL && pTextEditOutliner->IsInSelectionMode(); 1835 } 1836 1837 //////////////////////////////////////////////////////////////////////////////////////////////////// 1838 // 1839 // @@ @@ @@@@ @@@@ @@@@@ @@@@ @@ @@ @@@@ @@@@@ @@@@@ 1840 // @@@ @@@ @@ @@ @@ @@ @@ @@ @@ @@ @@@ @@@ @@ @@ @@ @@ @@ 1841 // @@@@@@@ @@ @@ @@ @@ @@ @@ @@ @@@@@@@ @@ @@ @@ @@ @@ 1842 // @@@@@@@ @@@@@@ @@ @@@@@ @@ @@ @@@@@@@ @@ @@ @@ @@ @@@@ 1843 // @@ @ @@ @@ @@ @@ @@ @@ @@ @@ @@ @ @@ @@ @@ @@ @@ @@ 1844 // @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ 1845 // @@ @@ @@ @@ @@@@ @@ @@ @@@@ @@ @@ @@@@ @@@@@ @@@@@ 1846 // 1847 //////////////////////////////////////////////////////////////////////////////////////////////////// 1848 1849 sal_Bool SdrObjEditView::BegMacroObj(const Point& rPnt, short nTol, SdrObject* pObj, SdrPageView* pPV, Window* pWin) 1850 { 1851 sal_Bool bRet=sal_False; 1852 BrkMacroObj(); 1853 if (pObj!=NULL && pPV!=NULL && pWin!=NULL && pObj->HasMacro()) { 1854 nTol=ImpGetHitTolLogic(nTol,NULL); 1855 pMacroObj=pObj; 1856 pMacroPV=pPV; 1857 pMacroWin=pWin; 1858 bMacroDown=sal_False; 1859 nMacroTol=sal_uInt16(nTol); 1860 aMacroDownPos=rPnt; 1861 MovMacroObj(rPnt); 1862 } 1863 return bRet; 1864 } 1865 1866 void SdrObjEditView::ImpMacroUp(const Point& rUpPos) 1867 { 1868 if (pMacroObj!=NULL && bMacroDown) 1869 { 1870 SdrObjMacroHitRec aHitRec; 1871 aHitRec.aPos=rUpPos; 1872 aHitRec.aDownPos=aMacroDownPos; 1873 aHitRec.nTol=nMacroTol; 1874 aHitRec.pVisiLayer=&pMacroPV->GetVisibleLayers(); 1875 aHitRec.pPageView=pMacroPV; 1876 aHitRec.pOut=pMacroWin; 1877 pMacroObj->PaintMacro(*pMacroWin,Rectangle(),aHitRec); 1878 bMacroDown=sal_False; 1879 } 1880 } 1881 1882 void SdrObjEditView::ImpMacroDown(const Point& rDownPos) 1883 { 1884 if (pMacroObj!=NULL && !bMacroDown) 1885 { 1886 SdrObjMacroHitRec aHitRec; 1887 aHitRec.aPos=rDownPos; 1888 aHitRec.aDownPos=aMacroDownPos; 1889 aHitRec.nTol=nMacroTol; 1890 aHitRec.pVisiLayer=&pMacroPV->GetVisibleLayers(); 1891 aHitRec.pPageView=pMacroPV; 1892 aHitRec.bDown=sal_True; 1893 aHitRec.pOut=pMacroWin; 1894 pMacroObj->PaintMacro(*pMacroWin,Rectangle(),aHitRec); 1895 bMacroDown=sal_True; 1896 } 1897 } 1898 1899 void SdrObjEditView::MovMacroObj(const Point& rPnt) 1900 { 1901 if (pMacroObj!=NULL) { 1902 SdrObjMacroHitRec aHitRec; 1903 aHitRec.aPos=rPnt; 1904 aHitRec.aDownPos=aMacroDownPos; 1905 aHitRec.nTol=nMacroTol; 1906 aHitRec.pVisiLayer=&pMacroPV->GetVisibleLayers(); 1907 aHitRec.pPageView=pMacroPV; 1908 aHitRec.bDown=bMacroDown; 1909 aHitRec.pOut=pMacroWin; 1910 sal_Bool bDown=pMacroObj->IsMacroHit(aHitRec); 1911 if (bDown) ImpMacroDown(rPnt); 1912 else ImpMacroUp(rPnt); 1913 } 1914 } 1915 1916 void SdrObjEditView::BrkMacroObj() 1917 { 1918 if (pMacroObj!=NULL) { 1919 ImpMacroUp(aMacroDownPos); 1920 pMacroObj=NULL; 1921 pMacroPV=NULL; 1922 pMacroWin=NULL; 1923 } 1924 } 1925 1926 sal_Bool SdrObjEditView::EndMacroObj() 1927 { 1928 if (pMacroObj!=NULL && bMacroDown) { 1929 ImpMacroUp(aMacroDownPos); 1930 SdrObjMacroHitRec aHitRec; 1931 aHitRec.aPos=aMacroDownPos; 1932 aHitRec.aDownPos=aMacroDownPos; 1933 aHitRec.nTol=nMacroTol; 1934 aHitRec.pVisiLayer=&pMacroPV->GetVisibleLayers(); 1935 aHitRec.pPageView=pMacroPV; 1936 aHitRec.bDown=sal_True; 1937 aHitRec.pOut=pMacroWin; 1938 bool bRet=pMacroObj->DoMacro(aHitRec); 1939 pMacroObj=NULL; 1940 pMacroPV=NULL; 1941 pMacroWin=NULL; 1942 return bRet; 1943 } else { 1944 BrkMacroObj(); 1945 return sal_False; 1946 } 1947 } 1948 1949 /** fills the given any with a XTextCursor for the current text selection. 1950 Leaves the any untouched if there currently is no text selected */ 1951 void SdrObjEditView::getTextSelection( ::com::sun::star::uno::Any& rSelection ) 1952 { 1953 if( IsTextEdit() ) 1954 { 1955 OutlinerView* pOutlinerView = GetTextEditOutlinerView(); 1956 if( pOutlinerView && pOutlinerView->HasSelection() ) 1957 { 1958 SdrObject* pObj = GetTextEditObject(); 1959 1960 if( pObj ) 1961 { 1962 ::com::sun::star::uno::Reference< ::com::sun::star::text::XText > xText( pObj->getUnoShape(), ::com::sun::star::uno::UNO_QUERY ); 1963 if( xText.is() ) 1964 { 1965 SvxUnoTextBase* pRange = SvxUnoTextBase::getImplementation( xText ); 1966 if( pRange ) 1967 { 1968 rSelection <<= pRange->createTextCursorBySelection( pOutlinerView->GetSelection() ); 1969 } 1970 } 1971 } 1972 } 1973 } 1974 } 1975 1976 namespace sdr { namespace table { 1977 extern rtl::Reference< sdr::SelectionController > CreateTableController( SdrObjEditView* pView, const SdrObject* pObj, const rtl::Reference< sdr::SelectionController >& xRefController ); 1978 } } 1979 1980 /* check if we have a single selection and that single object likes 1981 to handle the mouse and keyboard events itself 1982 1983 @todo: the selection controller should be queried from the 1984 object specific view contact. Currently this method only 1985 works for tables. 1986 */ 1987 void SdrObjEditView::MarkListHasChanged() 1988 { 1989 SdrGlueEditView::MarkListHasChanged(); 1990 1991 if( mxSelectionController.is() ) 1992 { 1993 mxLastSelectionController = mxSelectionController; 1994 mxSelectionController->onSelectionHasChanged(); 1995 } 1996 1997 mxSelectionController.clear(); 1998 1999 const SdrMarkList& rMarkList=GetMarkedObjectList(); 2000 if( rMarkList.GetMarkCount() == 1 ) 2001 { 2002 const SdrObject* pObj= rMarkList.GetMark(0)->GetMarkedSdrObj(); 2003 // check for table 2004 if( pObj && (pObj->GetObjInventor() == SdrInventor ) && (pObj->GetObjIdentifier() == OBJ_TABLE) ) 2005 { 2006 mxSelectionController = sdr::table::CreateTableController( this, pObj, mxLastSelectionController ); 2007 if( mxSelectionController.is() ) 2008 { 2009 mxLastSelectionController.clear(); 2010 mxSelectionController->onSelectionHasChanged(); 2011 } 2012 } 2013 } 2014 } 2015 2016 IMPL_LINK( SdrObjEditView, EndPasteOrDropHdl, PasteOrDropInfos*, pInfos ) 2017 { 2018 OnEndPasteOrDrop( pInfos ); 2019 return 0; 2020 } 2021 2022 IMPL_LINK( SdrObjEditView, BeginPasteOrDropHdl, PasteOrDropInfos*, pInfos ) 2023 { 2024 OnBeginPasteOrDrop( pInfos ); 2025 return 0; 2026 } 2027 2028 void SdrObjEditView::OnBeginPasteOrDrop( PasteOrDropInfos* ) 2029 { 2030 // applications can derive from these virtual methods to do something before a drop or paste operation 2031 } 2032 2033 void SdrObjEditView::OnEndPasteOrDrop( PasteOrDropInfos* ) 2034 { 2035 // applications can derive from these virtual methods to do something before a drop or paste operation 2036 } 2037 2038 bool SdrObjEditView::SupportsFormatPaintbrush( sal_uInt32 nObjectInventor, sal_uInt16 nObjectIdentifier ) const 2039 { 2040 if( nObjectInventor != SdrInventor && nObjectInventor != E3dInventor ) 2041 return false; 2042 switch(nObjectIdentifier) 2043 { 2044 case OBJ_NONE: 2045 case OBJ_GRUP: 2046 return false; 2047 case OBJ_LINE: 2048 case OBJ_RECT: 2049 case OBJ_CIRC: 2050 case OBJ_SECT: 2051 case OBJ_CARC: 2052 case OBJ_CCUT: 2053 case OBJ_POLY: 2054 case OBJ_PLIN: 2055 case OBJ_PATHLINE: 2056 case OBJ_PATHFILL: 2057 case OBJ_FREELINE: 2058 case OBJ_FREEFILL: 2059 case OBJ_SPLNLINE: 2060 case OBJ_SPLNFILL: 2061 case OBJ_TEXT: 2062 case OBJ_TEXTEXT: 2063 case OBJ_TITLETEXT: 2064 case OBJ_OUTLINETEXT: 2065 case OBJ_GRAF: 2066 case OBJ_OLE2: 2067 case OBJ_TABLE: 2068 return true; 2069 case OBJ_EDGE: 2070 case OBJ_CAPTION: 2071 return false; 2072 case OBJ_PATHPOLY: 2073 case OBJ_PATHPLIN: 2074 return true; 2075 case OBJ_PAGE: 2076 case OBJ_MEASURE: 2077 case OBJ_DUMMY: 2078 case OBJ_FRAME: 2079 case OBJ_UNO: 2080 return false; 2081 case OBJ_CUSTOMSHAPE: 2082 return true; 2083 default: 2084 return false; 2085 } 2086 } 2087 2088 static const sal_uInt16* GetFormatRangeImpl( bool bTextOnly ) 2089 { 2090 static const sal_uInt16 gRanges[] = { 2091 SDRATTR_SHADOW_FIRST, SDRATTR_SHADOW_LAST, 2092 SDRATTR_GRAF_FIRST, SDRATTR_GRAF_LAST, 2093 SDRATTR_TABLE_FIRST, SDRATTR_TABLE_LAST, 2094 XATTR_LINE_FIRST, XATTR_LINE_LAST, 2095 XATTR_FILL_FIRST, XATTRSET_FILL, 2096 EE_PARA_START, EE_PARA_END, 2097 EE_CHAR_START, EE_CHAR_END, 2098 0,0 2099 }; 2100 return &gRanges[ bTextOnly ? 10 : 0]; 2101 } 2102 2103 bool SdrObjEditView::TakeFormatPaintBrush( boost::shared_ptr< SfxItemSet >& rFormatSet ) 2104 { 2105 if( mxSelectionController.is() && mxSelectionController->TakeFormatPaintBrush(rFormatSet) ) 2106 return true; 2107 2108 const SdrMarkList& rMarkList = GetMarkedObjectList(); 2109 if( rMarkList.GetMarkCount() >= 1 ) 2110 { 2111 OutlinerView* pOLV = GetTextEditOutlinerView(); 2112 2113 rFormatSet.reset( new SfxItemSet( GetModel()->GetItemPool(), GetFormatRangeImpl( pOLV != NULL ) ) ); 2114 if( pOLV ) 2115 { 2116 rFormatSet->Put( pOLV->GetAttribs() ); 2117 } 2118 else 2119 { 2120 const sal_Bool bOnlyHardAttr = sal_False; 2121 rFormatSet->Put( GetAttrFromMarked(bOnlyHardAttr) ); 2122 } 2123 return true; 2124 } 2125 2126 return false; 2127 } 2128 2129 static SfxItemSet CreatePaintSet( const sal_uInt16 *pRanges, SfxItemPool& rPool, const SfxItemSet& rSourceSet, const SfxItemSet& rTargetSet, bool bNoCharacterFormats, bool bNoParagraphFormats ) 2130 { 2131 SfxItemSet aPaintSet( rPool, pRanges ); 2132 2133 while( *pRanges ) 2134 { 2135 sal_uInt16 nWhich = *pRanges++; 2136 const sal_uInt16 nLastWhich = *pRanges++; 2137 2138 if( bNoCharacterFormats && (nWhich == EE_CHAR_START) ) 2139 continue; 2140 2141 if( bNoParagraphFormats && (nWhich == EE_PARA_START ) ) 2142 continue; 2143 2144 for( ; nWhich < nLastWhich; nWhich++ ) 2145 { 2146 const SfxPoolItem* pSourceItem = rSourceSet.GetItem( nWhich ); 2147 const SfxPoolItem* pTargetItem = rTargetSet.GetItem( nWhich ); 2148 2149 if( (pSourceItem && !pTargetItem) || (pSourceItem && pTargetItem && !((*pSourceItem) == (*pTargetItem)) ) ) 2150 { 2151 aPaintSet.Put( *pSourceItem ); 2152 } 2153 } 2154 } 2155 return aPaintSet; 2156 } 2157 2158 void SdrObjEditView::ApplyFormatPaintBrushToText( SfxItemSet& rFormatSet, SdrTextObj& rTextObj, SdrText* pText, bool bNoCharacterFormats, bool bNoParagraphFormats ) 2159 { 2160 OutlinerParaObject* pParaObj = pText ? pText->GetOutlinerParaObject() : 0; 2161 if(pParaObj) 2162 { 2163 SdrOutliner& rOutliner = rTextObj.ImpGetDrawOutliner(); 2164 rOutliner.SetText(*pParaObj); 2165 2166 sal_uInt32 nParaCount(rOutliner.GetParagraphCount()); 2167 2168 if(nParaCount) 2169 { 2170 for(sal_uInt16 nPara = 0; nPara < nParaCount; nPara++) 2171 { 2172 if( !bNoCharacterFormats ) 2173 rOutliner.QuickRemoveCharAttribs( nPara, /* remove all */0 ); 2174 2175 SfxItemSet aSet(rOutliner.GetParaAttribs(nPara)); 2176 aSet.Put(CreatePaintSet( GetFormatRangeImpl(true), *aSet.GetPool(), rFormatSet, aSet, bNoCharacterFormats, bNoParagraphFormats ) ); 2177 rOutliner.SetParaAttribs(nPara, aSet); 2178 } 2179 2180 OutlinerParaObject* pTemp = rOutliner.CreateParaObject(0, (sal_uInt16)nParaCount); 2181 rOutliner.Clear(); 2182 2183 rTextObj.NbcSetOutlinerParaObjectForText(pTemp,pText); 2184 } 2185 } 2186 } 2187 2188 void SdrObjEditView::ApplyFormatPaintBrush( SfxItemSet& rFormatSet, bool bNoCharacterFormats, bool bNoParagraphFormats ) 2189 { 2190 if( !mxSelectionController.is() || !mxSelectionController->ApplyFormatPaintBrush( rFormatSet, bNoCharacterFormats, bNoParagraphFormats ) ) 2191 { 2192 const SdrMarkList& rMarkList = GetMarkedObjectList(); 2193 SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); 2194 OutlinerView* pOLV = GetTextEditOutlinerView(); 2195 2196 const SfxItemSet& rShapeSet = pObj->GetMergedItemSet(); 2197 2198 if( !pOLV ) 2199 { 2200 // if not in text edit mode (aka the user selected text or clicked on a word) 2201 // apply formating attributes to selected shape 2202 // All formating items (see ranges above) that are unequal in selected shape and 2203 // the format paintbrush are hard set on the selected shape. 2204 2205 const sal_uInt16* pRanges = rFormatSet.GetRanges(); 2206 bool bTextOnly = true; 2207 2208 while( *pRanges ) 2209 { 2210 if( (*pRanges != EE_PARA_START) && (*pRanges != EE_CHAR_START) ) 2211 { 2212 bTextOnly = false; 2213 break; 2214 } 2215 pRanges += 2; 2216 } 2217 2218 if( !bTextOnly ) 2219 { 2220 SfxItemSet aPaintSet( CreatePaintSet( GetFormatRangeImpl(false), *rShapeSet.GetPool(), rFormatSet, rShapeSet, bNoCharacterFormats, bNoParagraphFormats ) ); 2221 const sal_Bool bReplaceAll = sal_False; 2222 SetAttrToMarked(aPaintSet, bReplaceAll); 2223 } 2224 2225 // now apply character and paragraph formating to text, if the shape has any 2226 SdrTextObj* pTextObj = dynamic_cast<SdrTextObj*>(pObj); 2227 if( pTextObj ) 2228 { 2229 sal_Int32 nText = pTextObj->getTextCount(); 2230 2231 while( --nText >= 0 ) 2232 { 2233 SdrText* pText = pTextObj->getText( nText ); 2234 ApplyFormatPaintBrushToText( rFormatSet, *pTextObj, pText, bNoCharacterFormats, bNoParagraphFormats ); 2235 } 2236 } 2237 } 2238 else 2239 { 2240 ::Outliner* pOutliner = pOLV->GetOutliner(); 2241 if( pOutliner ) 2242 { 2243 const EditEngine& rEditEngine = pOutliner->GetEditEngine(); 2244 2245 ESelection aSel( pOLV->GetSelection() ); 2246 if( !aSel.HasRange() ) 2247 pOLV->SetSelection( rEditEngine.GetWord( aSel, com::sun::star::i18n::WordType::DICTIONARY_WORD ) ); 2248 2249 const sal_Bool bRemoveParaAttribs = !bNoParagraphFormats; 2250 pOLV->RemoveAttribsKeepLanguages( bRemoveParaAttribs ); 2251 SfxItemSet aSet( pOLV->GetAttribs() ); 2252 SfxItemSet aPaintSet( CreatePaintSet(GetFormatRangeImpl(true), *aSet.GetPool(), rFormatSet, aSet, bNoCharacterFormats, bNoParagraphFormats ) ); 2253 pOLV->SetAttribs( aPaintSet ); 2254 } 2255 } 2256 } 2257 } 2258