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