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_sd.hxx" 26 27 28 #include "futext.hxx" 29 #include <editeng/eeitem.hxx> 30 #include <editeng/editerr.hxx> 31 #include <svx/dlgutil.hxx> 32 #include <svx/svxerr.hxx> 33 #include <tools/urlobj.hxx> 34 #include <vcl/help.hxx> 35 #include <editeng/editstat.hxx> 36 #include <svl/aeitem.hxx> 37 #include <svl/intitem.hxx> 38 #include <svx/svdotext.hxx> 39 #include <svx/svdogrp.hxx> 40 #include <editeng/flditem.hxx> 41 #include <svl/style.hxx> 42 #include <svx/svdpagv.hxx> 43 #include <sfx2/viewfrm.hxx> 44 #include <sfx2/dispatch.hxx> 45 #include <sfx2/bindings.hxx> 46 #include <sfx2/request.hxx> 47 #include <editeng/editeng.hxx> 48 #include <svx/svdoutl.hxx> 49 #include <svx/svxids.hrc> 50 #include <sfx2/docfile.hxx> 51 #include <comphelper/processfactory.hxx> 52 #include <editeng/outlobj.hxx> 53 #include <svtools/langtab.hxx> 54 55 // #104122# 56 #include <editeng/frmdiritem.hxx> 57 58 #include <svx/svdetc.hxx> 59 #include <editeng/editview.hxx> 60 61 #include "sdresid.hxx" 62 #include "app.hrc" 63 #include "res_bmp.hrc" 64 #include "ViewShell.hxx" 65 #include "ViewShellBase.hxx" 66 #include "View.hxx" 67 #include "Outliner.hxx" 68 #include "Window.hxx" 69 #include "drawdoc.hxx" 70 #include "sdpage.hxx" 71 #include "sdmod.hxx" 72 #include "FrameView.hxx" 73 #include "ToolBarManager.hxx" 74 #include "DrawDocShell.hxx" 75 #include "glob.hrc" 76 #include "pres.hxx" 77 #include "optsitem.hxx" 78 79 using ::rtl::OUString; 80 using namespace ::com::sun::star; 81 using namespace ::com::sun::star::uno; 82 using namespace ::com::sun::star::lang; 83 using namespace ::com::sun::star::linguistic2; 84 85 namespace sd { 86 87 static sal_uInt16 SidArray[] = { 88 SID_STYLE_FAMILY2, // 5542 89 SID_STYLE_FAMILY5, // 5545 90 SID_CUT, // 5710 91 SID_COPY, // 5711 92 SID_ATTR_TABSTOP, // 10002 93 SID_ATTR_CHAR_FONT, // 10007 94 SID_ATTR_CHAR_POSTURE, // 10008 95 SID_ATTR_CHAR_WEIGHT, // 10009 96 SID_ATTR_CHAR_UNDERLINE, // 10014 97 SID_ATTR_CHAR_FONTHEIGHT, // 10015 98 SID_ATTR_CHAR_COLOR, // 10017 99 SID_ATTR_PARA_ADJUST_LEFT, // 10028 100 SID_ATTR_PARA_ADJUST_RIGHT, // 10029 101 SID_ATTR_PARA_ADJUST_CENTER, // 10030 102 SID_ATTR_PARA_ADJUST_BLOCK, // 10031 103 SID_ATTR_PARA_LINESPACE_10, // 10034 104 SID_ATTR_PARA_LINESPACE_15, // 10035 105 SID_ATTR_PARA_LINESPACE_20, // 10036 106 SID_ATTR_PARA_LRSPACE, // 10043 107 SID_ATTR_TRANSFORM_POS_X, // 10088 108 SID_ATTR_TRANSFORM_POS_Y, // 10089 109 SID_ATTR_TRANSFORM_WIDTH, // 10090 110 SID_ATTR_TRANSFORM_HEIGHT,// 10091 111 SID_ATTR_TRANSFORM_ROT_X, // 10093 112 SID_ATTR_TRANSFORM_ROT_Y, // 10094 113 SID_ATTR_TRANSFORM_ANGLE, // 10095 //Added 114 SID_OUTLINE_UP, // 10150 115 SID_OUTLINE_DOWN, // 10151 116 SID_OUTLINE_LEFT, // 10152 117 SID_OUTLINE_RIGHT, // 10153 118 SID_ATTR_TRANSFORM_PROTECT_POS,// 10236 119 SID_ATTR_TRANSFORM_PROTECT_SIZE,// 10237 //Added 120 SID_FORMTEXT_STYLE, // 10257 121 SID_SET_SUPER_SCRIPT, // 10294 122 SID_SET_SUB_SCRIPT, // 10295 123 SID_ATTR_TRANSFORM_AUTOWIDTH,// 10310 124 SID_ATTR_TRANSFORM_AUTOHEIGHT,// 10311 //Added 125 SID_HYPERLINK_GETLINK, // 10361 126 SID_CHARMAP, // 10503 127 SID_TEXTDIRECTION_LEFT_TO_RIGHT, // 10907 128 SID_TEXTDIRECTION_TOP_TO_BOTTOM, // 10908 129 SID_ATTR_PARA_LEFT_TO_RIGHT, // 10950 130 SID_ATTR_PARA_RIGHT_TO_LEFT, // 10951 131 FN_NUM_BULLET_ON, // 20138 132 SID_PARASPACE_INCREASE, // 27346 133 SID_PARASPACE_DECREASE, // 27347 134 0 }; 135 136 TYPEINIT1( FuText, FuConstruct ); 137 138 139 static sal_Bool bTestText = 0; 140 141 /************************************************************************* 142 |* 143 |* Basisklasse fuer Textfunktionen 144 |* 145 \************************************************************************/ 146 147 FuText::FuText( ViewShell* pViewSh, ::sd::Window* pWin, ::sd::View* pView, SdDrawDocument* pDoc, SfxRequest& rReq ) 148 : FuConstruct(pViewSh, pWin, pView, pDoc, rReq) 149 , bFirstObjCreated(sal_False) 150 , rRequest (rReq) 151 { 152 } 153 154 FunctionReference FuText::Create( ViewShell* pViewSh, ::sd::Window* pWin, ::sd::View* pView, SdDrawDocument* pDoc, SfxRequest& rReq ) 155 { 156 FunctionReference xFunc( new FuText( pViewSh, pWin, pView, pDoc, rReq ) ); 157 return xFunc; 158 } 159 160 /************************************************************************* 161 |* 162 |* Destruktor 163 |* 164 \************************************************************************/ 165 166 void FuText::disposing() 167 { 168 if(mpView) 169 { 170 if(mpView->SdrEndTextEdit(sal_False) == SDRENDTEXTEDIT_DELETED) 171 mxTextObj.reset( 0 ); 172 173 // die RequestHandler der benutzten Outliner zuruecksetzen auf den 174 // Handler am Dokument 175 ::Outliner* pOutliner = mpView->GetTextEditOutliner(); 176 177 if (pOutliner) 178 pOutliner->SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(mpDoc->GetStyleSheetPool())); 179 } 180 } 181 182 /************************************************************************* 183 |* 184 |* Execute functionality of this class: 185 |* 186 |* #71422: Start the functionality of this class in this method 187 |* and not in the ctor. 188 |* If you construct an object of this class and you put the 189 |* address of this object to pFuActual you've got a problem, 190 |* because some methods inside DoExecute use the pFuActual-Pointer. 191 |* If the code inside DoExecute is executed inside the ctor, 192 |* the value of pFuActual is not right. And the value will not 193 |* be right until the ctor finished !!! 194 |* 195 \************************************************************************/ 196 void FuText::DoExecute( SfxRequest& ) 197 { 198 mpViewShell->GetViewShellBase().GetToolBarManager()->SetToolBarShell( 199 ToolBarManager::TBG_FUNCTION, 200 RID_DRAW_TEXT_TOOLBOX); 201 202 mpView->SetCurrentObj(OBJ_TEXT); 203 mpView->SetEditMode(SDREDITMODE_EDIT); 204 205 MouseEvent aMEvt(mpWindow->GetPointerPosPixel()); 206 207 if (nSlotId == SID_TEXTEDIT) 208 { 209 // Try to select an object 210 SdrPageView* pPV = mpView->GetSdrPageView(); 211 SdrViewEvent aVEvt; 212 mpView->PickAnything(aMEvt, SDRMOUSEBUTTONDOWN, aVEvt); 213 mpView->MarkObj(aVEvt.pRootObj, pPV); 214 215 mxTextObj.reset( dynamic_cast< SdrTextObj* >( aVEvt.pObj ) ); 216 } 217 else if (mpView->AreObjectsMarked()) 218 { 219 const SdrMarkList& rMarkList = mpView->GetMarkedObjectList(); 220 221 if (rMarkList.GetMarkCount() == 1) 222 { 223 SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); 224 mxTextObj.reset( dynamic_cast< SdrTextObj* >( pObj ) ); 225 } 226 } 227 228 // check for table 229 if (mpView->AreObjectsMarked()) 230 { 231 const SdrMarkList& rMarkList = mpView->GetMarkedObjectList(); 232 233 if (rMarkList.GetMarkCount() == 1) 234 { 235 SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); 236 if( pObj && (pObj->GetObjInventor() == SdrInventor ) && (pObj->GetObjIdentifier() == OBJ_TABLE) ) 237 { 238 mpViewShell->GetViewShellBase().GetToolBarManager()->AddToolBarShell( ToolBarManager::TBG_FUNCTION, RID_DRAW_TABLE_TOOLBOX ); 239 } 240 } 241 } 242 243 sal_Bool bQuickDrag = sal_True; 244 245 const SfxItemSet* pArgs = rRequest.GetArgs(); 246 247 if (pArgs 248 249 // #98198# test for type before using 250 && SID_TEXTEDIT == nSlotId 251 && SFX_ITEM_SET == pArgs->GetItemState(SID_TEXTEDIT) 252 253 && (sal_uInt16)((SfxUInt16Item&)pArgs->Get(SID_TEXTEDIT)).GetValue() == 2) 254 { 255 // Selection by doubleclick -> don't allow QuickDrag 256 bQuickDrag = sal_False; 257 } 258 259 SetInEditMode(aMEvt, bQuickDrag); 260 } 261 262 /************************************************************************* 263 |* 264 |* MouseButtonDown-event 265 |* 266 \************************************************************************/ 267 268 sal_Bool FuText::MouseButtonDown(const MouseEvent& rMEvt) 269 { 270 bMBDown = sal_True; 271 272 sal_Bool bReturn = FuDraw::MouseButtonDown(rMEvt); 273 274 /* af: (de)Select object before showing the context menu. 275 // Fuer PopupMenu (vorher DrawViewShell) 276 if ((rMEvt.GetButtons() == MOUSE_RIGHT) && rMEvt.GetClicks() == 1 && 277 mpView->IsTextEdit()) 278 { 279 return (sal_True); 280 } 281 */ 282 283 mpView->SetMarkHdlWhenTextEdit(sal_True); 284 SdrViewEvent aVEvt; 285 SdrHitKind eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt); 286 287 if (eHit == SDRHIT_TEXTEDIT) 288 { 289 // Text getroffen -> Event von SdrView auswerten lassen 290 if (mpView->MouseButtonDown(rMEvt, mpWindow)) 291 return (sal_True); 292 } 293 294 if (rMEvt.GetClicks() == 1) 295 { 296 if (mpView->IsTextEdit() && eHit != SDRHIT_MARKEDOBJECT && eHit != SDRHIT_HANDLE) 297 { 298 // Texteingabe beenden 299 if(mpView->SdrEndTextEdit() == SDRENDTEXTEDIT_DELETED) 300 { 301 // Bugfix von MBA: bei Doppelclick auf der Wiese im Modus Text wird 302 // beim zweiten Click eHit = SDRHIT_TEXTEDITOBJ erhalten, weil ja der 303 // zweite Click auf das im ersten Click angelegte TextObject geht. 304 // Dieses wird aber in SdrEndTextEdit entfernt, weil es leer ist. Es 305 // befindet sich aber noch in der Mark-Liste und der Aufruf MarkObj 306 // weiter unten greift dann auf das tote Object zu. 307 // Als einfacher Fix wird nach SdrEndTextEdit noch einmal eHit ermittelt, 308 // was dann SDRHIT_NONE liefert. 309 mxTextObj.reset( NULL ); 310 eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt); 311 } 312 313 mpView->SetCurrentObj(OBJ_TEXT); 314 mpView->SetEditMode(SDREDITMODE_EDIT); 315 } 316 317 if (rMEvt.IsLeft() || rMEvt.IsRight()) 318 { 319 mpWindow->CaptureMouse(); 320 SdrObject* pObj; 321 SdrPageView* pPV = mpView->GetSdrPageView(); 322 323 if (eHit == SDRHIT_TEXTEDIT) 324 { 325 SetInEditMode(rMEvt, sal_False); 326 } 327 else 328 { 329 sal_Bool bMacro = sal_False; 330 331 if (bMacro && mpView->PickObj(aMDPos,mpView->getHitTolLog(),pObj,pPV,SDRSEARCH_PICKMACRO)) 332 { 333 // Makro 334 sal_uInt16 nHitLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(HITPIX,0)).Width() ); 335 mpView->BegMacroObj(aMDPos,nHitLog,pObj,pPV,mpWindow); 336 } 337 else 338 { 339 if (eHit != SDRHIT_HANDLE) 340 { 341 // Selektion aufheben 342 if (!rMEvt.IsShift() && eHit == SDRHIT_TEXTEDITOBJ) 343 { 344 mpView->UnmarkAll(); 345 mpView->SetDragMode(SDRDRAG_MOVE); 346 } 347 } 348 349 if ( aVEvt.eEvent == SDREVENT_EXECUTEURL || 350 eHit == SDRHIT_HANDLE || 351 eHit == SDRHIT_MARKEDOBJECT || 352 eHit == SDRHIT_TEXTEDITOBJ || 353 ( eHit == SDRHIT_UNMARKEDOBJECT && bFirstObjCreated && 354 !bPermanent ) ) 355 { 356 /********************************************************** 357 * Handle, markiertes oder unmarkiertes Objekt getroffen 358 **********************************************************/ 359 if (eHit == SDRHIT_TEXTEDITOBJ) 360 { 361 /****************************************************** 362 * Text eines unmarkierten Objekts getroffen: 363 * Objekt wird selektiert und in EditMode versetzt 364 ******************************************************/ 365 mpView->MarkObj(aVEvt.pRootObj, pPV); 366 367 if (aVEvt.pObj && aVEvt.pObj->ISA(SdrTextObj)) 368 { 369 mxTextObj.reset( static_cast<SdrTextObj*>(aVEvt.pObj) ); 370 } 371 372 SetInEditMode(rMEvt, sal_True); 373 } 374 else if (aVEvt.eEvent == SDREVENT_EXECUTEURL && !rMEvt.IsMod2()) 375 { 376 /****************************************************** 377 * URL ausfuehren 378 ******************************************************/ 379 mpWindow->ReleaseMouse(); 380 SfxStringItem aStrItem(SID_FILE_NAME, aVEvt.pURLField->GetURL()); 381 SfxStringItem aReferer(SID_REFERER, mpDocSh->GetMedium()->GetName()); 382 SfxBoolItem aBrowseItem( SID_BROWSE, sal_True ); 383 SfxViewFrame* pFrame = mpViewShell->GetViewFrame(); 384 mpWindow->ReleaseMouse(); 385 386 if (rMEvt.IsMod1()) 387 { 388 // Im neuen Frame oeffnen 389 pFrame->GetDispatcher()->Execute(SID_OPENDOC, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, 390 &aStrItem, &aBrowseItem, &aReferer, 0L); 391 } 392 else 393 { 394 // Im aktuellen Frame oeffnen 395 SfxFrameItem aFrameItem(SID_DOCFRAME, pFrame); 396 pFrame->GetDispatcher()->Execute(SID_OPENDOC, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, 397 &aStrItem, &aFrameItem, &aBrowseItem, &aReferer, 0L); 398 } 399 } 400 else 401 { 402 /****************************************************** 403 * Objekt oder Handle draggen 404 ******************************************************/ 405 406 // #i78748# 407 // do the EndTextEdit first, it will delete the handles and force a 408 // recreation. This will make aVEvt.pHdl to point to a deleted handle, 409 // thus it is necessary to reset it and to get it again. 410 411 // #i112855# 412 // cl: I'm not sure why we checked here also for mxTextObj->GetOutlinerParaObjet 413 // this caused SdrEndTextEdit() to be called also when not in text editing and 414 // this does not make sense and caused troubles. (see issue 112855) 415 416 // ::Outliner* pOutl = mpView->GetTextEditOutliner(); 417 // 418 // if (mxTextObj.is() && (mxTextObj->GetOutlinerParaObject() || 419 // (pOutl && pOutl->GetText(pOutl->GetParagraph( 0 )).Len() != 0))) 420 if( mpView->IsTextEdit() ) 421 { 422 mpView->SdrEndTextEdit(); 423 424 if(aVEvt.pHdl) 425 { 426 // force new handle identification, the pointer will be dead here 427 // since SdrEndTextEdit has resetted (deleted) the handles. 428 aVEvt.pHdl = 0; 429 mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt); 430 } 431 } 432 433 if (!aVEvt.pHdl) 434 { 435 if( eHit == SDRHIT_UNMARKEDOBJECT ) 436 { 437 if ( !rMEvt.IsShift() ) 438 mpView->UnmarkAll(); 439 440 mpView->MarkObj(aVEvt.pRootObj, pPV); 441 } 442 443 // Objekt draggen 444 bFirstMouseMove = sal_True; 445 aDragTimer.Start(); 446 } 447 448 449 if ( ! rMEvt.IsRight()) 450 { 451 // we need to pick again since SdrEndTextEdit can rebuild the handles list 452 eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt); 453 if( (eHit == SDRHIT_HANDLE) || (eHit == SDRHIT_MARKEDOBJECT) ) 454 { 455 sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() ); 456 mpView->BegDragObj(aMDPos, (OutputDevice*) NULL, aVEvt.pHdl, nDrgLog); 457 } 458 } 459 bReturn = true; 460 } 461 } 462 else if ( nSlotId != SID_TEXTEDIT && 463 (bPermanent || !bFirstObjCreated) ) 464 { 465 /********************************************************** 466 * Objekt erzeugen 467 **********************************************************/ 468 mpView->SetCurrentObj(OBJ_TEXT); 469 mpView->SetEditMode(SDREDITMODE_CREATE); 470 sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() ); 471 mpView->BegCreateObj(aMDPos, (OutputDevice*) NULL, nDrgLog); 472 } 473 else 474 { 475 /********************************************************** 476 * Selektieren 477 **********************************************************/ 478 if( !rMEvt.IsShift() ) 479 mpView->UnmarkAll(); 480 481 mpView->BegMarkObj( aMDPos ); 482 } 483 } 484 } 485 } 486 } 487 else if ( rMEvt.GetClicks() == 2 && !mpView->IsTextEdit() ) 488 { 489 MouseEvent aMEvt( mpWindow->GetPointerPosPixel() ); 490 SetInEditMode( aMEvt, sal_False ); 491 } 492 493 if (!bIsInDragMode) 494 { 495 ForcePointer(&rMEvt); 496 mpViewShell->GetViewFrame()->GetBindings().Invalidate(SidArray); 497 } 498 499 return (bReturn); 500 } 501 502 /************************************************************************* 503 |* 504 |* MouseMove-event 505 |* 506 \************************************************************************/ 507 508 sal_Bool FuText::MouseMove(const MouseEvent& rMEvt) 509 { 510 sal_Bool bReturn = FuDraw::MouseMove(rMEvt); 511 512 if (aDragTimer.IsActive() ) 513 { 514 if( bFirstMouseMove ) 515 bFirstMouseMove = sal_False; 516 else 517 aDragTimer.Stop(); 518 } 519 520 if (!bReturn && mpView->IsAction() && !mpDocSh->IsReadOnly()) 521 { 522 Point aPix(rMEvt.GetPosPixel()); 523 Point aPnt(mpWindow->PixelToLogic(aPix)); 524 525 ForceScroll(aPix); 526 mpView->MovAction(aPnt); 527 } 528 529 ForcePointer(&rMEvt); 530 531 return (bReturn); 532 } 533 534 /************************************************************************* 535 |* 536 |* MouseButtonUp-event 537 |* 538 \************************************************************************/ 539 540 // #97016# 541 void FuText::ImpSetAttributesForNewTextObject(SdrTextObj* pTxtObj) 542 { 543 if(mpDoc->GetDocumentType() == DOCUMENT_TYPE_IMPRESS) 544 { 545 if( nSlotId == SID_ATTR_CHAR ) 546 { 547 // Impress-Textobjekt wird erzeugt (faellt auf Zeilenhoehe zusammen) 548 // Damit das Objekt beim anschliessenden Erzeugen gleich die richtige 549 // Hoehe bekommt (sonst wird zuviel gepainted) 550 SfxItemSet aSet(mpViewShell->GetPool()); 551 aSet.Put(SdrTextMinFrameHeightItem(0)); 552 aSet.Put(SdrTextAutoGrowWidthItem(sal_False)); 553 aSet.Put(SdrTextAutoGrowHeightItem(sal_True)); 554 pTxtObj->SetMergedItemSet(aSet); 555 pTxtObj->AdjustTextFrameWidthAndHeight(); 556 aSet.Put(SdrTextMaxFrameHeightItem(pTxtObj->GetLogicRect().GetSize().Height())); 557 pTxtObj->SetMergedItemSet(aSet); 558 } 559 else if( nSlotId == SID_ATTR_CHAR_VERTICAL ) 560 { 561 SfxItemSet aSet(mpViewShell->GetPool()); 562 aSet.Put(SdrTextMinFrameWidthItem(0)); 563 aSet.Put(SdrTextAutoGrowWidthItem(sal_True)); 564 aSet.Put(SdrTextAutoGrowHeightItem(sal_False)); 565 566 // #91853# Needs to be set since default is SDRTEXTHORZADJUST_BLOCK 567 aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT)); 568 pTxtObj->SetMergedItemSet(aSet); 569 pTxtObj->AdjustTextFrameWidthAndHeight(); 570 aSet.Put(SdrTextMaxFrameWidthItem(pTxtObj->GetLogicRect().GetSize().Width())); 571 pTxtObj->SetMergedItemSet(aSet); 572 } 573 } 574 else 575 { 576 if( nSlotId == SID_ATTR_CHAR_VERTICAL ) 577 { 578 // draw text object, needs to be initialized when vertical text is used 579 SfxItemSet aSet(mpViewShell->GetPool()); 580 581 // #91510# 582 aSet.Put(SdrTextAutoGrowWidthItem(sal_True)); 583 aSet.Put(SdrTextAutoGrowHeightItem(sal_False)); 584 585 // #91508# 586 //aSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_TOP)); 587 //aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT)); 588 589 // #107235# 590 // Set defaults for vertical klick-n'drag text object, pool defaults are: 591 // SdrTextVertAdjustItem: SDRTEXTVERTADJUST_TOP 592 // SdrTextHorzAdjustItem: SDRTEXTHORZADJUST_BLOCK 593 // Analog to that (thus, #91508# was not completely correct): 594 aSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BLOCK)); 595 aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT)); 596 597 pTxtObj->SetMergedItemSet(aSet); 598 } 599 } 600 } 601 602 // #97016# 603 void FuText::ImpSetAttributesFitToSize(SdrTextObj* pTxtObj) 604 { 605 // FitToSize (An Rahmen anpassen) 606 SfxItemSet aSet(mpViewShell->GetPool(), SDRATTR_TEXT_AUTOGROWHEIGHT, SDRATTR_TEXT_AUTOGROWWIDTH); 607 SdrFitToSizeType eFTS = SDRTEXTFIT_PROPORTIONAL; 608 aSet.Put(SdrTextFitToSizeTypeItem(eFTS)); 609 aSet.Put(SdrTextAutoGrowHeightItem(sal_False)); 610 aSet.Put(SdrTextAutoGrowWidthItem(sal_False)); 611 pTxtObj->SetMergedItemSet(aSet); 612 pTxtObj->AdjustTextFrameWidthAndHeight(); 613 } 614 615 // #97016# 616 void FuText::ImpSetAttributesFitToSizeVertical(SdrTextObj* pTxtObj) 617 { 618 SfxItemSet aSet(mpViewShell->GetPool(), 619 SDRATTR_TEXT_AUTOGROWHEIGHT, SDRATTR_TEXT_AUTOGROWWIDTH); 620 SdrFitToSizeType eFTS = SDRTEXTFIT_PROPORTIONAL; 621 aSet.Put(SdrTextFitToSizeTypeItem(eFTS)); 622 aSet.Put(SdrTextAutoGrowHeightItem(sal_False)); 623 aSet.Put(SdrTextAutoGrowWidthItem(sal_False)); 624 pTxtObj->SetMergedItemSet(aSet); 625 pTxtObj->AdjustTextFrameWidthAndHeight(); 626 } 627 628 // #97016# 629 void FuText::ImpSetAttributesFitCommon(SdrTextObj* pTxtObj) 630 { 631 // Normales Textobjekt 632 if (mpDoc->GetDocumentType() == DOCUMENT_TYPE_IMPRESS) 633 { 634 if( nSlotId == SID_ATTR_CHAR ) 635 { 636 // Impress-Textobjekt (faellt auf Zeilenhoehe zusammen) 637 SfxItemSet aSet(mpViewShell->GetPool()); 638 aSet.Put(SdrTextMinFrameHeightItem(0)); 639 aSet.Put(SdrTextMaxFrameHeightItem(0)); 640 aSet.Put(SdrTextAutoGrowHeightItem(sal_True)); 641 aSet.Put(SdrTextAutoGrowWidthItem(sal_False)); 642 pTxtObj->SetMergedItemSet(aSet); 643 } 644 else if( nSlotId == SID_ATTR_CHAR_VERTICAL ) 645 { 646 SfxItemSet aSet(mpViewShell->GetPool()); 647 aSet.Put(SdrTextMinFrameWidthItem(0)); 648 aSet.Put(SdrTextMaxFrameWidthItem(0)); 649 aSet.Put(SdrTextAutoGrowWidthItem(sal_True)); 650 aSet.Put(SdrTextAutoGrowHeightItem(sal_False)); 651 pTxtObj->SetMergedItemSet(aSet); 652 } 653 654 pTxtObj->AdjustTextFrameWidthAndHeight(); 655 } 656 } 657 658 sal_Bool FuText::MouseButtonUp(const MouseEvent& rMEvt) 659 { 660 sal_Bool bReturn = sal_False; 661 662 if (aDragTimer.IsActive()) 663 { 664 aDragTimer.Stop(); 665 bIsInDragMode = sal_False; 666 } 667 668 mpViewShell->GetViewFrame()->GetBindings().Invalidate( SidArray ); 669 670 Point aPnt( mpWindow->PixelToLogic( rMEvt.GetPosPixel() ) ); 671 672 if( (mpView && mpView->MouseButtonUp(rMEvt, mpWindow)) || rMEvt.GetClicks() == 2 ) 673 return (sal_True); // Event von der SdrView ausgewertet 674 675 sal_Bool bEmptyTextObj = sal_False; 676 677 if (mxTextObj.is()) 678 { 679 const SdrMarkList& rMarkList = mpView->GetMarkedObjectList(); 680 681 if (rMarkList.GetMarkCount() == 1 682 && ( rMarkList.GetMark(0)->GetMarkedSdrObj() == mxTextObj.get()) ) 683 { 684 if( mxTextObj.is() && !GetTextObj()->GetOutlinerParaObject() ) 685 bEmptyTextObj = sal_True; 686 else 687 bFirstObjCreated = sal_True; 688 } 689 else 690 { 691 mxTextObj.reset( 0 ); 692 } 693 } 694 695 if( mpView && mpView->IsDragObj()) 696 { 697 /********************************************************************** 698 * Objekt wurde verschoben 699 **********************************************************************/ 700 FrameView* pFrameView = mpViewShell->GetFrameView(); 701 sal_Bool bDragWithCopy = (rMEvt.IsMod1() && pFrameView->IsDragWithCopy()); 702 703 if (bDragWithCopy) 704 { 705 bDragWithCopy = !mpView->IsPresObjSelected(sal_False, sal_True); 706 } 707 708 mpView->SetDragWithCopy(bDragWithCopy); 709 mpView->EndDragObj( mpView->IsDragWithCopy() ); 710 mpView->ForceMarkedToAnotherPage(); 711 mpView->SetCurrentObj(OBJ_TEXT); 712 713 sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() ); 714 715 if ( mpView->IsRotateAllowed() && mpViewShell->GetFrameView()->IsClickChangeRotation() && (rMEvt.GetClicks() != 2) && 716 !rMEvt.IsShift() && !rMEvt.IsMod1() && !rMEvt.IsMod2() && !rMEvt.IsRight() && 717 Abs(aPnt.X() - aMDPos.X()) < nDrgLog && 718 Abs(aPnt.Y() - aMDPos.Y()) < nDrgLog) 719 { 720 // toggle to rotation mode 721 mpViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_OBJECT_ROTATE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD ); 722 } 723 } 724 else if( mpView && mpView->IsCreateObj() && rMEvt.IsLeft()) 725 { 726 /********************************************************************** 727 * Objekt wurde erzeugt 728 **********************************************************************/ 729 mxTextObj.reset( dynamic_cast< SdrTextObj* >( mpView->GetCreateObj() ) ); 730 731 if( mxTextObj.is() ) 732 { 733 //AW outliner needs to be set to vertical when there is no 734 // outliner object up to now; also it needs to be set back to not 735 // vertical when there was a vertical one used last time. 736 OutlinerParaObject* pOPO = GetTextObj()->GetOutlinerParaObject(); 737 SdrOutliner& rOutl = mxTextObj->GetModel()->GetDrawOutliner(GetTextObj()); 738 sal_Bool bVertical((pOPO && pOPO->IsVertical()) 739 || nSlotId == SID_ATTR_CHAR_VERTICAL 740 || nSlotId == SID_TEXT_FITTOSIZE_VERTICAL); 741 rOutl.SetVertical(bVertical); 742 743 // #107235# 744 // Before ImpSetAttributesForNewTextObject the vertical writing mode 745 // needs to be set at the object. This is done here at the OutlinerParaObject 746 // directly to not mirror the layout text items involved. These items will be set 747 // from ImpSetAttributesForNewTextObject and below. 748 OutlinerParaObject* pPara = GetTextObj()->GetOutlinerParaObject(); 749 750 if(!pPara) 751 { 752 GetTextObj()->ForceOutlinerParaObject(); 753 pPara = GetTextObj()->GetOutlinerParaObject(); 754 } 755 756 if(pPara && (bool)bVertical != pPara->IsVertical()) 757 { 758 // set ParaObject orientation accordingly 759 pPara->SetVertical(bVertical); 760 } 761 762 // #97016# 763 ImpSetAttributesForNewTextObject(GetTextObj()); 764 } 765 766 if (!mpView->EndCreateObj(SDRCREATE_FORCEEND)) 767 { 768 // Textobjekt konnte nicht erzeugt werden 769 mxTextObj.reset(0); 770 } 771 else if (nSlotId == SID_TEXT_FITTOSIZE) 772 { 773 // #97016# 774 ImpSetAttributesFitToSize(GetTextObj()); 775 776 SetInEditMode(rMEvt, sal_False); 777 } 778 else if ( nSlotId == SID_TEXT_FITTOSIZE_VERTICAL ) 779 { 780 // #97016# 781 ImpSetAttributesFitToSizeVertical(GetTextObj()); 782 783 SetInEditMode(rMEvt, sal_False); 784 } 785 else 786 { 787 // #97016# 788 ImpSetAttributesFitCommon(GetTextObj()); 789 790 // Damit die Handles und der graue Rahmen stimmen 791 mpView->AdjustMarkHdl(); 792 mpView->PickHandle(aPnt); 793 SetInEditMode(rMEvt, sal_False); 794 } 795 } 796 else if ( mpView && mpView->IsAction()) 797 { 798 mpView->EndAction(); 799 } 800 801 ForcePointer(&rMEvt); 802 mpWindow->ReleaseMouse(); 803 sal_uInt16 nDrgLog1 = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() ); 804 805 if ( mpView && !mpView->AreObjectsMarked() && 806 Abs(aMDPos.X() - aPnt.X()) < nDrgLog1 && 807 Abs(aMDPos.Y() - aPnt.Y()) < nDrgLog1 && 808 !rMEvt.IsShift() && !rMEvt.IsMod2() ) 809 { 810 SdrPageView* pPV = mpView->GetSdrPageView(); 811 SdrViewEvent aVEvt; 812 mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt); 813 mpView->MarkObj(aVEvt.pRootObj, pPV); 814 } 815 816 if ( !mxTextObj.is() && mpView ) 817 { 818 if ( ( (!bEmptyTextObj && bPermanent) || 819 (!bFirstObjCreated && !bPermanent) ) && 820 !mpDocSh->IsReadOnly() && 821 nSlotId != SID_TEXTEDIT ) 822 { 823 /********************************************************************** 824 * Mengentext (linksbuendiges AutoGrow) 825 **********************************************************************/ 826 mpView->SetCurrentObj(OBJ_TEXT); 827 mpView->SetEditMode(SDREDITMODE_CREATE); 828 sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() ); 829 mpView->BegCreateObj(aMDPos, (OutputDevice*) NULL, nDrgLog); 830 831 sal_Bool bSnapEnabled = mpView->IsSnapEnabled(); 832 833 if (bSnapEnabled) 834 mpView->SetSnapEnabled(sal_False); 835 836 aPnt.X() += nDrgLog + nDrgLog; 837 aPnt.Y() += nDrgLog + nDrgLog; 838 mpView->MovAction(aPnt); 839 840 mxTextObj.reset( dynamic_cast< SdrTextObj* >( mpView->GetCreateObj() ) ); 841 842 if(mxTextObj.is()) 843 { 844 GetTextObj()->SetDisableAutoWidthOnDragging(sal_True); 845 } 846 847 if(!mpView->EndCreateObj(SDRCREATE_FORCEEND)) 848 { 849 mxTextObj.reset(0); 850 } 851 852 if(bSnapEnabled) 853 mpView->SetSnapEnabled(bSnapEnabled); 854 855 if(mxTextObj.is()) 856 { 857 SfxItemSet aSet(mpViewShell->GetPool()); 858 aSet.Put(SdrTextMinFrameHeightItem(0)); 859 aSet.Put(SdrTextMinFrameWidthItem(0)); 860 aSet.Put(SdrTextAutoGrowHeightItem(sal_True)); 861 aSet.Put(SdrTextAutoGrowWidthItem(sal_True)); 862 863 // #91508# 864 if(nSlotId == SID_ATTR_CHAR_VERTICAL) 865 { 866 // #107235# 867 // 868 // Here, all items which need to be different from pool default need to be set 869 // again on the newly created text object. 870 // Since this is a simple klick text object, it is first created, then SetVertical() 871 // is used, then ImpSetAttributesForNewTextObject is called and then the object is 872 // deleted again since not the minimum drag distance was travelled. Then, a new 873 // klick text object is created and thus all that stuff needs to be set again here. 874 // 875 // Before using the new object the vertical writing mode 876 // needs to be set. This is done here at the OutlinerParaObject 877 // directly to not mirror the layout text items involved. These items will be set 878 // below. 879 OutlinerParaObject* pPara = GetTextObj()->GetOutlinerParaObject(); 880 881 if(!pPara) 882 { 883 GetTextObj()->ForceOutlinerParaObject(); 884 pPara = GetTextObj()->GetOutlinerParaObject(); 885 } 886 887 if(pPara && sal_True != pPara->IsVertical()) 888 { 889 // set ParaObject orientation accordingly 890 pPara->SetVertical(sal_True); 891 } 892 893 // #91508# 894 // aSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_TOP)); 895 aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT)); 896 897 // #107235# 898 // Analog to the else case below, for vertical simple click texts 899 // one of the defaulted setted items from ImpSetAttributesForNewTextObject 900 // needs to be adapted to non-block mode. This could have been done with the 901 // #104122#, but was obviously overseen. 902 const SfxItemSet& rSet = mpView->GetDefaultAttr(); 903 SvxFrameDirection eDirection = (SvxFrameDirection)((SvxFrameDirectionItem&)rSet.Get(EE_PARA_WRITINGDIR)).GetValue(); 904 905 if(FRMDIR_HORI_RIGHT_TOP == eDirection || FRMDIR_VERT_TOP_RIGHT == eDirection) 906 { 907 aSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BOTTOM)); 908 } 909 else 910 { 911 aSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_TOP)); 912 } 913 } 914 else 915 { 916 // #104122# This is for Format/Page settings. Since this also leads 917 // to the object defaults to be changed, i think this code can be 918 // removed. CL. wanted to take a look before adding this. 919 //const SdrTextHorzAdjust eHA = ( ( pDoc && pDoc->GetDefaultWritingMode() == ::com::sun::star::text::WritingMode_RL_TB ) ? 920 // SDRTEXTHORZADJUST_RIGHT : SDRTEXTHORZADJUST_LEFT ); 921 //aSet.Put( SdrTextHorzAdjustItem( eHA ) ); 922 923 // #104122# Look in the object defaults if left-to-right is wanted. If 924 // yes, set text anchoring to right to let the box grow to left. 925 const SfxItemSet& rSet = mpView->GetDefaultAttr(); 926 SvxFrameDirection eDirection = (SvxFrameDirection)((SvxFrameDirectionItem&)rSet.Get(EE_PARA_WRITINGDIR)).GetValue(); 927 928 if(FRMDIR_HORI_RIGHT_TOP == eDirection) 929 { 930 aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT)); 931 } 932 else 933 { 934 aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_LEFT)); 935 } 936 } 937 938 GetTextObj()->SetMergedItemSet(aSet); 939 GetTextObj()->SetDisableAutoWidthOnDragging(sal_True); 940 SetInEditMode(rMEvt, sal_False); 941 } 942 943 bFirstObjCreated = sal_True; 944 } 945 else 946 { 947 // In die Fkt. Selektion wechseln 948 if (mpView->SdrEndTextEdit() == SDRENDTEXTEDIT_DELETED) 949 { 950 mxTextObj.reset(0); 951 } 952 953 mpViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_OBJECT_SELECT, 954 SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD ); 955 } 956 } 957 958 bMBDown = sal_False; 959 FuConstruct::MouseButtonUp(rMEvt); 960 return (bReturn); 961 } 962 963 /************************************************************************* 964 |* 965 |* Tastaturereignisse bearbeiten 966 |* 967 |* Wird ein KeyEvent bearbeitet, so ist der Return-Wert sal_True, andernfalls 968 |* sal_False. 969 |* 970 \************************************************************************/ 971 972 sal_Bool FuText::KeyInput(const KeyEvent& rKEvt) 973 { 974 sal_Bool bReturn = sal_False; 975 mpView->SetMarkHdlWhenTextEdit(sal_True); 976 977 KeyCode nCode = rKEvt.GetKeyCode(); 978 sal_Bool bShift = nCode.IsShift(); 979 980 // #97016# IV 981 if(mxTextObj.is()) 982 { 983 // maybe object is deleted, test if it's equal to the selected object 984 const SdrMarkList& rMarkList = mpView->GetMarkedObjectList(); 985 SdrObject* pSelectedObj = 0L; 986 987 if(1 == rMarkList.GetMarkCount()) 988 { 989 SdrMark* pMark = rMarkList.GetMark(0); 990 pSelectedObj = pMark->GetMarkedSdrObj(); 991 } 992 993 if(mxTextObj.get() != pSelectedObj) 994 { 995 mxTextObj.reset(0); 996 } 997 } 998 999 if ( mxTextObj.is() && mxTextObj->GetObjInventor() == SdrInventor && mxTextObj->GetObjIdentifier() == OBJ_TITLETEXT && rKEvt.GetKeyCode().GetCode() == KEY_RETURN ) 1000 { 1001 // Titeltext-Objekt: immer "weiche" Umbrueche 1002 bShift = sal_True; 1003 } 1004 1005 sal_uInt16 nKey = nCode.GetCode(); 1006 KeyCode aKeyCode (nKey, bShift, nCode.IsMod1(), nCode.IsMod2(), nCode.IsMod3() ); 1007 KeyEvent aKEvt(rKEvt.GetCharCode(), aKeyCode); 1008 1009 sal_Bool bOK = sal_True; 1010 1011 if (mpDocSh->IsReadOnly()) 1012 { 1013 bOK = !EditEngine::DoesKeyChangeText(aKEvt); 1014 } 1015 if( aKeyCode.GetCode() == KEY_PAGEUP || aKeyCode.GetCode() == KEY_PAGEDOWN ) 1016 { 1017 bOK = sal_False; // default handling in base class 1018 } 1019 1020 if (bOK && mpView->KeyInput(aKEvt, mpWindow) ) 1021 { 1022 bReturn = sal_True; 1023 1024 mpViewShell->GetViewFrame()->GetBindings().Invalidate( SidArray ); 1025 1026 // if ( pTextObj ) 1027 // pTextObj->SetEmptyPresObj(sal_False); 1028 } 1029 else if (aKeyCode == KEY_ESCAPE) 1030 { 1031 bReturn = cancel(); 1032 } 1033 1034 if( bPermanent ) 1035 { 1036 mpView->SetCurrentObj(OBJ_TEXT); 1037 mpView->SetEditMode(SDREDITMODE_CREATE); 1038 } 1039 1040 if (!bReturn) 1041 { 1042 bReturn = FuDraw::KeyInput(aKEvt); 1043 } 1044 1045 return (bReturn); 1046 } 1047 1048 1049 1050 /************************************************************************* 1051 |* 1052 |* Function aktivieren 1053 |* 1054 \************************************************************************/ 1055 1056 void FuText::Activate() 1057 { 1058 mpView->SetQuickTextEditMode(mpViewShell->GetFrameView()->IsQuickEdit()); 1059 1060 // #i89661# it's no longer necessary to make it so big here, it's fine tuned 1061 // for text objects in SdrMarkView::CheckSingleSdrObjectHit 1062 mpView->SetHitTolerancePixel( 2 * HITPIX ); 1063 1064 OutlinerView* pOLV = mpView->GetTextEditOutlinerView(); 1065 1066 if (pOLV) 1067 pOLV->ShowCursor(); 1068 1069 FuConstruct::Activate(); 1070 1071 if( pOLV ) 1072 mpView->SetEditMode(SDREDITMODE_EDIT); 1073 } 1074 1075 1076 /************************************************************************* 1077 |* 1078 |* Function deaktivieren 1079 |* 1080 \************************************************************************/ 1081 1082 void FuText::Deactivate() 1083 { 1084 OutlinerView* pOLV = mpView->GetTextEditOutlinerView(); 1085 1086 if (pOLV) 1087 pOLV->HideCursor(); 1088 1089 mpView->SetHitTolerancePixel( HITPIX ); 1090 1091 FuConstruct::Deactivate(); 1092 } 1093 1094 1095 /************************************************************************* 1096 |* 1097 |* Objekt in Edit-Mode setzen 1098 |* 1099 \************************************************************************/ 1100 1101 void FuText::SetInEditMode(const MouseEvent& rMEvt, sal_Bool bQuickDrag) 1102 { 1103 SdrPageView* pPV = mpView->GetSdrPageView(); 1104 if( mxTextObj.is() && (mxTextObj->GetPage() == pPV->GetPage()) ) 1105 { 1106 mpView->SetCurrentObj(OBJ_TEXT); 1107 1108 if( bPermanent ) 1109 mpView->SetEditMode(SDREDITMODE_CREATE); 1110 else 1111 mpView->SetEditMode(SDREDITMODE_EDIT); 1112 1113 sal_Bool bEmptyOutliner = sal_False; 1114 1115 if (!GetTextObj()->GetOutlinerParaObject() && mpView->GetTextEditOutliner()) 1116 { 1117 ::Outliner* pOutl = mpView->GetTextEditOutliner(); 1118 sal_uLong nParaAnz = pOutl->GetParagraphCount(); 1119 Paragraph* p1stPara = pOutl->GetParagraph( 0 ); 1120 1121 if (nParaAnz==1 && p1stPara) 1122 { 1123 // Bei nur einem Pararaph 1124 if (pOutl->GetText(p1stPara).Len() == 0) 1125 { 1126 bEmptyOutliner = sal_True; 1127 } 1128 } 1129 } 1130 1131 if (GetTextObj() != mpView->GetTextEditObject() || bEmptyOutliner) 1132 { 1133 sal_uInt32 nInv = mxTextObj->GetObjInventor(); 1134 sal_uInt16 nSdrObjKind = mxTextObj->GetObjIdentifier(); 1135 1136 if (nInv == SdrInventor && GetTextObj()->HasTextEdit() && 1137 (nSdrObjKind == OBJ_TEXT || 1138 nSdrObjKind == OBJ_TITLETEXT || 1139 nSdrObjKind == OBJ_OUTLINETEXT || !mxTextObj->IsEmptyPresObj() ) ) 1140 { 1141 // Neuen Outliner machen (gehoert der SdrObjEditView) 1142 SdrOutliner* pOutl = SdrMakeOutliner( OUTLINERMODE_OUTLINEOBJECT, mpDoc ); 1143 1144 if (bEmptyOutliner) 1145 mpView->SdrEndTextEdit(sal_True); 1146 1147 SdrTextObj* pTextObj = GetTextObj(); 1148 if( pTextObj ) 1149 { 1150 OutlinerParaObject* pOPO = pTextObj->GetOutlinerParaObject(); 1151 if( ( pOPO && pOPO->IsVertical() ) || (nSlotId == SID_ATTR_CHAR_VERTICAL) || (nSlotId == SID_TEXT_FITTOSIZE_VERTICAL) ) 1152 pOutl->SetVertical( sal_True ); 1153 1154 if( pTextObj->getTextCount() > 1 ) 1155 { 1156 Point aPix(rMEvt.GetPosPixel()); 1157 Point aPnt(mpWindow->PixelToLogic(aPix)); 1158 pTextObj->setActiveText( pTextObj->CheckTextHit(aPnt ) ); 1159 } 1160 1161 if (mpView->SdrBeginTextEdit(pTextObj, pPV, mpWindow, sal_True, pOutl) && mxTextObj->GetObjInventor() == SdrInventor) 1162 { 1163 bFirstObjCreated = sal_True; 1164 DeleteDefaultText(); 1165 1166 OutlinerView* pOLV = mpView->GetTextEditOutlinerView(); 1167 1168 nSdrObjKind = mxTextObj->GetObjIdentifier(); 1169 1170 SdrViewEvent aVEvt; 1171 SdrHitKind eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt); 1172 1173 if (eHit == SDRHIT_TEXTEDIT) 1174 { 1175 // Text getroffen 1176 if (nSdrObjKind == OBJ_TEXT || 1177 nSdrObjKind == OBJ_TITLETEXT || 1178 nSdrObjKind == OBJ_OUTLINETEXT || 1179 nSdrObjKind == OBJ_TABLE || 1180 nSlotId == SID_TEXTEDIT || 1181 !bQuickDrag) 1182 { 1183 pOLV->MouseButtonDown(rMEvt); 1184 pOLV->MouseMove(rMEvt); 1185 pOLV->MouseButtonUp(rMEvt); 1186 } 1187 1188 if (mpViewShell->GetFrameView()->IsQuickEdit() && bQuickDrag && GetTextObj()->GetOutlinerParaObject()) 1189 { 1190 pOLV->MouseButtonDown(rMEvt); 1191 } 1192 } 1193 else 1194 { 1195 // #98198# Move cursor to end of text 1196 ESelection aNewSelection(EE_PARA_NOT_FOUND, EE_INDEX_NOT_FOUND, EE_PARA_NOT_FOUND, EE_INDEX_NOT_FOUND); 1197 if (pOLV != NULL) 1198 pOLV->SetSelection(aNewSelection); 1199 } 1200 } 1201 else 1202 { 1203 mpView->RestoreDefaultText(dynamic_cast< SdrTextObj* >( mxTextObj.get() )); 1204 } 1205 } 1206 } 1207 } 1208 } 1209 else 1210 { 1211 mxTextObj.reset(0); 1212 } 1213 } 1214 1215 /************************************************************************* 1216 |* 1217 |* Texteingabe wird gestartet, ggf. Default-Text loeschen 1218 |* 1219 \************************************************************************/ 1220 1221 sal_Bool FuText::DeleteDefaultText() 1222 { 1223 sal_Bool bDeleted = sal_False; 1224 1225 if ( mxTextObj.is() && mxTextObj->IsEmptyPresObj() ) 1226 { 1227 String aString; 1228 SdPage* pPage = (SdPage*) mxTextObj->GetPage(); 1229 1230 if (pPage) 1231 { 1232 PresObjKind ePresObjKind = pPage->GetPresObjKind(mxTextObj.get()); 1233 1234 if ( (ePresObjKind == PRESOBJ_TITLE || 1235 ePresObjKind == PRESOBJ_OUTLINE || 1236 ePresObjKind == PRESOBJ_NOTES || 1237 ePresObjKind == PRESOBJ_TEXT) && 1238 !pPage->IsMasterPage() ) 1239 { 1240 ::Outliner* pOutliner = mpView->GetTextEditOutliner(); 1241 SfxStyleSheet* pSheet = pOutliner->GetStyleSheet( 0 ); 1242 sal_Bool bIsUndoEnabled = pOutliner->IsUndoEnabled(); 1243 if( bIsUndoEnabled ) 1244 pOutliner->EnableUndo(sal_False); 1245 1246 pOutliner->SetText( String(), pOutliner->GetParagraph( 0 ) ); 1247 1248 if( bIsUndoEnabled ) 1249 pOutliner->EnableUndo(sal_True); 1250 1251 if (pSheet && 1252 (ePresObjKind == PRESOBJ_NOTES || ePresObjKind == PRESOBJ_TEXT)) 1253 pOutliner->SetStyleSheet(0, pSheet); 1254 1255 mxTextObj->SetEmptyPresObj(sal_True); 1256 bDeleted = sal_True; 1257 } 1258 } 1259 } 1260 1261 return(bDeleted); 1262 } 1263 1264 /************************************************************************* 1265 |* 1266 |* Command-event 1267 |* 1268 \************************************************************************/ 1269 1270 sal_Bool FuText::Command(const CommandEvent& rCEvt) 1271 { 1272 return( FuPoor::Command(rCEvt) ); 1273 } 1274 1275 /************************************************************************* 1276 |* 1277 |* Help-event 1278 |* 1279 \************************************************************************/ 1280 1281 sal_Bool FuText::RequestHelp(const HelpEvent& rHEvt) 1282 { 1283 sal_Bool bReturn = sal_False; 1284 1285 OutlinerView* pOLV = mpView->GetTextEditOutlinerView(); 1286 1287 if ((Help::IsBalloonHelpEnabled() || Help::IsQuickHelpEnabled()) && 1288 mxTextObj.is() && pOLV && pOLV->GetFieldUnderMousePointer()) 1289 { 1290 String aHelpText; 1291 const SvxFieldItem* pFieldItem = pOLV->GetFieldUnderMousePointer(); 1292 const SvxFieldData* pField = pFieldItem->GetField(); 1293 1294 if (pField && pField->ISA(SvxURLField)) 1295 { 1296 /****************************************************************** 1297 * URL-Field 1298 ******************************************************************/ 1299 aHelpText = INetURLObject::decode( ((const SvxURLField*)pField)->GetURL(), '%', INetURLObject::DECODE_WITH_CHARSET ); 1300 } 1301 if (aHelpText.Len()) 1302 { 1303 Rectangle aLogicPix = mpWindow->LogicToPixel(mxTextObj->GetLogicRect()); 1304 Rectangle aScreenRect(mpWindow->OutputToScreenPixel(aLogicPix.TopLeft()), 1305 mpWindow->OutputToScreenPixel(aLogicPix.BottomRight())); 1306 1307 if (Help::IsBalloonHelpEnabled()) 1308 { 1309 bReturn = Help::ShowBalloon( (Window*)mpWindow, rHEvt.GetMousePosPixel(), aScreenRect, aHelpText); 1310 } 1311 else if (Help::IsQuickHelpEnabled()) 1312 { 1313 bReturn = Help::ShowQuickHelp( (Window*)mpWindow, aScreenRect, aHelpText); 1314 } 1315 } 1316 } 1317 1318 if (!bReturn) 1319 { 1320 bReturn = FuConstruct::RequestHelp(rHEvt); 1321 } 1322 1323 return(bReturn); 1324 } 1325 1326 /************************************************************************* 1327 |* 1328 |* Request verarbeiten 1329 |* 1330 \************************************************************************/ 1331 1332 void FuText::ReceiveRequest(SfxRequest& rReq) 1333 { 1334 nSlotId = rReq.GetSlot(); 1335 1336 // Dann Basisklasse rufen (dort wird u.a. nSlotId NICHT gesetzt) 1337 FuPoor::ReceiveRequest(rReq); 1338 1339 if (nSlotId == SID_TEXTEDIT || mpViewShell->GetFrameView()->IsQuickEdit() || /*#95971#*/ SID_ATTR_CHAR == nSlotId) 1340 { 1341 MouseEvent aMEvt(mpWindow->GetPointerPosPixel()); 1342 1343 mxTextObj.reset(0); 1344 1345 if (nSlotId == SID_TEXTEDIT) 1346 { 1347 // Wird gerade editiert? 1348 if(!bTestText) 1349 mxTextObj.reset( dynamic_cast< SdrTextObj* >( mpView->GetTextEditObject() ) ); 1350 1351 if (!mxTextObj.is()) 1352 { 1353 // Versuchen, ein Obj zu selektieren 1354 SdrPageView* pPV = mpView->GetSdrPageView(); 1355 SdrViewEvent aVEvt; 1356 mpView->PickAnything(aMEvt, SDRMOUSEBUTTONDOWN, aVEvt); 1357 mpView->MarkObj(aVEvt.pRootObj, pPV); 1358 1359 if (aVEvt.pObj && aVEvt.pObj->ISA(SdrTextObj)) 1360 { 1361 mxTextObj.reset( static_cast< SdrTextObj* >( aVEvt.pObj ) ); 1362 } 1363 } 1364 } 1365 else if (mpView->AreObjectsMarked()) 1366 { 1367 const SdrMarkList& rMarkList = mpView->GetMarkedObjectList(); 1368 1369 if (rMarkList.GetMarkCount() == 1) 1370 { 1371 SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); 1372 1373 if (pObj->ISA(SdrTextObj)) 1374 { 1375 mxTextObj.reset( static_cast< SdrTextObj* >( pObj ) ); 1376 } 1377 } 1378 } 1379 1380 sal_Bool bQuickDrag = sal_True; 1381 1382 const SfxItemSet* pArgs = rReq.GetArgs(); 1383 1384 if (pArgs 1385 1386 // #98198# test for type before using 1387 && SID_TEXTEDIT == nSlotId 1388 && SFX_ITEM_SET == pArgs->GetItemState(SID_TEXTEDIT) 1389 1390 && (sal_uInt16) ((SfxUInt16Item&) pArgs->Get(SID_TEXTEDIT)).GetValue() == 2) 1391 { 1392 // Anwahl per Doppelklick -> kein QuickDrag zulassen 1393 bQuickDrag = sal_False; 1394 } 1395 1396 SetInEditMode(aMEvt, bQuickDrag); 1397 } 1398 } 1399 1400 1401 1402 /************************************************************************* 1403 |* 1404 |* SpellChecker: Error-LinkHdl 1405 |* 1406 \************************************************************************/ 1407 1408 IMPL_LINK( FuText, SpellError, void *, nLang ) 1409 { 1410 String aError( SvtLanguageTable::GetLanguageString( (LanguageType)(sal_uLong)nLang ) ); 1411 ErrorHandler::HandleError(* new StringErrorInfo( 1412 ERRCODE_SVX_LINGU_LANGUAGENOTEXISTS, aError) ); 1413 return 0; 1414 } 1415 1416 1417 /************************************************************************* 1418 |* 1419 |* Reaktion auf Doppelklick 1420 |* 1421 \************************************************************************/ 1422 void FuText::DoubleClick(const MouseEvent& ) 1423 { 1424 // Nichts zu tun 1425 } 1426 1427 /** #97016# 1428 #105815# Removed the insertion of default text and putting a new text 1429 object directly into edit mode. 1430 */ 1431 SdrObject* FuText::CreateDefaultObject(const sal_uInt16 nID, const Rectangle& rRectangle) 1432 { 1433 // case SID_TEXTEDIT: // BASIC ??? 1434 // case SID_ATTR_CHAR: 1435 // case SID_ATTR_CHAR_VERTICAL: 1436 // case SID_TEXT_FITTOSIZE: 1437 // case SID_TEXT_FITTOSIZE_VERTICAL: 1438 1439 SdrObject* pObj = SdrObjFactory::MakeNewObject( 1440 mpView->GetCurrentObjInventor(), mpView->GetCurrentObjIdentifier(), 1441 0L, mpDoc); 1442 1443 if(pObj) 1444 { 1445 if(pObj->ISA(SdrTextObj)) 1446 { 1447 SdrTextObj* pText = (SdrTextObj*)pObj; 1448 pText->SetLogicRect(rRectangle); 1449 1450 sal_Bool bVertical = (SID_ATTR_CHAR_VERTICAL == nID || SID_TEXT_FITTOSIZE_VERTICAL == nID); 1451 pText->SetVerticalWriting(bVertical); 1452 1453 // #97016# 1454 ImpSetAttributesForNewTextObject(pText); 1455 1456 if (nSlotId == SID_TEXT_FITTOSIZE) 1457 { 1458 // #97016# 1459 ImpSetAttributesFitToSize(pText); 1460 } 1461 else if ( nSlotId == SID_TEXT_FITTOSIZE_VERTICAL ) 1462 { 1463 // #97016# 1464 ImpSetAttributesFitToSizeVertical(pText); 1465 } 1466 else 1467 { 1468 // #97016# 1469 ImpSetAttributesFitCommon(pText); 1470 } 1471 1472 // Put text object into edit mode. 1473 SdrPageView* pPV = mpView->GetSdrPageView(); 1474 mpView->SdrBeginTextEdit(pText, pPV); 1475 } 1476 else 1477 { 1478 DBG_ERROR("Object is NO text object"); 1479 } 1480 } 1481 1482 return pObj; 1483 } 1484 1485 1486 1487 1488 /** is called when the currenct function should be aborted. <p> 1489 This is used when a function gets a KEY_ESCAPE but can also 1490 be called directly. 1491 1492 @returns true if a active function was aborted 1493 */ 1494 bool FuText::cancel() 1495 { 1496 if ( mpView->IsTextEdit() ) 1497 { 1498 if(mpView->SdrEndTextEdit() == SDRENDTEXTEDIT_DELETED) 1499 mxTextObj.reset(0); 1500 1501 mpView->SetCurrentObj(OBJ_TEXT); 1502 mpView->SetEditMode(SDREDITMODE_EDIT); 1503 return true; 1504 } 1505 else 1506 { 1507 return false; 1508 } 1509 } 1510 1511 void FuText::ChangeFontSize( bool bGrow, OutlinerView* pOLV, const FontList* pFontList, ::sd::View* pView ) 1512 { 1513 if( !pFontList || !pView ) 1514 return; 1515 1516 if( pOLV ) 1517 { 1518 pOLV->GetEditView().ChangeFontSize( bGrow, pFontList ); 1519 } 1520 else 1521 { 1522 // SdDrawDocument* pDoc = pView->GetDoc(); 1523 1524 const SdrMarkList& rMarkList = pView->GetMarkedObjectList(); 1525 for( sal_uInt32 nMark = 0; nMark < rMarkList.GetMarkCount(); nMark++ ) 1526 { 1527 SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( rMarkList.GetMark(nMark)->GetMarkedSdrObj() ); 1528 if( pTextObj ) 1529 { 1530 for( sal_Int32 nText = 0; nText < pTextObj->getTextCount(); nText++ ) 1531 { 1532 pTextObj->setActiveText( nText ); 1533 1534 // Put text object into edit mode. 1535 SdrPageView* pPV = pView->GetSdrPageView(); 1536 pView->SdrBeginTextEdit(pTextObj, pPV); 1537 1538 pOLV = pView->GetTextEditOutlinerView(); 1539 if( pOLV ) 1540 { 1541 EditEngine* pEditEngine = pOLV->GetEditView().GetEditEngine(); 1542 if( pEditEngine ) 1543 { 1544 ESelection aSel; 1545 aSel.nEndPara = pEditEngine->GetParagraphCount()-1; 1546 aSel.nEndPos = pEditEngine->GetTextLen(aSel.nEndPara); 1547 pOLV->SetSelection(aSel); 1548 } 1549 1550 ChangeFontSize( bGrow, pOLV, pFontList, pView ); 1551 } 1552 1553 pView->SdrEndTextEdit(); 1554 } 1555 1556 SfxItemSet aShapeSet( pTextObj->GetMergedItemSet() ); 1557 if( EditView::ChangeFontSize( bGrow, aShapeSet, pFontList ) ) 1558 { 1559 pTextObj->SetObjectItemNoBroadcast( aShapeSet.Get( EE_CHAR_FONTHEIGHT ) ); 1560 pTextObj->SetObjectItemNoBroadcast( aShapeSet.Get( EE_CHAR_FONTHEIGHT_CJK ) ); 1561 pTextObj->SetObjectItemNoBroadcast( aShapeSet.Get( EE_CHAR_FONTHEIGHT_CTL ) ); 1562 } 1563 } 1564 } 1565 } 1566 } 1567 1568 } // end of namespace sd 1569 1570