sd/source/ui/func/futext.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <futext.hxx>
  21 #include <editeng/eeitem.hxx>
  22 #include <svx/sdrpagewindow.hxx>
  23 #include <svx/sdrpaintwindow.hxx>
  24 #include <tools/urlobj.hxx>
  25 #include <vcl/help.hxx>
  26 #include <editeng/fhgtitem.hxx>
  27 #include <svl/intitem.hxx>
  28 #include <svl/stritem.hxx>
  29 #include <svx/svdotext.hxx>
  30 #include <editeng/flditem.hxx>
  31 #include <svl/style.hxx>
  32 #include <svx/svdpagv.hxx>
  33 #include <svx/sdtmfitm.hxx>
  34 #include <svx/sdtagitm.hxx>
  35 #include <svx/sdtfsitm.hxx>
  36 #include <sfx2/viewfrm.hxx>
  37 #include <sfx2/dispatch.hxx>
  38 #include <sfx2/bindings.hxx>
  39 #include <sfx2/request.hxx>
  40 #include <editeng/editeng.hxx>
  41 #include <svx/svdoutl.hxx>
  42 #include <svx/svxids.hrc>
  43 #include <svx/sdr/overlay/overlaymanager.hxx>
  44 #include <sfx2/docfile.hxx>
  45 #include <editeng/outlobj.hxx>
  46 #include <osl/diagnose.h>
  47
  48 #include <editeng/frmdiritem.hxx>
  49
  50 #include <svx/svdetc.hxx>
  51 #include <editeng/editview.hxx>
  52
  53 #include <sdresid.hxx>
  54 #include <app.hrc>
  55
  56 #include <ViewShell.hxx>
  57 #include <ViewShellBase.hxx>
  58 #include <View.hxx>
  59 #include <Window.hxx>
  60 #include <drawdoc.hxx>
  61 #include <sdpage.hxx>
  62 #include <FrameView.hxx>
  63 #include <ToolBarManager.hxx>
  64 #include <DrawDocShell.hxx>
  65 #include <strings.hrc>
  66 #include <pres.hxx>
  67
  68 using namespace ::com::sun::star;
  69 using namespace ::com::sun::star::uno;
  70 using namespace ::com::sun::star::lang;
  71 using namespace ::com::sun::star::linguistic2;
  72
  73 namespace sd {
  74
  75 const sal_uInt16 SidArray[] = {
  76     SID_STYLE_FAMILY2,                //    5542
  77     SID_STYLE_FAMILY5,                //    5545
  78     SID_REDO,                         //    5700
  79     SID_UNDO,                         //    5701
  80     SID_CUT,                          //    5710
  81     SID_COPY,                         //    5711
  82     SID_ATTR_TABSTOP,                 //   10002
  83     SID_ATTR_CHAR_FONT,               //   10007
  84     SID_ATTR_CHAR_POSTURE,            //   10008
  85     SID_ATTR_CHAR_WEIGHT,             //   10009
  86     SID_ATTR_CHAR_SHADOWED,           //   10010
  87     SID_ATTR_CHAR_STRIKEOUT,          //   10013
  88     SID_ATTR_CHAR_UNDERLINE,          //   10014
  89     SID_ATTR_CHAR_FONTHEIGHT,         //   10015
  90     SID_ATTR_CHAR_COLOR,              //   10017
  91     SID_ATTR_CHAR_KERNING,            //   10018
  92     SID_ATTR_CHAR_CASEMAP,            //   10019
  93     SID_ATTR_PARA_ADJUST_LEFT,        //   10028
  94     SID_ATTR_PARA_ADJUST_RIGHT,       //   10029
  95     SID_ATTR_PARA_ADJUST_CENTER,      //   10030
  96     SID_ATTR_PARA_ADJUST_BLOCK,       //   10031
  97     SID_ATTR_PARA_LINESPACE_10,       //   10034
  98     SID_ATTR_PARA_LINESPACE_15,       //   10035
  99     SID_ATTR_PARA_LINESPACE_20,       //   10036
 100     SID_ATTR_PARA_ULSPACE,            //   10042
 101     SID_ATTR_PARA_LRSPACE,            //   10043
 102     SID_ATTR_TRANSFORM_POS_X,         //   10088
 103     SID_ATTR_TRANSFORM_POS_Y,         //   10089
 104     SID_ATTR_TRANSFORM_WIDTH,         //   10090
 105     SID_ATTR_TRANSFORM_HEIGHT,        //   10091
 106     SID_ATTR_TRANSFORM_ROT_X,         //   10093
 107     SID_ATTR_TRANSFORM_ROT_Y,         //   10094
 108     SID_ATTR_TRANSFORM_ANGLE,         //   10095 //Added
 109     SID_OUTLINE_UP,                   //   10150
 110     SID_OUTLINE_DOWN,                 //   10151
 111     SID_OUTLINE_LEFT,                 //   10152
 112     SID_OUTLINE_RIGHT,                //   10153
 113     SID_ATTR_TRANSFORM_PROTECT_POS,   //   10236
 114     SID_ATTR_TRANSFORM_PROTECT_SIZE,  //   10237 //Added
 115     SID_FORMTEXT_STYLE,               //   10257
 116     SID_SET_SUPER_SCRIPT,             //   10294
 117     SID_SET_SUB_SCRIPT,               //   10295
 118     SID_ATTR_TRANSFORM_AUTOWIDTH,     //   10310
 119     SID_ATTR_TRANSFORM_AUTOHEIGHT,    //   10311 //Added
 120     SID_HYPERLINK_GETLINK,            //   10361
 121     SID_DEC_INDENT,                   //   10461
 122     SID_INC_INDENT,                   //   10462
 123     SID_CHARMAP,                      //   10503
 124     SID_TEXTDIRECTION_LEFT_TO_RIGHT,  //   10907
 125     SID_TEXTDIRECTION_TOP_TO_BOTTOM,  //   10908
 126     SID_ATTR_PARA_LEFT_TO_RIGHT,      //   10950
 127     SID_ATTR_PARA_RIGHT_TO_LEFT,      //   10951
 128     SID_PARASPACE_INCREASE,           //   11145
 129     SID_PARASPACE_DECREASE,           //   11146
 130     FN_NUM_BULLET_ON,                 //   20138
 131                             0 };
 132
 133
 134 /**
 135  * base class for text functions
 136  */
 137 FuText::FuText( ViewShell* pViewSh, ::sd::Window* pWin, ::sd::View* pView, SdDrawDocument* pDoc, SfxRequest& rReq )
 138 : FuConstruct(pViewSh, pWin, pView, pDoc, rReq)
 139 , bFirstObjCreated(false)
 140 , bJustEndedEdit(false)
 141 , rRequest (rReq)
 142 {
 143 }
 144
 145 rtl::Reference<FuPoor> FuText::Create( ViewShell* pViewSh, ::sd::Window* pWin, ::sd::View* pView, SdDrawDocument* pDoc, SfxRequest& rReq )
 146 {
 147     rtl::Reference<FuPoor> xFunc( new FuText( pViewSh, pWin, pView, pDoc, rReq ) );
 148     return xFunc;
 149 }
 150
 151 void FuText::disposing()
 152 {
 153     if(mpView)
 154     {
 155         if(mpView->SdrEndTextEdit() == SdrEndTextEditKind::Deleted)
 156             mxTextObj = nullptr;
 157
 158         // reset the RequestHandler of the used Outliner to the handler of the document
 159         ::Outliner* pOutliner = mpView->GetTextEditOutliner();
 160
 161         if (pOutliner)
 162             pOutliner->SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(mpDoc->GetStyleSheetPool()));
 163     }
 164 }
 165
 166 /*************************************************************************
 167 |*
 168 |* Execute functionality of this class:
 169 |*
 170 |* #71422: Start the functionality of this class in this method
 171 |* and not in the ctor.
 172 |* If you construct an object of this class and you put the
 173 |* address of this object to pFuActual you've got a problem,
 174 |* because some methods inside DoExecute use the pFuActual-Pointer.
 175 |* If the code inside DoExecute is executed inside the ctor,
 176 |* the value of pFuActual is not right. And the value will not
 177 |* be right until the ctor finished !!!
 178 |*
 179 \************************************************************************/
 180 void FuText::DoExecute( SfxRequest& )
 181 {
 182     mpViewShell->GetViewShellBase().GetToolBarManager()->SetToolBarShell(
 183         ToolBarManager::ToolBarGroup::Function,
 184         ToolbarId::Draw_Text_Toolbox_Sd);
 185
 186     mpView->SetCurrentObj(SdrObjKind::Text);
 187     mpView->SetEditMode(SdrViewEditMode::Edit);
 188
 189     MouseEvent aMEvt(mpWindow->GetPointerPosPixel());
 190
 191     if (nSlotId == SID_TEXTEDIT)
 192     {
 193         // Try to select an object
 194         SdrPageView* pPV = mpView->GetSdrPageView();
 195         SdrViewEvent aVEvt;
 196         mpView->PickAnything(aMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt);
 197         mpView->MarkObj(aVEvt.mpRootObj, pPV);
 198
 199         mxTextObj = DynCastSdrTextObj( aVEvt.mpObj );
 200     }
 201     else if (mpView->AreObjectsMarked())
 202     {
 203         const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
 204
 205         if (rMarkList.GetMarkCount() == 1)
 206         {
 207             SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
 208             mxTextObj = DynCastSdrTextObj( pObj );
 209         }
 210     }
 211
 212     // check for table
 213     if (mpView->AreObjectsMarked())
 214     {
 215         const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
 216
 217         if (rMarkList.GetMarkCount() == 1)
 218         {
 219             SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
 220             if( pObj && (pObj->GetObjInventor() == SdrInventor::Default ) && (pObj->GetObjIdentifier() == SdrObjKind::Table) )
 221             {
 222                 mpViewShell->GetViewShellBase().GetToolBarManager()->AddToolBarShell(ToolBarManager::ToolBarGroup::Function, ToolbarId::Draw_Table_Toolbox);
 223             }
 224         }
 225     }
 226
 227     bool bQuickDrag = true;
 228
 229     const SfxItemSet* pArgs = rRequest.GetArgs();
 230
 231     if (pArgs
 232
 233         // test for type before using
 234         && SID_TEXTEDIT == nSlotId
 235         && SfxItemState::SET == pArgs->GetItemState(SID_TEXTEDIT)
 236
 237         && static_cast<const SfxUInt16Item&>(pArgs->Get(SID_TEXTEDIT)).GetValue() == 2)
 238     {
 239         // Selection by doubleclick -> don't allow QuickDrag
 240         bQuickDrag = false;
 241     }
 242
 243     SetInEditMode(aMEvt, bQuickDrag);
 244 }
 245
 246 bool FuText::MouseButtonDown(const MouseEvent& rMEvt)
 247 {
 248     bMBDown = true;
 249     bJustEndedEdit = false;
 250
 251     bool bReturn = FuDraw::MouseButtonDown(rMEvt);
 252
 253     SdrViewEvent aVEvt;
 254     SdrHitKind eHit = mpView->PickAnything(rMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt);
 255
 256     // handle URL also during the text editing
 257     if (rMEvt.GetClicks() == 1 && rMEvt.IsLeft() && rMEvt.IsMod1())
 258     {
 259         OutlinerView* pOLV = mpView->GetTextEditOutlinerView();
 260
 261         if (mxTextObj.get().is() && pOLV && pOLV->GetFieldUnderMousePointer())
 262         {
 263             const SvxFieldItem* pFieldItem = pOLV->GetFieldUnderMousePointer();
 264             if (pFieldItem)
 265             {
 266                 const SvxFieldData* pField = pFieldItem->GetField();
 267
 268                 if (auto pURLField = dynamic_cast< const SvxURLField *>( pField ))
 269                 {
 270                     eHit = SdrHitKind::MarkedObject;
 271                     aVEvt.meEvent = SdrEventKind::ExecuteUrl;
 272                     aVEvt.mpURLField = pURLField;
 273                 }
 274             }
 275         }
 276     }
 277
 278     if (eHit == SdrHitKind::TextEdit)
 279     {
 280         // hit text -> SdrView handles event
 281         if (mpView->MouseButtonDown(rMEvt, mpWindow->GetOutDev()))
 282             return true;
 283     }
 284
 285     if (rMEvt.GetClicks() == 1)
 286     {
 287         if (mpView->IsTextEdit() && eHit != SdrHitKind::MarkedObject && eHit != SdrHitKind::Handle)
 288         {
 289             // finish text input
 290             if(mpView->SdrEndTextEdit() == SdrEndTextEditKind::Deleted)
 291             {
 292                 /* Bugfix from MBA: during a double click onto the unused? area
 293                    in text mode, we get with the second click eHit =
 294                    SdrHitKind::TextEditObj since it goes to the TextObject which was
 295                    created with the first click. But this is removed by
 296                    SdrEndTextEdit since it is empty. But it is still in the mark
 297                    list. The call MarkObj further below accesses then the dead
 298                    object. As a simple fix, we determine eHit after
 299                    SdrEndTextEdit again, this returns then SdrHitKind::NONE. */
 300                 mxTextObj = nullptr;
 301                 eHit = mpView->PickAnything(rMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt);
 302             }
 303
 304             mpView->SetCurrentObj(SdrObjKind::Text);
 305             mpView->SetEditMode(SdrViewEditMode::Edit);
 306         }
 307
 308         if (rMEvt.IsLeft() || rMEvt.IsRight())
 309         {
 310             mpWindow->CaptureMouse();
 311             SdrPageView* pPV = mpView->GetSdrPageView();
 312
 313             if (eHit == SdrHitKind::TextEdit)
 314             {
 315                 SetInEditMode(rMEvt, false);
 316             }
 317             else
 318             {
 319                 // Don't remark table when clicking in it, mark change triggers a lot of updating
 320                 bool bMarkChanges = true;
 321                 rtl::Reference< sdr::SelectionController > xSelectionController(mpView->getSelectionController());
 322                 if (eHit == SdrHitKind::TextEditObj && xSelectionController.is())
 323                 {
 324                     const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
 325                     if (rMarkList.GetMarkCount() == 1 && rMarkList.GetMark(0)->GetMarkedSdrObj() == aVEvt.mpRootObj)
 326                         bMarkChanges = false;
 327                 }
 328
 329                 if (eHit != SdrHitKind::Handle)
 330                 {
 331                     // deselect selection
 332                     if (!rMEvt.IsShift() && eHit == SdrHitKind::TextEditObj)
 333                     {
 334                         if(bMarkChanges)
 335                         {
 336                             mpView->UnmarkAll();
 337                             mpView->SetDragMode(SdrDragMode::Move);
 338                         }
 339                     }
 340                 }
 341
 342                 if ( aVEvt.meEvent == SdrEventKind::ExecuteUrl                   ||
 343                      eHit == SdrHitKind::Handle                                 ||
 344                      eHit == SdrHitKind::MarkedObject                           ||
 345                      eHit == SdrHitKind::TextEditObj                            ||
 346                      ( eHit == SdrHitKind::UnmarkedObject && bFirstObjCreated &&
 347                        !bPermanent ) )
 348                 {
 349                     // Handle, hit marked or unmarked object
 350                     if (eHit == SdrHitKind::TextEditObj)
 351                     {
 352                         /* hit text of unmarked object:
 353                            select object and set to EditMode */
 354                         if (bMarkChanges)
 355                             mpView->MarkObj(aVEvt.mpRootObj, pPV);
 356
 357                         if (auto pSdrTextObj = DynCastSdrTextObj(aVEvt.mpObj))
 358                         {
 359                             mxTextObj = pSdrTextObj;
 360                         }
 361
 362                         SetInEditMode(rMEvt, true);
 363                     }
 364                     else if (aVEvt.meEvent == SdrEventKind::ExecuteUrl && !rMEvt.IsMod2())
 365                     {
 366                         // execute URL
 367                         mpWindow->ReleaseMouse();
 368
 369                         if (aVEvt.mpURLField)
 370                         {
 371                             SfxStringItem aStrItem(SID_FILE_NAME, aVEvt.mpURLField->GetURL());
 372                             SfxStringItem aReferer(SID_REFERER, mpDocSh->GetMedium()->GetName());
 373                             SfxBoolItem aBrowseItem( SID_BROWSE, true );
 374                             SfxViewFrame* pFrame = mpViewShell->GetViewFrame();
 375
 376                             if (rMEvt.IsMod1())
 377                             {
 378                                 // open in new frame
 379                                 pFrame->GetDispatcher()->ExecuteList(SID_OPENDOC,
 380                                     SfxCallMode::ASYNCHRON | SfxCallMode::RECORD,
 381                                     { &aStrItem, &aBrowseItem, &aReferer });
 382                             }
 383                             else
 384                             {
 385                                 // open in current frame
 386                                 SfxFrameItem aFrameItem(SID_DOCFRAME, pFrame);
 387                                 pFrame->GetDispatcher()->ExecuteList(SID_OPENDOC,
 388                                     SfxCallMode::ASYNCHRON | SfxCallMode::RECORD,
 389                                     { &aStrItem, &aFrameItem, &aBrowseItem, &aReferer });
 390                             }
 391                         }
 392                     }
 393                     else
 394                     {
 395                         // drag object or handle
 396
 397                         // #i78748#
 398                         // do the EndTextEdit first, it will delete the handles and force a
 399                         // recreation. This will make aVEvt.mpHdl to point to a deleted handle,
 400                         // thus it is necessary to reset it and to get it again.
 401
 402                         // #i112855#
 403                         // cl: I'm not sure why we checked here also for mxTextObj->GetOutlinerParaObject
 404                         // this caused SdrEndTextEdit() to be called also when not in text editing and
 405                         // this does not make sense and caused troubles. (see issue 112855)
 406
 407                         if( mpView->IsTextEdit() )
 408                         {
 409                             mpView->SdrEndTextEdit();
 410                             bJustEndedEdit = true;
 411
 412                             if(aVEvt.mpHdl)
 413                             {
 414                                 // force new handle identification, the pointer will be dead here
 415                                 // since SdrEndTextEdit has reset (deleted) the handles.
 416                                 aVEvt.mpHdl = nullptr;
 417                                 mpView->PickAnything(rMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt);
 418                             }
 419                         }
 420
 421                         if (!aVEvt.mpHdl)
 422                         {
 423                             if( eHit == SdrHitKind::UnmarkedObject )
 424                             {
 425                                 if ( !rMEvt.IsShift() )
 426                                     mpView->UnmarkAll();
 427
 428                                 mpView->MarkObj(aVEvt.mpRootObj, pPV);
 429                             }
 430
 431                             // Drag object
 432                             bFirstMouseMove = true;
 433                             aDragTimer.Start();
 434                         }
 435
 436                         if ( ! rMEvt.IsRight())
 437                         {
 438                             // we need to pick again since SdrEndTextEdit can rebuild the handles list
 439                             eHit = mpView->PickAnything(rMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt);
 440                             if( (eHit == SdrHitKind::Handle) || (eHit == SdrHitKind::MarkedObject) )
 441                             {
 442                                 sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
 443                                 mpView->BegDragObj(aMDPos, nullptr, aVEvt.mpHdl, nDrgLog);
 444                             }
 445                         }
 446                         bReturn = true;
 447                     }
 448                 }
 449                 else if ( nSlotId != SID_TEXTEDIT &&
 450                           (bPermanent || !bFirstObjCreated) )
 451                 {
 452                     // create object
 453                     mpView->SetCurrentObj(SdrObjKind::Text);
 454                     mpView->SetEditMode(SdrViewEditMode::Create);
 455                     sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
 456                     mpView->BegCreateObj(aMDPos, nullptr, nDrgLog);
 457                 }
 458                 else
 459                 {
 460                     // select
 461                     if( !rMEvt.IsShift() )
 462                         mpView->UnmarkAll();
 463
 464                     mpView->BegMarkObj( aMDPos );
 465                 }
 466             }
 467         }
 468     }
 469     else if ( rMEvt.GetClicks() == 2 && !mpView->IsTextEdit() )
 470     {
 471         MouseEvent aMEvt( mpWindow->GetPointerPosPixel() );
 472         SetInEditMode( aMEvt, false );
 473     }
 474
 475     if (!bIsInDragMode)
 476     {
 477         ForcePointer(&rMEvt);
 478         mpViewShell->GetViewFrame()->GetBindings().Invalidate(SidArray);
 479     }
 480
 481     return bReturn;
 482 }
 483
 484 bool FuText::MouseMove(const MouseEvent& rMEvt)
 485 {
 486     bool bReturn = FuDraw::MouseMove(rMEvt);
 487
 488     if (aDragTimer.IsActive() )
 489     {
 490         if( bFirstMouseMove )
 491             bFirstMouseMove = false;
 492         else
 493             aDragTimer.Stop();
 494     }
 495
 496     if (!bReturn && mpView->IsAction() && !mpDocSh->IsReadOnly())
 497     {
 498         Point aPix(rMEvt.GetPosPixel());
 499         Point aPnt(mpWindow->PixelToLogic(aPix));
 500
 501         ForceScroll(aPix);
 502         mpView->MovAction(aPnt);
 503     }
 504
 505     ForcePointer(&rMEvt);
 506
 507     return bReturn;
 508 }
 509
 510 void FuText::ImpSetAttributesForNewTextObject(SdrTextObj* pTxtObj)
 511 {
 512     if( nSlotId == SID_ATTR_CHAR )
 513     {
 514         SfxItemSet aSet(mpViewShell->GetPool());
 515         aSet.Put(makeSdrTextAutoGrowWidthItem(false));
 516         aSet.Put(makeSdrTextAutoGrowHeightItem(true));
 517         pTxtObj->SetMergedItemSet(aSet);
 518         pTxtObj->AdjustTextFrameWidthAndHeight();
 519         const SfxViewShell* pCurrentViewShell = SfxViewShell::Current();
 520         if (pCurrentViewShell && (pCurrentViewShell->isLOKMobilePhone() || pCurrentViewShell->isLOKTablet()))
 521             pTxtObj->SetText(SdResId(STR_PRESOBJ_TEXT_EDIT_MOBILE));
 522     }
 523     else if( nSlotId == SID_ATTR_CHAR_VERTICAL )
 524     {
 525         // draw text object, needs to be initialized when vertical text is used
 526         SfxItemSet aSet(mpViewShell->GetPool());
 527
 528         aSet.Put(makeSdrTextAutoGrowWidthItem(true));
 529         aSet.Put(makeSdrTextAutoGrowHeightItem(false));
 530
 531         // Set defaults for vertical click-n'drag text object, pool defaults are:
 532         // SdrTextVertAdjustItem: SDRTEXTVERTADJUST_TOP
 533         // SdrTextHorzAdjustItem: SDRTEXTHORZADJUST_BLOCK
 534         // Analog to that:
 535         aSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BLOCK));
 536         aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT));
 537
 538         pTxtObj->SetMergedItemSet(aSet);
 539         pTxtObj->AdjustTextFrameWidthAndHeight();
 540     }
 541 }
 542
 543 void FuText::ImpSetAttributesFitToSize(SdrTextObj* pTxtObj)
 544 {
 545     // FitToSize (fit to frame)
 546     SfxItemSetFixed<SDRATTR_TEXT_AUTOGROWHEIGHT, SDRATTR_TEXT_AUTOGROWWIDTH> aSet(mpViewShell->GetPool());
 547     aSet.Put(SdrTextFitToSizeTypeItem(drawing::TextFitToSizeType_PROPORTIONAL));
 548     aSet.Put(makeSdrTextAutoGrowHeightItem(false));
 549     aSet.Put(makeSdrTextAutoGrowWidthItem(false));
 550     pTxtObj->SetMergedItemSet(aSet);
 551     pTxtObj->AdjustTextFrameWidthAndHeight();
 552 }
 553
 554 void FuText::ImpSetAttributesFitToSizeVertical(SdrTextObj* pTxtObj)
 555 {
 556     SfxItemSetFixed<SDRATTR_TEXT_AUTOGROWHEIGHT, SDRATTR_TEXT_AUTOGROWWIDTH>  aSet(mpViewShell->GetPool());
 557     aSet.Put(SdrTextFitToSizeTypeItem(drawing::TextFitToSizeType_PROPORTIONAL));
 558     aSet.Put(makeSdrTextAutoGrowHeightItem(false));
 559     aSet.Put(makeSdrTextAutoGrowWidthItem(false));
 560     pTxtObj->SetMergedItemSet(aSet);
 561     pTxtObj->AdjustTextFrameWidthAndHeight();
 562 }
 563
 564 bool FuText::MouseButtonUp(const MouseEvent& rMEvt)
 565 {
 566     bool bReturn = false;
 567     if (aDragTimer.IsActive())
 568     {
 569         aDragTimer.Stop();
 570         bIsInDragMode = false;
 571     }
 572
 573     mpViewShell->GetViewFrame()->GetBindings().Invalidate( SidArray );
 574
 575     Point aPnt( mpWindow->PixelToLogic( rMEvt.GetPosPixel() ) );
 576
 577     if( (mpView && mpView->MouseButtonUp(rMEvt, mpWindow->GetOutDev())) || rMEvt.GetClicks() == 2 )
 578         return true; // handle event from SdrView
 579
 580     bool bEmptyTextObj = false;
 581
 582     if (mxTextObj.get().is())
 583     {
 584         bool bReset = true;
 585
 586         if (mpView)
 587         {
 588             const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
 589
 590             if (rMarkList.GetMarkCount() == 1
 591                 && ( rMarkList.GetMark(0)->GetMarkedSdrObj() == mxTextObj.get().get()) )
 592             {
 593                 if( mxTextObj.get().is() && !GetTextObj()->GetOutlinerParaObject() )
 594                     bEmptyTextObj = true;
 595                 else
 596                     bFirstObjCreated = true;
 597                 bReset = false;
 598             }
 599         }
 600
 601         if (bReset)
 602         {
 603             mxTextObj = nullptr;
 604         }
 605     }
 606
 607     if( mpView && mpView->IsDragObj())
 608     {
 609         // object was moved
 610         FrameView* pFrameView = mpViewShell->GetFrameView();
 611         bool bDragWithCopy = (rMEvt.IsMod1() && pFrameView->IsDragWithCopy());
 612
 613         if (bDragWithCopy)
 614         {
 615             bDragWithCopy = !mpView->IsPresObjSelected(false);
 616         }
 617
 618         mpView->SetDragWithCopy(bDragWithCopy);
 619         mpView->EndDragObj( mpView->IsDragWithCopy() );
 620         mpView->ForceMarkedToAnotherPage();
 621         mpView->SetCurrentObj(SdrObjKind::Text);
 622
 623         sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
 624
 625         if (bJustEndedEdit)
 626         {
 627             bJustEndedEdit = false;
 628             FuPoor::cancel();
 629         }
 630         if ((rMEvt.GetClicks() != 2) &&
 631             !rMEvt.IsShift() && !rMEvt.IsMod1() && !rMEvt.IsMod2() && !rMEvt.IsRight() &&
 632             std::abs(aPnt.X() - aMDPos.X()) < nDrgLog &&
 633             std::abs(aPnt.Y() - aMDPos.Y()) < nDrgLog)
 634         {
 635             /*************************************************************
 636             * From text mode, you don't want to rotate immediately.
 637             **************************************************************/
 638             SdrPageView* pPV;
 639             SdrObject* pObj = mpView->PickObj(aMDPos, mpView->getHitTolLog(), pPV, SdrSearchOptions::ALSOONMASTER | SdrSearchOptions::BEFOREMARK);
 640             if (pObj && pPV->IsObjMarkable(pObj))
 641             {
 642                 mpView->UnmarkAllObj();
 643                 mpView->MarkObj(pObj,pPV);
 644                 return bReturn;
 645             }
 646         }
 647     }
 648     else if( mpView && mpView->IsCreateObj() && rMEvt.IsLeft())
 649     {
 650         // object was created
 651         rtl::Reference<SdrTextObj> pTextObj = DynCastSdrTextObj( mpView->GetCreateObj() );
 652         mxTextObj = pTextObj.get();
 653
 654         if( pTextObj )
 655         {
 656             //AW outliner needs to be set to vertical when there is no
 657             // outliner object up to now; also it needs to be set back to not
 658             // vertical when there was a vertical one used last time.
 659             OutlinerParaObject* pOPO = GetTextObj()->GetOutlinerParaObject();
 660             SdrOutliner& rOutl(pTextObj->getSdrModelFromSdrObject().GetDrawOutliner(GetTextObj()));
 661             bool bVertical((pOPO && pOPO->IsEffectivelyVertical())
 662                 || nSlotId == SID_ATTR_CHAR_VERTICAL
 663                 || nSlotId == SID_TEXT_FITTOSIZE_VERTICAL);
 664             rOutl.SetVertical(bVertical);
 665
 666             // Before ImpSetAttributesForNewTextObject the vertical writing mode
 667             // needs to be set at the object. This is done here at the OutlinerParaObject
 668             // directly to not mirror the layout text items involved. These items will be set
 669             // from ImpSetAttributesForNewTextObject and below.
 670             OutlinerParaObject* pPara = GetTextObj()->GetOutlinerParaObject();
 671
 672             if(!pPara)
 673             {
 674                 GetTextObj()->ForceOutlinerParaObject();
 675                 pPara = GetTextObj()->GetOutlinerParaObject();
 676             }
 677
 678             if(pPara && bVertical != pPara->IsEffectivelyVertical())
 679             {
 680                 // set ParaObject orientation accordingly
 681                 pPara->SetVertical(bVertical);
 682             }
 683
 684             ImpSetAttributesForNewTextObject(GetTextObj());
 685         }
 686
 687         if (!mpView->EndCreateObj(SdrCreateCmd::ForceEnd))
 688         {
 689             // it was not possible to create text object
 690             mxTextObj = nullptr;
 691             pTextObj = nullptr;
 692         }
 693         else if (nSlotId == SID_TEXT_FITTOSIZE)
 694         {
 695             ImpSetAttributesFitToSize(GetTextObj());
 696
 697             SetInEditMode(rMEvt, false);
 698         }
 699         else if ( nSlotId == SID_TEXT_FITTOSIZE_VERTICAL )
 700         {
 701             ImpSetAttributesFitToSizeVertical(GetTextObj());
 702
 703             SetInEditMode(rMEvt, false);
 704         }
 705         else
 706         {
 707             // thereby the handles and the gray frame are correct
 708             mpView->AdjustMarkHdl();
 709             mpView->PickHandle(aPnt);
 710             SetInEditMode(rMEvt, false);
 711         }
 712     }
 713     else if ( mpView && mpView->IsAction())
 714     {
 715         mpView->EndAction();
 716     }
 717
 718     ForcePointer(&rMEvt);
 719     mpWindow->ReleaseMouse();
 720     sal_uInt16 nDrgLog1 = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
 721
 722     if ( mpView && !mpView->AreObjectsMarked() &&
 723          std::abs(aMDPos.X() - aPnt.X()) < nDrgLog1 &&
 724          std::abs(aMDPos.Y() - aPnt.Y()) < nDrgLog1 &&
 725          !rMEvt.IsShift() && !rMEvt.IsMod2() )
 726     {
 727         SdrPageView* pPV2 = mpView->GetSdrPageView();
 728         SdrViewEvent aVEvt;
 729         mpView->PickAnything(rMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt);
 730         mpView->MarkObj(aVEvt.mpRootObj, pPV2);
 731     }
 732
 733     if ( !mxTextObj.get().is() && mpView )
 734     {
 735         if ( ( (!bEmptyTextObj   &&  bPermanent) ||
 736              (!bFirstObjCreated && !bPermanent) ) &&
 737               !mpDocSh->IsReadOnly()               &&
 738               nSlotId != SID_TEXTEDIT )
 739         {
 740             // text body (left-justified AutoGrow)
 741             mpView->SetCurrentObj(SdrObjKind::Text);
 742             mpView->SetEditMode(SdrViewEditMode::Create);
 743             sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
 744             mpView->BegCreateObj(aMDPos, nullptr, nDrgLog);
 745
 746             bool bSnapEnabled = mpView->IsSnapEnabled();
 747
 748             if (bSnapEnabled)
 749                 mpView->SetSnapEnabled(false);
 750
 751             aPnt.AdjustX(nDrgLog + nDrgLog );
 752             aPnt.AdjustY(nDrgLog + nDrgLog );
 753             mpView->MovAction(aPnt);
 754
 755             mxTextObj = DynCastSdrTextObj( mpView->GetCreateObj() );
 756
 757             if(mxTextObj.get().is())
 758             {
 759                 GetTextObj()->SetDisableAutoWidthOnDragging(true);
 760             }
 761
 762             if(!mpView->EndCreateObj(SdrCreateCmd::ForceEnd))
 763             {
 764                 mxTextObj.clear();
 765             }
 766
 767             if(bSnapEnabled)
 768                 mpView->SetSnapEnabled(bSnapEnabled);
 769
 770             if(mxTextObj.get().is())
 771             {
 772                 SfxItemSet aSet(mpViewShell->GetPool());
 773                 aSet.Put(makeSdrTextMinFrameHeightItem(0));
 774                 aSet.Put(makeSdrTextMinFrameWidthItem(0));
 775                 aSet.Put(makeSdrTextAutoGrowHeightItem(true));
 776                 aSet.Put(makeSdrTextAutoGrowWidthItem(true));
 777
 778                 if(nSlotId == SID_ATTR_CHAR_VERTICAL)
 779                 {
 780                     // Here, all items which need to be different from pool default need to be set
 781                     // again on the newly created text object.
 782                     // Since this is a simple click text object, it is first created, then SetVertical()
 783                     // is used, then ImpSetAttributesForNewTextObject is called and then the object is
 784                     // deleted again since not the minimum drag distance was travelled. Then, a new
 785                     // click text object is created and thus all that stuff needs to be set again here.
 786
 787                     // Before using the new object the vertical writing mode
 788                     // needs to be set. This is done here at the OutlinerParaObject
 789                     // directly to not mirror the layout text items involved. These items will be set
 790                     // below.
 791                     OutlinerParaObject* pPara = GetTextObj()->GetOutlinerParaObject();
 792
 793                     if(!pPara)
 794                     {
 795                         GetTextObj()->ForceOutlinerParaObject();
 796                         pPara = GetTextObj()->GetOutlinerParaObject();
 797                     }
 798
 799                     if(pPara && !pPara->IsEffectivelyVertical())
 800                     {
 801                         // set ParaObject orientation accordingly
 802                         pPara->SetVertical(true);
 803                     }
 804
 805                     aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT));
 806
 807                     // Analog to the else case below, for vertical simple click texts
 808                     // one of the default set items from ImpSetAttributesForNewTextObject
 809                     // needs to be adapted to non-block mode.
 810                     const SfxItemSet& rSet = mpView->GetDefaultAttr();
 811                     SvxFrameDirection eDirection = rSet.Get(EE_PARA_WRITINGDIR).GetValue();
 812
 813                     if(SvxFrameDirection::Horizontal_RL_TB == eDirection || SvxFrameDirection::Vertical_RL_TB == eDirection)
 814                     {
 815                         aSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BOTTOM));
 816                     }
 817                     else
 818                     {
 819                         aSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_TOP));
 820                     }
 821                 }
 822                 else
 823                 {
 824                     // This is for Format/Page settings. Since this also leads
 825                     // to the object defaults to be changed, i think this code can be
 826                     // removed. CL. wanted to take a look before adding this.
 827
 828                     // Look in the object defaults if left-to-right is wanted. If
 829                     // yes, set text anchoring to right to let the box grow to left.
 830                     const SfxItemSet& rSet = mpView->GetDefaultAttr();
 831                     SvxFrameDirection eDirection = rSet.Get(EE_PARA_WRITINGDIR).GetValue();
 832
 833                     if(SvxFrameDirection::Horizontal_RL_TB == eDirection)
 834                     {
 835                         aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT));
 836                     }
 837                     else
 838                     {
 839                         aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_LEFT));
 840                     }
 841                 }
 842
 843                 GetTextObj()->SetMergedItemSet(aSet);
 844                 GetTextObj()->SetDisableAutoWidthOnDragging(true);
 845                 SetInEditMode(rMEvt, false);
 846             }
 847
 848             bFirstObjCreated = true;
 849         }
 850         else
 851         {
 852             // switch to selection
 853             if (mpView->SdrEndTextEdit() == SdrEndTextEditKind::Deleted)
 854             {
 855                 mxTextObj = nullptr;
 856             }
 857
 858             mpViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_OBJECT_SELECT,
 859                                       SfxCallMode::ASYNCHRON | SfxCallMode::RECORD );
 860         }
 861     }
 862     if (bJustEndedEdit)
 863     {
 864         bJustEndedEdit = false;
 865         FuPoor::cancel();
 866     }
 867     bMBDown = false;
 868     FuConstruct::MouseButtonUp(rMEvt);
 869     return bReturn;
 870 }
 871
 872 /**
 873  * handle keyboard events
 874  * @returns sal_True if the event was handled, sal_False otherwise
 875  */
 876 bool FuText::KeyInput(const KeyEvent& rKEvt)
 877 {
 878     bool bReturn = false;
 879
 880     vcl::KeyCode nCode = rKEvt.GetKeyCode();
 881     bool bShift = nCode.IsShift();
 882
 883     if(mxTextObj.get().is())
 884     {
 885         // maybe object is deleted, test if it's equal to the selected object
 886         const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
 887         SdrObject* pSelectedObj = nullptr;
 888
 889         if(1 == rMarkList.GetMarkCount())
 890         {
 891             SdrMark* pMark = rMarkList.GetMark(0);
 892             pSelectedObj = pMark->GetMarkedSdrObj();
 893         }
 894
 895         if(mxTextObj.get().get() != pSelectedObj)
 896         {
 897             mxTextObj = nullptr;
 898         }
 899     }
 900
 901     if (auto pTextObj = mxTextObj.get())
 902         if ( pTextObj->GetObjInventor() == SdrInventor::Default && pTextObj->GetObjIdentifier() == SdrObjKind::TitleText && rKEvt.GetKeyCode().GetCode() == KEY_RETURN )
 903         {
 904             // title text object: always soft breaks
 905             bShift = true;
 906         }
 907
 908     sal_uInt16 nKey = nCode.GetCode();
 909     vcl::KeyCode aKeyCode (nKey, bShift, nCode.IsMod1(), nCode.IsMod2(), nCode.IsMod3() );
 910     KeyEvent aKEvt(rKEvt.GetCharCode(), aKeyCode);
 911
 912     bool bOK = true;
 913
 914     if (mpDocSh->IsReadOnly())
 915     {
 916         bOK = !EditEngine::DoesKeyChangeText(aKEvt);
 917     }
 918     if( aKeyCode.GetCode() == KEY_PAGEUP || aKeyCode.GetCode() == KEY_PAGEDOWN )
 919     {
 920         bOK = false;   // default handling in base class
 921     }
 922
 923     if (bOK && mpView->KeyInput(aKEvt, mpWindow) )
 924     {
 925         bReturn = true;
 926
 927         mpViewShell->GetViewFrame()->GetBindings().Invalidate( SidArray );
 928
 929     }
 930     else if (aKeyCode == KEY_ESCAPE)
 931     {
 932         bReturn = cancel();
 933     }
 934
 935     if( bPermanent )
 936     {
 937         mpView->SetCurrentObj(SdrObjKind::Text);
 938         mpView->SetEditMode(SdrViewEditMode::Create);
 939     }
 940
 941     if (!bReturn)
 942     {
 943         bReturn = FuDraw::KeyInput(aKEvt);
 944     }
 945
 946     return bReturn;
 947 }
 948
 949 void FuText::Activate()
 950 {
 951     mpView->SetQuickTextEditMode(mpViewShell->GetFrameView()->IsQuickEdit());
 952
 953     // #i89661# it's no longer necessary to make it so big here, it's fine tuned
 954     // for text objects in SdrMarkView::CheckSingleSdrObjectHit
 955     mpView->SetHitTolerancePixel( 2 * HITPIX );
 956
 957     OutlinerView* pOLV = mpView->GetTextEditOutlinerView();
 958
 959     if (pOLV)
 960         pOLV->ShowCursor(/*bGotoCursor=*/true, /*bActivate=*/true);
 961
 962     FuConstruct::Activate();
 963
 964     if( pOLV )
 965         mpView->SetEditMode(SdrViewEditMode::Edit);
 966 }
 967
 968 void FuText::Deactivate()
 969 {
 970     OutlinerView* pOLV = mpView->GetTextEditOutlinerView();
 971
 972     if (pOLV)
 973         pOLV->HideCursor(/*bDeactivate=*/true);
 974
 975     mpView->SetHitTolerancePixel( HITPIX );
 976
 977     FuConstruct::Deactivate();
 978 }
 979
 980 /**
 981  * Sets the object into the edit mode.
 982  */
 983 void FuText::SetInEditMode(const MouseEvent& rMEvt, bool bQuickDrag)
 984 {
 985     SdrPageView* pPV = mpView->GetSdrPageView();
 986     if( mxTextObj.get().is() && (mxTextObj.get()->getSdrPageFromSdrObject() == pPV->GetPage()) )
 987     {
 988         mpView->SetCurrentObj(SdrObjKind::Text);
 989
 990         if( bPermanent )
 991             mpView->SetEditMode(SdrViewEditMode::Create);
 992         else
 993             mpView->SetEditMode(SdrViewEditMode::Edit);
 994
 995         bool bEmptyOutliner = false;
 996
 997         if (!GetTextObj()->GetOutlinerParaObject() && mpView->GetTextEditOutliner())
 998         {
 999             ::Outliner* pOutl = mpView->GetTextEditOutliner();
1000             sal_Int32 nParagraphCnt = pOutl->GetParagraphCount();
1001             Paragraph* p1stPara = pOutl->GetParagraph( 0 );
1002
1003             if (nParagraphCnt==1 && p1stPara)
1004             {
1005                 // with only one paragraph
1006                 if (pOutl->GetText(p1stPara).isEmpty())
1007                 {
1008                     bEmptyOutliner = true;
1009                 }
1010             }
1011         }
1012
1013         if (GetTextObj() != mpView->GetTextEditObject() || bEmptyOutliner)
1014         {
1015             rtl::Reference<SdrTextObj> pTextObj = mxTextObj.get();
1016             SdrInventor nInv = pTextObj->GetObjInventor();
1017             SdrObjKind  nSdrObjKind = pTextObj->GetObjIdentifier();
1018
1019             if (nInv == SdrInventor::Default && GetTextObj()->HasTextEdit() &&
1020                 (nSdrObjKind == SdrObjKind::Text ||
1021                  nSdrObjKind == SdrObjKind::TitleText ||
1022                  nSdrObjKind == SdrObjKind::OutlineText || !pTextObj->IsEmptyPresObj() ) )
1023             {
1024                 // create new outliner (owned by SdrObjEditView)
1025                 std::unique_ptr<SdrOutliner> pOutl = SdrMakeOutliner(OutlinerMode::OutlineObject, *mpDoc);
1026
1027                 if (bEmptyOutliner)
1028                     mpView->SdrEndTextEdit(true);
1029
1030                 pTextObj = GetTextObj();
1031                 if( pTextObj )
1032                 {
1033                     OutlinerParaObject* pOPO = pTextObj->GetOutlinerParaObject();
1034                     if( pOPO && pOPO->IsEffectivelyVertical() )
1035                     {
1036                         pOutl->SetVertical(pOPO->GetVertical());
1037                         pOutl->SetRotation(pOPO->GetRotation());
1038                     }
1039                     else if (nSlotId == SID_ATTR_CHAR_VERTICAL || nSlotId == SID_TEXT_FITTOSIZE_VERTICAL)
1040                         pOutl->SetVertical( true );
1041
1042                     if( pTextObj->getTextCount() > 1 )
1043                     {
1044                         Point aPix(rMEvt.GetPosPixel());
1045                         Point aPnt(mpWindow->PixelToLogic(aPix));
1046                         pTextObj->setActiveText( pTextObj->CheckTextHit(aPnt ) );
1047                     }
1048
1049                     if (mpView->SdrBeginTextEdit(pTextObj.get(), pPV, mpWindow, true, pOutl.release()) && mxTextObj.get()->GetObjInventor() == SdrInventor::Default)
1050                     {
1051                         //tdf#102293 flush overlay before going on to pass clicks down to
1052                         //the outline view which will want to paint selections
1053                         for (sal_uInt32 b = 0; b < pPV->PageWindowCount(); ++b)
1054                         {
1055                             const SdrPageWindow& rPageWindow = *pPV->GetPageWindow(b);
1056                             if (!rPageWindow.GetPaintWindow().OutputToWindow())
1057                                 continue;
1058                             const rtl::Reference< sdr::overlay::OverlayManager >& xManager = rPageWindow.GetOverlayManager();
1059                             if (!xManager.is())
1060                                 continue;
1061                             xManager->flush();
1062                         }
1063
1064                         bFirstObjCreated = true;
1065                         DeleteDefaultText();
1066
1067                         OutlinerView* pOLV = mpView->GetTextEditOutlinerView();
1068
1069                         nSdrObjKind = mxTextObj.get()->GetObjIdentifier();
1070
1071                         SdrViewEvent aVEvt;
1072                         SdrHitKind eHit = mpView->PickAnything(rMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt);
1073
1074                         if (eHit == SdrHitKind::TextEdit)
1075                         {
1076                             // hit text
1077                             if (nSdrObjKind == SdrObjKind::Text ||
1078                                 nSdrObjKind == SdrObjKind::TitleText ||
1079                                 nSdrObjKind == SdrObjKind::OutlineText ||
1080                                 nSdrObjKind == SdrObjKind::Table ||
1081                                 nSlotId == SID_TEXTEDIT ||
1082                                 !bQuickDrag)
1083                             {
1084                                 pOLV->MouseButtonDown(rMEvt);
1085                                 pOLV->MouseMove(rMEvt);
1086                                 pOLV->MouseButtonUp(rMEvt);
1087                             }
1088
1089                             if (mpViewShell->GetFrameView()->IsQuickEdit() && bQuickDrag && GetTextObj()->GetOutlinerParaObject())
1090                             {
1091                                 pOLV->MouseButtonDown(rMEvt);
1092                             }
1093                         }
1094                         else
1095                         {
1096                             // Move cursor to end of text
1097                             ESelection aNewSelection(EE_PARA_NOT_FOUND, EE_INDEX_NOT_FOUND, EE_PARA_NOT_FOUND, EE_INDEX_NOT_FOUND);
1098                             if (pOLV != nullptr)
1099                                 pOLV->SetSelection(aNewSelection);
1100                         }
1101                     }
1102                     else
1103                     {
1104                         mpView->RestoreDefaultText( mxTextObj.get().get() );
1105                     }
1106                 }
1107             }
1108         }
1109     }
1110     else
1111     {
1112         mxTextObj = nullptr;
1113     }
1114 }
1115
1116 /**
1117  * Text entry is started, if necessary delete the default text.
1118  */
1119 void FuText::DeleteDefaultText()
1120 {
1121     if ( !(mxTextObj.get().is() && mxTextObj.get()->IsEmptyPresObj()) )
1122         return;
1123
1124     SdPage* pPage = static_cast<SdPage*>( mxTextObj.get()->getSdrPageFromSdrObject() );
1125
1126     if (!pPage)
1127         return;
1128
1129     PresObjKind ePresObjKind = pPage->GetPresObjKind(mxTextObj.get().get());
1130
1131     if ( !(ePresObjKind == PresObjKind::Title   ||
1132            ePresObjKind == PresObjKind::Outline ||
1133            ePresObjKind == PresObjKind::Notes   ||
1134            ePresObjKind == PresObjKind::Text      ) ||
1135           pPage->IsMasterPage() )
1136         return;
1137
1138     ::Outliner* pOutliner = mpView->GetTextEditOutliner();
1139     SfxStyleSheet* pSheet = pOutliner->GetStyleSheet( 0 );
1140     bool bIsUndoEnabled = pOutliner->IsUndoEnabled();
1141     if( bIsUndoEnabled )
1142         pOutliner->EnableUndo(false);
1143
1144     pOutliner->SetText( OUString(), pOutliner->GetParagraph( 0 ) );
1145
1146     if( bIsUndoEnabled )
1147         pOutliner->EnableUndo(true);
1148
1149     if (pSheet &&
1150         (ePresObjKind == PresObjKind::Notes || ePresObjKind == PresObjKind::Text))
1151         pOutliner->SetStyleSheet(0, pSheet);
1152
1153     mxTextObj.get()->SetEmptyPresObj(true);
1154 }
1155
1156 bool FuText::RequestHelp(const HelpEvent& rHEvt)
1157 {
1158     bool bReturn = false;
1159
1160     OutlinerView* pOLV = mpView->GetTextEditOutlinerView();
1161
1162     if ((Help::IsBalloonHelpEnabled() || Help::IsQuickHelpEnabled()) &&
1163         mxTextObj.get().is() && pOLV && pOLV->GetFieldUnderMousePointer())
1164     {
1165         OUString aHelpText;
1166         const SvxFieldItem* pFieldItem = pOLV->GetFieldUnderMousePointer();
1167         const SvxFieldData* pField = pFieldItem->GetField();
1168
1169         if (auto pURLField = dynamic_cast< const SvxURLField *>( pField ))
1170         {
1171             // URL-Field
1172             aHelpText = INetURLObject::decode( pURLField->GetURL(), INetURLObject::DecodeMechanism::WithCharset );
1173         }
1174         if (!aHelpText.isEmpty())
1175         {
1176             ::tools::Rectangle aLogicPix = mpWindow->LogicToPixel(mxTextObj.get()->GetLogicRect());
1177             ::tools::Rectangle aScreenRect(mpWindow->OutputToScreenPixel(aLogicPix.TopLeft()),
1178                                   mpWindow->OutputToScreenPixel(aLogicPix.BottomRight()));
1179
1180             if (Help::IsBalloonHelpEnabled())
1181             {
1182                 Help::ShowBalloon( static_cast<vcl::Window*>(mpWindow), rHEvt.GetMousePosPixel(), aScreenRect, aHelpText);
1183                 bReturn = true;
1184             }
1185             else if (Help::IsQuickHelpEnabled())
1186             {
1187                 Help::ShowQuickHelp( static_cast<vcl::Window*>(mpWindow), aScreenRect, aHelpText);
1188                 bReturn = true;
1189             }
1190         }
1191     }
1192
1193     if (!bReturn)
1194     {
1195         bReturn = FuConstruct::RequestHelp(rHEvt);
1196     }
1197
1198     return bReturn;
1199 }
1200
1201 void FuText::ReceiveRequest(SfxRequest& rReq)
1202 {
1203     nSlotId = rReq.GetSlot();
1204
1205     // then we call the base class (besides others, nSlotId is NOT set there)
1206     FuPoor::ReceiveRequest(rReq);
1207
1208     if (!(nSlotId == SID_TEXTEDIT || mpViewShell->GetFrameView()->IsQuickEdit() || SID_ATTR_CHAR == nSlotId))
1209         return;
1210
1211     MouseEvent aMEvt(mpWindow->GetPointerPosPixel());
1212
1213     mxTextObj = nullptr;
1214
1215     if (nSlotId == SID_TEXTEDIT)
1216     {
1217         // are we currently editing?
1218         mxTextObj = mpView->GetTextEditObject();
1219
1220         if (!mxTextObj.get().is())
1221         {
1222             // Try to select an object
1223             SdrPageView* pPV = mpView->GetSdrPageView();
1224             SdrViewEvent aVEvt;
1225             mpView->PickAnything(aMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt);
1226             mpView->MarkObj(aVEvt.mpRootObj, pPV);
1227
1228             if (auto pSdrTextObj = DynCastSdrTextObj(aVEvt.mpObj))
1229             {
1230                 mxTextObj = pSdrTextObj;
1231             }
1232         }
1233     }
1234     else if (mpView->AreObjectsMarked())
1235     {
1236         const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
1237
1238         if (rMarkList.GetMarkCount() == 1)
1239         {
1240             SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
1241
1242             if( auto pTextObj = DynCastSdrTextObj( pObj ))
1243             {
1244                 mxTextObj = pTextObj;
1245             }
1246         }
1247     }
1248
1249     bool bQuickDrag = true;
1250
1251     const SfxItemSet* pArgs = rReq.GetArgs();
1252
1253     if (pArgs
1254
1255         // test for type before using
1256         && SID_TEXTEDIT == nSlotId
1257         && SfxItemState::SET == pArgs->GetItemState(SID_TEXTEDIT)
1258
1259         && static_cast<const SfxUInt16Item&>( pArgs->Get(SID_TEXTEDIT)).GetValue() == 2)
1260     {
1261         // selection with double click -> do not allow QuickDrag
1262         bQuickDrag = false;
1263     }
1264
1265     SetInEditMode(aMEvt, bQuickDrag);
1266 }
1267
1268 void FuText::DoubleClick(const MouseEvent& )
1269 {
1270     // Nothing to do
1271 }
1272
1273 /** Removed the insertion of default text and putting a new text
1274     object directly into edit mode.
1275 */
1276 rtl::Reference<SdrObject> FuText::CreateDefaultObject(const sal_uInt16 nID, const ::tools::Rectangle& rRectangle)
1277 {
1278     rtl::Reference<SdrObject> pObj( SdrObjFactory::MakeNewObject(
1279         mpView->getSdrModelFromSdrView(),
1280         mpView->GetCurrentObjInventor(),
1281         mpView->GetCurrentObjIdentifier(),
1282         nullptr) );
1283
1284     if(pObj)
1285     {
1286         if( auto pText = DynCastSdrTextObj( pObj.get() ) )
1287         {
1288             pText->SetLogicRect(rRectangle);
1289
1290             bool bVertical = (SID_ATTR_CHAR_VERTICAL == nID || SID_TEXT_FITTOSIZE_VERTICAL == nID);
1291             pText->SetVerticalWriting(bVertical);
1292
1293             ImpSetAttributesForNewTextObject(pText);
1294
1295             if (nSlotId == SID_TEXT_FITTOSIZE)
1296             {
1297                 ImpSetAttributesFitToSize(pText);
1298             }
1299             else if ( nSlotId == SID_TEXT_FITTOSIZE_VERTICAL )
1300             {
1301                 ImpSetAttributesFitToSizeVertical(pText);
1302             }
1303
1304             // Put text object into edit mode.
1305             SdrPageView* pPV = mpView->GetSdrPageView();
1306             mpView->SdrBeginTextEdit(pText, pPV);
1307         }
1308         else
1309         {
1310             OSL_FAIL("Object is NO text object");
1311         }
1312     }
1313
1314     return pObj;
1315 }
1316
1317 /** is called when the current function should be aborted. <p>
1318     This is used when a function gets a KEY_ESCAPE but can also
1319     be called directly.
1320
1321     @returns true if an active function was aborted
1322 */
1323 bool FuText::cancel()
1324 {
1325     if ( mpView->IsTextEdit() )
1326     {
1327         if(mpView->SdrEndTextEdit() == SdrEndTextEditKind::Deleted)
1328             mxTextObj = nullptr;
1329
1330         mpView->SetCurrentObj(SdrObjKind::Text);
1331         mpView->SetEditMode(SdrViewEditMode::Edit);
1332         return true;
1333     }
1334     else
1335     {
1336         return false;
1337     }
1338 }
1339
1340 void FuText::ChangeFontSize( bool bGrow, OutlinerView* pOLV, const FontList* pFontList, ::sd::View* pView )
1341 {
1342     if( !pFontList || !pView )
1343         return;
1344
1345     if( pOLV )
1346     {
1347         pOLV->GetEditView().ChangeFontSize( bGrow, pFontList );
1348     }
1349     else
1350     {
1351
1352         pView->BegUndo(SdResId(bGrow ? STR_GROW_FONT_SIZE : STR_SHRINK_FONT_SIZE));
1353         const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
1354         for( size_t nMark = 0; nMark < rMarkList.GetMarkCount(); ++nMark )
1355         {
1356             SdrTextObj* pTextObj = DynCastSdrTextObj( rMarkList.GetMark(nMark)->GetMarkedSdrObj() );
1357             if( pTextObj )
1358             {
1359                 rtl::Reference<sdr::SelectionController> xSelectionController(pView->getSelectionController());
1360                 if (xSelectionController.is() && xSelectionController->ChangeFontSize(bGrow, pFontList))
1361                 {
1362                     continue;
1363                 }
1364                 for( sal_Int32 nText = 0; nText < pTextObj->getTextCount(); nText++ )
1365                 {
1366                     pTextObj->setActiveText( nText );
1367
1368                     // Put text object into edit mode.
1369                     SdrPageView* pPV = pView->GetSdrPageView();
1370                     pView->SdrBeginTextEdit(pTextObj, pPV);
1371
1372                     pOLV = pView->GetTextEditOutlinerView();
1373                     if( pOLV )
1374                     {
1375                         EditEngine* pEditEngine = pOLV->GetEditView().GetEditEngine();
1376                         if( pEditEngine )
1377                         {
1378                             ESelection aSel;
1379                             aSel.nEndPara = pEditEngine->GetParagraphCount()-1;
1380                             aSel.nEndPos = pEditEngine->GetTextLen(aSel.nEndPara);
1381                             pOLV->SetSelection(aSel);
1382                         }
1383
1384                         ChangeFontSize( bGrow, pOLV, pFontList, pView );
1385                     }
1386
1387                     pView->SdrEndTextEdit();
1388                 }
1389
1390                 SfxItemSet aShapeSet( pTextObj->GetMergedItemSet() );
1391                 if( EditView::ChangeFontSize( bGrow, aShapeSet, pFontList ) )
1392                 {
1393                     pTextObj->SetObjectItemNoBroadcast( aShapeSet.Get( EE_CHAR_FONTHEIGHT ) );
1394                     pTextObj->SetObjectItemNoBroadcast( aShapeSet.Get( EE_CHAR_FONTHEIGHT_CJK ) );
1395                     pTextObj->SetObjectItemNoBroadcast( aShapeSet.Get( EE_CHAR_FONTHEIGHT_CTL ) );
1396                 }
1397             }
1398         }
1399         pView->EndUndo();
1400     }
1401 }
1402
1403 void FuText::InvalidateBindings()
1404 {
1405     mpViewShell->GetViewFrame()->GetBindings().Invalidate(SidArray);
1406 }
1407
1408
1409 } // end of namespace sd
1410
1411 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */