LCOV - code coverage report
Current view: top level - libreoffice/sd/source/ui/func - fupoor.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 0 441 0.0 %
Date: 2012-12-27 Functions: 0 36 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10