sd/source/ui/func/fupoor.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 <fupoor.hxx>
  21
  22 #include <svx/svxids.hrc>
  23 #include <svl/aeitem.hxx>
  24 #include <svx/svdpagv.hxx>
  25 #include <svx/svdoole2.hxx>
  26 #include <svx/svdograf.hxx>
  27 #include <vcl/seleng.hxx>
  28 #include <sfx2/app.hxx>
  29 #include <sfx2/dispatch.hxx>
  30 #include <sfx2/bindings.hxx>
  31 #include <sfx2/request.hxx>
  32 #include <vcl/dialog.hxx>
  33 #include <com/sun/star/beans/XPropertySet.hpp>
  34 #include <com/sun/star/drawing/XLayer.hpp>
  35 #include <com/sun/star/drawing/XLayerManager.hpp>
  36 #include <com/sun/star/container/XChild.hpp>
  37
  38 #include <FrameView.hxx>
  39 #include <app.hrc>
  40 #include <fusel.hxx>
  41 #include <sdpage.hxx>
  42 #include <drawview.hxx>
  43 #include <DrawViewShell.hxx>
  44 #include <Window.hxx>
  45 #include <drawdoc.hxx>
  46 #include <DrawDocShell.hxx>
  47 #include <zoomlist.hxx>
  48 #include <Client.hxx>
  49 #include <slideshow.hxx>
  50 #include <LayerTabBar.hxx>
  51
  52 #include <sfx2/viewfrm.hxx>
  53
  54 #include <svx/svditer.hxx>
  55
  56 #include <editeng/editeng.hxx>
  57
  58 using namespace ::com::sun::star;
  59
  60 namespace sd {
  61
  62
  63 FuPoor::FuPoor (
  64     ViewShell* pViewSh,
  65     ::sd::Window* pWin,
  66     ::sd::View* pView,
  67     SdDrawDocument* pDrDoc,
  68     SfxRequest& rReq)
  69     : mpView(pView),
  70       mpViewShell(pViewSh),
  71       mpWindow(pWin),
  72       mpDocSh( pDrDoc->GetDocSh() ),
  73       mpDoc(pDrDoc),
  74       nSlotId( rReq.GetSlot() ),
  75       pDialog(nullptr),
  76       bIsInDragMode(false),
  77       bNoScrollUntilInside (true),
  78       bScrollable (false),
  79       bDelayActive (false),
  80       bFirstMouseMove (false),
  81       // remember MouseButton state
  82       mnCode(0)
  83 {
  84     ReceiveRequest(rReq);
  85
  86     aScrollTimer.SetInvokeHandler( LINK(this, FuPoor, ScrollHdl) );
  87     aScrollTimer.SetTimeout(SELENG_AUTOREPEAT_INTERVAL);
  88
  89     aDragTimer.SetInvokeHandler( LINK(this, FuPoor, DragHdl) );
  90     aDragTimer.SetTimeout(SELENG_DRAGDROP_TIMEOUT);
  91
  92     aDelayToScrollTimer.SetInvokeHandler( LINK(this, FuPoor, DelayHdl) );
  93     aDelayToScrollTimer.SetTimeout(2000);
  94 }
  95
  96 FuPoor::~FuPoor()
  97 {
  98     aDragTimer.Stop();
  99     aScrollTimer.Stop();
 100     aDelayToScrollTimer.Stop();
 101     pDialog.disposeAndClear();
 102 }
 103
 104 void FuPoor::Activate()
 105 {
 106     if (pDialog)
 107     {
 108         pDialog->Show();
 109     }
 110 }
 111
 112 void FuPoor::Deactivate()
 113 {
 114     aDragTimer.Stop();
 115     aScrollTimer.Stop();
 116     aDelayToScrollTimer.Stop ();
 117     bScrollable = bDelayActive = false;
 118
 119     if (pDialog)
 120     {
 121         pDialog->Hide();
 122     }
 123
 124     if (mpWindow && mpWindow->IsMouseCaptured())
 125         mpWindow->ReleaseMouse();
 126 }
 127
 128 void FuPoor::SetWindow(::sd::Window* pWin)
 129 {
 130     mpWindow = pWin;
 131 }
 132
 133 /**
 134  * scroll when approached the border of the window; is called by MouseMove
 135  */
 136 void FuPoor::ForceScroll(const Point& aPixPos)
 137 {
 138     aScrollTimer.Stop();
 139
 140     if ( !mpView->IsDragHelpLine() && !mpView->IsSetPageOrg() &&
 141             !SlideShow::IsRunning( mpViewShell->GetViewShellBase() ) )
 142     {
 143         Point aPos = mpWindow->OutputToScreenPixel(aPixPos);
 144         const ::tools::Rectangle& rRect = mpViewShell->GetAllWindowRect();
 145
 146         if ( bNoScrollUntilInside )
 147         {
 148             if ( rRect.IsInside(aPos) )
 149                 bNoScrollUntilInside = false;
 150         }
 151         else
 152         {
 153             short dx = 0, dy = 0;
 154
 155             if ( aPos.X() <= rRect.Left()   ) dx = -1;
 156             if ( aPos.X() >= rRect.Right()  ) dx =  1;
 157             if ( aPos.Y() <= rRect.Top()    ) dy = -1;
 158             if ( aPos.Y() >= rRect.Bottom() ) dy =  1;
 159
 160             if ( dx != 0 || dy != 0 )
 161             {
 162                 if (bScrollable)
 163                 {
 164                     // scroll action in derived class
 165                     mpViewShell->ScrollLines(dx, dy);
 166                     aScrollTimer.Start();
 167                 }
 168                 else if (! bDelayActive) StartDelayToScrollTimer ();
 169             }
 170         }
 171     }
 172 }
 173
 174 /**
 175  * timer handler for window scrolling
 176  */
 177 IMPL_LINK_NOARG(FuPoor, ScrollHdl, Timer *, void)
 178 {
 179     Point aPnt(mpWindow->GetPointerPosPixel());
 180
 181     // use remembered MouseButton state to create correct
 182     // MouseEvents for this artificial MouseMove.
 183     MouseMove(MouseEvent(aPnt, 1, MouseEventModifiers::NONE, GetMouseButtonCode()));
 184 }
 185
 186 /**
 187  * handle keyboard events
 188  * @returns sal_True if the event was handled, sal_False otherwise
 189  */
 190 bool FuPoor::KeyInput(const KeyEvent& rKEvt)
 191 {
 192     sal_uInt16          nCode = rKEvt.GetKeyCode().GetCode();
 193     bool            bReturn = false;
 194     bool            bSlideShow = SlideShow::IsRunning( mpViewShell->GetViewShellBase() );
 195
 196     switch (nCode)
 197     {
 198         case KEY_RETURN:
 199         {
 200             if(rKEvt.GetKeyCode().IsMod1())
 201             {
 202                 if( dynamic_cast< const DrawViewShell *>( mpViewShell ) !=  nullptr)
 203                 {
 204                     DrawViewShell* pDrawViewShell =
 205                         static_cast<DrawViewShell*>(mpViewShell);
 206                     SdPage* pActualPage = pDrawViewShell->GetActualPage();
 207                     SdrTextObj* pCandidate = nullptr;
 208
 209                     if(pActualPage)
 210                     {
 211                         SdrObjListIter aIter(*pActualPage, SdrIterMode::DeepNoGroups);
 212
 213                         while(aIter.IsMore() && !pCandidate)
 214                         {
 215                             SdrObject* pObj = aIter.Next();
 216
 217                             if(pObj && dynamic_cast< const SdrTextObj *>( pObj ) !=  nullptr)
 218                             {
 219                                 SdrInventor nInv(pObj->GetObjInventor());
 220                                 sal_uInt16 nKnd(pObj->GetObjIdentifier());
 221
 222                                 if(SdrInventor::Default == nInv &&
 223                                     (OBJ_TITLETEXT == nKnd || OBJ_OUTLINETEXT == nKnd || OBJ_TEXT == nKnd))
 224                                 {
 225                                     pCandidate = static_cast<SdrTextObj*>(pObj);
 226                                 }
 227                             }
 228                         }
 229                     }
 230
 231                     if(pCandidate)
 232                     {
 233                         mpView->UnMarkAll();
 234                         mpView->MarkObj(pCandidate, mpView->GetSdrPageView());
 235
 236                         mpViewShell->GetViewFrame()->GetDispatcher()->Execute(
 237                             SID_ATTR_CHAR, SfxCallMode::ASYNCHRON);
 238                     }
 239                     else
 240                     {
 241                         // insert a new page with the same page layout
 242                         mpViewShell->GetViewFrame()->GetDispatcher()->Execute(
 243                             SID_INSERTPAGE_QUICK, SfxCallMode::ASYNCHRON);
 244                     }
 245
 246                     // consumed
 247                     bReturn = true;
 248                 }
 249             }
 250             else
 251             {
 252                 // activate OLE object on RETURN for selected object
 253                 // activate text edit on RETURN for selected object
 254                 const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
 255
 256                 if( !mpView->IsTextEdit() && 1 == rMarkList.GetMarkCount() )
 257                 {
 258                     SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 259
 260                     if( pObj && dynamic_cast< const SdrOle2Obj* >( pObj ) !=  nullptr && !mpDocSh->IsUIActive() )
 261                     {
 262                         //HMHmpView->HideMarkHdl();
 263                         mpViewShell->ActivateObject( static_cast< SdrOle2Obj* >( pObj ), 0 );
 264                     }
 265                     else if( pObj && pObj->IsEmptyPresObj() && dynamic_cast< const SdrGrafObj *>( pObj ) !=  nullptr )
 266                     {
 267                         mpViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_INSERT_GRAPHIC, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD );
 268                     }
 269                     else
 270                     {
 271                         mpViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_ATTR_CHAR, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD );
 272                     }
 273
 274                     // consumed
 275                     bReturn = true;
 276                 }
 277             }
 278         }
 279         break;
 280
 281         case KEY_TAB:
 282         {
 283             // handle Mod1 and Mod2 to get travelling running on different systems
 284             if(rKEvt.GetKeyCode().IsMod1() || rKEvt.GetKeyCode().IsMod2())
 285             {
 286                 // do something with a selected handle?
 287                 const SdrHdlList& rHdlList = mpView->GetHdlList();
 288                 bool bForward(!rKEvt.GetKeyCode().IsShift());
 289
 290                 const_cast<SdrHdlList&>(rHdlList).TravelFocusHdl(bForward);
 291
 292                 // guarantee visibility of focused handle
 293                 SdrHdl* pHdl = rHdlList.GetFocusHdl();
 294
 295                 if(pHdl)
 296                 {
 297                     Point aHdlPosition(pHdl->GetPos());
 298                     ::tools::Rectangle aVisRect(aHdlPosition - Point(100, 100), Size(200, 200));
 299                     mpView->MakeVisible(aVisRect, *mpWindow);
 300                 }
 301
 302                 // consumed
 303                 bReturn = true;
 304             }
 305         }
 306         break;
 307
 308         case KEY_ESCAPE:
 309         {
 310             bReturn = FuPoor::cancel();
 311         }
 312         break;
 313
 314         case KEY_ADD:
 315         {
 316             if (!mpView->IsTextEdit() && !bSlideShow && !mpDocSh->IsUIActive())
 317             {
 318                 // increase zoom
 319                 mpViewShell->SetZoom(mpWindow->GetZoom() * 3 / 2);
 320
 321                 if( dynamic_cast< const DrawViewShell *>( mpViewShell ) !=  nullptr)
 322                     static_cast<DrawViewShell*>(mpViewShell)
 323                         ->SetZoomOnPage(false);
 324
 325                 bReturn = true;
 326             }
 327         }
 328         break;
 329
 330         case KEY_SUBTRACT:
 331         {
 332             if (!mpView->IsTextEdit() && !bSlideShow && !mpDocSh->IsUIActive())
 333             {
 334                 // decrease zoom
 335                 mpViewShell->SetZoom(mpWindow->GetZoom() * 2 / 3);
 336
 337                 if( dynamic_cast< const DrawViewShell *>( mpViewShell ) !=  nullptr)
 338                     static_cast<DrawViewShell*>(mpViewShell)
 339                         ->SetZoomOnPage(false);
 340
 341                 bReturn = true;
 342             }
 343         }
 344         break;
 345
 346         case KEY_MULTIPLY:
 347         {
 348             if (!mpView->IsTextEdit() && !bSlideShow)
 349             {
 350                 // zoom to page
 351                 mpViewShell->GetViewFrame()->GetDispatcher()->
 352                 Execute(SID_SIZE_PAGE, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD);
 353                 bReturn = true;
 354             }
 355         }
 356         break;
 357
 358         case KEY_DIVIDE:
 359         {
 360             if (!mpView->IsTextEdit() && !bSlideShow)
 361             {
 362                 // zoom to selected objects
 363                 mpViewShell->GetViewFrame()->GetDispatcher()->
 364                 Execute(SID_SIZE_OPTIMAL, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD);
 365                 bReturn = true;
 366             }
 367         }
 368         break;
 369
 370         case KEY_POINT:
 371         {
 372             ZoomList* pZoomList = mpViewShell->GetZoomList();
 373
 374             if (!mpView->IsTextEdit() && pZoomList->IsNextPossible() && !bSlideShow && !mpDocSh->IsUIActive())
 375             {
 376                 // use next ZoomRect
 377                 mpViewShell->SetZoomRect(pZoomList->GetNextZoomRect());
 378                 bReturn = true;
 379             }
 380         }
 381         break;
 382
 383         case KEY_COMMA:
 384         {
 385             ZoomList* pZoomList = mpViewShell->GetZoomList();
 386
 387             if (!mpView->IsTextEdit() && pZoomList->IsPreviousPossible() && !bSlideShow && !mpDocSh->IsUIActive())
 388             {
 389                 // use previous ZoomRect
 390                 mpViewShell->SetZoomRect(pZoomList->GetPreviousZoomRect());
 391                 bReturn = true;
 392             }
 393         }
 394         break;
 395
 396         case KEY_HOME:
 397         {
 398             if (!mpView->IsTextEdit()
 399                 && dynamic_cast< const DrawViewShell *>( mpViewShell ) !=  nullptr
 400                 && !bSlideShow)
 401             {
 402                // jump to first page
 403                static_cast<DrawViewShell*>(mpViewShell)->SwitchPage(0);
 404                bReturn = true;
 405             }
 406         }
 407         break;
 408
 409         case KEY_END:
 410         {
 411             if (!mpView->IsTextEdit()
 412                 && dynamic_cast< const DrawViewShell *>( mpViewShell ) !=  nullptr
 413                 && !bSlideShow)
 414             {
 415                 // jump to last page
 416                 SdPage* pPage =
 417                     static_cast<DrawViewShell*>(mpViewShell)->GetActualPage();
 418                 static_cast<DrawViewShell*>(mpViewShell)
 419                     ->SwitchPage(mpDoc->GetSdPageCount(
 420                         pPage->GetPageKind()) - 1);
 421                 bReturn = true;
 422             }
 423         }
 424         break;
 425
 426         case KEY_PAGEUP:
 427         {
 428             if( rKEvt.GetKeyCode().IsMod1() && rKEvt.GetKeyCode().IsMod2() )
 429                 break;
 430
 431             if( dynamic_cast< const DrawViewShell *>( mpViewShell ) !=  nullptr && !bSlideShow)
 432             {
 433                 // The page-up key switches layers or pages depending on the
 434                 // modifier key.
 435                 if ( ! rKEvt.GetKeyCode().GetModifier())
 436                 {
 437                     // With no modifier pressed we move to the previous
 438                     // slide.
 439                     mpView->SdrEndTextEdit();
 440
 441                     // Previous page.
 442                     bReturn = true;
 443                     SdPage* pPage = static_cast<DrawViewShell*>(mpViewShell)->GetActualPage();
 444                     sal_uInt16 nSdPage = (pPage->GetPageNum() - 1) / 2;
 445
 446                     if (nSdPage > 0)
 447                     {
 448                         // Switch the page and send events regarding
 449                         // deactivation the old page and activating the new
 450                         // one.
 451                         TabControl& rPageTabControl =
 452                             static_cast<DrawViewShell*>(mpViewShell)
 453                             ->GetPageTabControl();
 454                         if (rPageTabControl.IsReallyShown())
 455                             rPageTabControl.SendDeactivatePageEvent ();
 456                         static_cast<DrawViewShell*>(mpViewShell)->SwitchPage(nSdPage - 1);
 457                         if (rPageTabControl.IsReallyShown())
 458                             rPageTabControl.SendActivatePageEvent ();
 459                     }
 460                 }
 461                 else if (rKEvt.GetKeyCode().IsMod1())
 462                 {
 463                     // With the CONTROL modifier we switch layers.
 464                     if (static_cast<DrawViewShell*>(mpViewShell)->IsLayerModeActive())
 465                     {
 466                         // Moves to the previous layer.
 467                         SwitchLayer (-1);
 468                     }
 469                 }
 470             }
 471         }
 472         break;
 473
 474         case KEY_PAGEDOWN:
 475         {
 476             if( rKEvt.GetKeyCode().IsMod1() && rKEvt.GetKeyCode().IsMod2() )
 477                 break;
 478             if(dynamic_cast< const DrawViewShell *>( mpViewShell ) !=  nullptr && !bSlideShow)
 479             {
 480                 // The page-down key switches layers or pages depending on the
 481                 // modifier key.
 482                 if ( ! rKEvt.GetKeyCode().GetModifier())
 483                 {
 484                     // With no modifier pressed we move to the next slide.
 485                     mpView->SdrEndTextEdit();
 486
 487                     // Next page.
 488                     bReturn = true;
 489                     SdPage* pPage = static_cast<DrawViewShell*>(mpViewShell)->GetActualPage();
 490                     sal_uInt16 nSdPage = (pPage->GetPageNum() - 1) / 2;
 491
 492                     if (nSdPage < mpDoc->GetSdPageCount(pPage->GetPageKind()) - 1)
 493                     {
 494                         // Switch the page and send events regarding
 495                         // deactivation the old page and activating the new
 496                         // one.
 497                         TabControl& rPageTabControl =
 498                             static_cast<DrawViewShell*>(mpViewShell)->GetPageTabControl();
 499                         if (rPageTabControl.IsReallyShown())
 500                             rPageTabControl.SendDeactivatePageEvent ();
 501                         static_cast<DrawViewShell*>(mpViewShell)->SwitchPage(nSdPage + 1);
 502                         if (rPageTabControl.IsReallyShown())
 503                             rPageTabControl.SendActivatePageEvent ();
 504                     }
 505                 }
 506                 else if (rKEvt.GetKeyCode().IsMod1())
 507                 {
 508                     // With the CONTROL modifier we switch layers.
 509                     if (static_cast<DrawViewShell*>(mpViewShell)->IsLayerModeActive())
 510                     {
 511                         // With the layer mode active pressing page-down
 512                         // moves to the next layer.
 513                         SwitchLayer (+1);
 514                     }
 515                 }
 516             }
 517         }
 518         break;
 519
 520         // change select state when focus is on poly point
 521         case KEY_SPACE:
 522         {
 523             const SdrHdlList& rHdlList = mpView->GetHdlList();
 524             SdrHdl* pHdl = rHdlList.GetFocusHdl();
 525
 526             if(pHdl)
 527             {
 528                 if(pHdl->GetKind() == SdrHdlKind::Poly)
 529                 {
 530                     // rescue ID of point with focus
 531                     sal_uInt32 nPol(pHdl->GetPolyNum());
 532                     sal_uInt32 nPnt(pHdl->GetPointNum());
 533
 534                     if(mpView->IsPointMarked(*pHdl))
 535                     {
 536                         if(rKEvt.GetKeyCode().IsShift())
 537                         {
 538                             mpView->UnmarkPoint(*pHdl);
 539                         }
 540                     }
 541                     else
 542                     {
 543                         if(!rKEvt.GetKeyCode().IsShift())
 544                         {
 545                             mpView->UnmarkAllPoints();
 546                         }
 547
 548                         mpView->MarkPoint(*pHdl);
 549                     }
 550
 551                     if(nullptr == rHdlList.GetFocusHdl())
 552                     {
 553                         // restore point with focus
 554                         SdrHdl* pNewOne = nullptr;
 555
 556                         for(size_t a = 0; !pNewOne && a < rHdlList.GetHdlCount(); ++a)
 557                         {
 558                             SdrHdl* pAct = rHdlList.GetHdl(a);
 559
 560                             if(pAct
 561                                 && pAct->GetKind() == SdrHdlKind::Poly
 562                                 && pAct->GetPolyNum() == nPol
 563                                 && pAct->GetPointNum() == nPnt)
 564                             {
 565                                 pNewOne = pAct;
 566                             }
 567                         }
 568
 569                         if(pNewOne)
 570                         {
 571                             const_cast<SdrHdlList&>(rHdlList).SetFocusHdl(pNewOne);
 572                         }
 573                     }
 574
 575                     bReturn = true;
 576                 }
 577             }
 578         }
 579         break;
 580
 581         case KEY_UP:
 582         case KEY_DOWN:
 583         case KEY_LEFT:
 584         case KEY_RIGHT:
 585         {
 586             if (!mpView->IsTextEdit() && !bSlideShow)
 587             {
 588                 long nX = 0;
 589                 long nY = 0;
 590
 591                 if (nCode == KEY_UP)
 592                 {
 593                     // scroll up
 594                     nX = 0;
 595                     nY =-1;
 596                 }
 597                 else if (nCode == KEY_DOWN)
 598                 {
 599                     // scroll down
 600                     nX = 0;
 601                     nY = 1;
 602                 }
 603                 else if (nCode == KEY_LEFT)
 604                 {
 605                     // scroll left
 606                     nX =-1;
 607                     nY = 0;
 608                 }
 609                 else if (nCode == KEY_RIGHT)
 610                 {
 611                     // scroll right
 612                     nX = 1;
 613                     nY = 0;
 614                 }
 615
 616                 if (mpView->AreObjectsMarked() && !rKEvt.GetKeyCode().IsMod1() &&
 617                     !mpDocSh->IsReadOnly())
 618                 {
 619                     const SdrHdlList& rHdlList = mpView->GetHdlList();
 620                     SdrHdl* pHdl = rHdlList.GetFocusHdl();
 621
 622                     bool bIsMoveOfConnectedHandle(false);
 623                     bool bOldSuppress = false;
 624                     SdrEdgeObj* pEdgeObj = nullptr;
 625
 626                     if(pHdl && pHdl->GetObj() && nullptr != dynamic_cast< const SdrEdgeObj *>( pHdl->GetObj() ) && 0 == pHdl->GetPolyNum())
 627                     {
 628                         pEdgeObj = static_cast<SdrEdgeObj*>(pHdl->GetObj());
 629
 630                         if(0 == pHdl->GetPointNum())
 631                         {
 632                             if(pEdgeObj->GetConnection(true).GetObject())
 633                             {
 634                                 bIsMoveOfConnectedHandle = true;
 635                             }
 636                         }
 637                         if(1 == pHdl->GetPointNum())
 638                         {
 639                             if(pEdgeObj->GetConnection(false).GetObject())
 640                             {
 641                                 bIsMoveOfConnectedHandle = true;
 642                             }
 643                         }
 644                     }
 645
 646                     if(pEdgeObj)
 647                     {
 648                         // Suppress default connects to inside object and object center
 649                         bOldSuppress = pEdgeObj->GetSuppressDefaultConnect();
 650                         pEdgeObj->SetSuppressDefaultConnect(true);
 651                     }
 652
 653                     if(bIsMoveOfConnectedHandle)
 654                     {
 655                         sal_uInt16 nMarkHdSiz(mpView->GetMarkHdlSizePixel());
 656                         Size aHalfConSiz(nMarkHdSiz + 1, nMarkHdSiz + 1);
 657                         aHalfConSiz = mpWindow->PixelToLogic(aHalfConSiz);
 658
 659                         if(100 < aHalfConSiz.Width())
 660                             nX *= aHalfConSiz.Width();
 661                         else
 662                             nX *= 100;
 663
 664                         if(100 < aHalfConSiz.Height())
 665                             nY *= aHalfConSiz.Height();
 666                         else
 667                             nY *= 100;
 668                     }
 669                     else if(rKEvt.GetKeyCode().IsMod2())
 670                     {
 671                         // move in 1 pixel distance
 672                         Size aLogicSizeOnePixel = mpWindow->PixelToLogic(Size(1,1));
 673                         nX *= aLogicSizeOnePixel.Width();
 674                         nY *= aLogicSizeOnePixel.Height();
 675                     }
 676                     else if(rKEvt.GetKeyCode().IsShift())
 677                     {
 678                         nX *= 1000;
 679                         nY *= 1000;
 680                     }
 681                     else
 682                     {
 683                         // old, fixed move distance
 684                         nX *= 100;
 685                         nY *= 100;
 686                     }
 687
 688                     if(nullptr == pHdl)
 689                     {
 690                         // only take action when move is allowed
 691                         if(mpView->IsMoveAllowed())
 692                         {
 693                             // restrict movement to WorkArea
 694                             const ::tools::Rectangle& rWorkArea = mpView->GetWorkArea();
 695
 696                             if(!rWorkArea.IsEmpty())
 697                             {
 698                                 ::tools::Rectangle aMarkRect(mpView->GetMarkedObjRect());
 699                                 aMarkRect.Move(nX, nY);
 700
 701                                 if(!aMarkRect.IsInside(rWorkArea))
 702                                 {
 703                                     if(aMarkRect.Left() < rWorkArea.Left())
 704                                     {
 705                                         nX += rWorkArea.Left() - aMarkRect.Left();
 706                                     }
 707
 708                                     if(aMarkRect.Right() > rWorkArea.Right())
 709                                     {
 710                                         nX -= aMarkRect.Right() - rWorkArea.Right();
 711                                     }
 712
 713                                     if(aMarkRect.Top() < rWorkArea.Top())
 714                                     {
 715                                         nY += rWorkArea.Top() - aMarkRect.Top();
 716                                     }
 717
 718                                     if(aMarkRect.Bottom() > rWorkArea.Bottom())
 719                                     {
 720                                         nY -= aMarkRect.Bottom() - rWorkArea.Bottom();
 721                                     }
 722                                 }
 723                             }
 724
 725                             // no handle selected
 726                             if(0 != nX || 0 != nY)
 727                             {
 728                                 mpView->MoveAllMarked(Size(nX, nY));
 729
 730                                 mpView->MakeVisible(mpView->GetAllMarkedRect(), *mpWindow);
 731                             }
 732                         }
 733                     }
 734                     else
 735                     {
 736                         // move handle with index nHandleIndex
 737                         if(pHdl && (nX || nY))
 738                         {
 739                             // now move the Handle (nX, nY)
 740                             Point aStartPoint(pHdl->GetPos());
 741                             Point aEndPoint(pHdl->GetPos() + Point(nX, nY));
 742                             const SdrDragStat& rDragStat = mpView->GetDragStat();
 743
 744                             // start dragging
 745                             mpView->BegDragObj(aStartPoint, nullptr, pHdl, 0);
 746
 747                             if(mpView->IsDragObj())
 748                             {
 749                                 bool bWasNoSnap = rDragStat.IsNoSnap();
 750                                 bool bWasSnapEnabled = mpView->IsSnapEnabled();
 751
 752                                 // switch snapping off
 753                                 if(!bWasNoSnap)
 754                                     const_cast<SdrDragStat&>(rDragStat).SetNoSnap();
 755                                 if(bWasSnapEnabled)
 756                                     mpView->SetSnapEnabled(false);
 757
 758                                 mpView->MovAction(aEndPoint);
 759                                 mpView->EndDragObj();
 760
 761                                 // restore snap
 762                                 if(!bWasNoSnap)
 763                                     const_cast<SdrDragStat&>(rDragStat).SetNoSnap(bWasNoSnap);
 764                                 if(bWasSnapEnabled)
 765                                     mpView->SetSnapEnabled(bWasSnapEnabled);
 766                             }
 767
 768                             // make moved handle visible
 769                             ::tools::Rectangle aVisRect(aEndPoint - Point(100, 100), Size(200, 200));
 770                             mpView->MakeVisible(aVisRect, *mpWindow);
 771                         }
 772                     }
 773
 774                     if(pEdgeObj)
 775                     {
 776                         // Restore original suppress value
 777                         pEdgeObj->SetSuppressDefaultConnect(bOldSuppress);
 778                     }
 779                 }
 780                 else
 781                 {
 782                     // scroll page
 783                     mpViewShell->ScrollLines(nX, nY);
 784                 }
 785
 786                 bReturn = true;
 787             }
 788         }
 789         break;
 790     }
 791
 792     if (bReturn)
 793     {
 794         mpWindow->ReleaseMouse();
 795     }
 796
 797     // when a text-editable object is selected and the
 798     // input character is printable, activate text edit on that object
 799     // and feed character to object
 800     if(!bReturn && !mpDocSh->IsReadOnly())
 801     {
 802         if (!mpView->IsTextEdit())
 803         {
 804             const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
 805
 806             if(1 == rMarkList.GetMarkCount())
 807             {
 808                 SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
 809
 810                 // #i118485# allow TextInput for OLEs, too
 811                 if( dynamic_cast< const SdrTextObj *>( pObj ) !=  nullptr && pObj->HasTextEdit())
 812                 {
 813                     // use common IsSimpleCharInput from the EditEngine.
 814                     bool bPrintable(EditEngine::IsSimpleCharInput(rKEvt));
 815
 816                     if(bPrintable)
 817                     {
 818                         // try to activate textedit mode for the selected object
 819                         SfxStringItem aInputString(SID_ATTR_CHAR, OUString(rKEvt.GetCharCode()));
 820
 821                         mpViewShell->GetViewFrame()->GetDispatcher()->ExecuteList(
 822                             SID_ATTR_CHAR,
 823                             SfxCallMode::ASYNCHRON,
 824                             { &aInputString });
 825
 826                         // consumed
 827                         bReturn = true;
 828                     }
 829                 }
 830             }
 831             else
 832             {
 833                 // test if there is a title object there. If yes, try to
 834                 // set it to edit mode and start typing...
 835                 DrawViewShell* pDrawViewShell = dynamic_cast<DrawViewShell*>(mpViewShell);
 836                 if (pDrawViewShell && EditEngine::IsSimpleCharInput(rKEvt))
 837                 {
 838                     SdPage* pActualPage = pDrawViewShell->GetActualPage();
 839                     SdrTextObj* pCandidate = nullptr;
 840
 841                     if(pActualPage)
 842                     {
 843                         SdrObjListIter aIter(*pActualPage, SdrIterMode::DeepNoGroups);
 844
 845                         while(aIter.IsMore() && !pCandidate)
 846                         {
 847                             SdrObject* pObj = aIter.Next();
 848
 849                             if(pObj && dynamic_cast< const SdrTextObj *>( pObj ) !=  nullptr)
 850                             {
 851                                 SdrInventor nInv(pObj->GetObjInventor());
 852                                 sal_uInt16 nKnd(pObj->GetObjIdentifier());
 853
 854                                 if(SdrInventor::Default == nInv && OBJ_TITLETEXT == nKnd)
 855                                 {
 856                                     pCandidate = static_cast<SdrTextObj*>(pObj);
 857                                 }
 858                             }
 859                         }
 860                     }
 861
 862                     // when candidate found and candidate is untouched, start editing text...
 863                     if(pCandidate && pCandidate->IsEmptyPresObj())
 864                     {
 865                         mpView->UnMarkAll();
 866                         mpView->MarkObj(pCandidate, mpView->GetSdrPageView());
 867                         SfxStringItem aInputString(SID_ATTR_CHAR, OUString(rKEvt.GetCharCode()));
 868
 869                         mpViewShell->GetViewFrame()->GetDispatcher()->ExecuteList(
 870                             SID_ATTR_CHAR,
 871                             SfxCallMode::ASYNCHRON,
 872                             { &aInputString });
 873
 874                         // consumed
 875                         bReturn = true;
 876                     }
 877                 }
 878             }
 879         }
 880     }
 881
 882     return bReturn;
 883 }
 884
 885 bool FuPoor::MouseMove(const MouseEvent& )
 886 {
 887     return false;
 888 }
 889
 890 void FuPoor::SelectionHasChanged()
 891 {
 892     const SdrHdlList& rHdlList = mpView->GetHdlList();
 893     const_cast<SdrHdlList&>(rHdlList).ResetFocusHdl();
 894 }
 895
 896 /**
 897  * Cut object to clipboard
 898  */
 899 void FuPoor::DoCut()
 900 {
 901     if (mpView)
 902     {
 903         mpView->DoCut();
 904     }
 905 }
 906
 907 /**
 908  * Copy object to clipboard
 909  */
 910 void FuPoor::DoCopy()
 911 {
 912     if (mpView)
 913     {
 914         mpView->DoCopy();
 915     }
 916 }
 917
 918 /**
 919  * Paste object from clipboard
 920  */
 921 void FuPoor::DoPaste()
 922 {
 923     if (mpView)
 924     {
 925         mpView->DoPaste(mpWindow);
 926     }
 927 }
 928
 929 /**
 930  * Paste unformatted text from clipboard
 931  */
 932 void FuPoor::DoPasteUnformatted()
 933 {
 934     if (mpView)
 935     {
 936         sal_Int8 nAction = DND_ACTION_COPY;
 937         TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( mpViewShell->GetActiveWindow() ) );
 938         if (aDataHelper.GetTransferable().is())
 939         {
 940             mpView->InsertData( aDataHelper,
 941                                 mpWindow->PixelToLogic( ::tools::Rectangle( Point(), mpWindow->GetOutputSizePixel() ).Center() ),
 942                                 nAction, false, SotClipboardFormatId::STRING);
 943         }
 944     }
 945 }
 946
 947 /**
 948  * Timer handler for Drag&Drop
 949  */
 950 IMPL_LINK_NOARG(FuPoor, DragHdl, Timer *, void)
 951 {
 952     if( mpView )
 953     {
 954         sal_uInt16 nHitLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(HITPIX,0)).Width() );
 955         SdrHdl* pHdl = mpView->PickHandle(aMDPos);
 956
 957         if ( pHdl==nullptr && mpView->IsMarkedHit(aMDPos, nHitLog)
 958              && !mpView->IsPresObjSelected(false) )
 959         {
 960             mpWindow->ReleaseMouse();
 961             bIsInDragMode = true;
 962             mpView->StartDrag( aMDPos, mpWindow );
 963         }
 964     }
 965 }
 966
 967 bool FuPoor::Command(const CommandEvent& rCEvt)
 968 {
 969     return mpView->Command(rCEvt,mpWindow);
 970 }
 971
 972 /**
 973  * Timer handler for window scrolling
 974  */
 975 IMPL_LINK_NOARG(FuPoor, DelayHdl, Timer *, void)
 976 {
 977     aDelayToScrollTimer.Stop ();
 978     bScrollable = true;
 979
 980     Point aPnt(mpWindow->GetPointerPosPixel());
 981
 982     // use remembered MouseButton state to create correct
 983     // MouseEvents for this artificial MouseMove.
 984     MouseMove(MouseEvent(aPnt, 1, MouseEventModifiers::NONE, GetMouseButtonCode()));
 985 }
 986
 987 bool FuPoor::MouseButtonUp (const MouseEvent& rMEvt)
 988 {
 989     // remember button state for creation of own MouseEvents
 990     SetMouseButtonCode(rMEvt.GetButtons());
 991
 992     aDelayToScrollTimer.Stop ();
 993     return bScrollable  =
 994         bDelayActive = false;
 995 }
 996
 997 bool FuPoor::MouseButtonDown(const MouseEvent& rMEvt)
 998 {
 999     // remember button state for creation of own MouseEvents
1000     SetMouseButtonCode(rMEvt.GetButtons());
1001
1002     return false;
1003 }
1004
1005 void FuPoor::StartDelayToScrollTimer ()
1006 {
1007     bDelayActive = true;
1008     aDelayToScrollTimer.Start ();
1009 }
1010
1011 bool FuPoor::RequestHelp(const HelpEvent& rHEvt)
1012 {
1013     bool bReturn = false;
1014
1015     SdrPageView* pPV = mpView->GetSdrPageView();
1016
1017     if (pPV)
1018     {
1019         SdPage* pPage = static_cast<SdPage*>( pPV->GetPage() );
1020
1021         if (pPage)
1022         {
1023             bReturn = FmFormPage::RequestHelp(mpWindow, mpView, rHEvt);
1024         }
1025     }
1026
1027     return bReturn;
1028 }
1029
1030 void FuPoor::ReceiveRequest(SfxRequest& /*rReq*/)
1031 {
1032 }
1033
1034 SdrObject* FuPoor::CreateDefaultObject(const sal_uInt16, const ::tools::Rectangle& )
1035 {
1036     // empty base implementation
1037     return nullptr;
1038 }
1039
1040 void FuPoor::ImpForceQuadratic(::tools::Rectangle& rRect)
1041 {
1042     if(rRect.GetWidth() > rRect.GetHeight())
1043     {
1044         rRect = ::tools::Rectangle(
1045             Point(rRect.Left() + ((rRect.GetWidth() - rRect.GetHeight()) / 2), rRect.Top()),
1046             Size(rRect.GetHeight(), rRect.GetHeight()));
1047     }
1048     else
1049     {
1050         rRect = ::tools::Rectangle(
1051             Point(rRect.Left(), rRect.Top() + ((rRect.GetHeight() - rRect.GetWidth()) / 2)),
1052             Size(rRect.GetWidth(), rRect.GetWidth()));
1053     }
1054 }
1055
1056 void FuPoor::SwitchLayer (sal_Int32 nOffset)
1057 {
1058     if(mpViewShell && dynamic_cast< const DrawViewShell *>( mpViewShell ) !=  nullptr)
1059     {
1060         DrawViewShell* pDrawViewShell =
1061             static_cast<DrawViewShell*>(mpViewShell);
1062
1063         // Calculate the new index.
1064         sal_Int32 nIndex = pDrawViewShell->GetActiveTabLayerIndex() + nOffset;
1065
1066         // Make sure the new index lies inside the range of valid indices.
1067         if (nIndex < 0)
1068             nIndex = 0;
1069         else if (nIndex >= pDrawViewShell->GetTabLayerCount ())
1070             nIndex = pDrawViewShell->GetTabLayerCount() - 1;
1071
1072         // Set the new active layer.
1073         if (nIndex != pDrawViewShell->GetActiveTabLayerIndex ())
1074         {
1075             LayerTabBar* pLayerTabControl =
1076                 static_cast<DrawViewShell*>(mpViewShell)->GetLayerTabControl();
1077             if (pLayerTabControl != nullptr)
1078                 pLayerTabControl->SendDeactivatePageEvent ();
1079
1080             pDrawViewShell->SetActiveTabLayerIndex (nIndex);
1081
1082             if (pLayerTabControl != nullptr)
1083                 pLayerTabControl->SendActivatePageEvent ();
1084         }
1085     }
1086 }
1087
1088 /** is called when the current function should be aborted. <p>
1089     This is used when a function gets a KEY_ESCAPE but can also
1090     be called directly.
1091
1092     @returns true if a active function was aborted
1093 */
1094 bool FuPoor::cancel()
1095 {
1096     if ( dynamic_cast< const FuSelection *>( this ) ==  nullptr )
1097     {
1098         mpViewShell->GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SfxCallMode::ASYNCHRON);
1099         return true;
1100     }
1101
1102     return false;
1103 }
1104
1105 // #i33136#
1106 bool FuPoor::doConstructOrthogonal() const
1107 {
1108     // Check whether a media object is selected
1109     bool bResizeKeepRatio = false;
1110     // tdf#89758 Avoid interactive crop preview from being proportionally scaled by default.
1111     if (mpView->AreObjectsMarked() && mpView->GetDragMode() != SdrDragMode::Crop)
1112     {
1113         const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
1114         if (rMarkList.GetMarkCount() == 1)
1115         {
1116             sal_uInt16 aObjIdentifier = rMarkList.GetMark(0)->GetMarkedSdrObj()->GetObjIdentifier();
1117             bResizeKeepRatio = aObjIdentifier == OBJ_GRAF ||
1118                                aObjIdentifier == OBJ_MEDIA ||
1119                                aObjIdentifier == OBJ_OLE2;
1120         }
1121     }
1122     SdrHdl* pHdl = mpView->PickHandle(aMDPos);
1123     // Resize proportionally when media is selected and the user drags on a corner
1124     if (pHdl)
1125         bResizeKeepRatio = bResizeKeepRatio && pHdl->IsCornerHdl();
1126
1127     return (
1128         bResizeKeepRatio ||
1129         SID_DRAW_XLINE == nSlotId ||
1130         SID_DRAW_CIRCLEARC == nSlotId ||
1131         SID_DRAW_SQUARE == nSlotId ||
1132         SID_DRAW_SQUARE_NOFILL == nSlotId ||
1133         SID_DRAW_SQUARE_ROUND == nSlotId ||
1134         SID_DRAW_SQUARE_ROUND_NOFILL == nSlotId ||
1135         SID_DRAW_CIRCLE == nSlotId ||
1136         SID_DRAW_CIRCLE_NOFILL == nSlotId ||
1137         SID_DRAW_CIRCLEPIE == nSlotId ||
1138         SID_DRAW_CIRCLEPIE_NOFILL == nSlotId ||
1139         SID_DRAW_CIRCLECUT == nSlotId ||
1140         SID_DRAW_CIRCLECUT_NOFILL == nSlotId ||
1141         SID_DRAW_XPOLYGON == nSlotId ||
1142         SID_DRAW_XPOLYGON_NOFILL == nSlotId ||
1143         SID_3D_CUBE == nSlotId ||
1144         SID_3D_SPHERE == nSlotId ||
1145         SID_3D_SHELL == nSlotId ||
1146         SID_3D_HALF_SPHERE == nSlotId ||
1147         SID_3D_TORUS == nSlotId ||
1148         SID_3D_CYLINDER == nSlotId ||
1149         SID_3D_CONE == nSlotId ||
1150         SID_3D_PYRAMID == nSlotId);
1151 }
1152
1153 void FuPoor::DoExecute( SfxRequest& )
1154 {
1155 }
1156
1157 } // end of namespace sd
1158
1159 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */