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