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