LCOV - code coverage report
Current view: top level - sc/source/ui/drawfunc - fusel.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 6 250 2.4 %
Date: 2014-11-03 Functions: 5 12 41.7 %
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 <com/sun/star/embed/EmbedStates.hpp>
      21             : 
      22             : #include <editeng/eeitem.hxx>
      23             : #include <editeng/flditem.hxx>
      24             : #include <svx/svddrgmt.hxx>
      25             : #include <svx/svdoole2.hxx>
      26             : #include <svx/svdotext.hxx>
      27             : #include <sfx2/dispatch.hxx>
      28             : #include <svtools/imapobj.hxx>
      29             : #include <svx/svdouno.hxx>
      30             : #include <svx/svdomedia.hxx>
      31             : #include <svx/svdpagv.hxx>
      32             : #include <editeng/outlobj.hxx>
      33             : #include <svx/svdocapt.hxx>
      34             : #include <sfx2/app.hxx>
      35             : 
      36             : #include "fusel.hxx"
      37             : #include "sc.hrc"
      38             : #include "fudraw.hxx"
      39             : #include "futext.hxx"
      40             : #include "drawview.hxx"
      41             : #include "tabvwsh.hxx"
      42             : #include "drawpage.hxx"
      43             : #include "globstr.hrc"
      44             : #include "drwlayer.hxx"
      45             : #include "userdat.hxx"
      46             : #include "scmod.hxx"
      47             : #include "client.hxx"
      48             : #include "charthelper.hxx"
      49             : #include "docuno.hxx"
      50             : #include "docsh.hxx"
      51             : 
      52             : //  Maximal erlaubte Mausbewegung um noch Drag&Drop zu starten
      53             : //! fusel,fuconstr,futext - zusammenfassen!
      54             : #define SC_MAXDRAGMOVE  3
      55             : // Min necessary mouse motion for normal dragging
      56             : #define SC_MINDRAGMOVE 2
      57             : 
      58             : using namespace com::sun::star;
      59             : 
      60             : /*************************************************************************
      61             : |*
      62             : |* Konstruktor
      63             : |*
      64             : \************************************************************************/
      65             : 
      66         546 : FuSelection::FuSelection(ScTabViewShell* pViewSh, vcl::Window* pWin, ScDrawView* pViewP,
      67             :                SdrModel* pDoc, SfxRequest& rReq ) :
      68             :     FuDraw(pViewSh, pWin, pViewP, pDoc, rReq),
      69         546 :     bVCAction(false)
      70             : {
      71         546 : }
      72             : 
      73             : /*************************************************************************
      74             : |*
      75             : |* Destruktor
      76             : |*
      77             : \************************************************************************/
      78             : 
      79        1092 : FuSelection::~FuSelection()
      80             : {
      81        1092 : }
      82             : 
      83           0 : sal_uInt8 FuSelection::Command(const CommandEvent& rCEvt)
      84             : {
      85           0 :     return FuDraw::Command( rCEvt );
      86             : }
      87             : 
      88             : /*************************************************************************
      89             : |*
      90             : |* MouseButtonDown-event
      91             : |*
      92             : \************************************************************************/
      93             : 
      94           0 : bool FuSelection::MouseButtonDown(const MouseEvent& rMEvt)
      95             : {
      96             :     // remember button state for creation of own MouseEvents
      97           0 :     SetMouseButtonCode(rMEvt.GetButtons());
      98           0 :     const bool bSelectionOnly = rMEvt.IsRight();
      99           0 :     if ( pView->IsAction() )
     100             :     {
     101           0 :         if ( bSelectionOnly )
     102           0 :             pView->BckAction();
     103           0 :         return true;
     104             :     }
     105             : 
     106           0 :     bVCAction = false;
     107           0 :     bIsInDragMode = false;      //  irgendwo muss es ja zurueckgesetzt werden (#50033#)
     108             : 
     109           0 :     bool bReturn = FuDraw::MouseButtonDown(rMEvt);
     110             : 
     111           0 :     aMDPos = pWindow->PixelToLogic( rMEvt.GetPosPixel() );
     112             : 
     113           0 :     if ( rMEvt.IsLeft() )
     114             :     {
     115           0 :         SdrHdl* pHdl = pView->PickHandle(aMDPos);
     116             : 
     117           0 :         if ( pHdl!=NULL || pView->IsMarkedHit(aMDPos) )
     118             :         {
     119             :             // Determine if this is the tail of a SdrCaptionObj i.e.
     120             :             // we need to disable the drag option on the tail of a note
     121             :             // object. Also, disable the ability to use the circular
     122             :             // drag of a note object.
     123           0 :             bool bDrag = false;
     124           0 :             const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
     125           0 :             if( rMarkList.GetMarkCount() == 1 )
     126             :             {
     127           0 :                 SdrObject* pMarkedObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
     128           0 :                 if( ScDrawLayer::IsNoteCaption( pMarkedObj ) )
     129             :                 {
     130             :                     // move using the valid caption handles for note text box.
     131           0 :                     if(pHdl && (pHdl->GetKind() != HDL_POLY && pHdl->GetKind() != HDL_CIRC))
     132           0 :                         bDrag = true;
     133             :                     // move the complete note box.
     134           0 :                     else if(!pHdl)
     135           0 :                         bDrag = true;
     136             :                 }
     137             :                 else
     138           0 :                     bDrag = true;   // different object
     139             :             }
     140             :             else
     141           0 :                 bDrag = true;       // several objects
     142             : 
     143           0 :             if ( bDrag )
     144             :             {
     145           0 :                 aDragTimer.Start();
     146           0 :                 if (pView->BegDragObj(aMDPos, (OutputDevice*) NULL, pHdl))
     147           0 :                     pView->GetDragMethod()->SetShiftPressed( rMEvt.IsShift() );
     148           0 :                 bReturn = true;
     149             :             }
     150             :         }
     151             :         else
     152             :         {
     153             :             SdrObject* pObj;
     154             :             SdrPageView* pPV;
     155           0 :             bool bAlt = rMEvt.IsMod2();
     156           0 :             if ( !bAlt && pView->PickObj(aMDPos, pView->getHitTolLog(), pObj, pPV, SDRSEARCH_PICKMACRO) )
     157             :             {
     158           0 :                 pView->BegMacroObj(aMDPos, pObj, pPV, pWindow);
     159           0 :                 bReturn = true;
     160             :             }
     161             :             else
     162             :             {
     163           0 :                 OUString sURL, sTarget;
     164           0 :                 if ( !bAlt && pView->PickObj(aMDPos, pView->getHitTolLog(), pObj, pPV, SDRSEARCH_ALSOONMASTER))
     165             :                 {
     166             :                    // Support for imported Excel docs
     167             :                    // Excel is of course not consistent and allows
     168             :                    // a hyperlink to be assigned for an object group
     169             :                    // and even though the hyperlink is exported in the Escher layer
     170             :                    // its never used, when dealing with a group object the link
     171             :                    // associated with the clicked object is used only
     172             : 
     173             :                    // additionally you can also select a macro in Excel for a grouped
     174             :                    // objects and this *usually* results in the macro being set
     175             :                    // for the elements in the group and no macro is exported
     176             :                    // for the group itself ( this however is not always true )
     177             :                    // if a macro and hlink are defined favour the hlink
     178             :                    // If a group object has no hyperlink use the hyperlink of the
     179             :                    // object clicked
     180             : 
     181           0 :                    if ( pObj->IsGroupObject() )
     182             :                    {
     183           0 :                        ScMacroInfo* pTmpInfo = ScDrawLayer::GetMacroInfo( pObj );
     184           0 :                        if ( !pTmpInfo || pTmpInfo->GetMacro().isEmpty() )
     185             :                        {
     186           0 :                            SdrObject* pHit = NULL;
     187           0 :                            if ( pView->PickObj(aMDPos, pView->getHitTolLog(), pHit, pPV, SDRSEARCH_DEEP ) )
     188           0 :                                pObj = pHit;
     189             :                        }
     190             :                    }
     191             : 
     192           0 :                    ScMacroInfo* pInfo = ScDrawLayer::GetMacroInfo( pObj, true );
     193             :                    // For interoperability favour links over macros if both are defined
     194           0 :                    if ( !pInfo->GetHlink().isEmpty() )
     195             :                    {
     196             :                        OSL_TRACE("** Got URL");
     197           0 :                        sURL = pInfo->GetHlink();
     198             :                    }
     199           0 :                    else if ( !pInfo->GetMacro().isEmpty() )
     200             :                    {
     201           0 :                        SfxObjectShell* pObjSh = SfxObjectShell::Current();
     202           0 :                        if ( pObjSh && SfxApplication::IsXScriptURL( pInfo->GetMacro() ) )
     203             :                        {
     204           0 :                            uno::Reference< beans::XPropertySet > xProps( pObj->getUnoShape(), uno::UNO_QUERY );
     205           0 :                            uno::Any aCaller;
     206           0 :                            if ( xProps.is() )
     207             :                            {
     208             :                                try
     209             :                                {
     210           0 :                                    aCaller = xProps->getPropertyValue("Name");
     211             :                                }
     212           0 :                                catch( uno::Exception& ) {}
     213             :                            }
     214           0 :                            uno::Any aRet;
     215           0 :                            uno::Sequence< sal_Int16 > aOutArgsIndex;
     216           0 :                            uno::Sequence< uno::Any > aOutArgs;
     217             :                            uno::Sequence< uno::Any >* pInArgs =
     218           0 :                                new uno::Sequence< uno::Any >(0);
     219           0 :                            pObjSh->CallXScript( pInfo->GetMacro(),
     220           0 :                                *pInArgs, aRet, aOutArgsIndex, aOutArgs, true, &aCaller );
     221           0 :                            pViewShell->FakeButtonUp( pViewShell->GetViewData().GetActivePart() );
     222           0 :                            return true;        // kein CaptureMouse etc.
     223             :                        }
     224             :                    }
     225             :                 }
     226             : 
     227             :                 //  URL / ImageMap
     228             : 
     229           0 :                 SdrViewEvent aVEvt;
     230           0 :                 if ( !bAlt &&
     231           0 :                     pView->PickAnything( rMEvt, SDRMOUSEBUTTONDOWN, aVEvt ) != SDRHIT_NONE &&
     232           0 :                     aVEvt.pObj != NULL )
     233             :                 {
     234           0 :                     if ( ScDrawLayer::GetIMapInfo( aVEvt.pObj ) )       // ImageMap
     235             :                     {
     236             :                         const IMapObject* pIMapObj =
     237           0 :                                 ScDrawLayer::GetHitIMapObject( aVEvt.pObj, aMDPos, *pWindow );
     238           0 :                         if ( pIMapObj && !pIMapObj->GetURL().isEmpty() )
     239             :                         {
     240           0 :                             sURL = pIMapObj->GetURL();
     241           0 :                             sTarget = pIMapObj->GetTarget();
     242             :                         }
     243             :                     }
     244           0 :                     if ( aVEvt.eEvent == SDREVENT_EXECUTEURL && aVEvt.pURLField )   // URL
     245             :                     {
     246           0 :                         sURL = aVEvt.pURLField->GetURL();
     247           0 :                         sTarget = aVEvt.pURLField->GetTargetFrame();
     248             :                     }
     249             :                 }
     250             : 
     251             :                 // open hyperlink, if found at object or in object's text
     252           0 :                 if ( !sURL.isEmpty() )
     253             :                 {
     254           0 :                     ScGlobal::OpenURL( sURL, sTarget );
     255           0 :                     pViewShell->FakeButtonUp( pViewShell->GetViewData().GetActivePart() );
     256           0 :                     return true;        // kein CaptureMouse etc.
     257             :                 }
     258             : 
     259             :                 //  Is another object being edited in this view?
     260             :                 //  (Editing is ended in MarkListHasChanged - test before UnmarkAll)
     261           0 :                 SfxInPlaceClient* pClient = pViewShell->GetIPClient();
     262           0 :                 bool bWasOleActive = ( pClient && pClient->IsObjectInPlaceActive() );
     263             : 
     264             :                 //  Markieren
     265             : 
     266             :                 // do not allow multiselection with note caption
     267           0 :                 bool bCaptionClicked = IsNoteCaptionClicked( aMDPos );
     268           0 :                 if ( !rMEvt.IsShift() || bCaptionClicked || IsNoteCaptionMarked() )
     269           0 :                     pView->UnmarkAll();
     270             : 
     271             :                 /*  Unlock internal layer, if a note caption is clicked. The
     272             :                     layer will be relocked in ScDrawView::MarkListHasChanged(). */
     273           0 :                 if( bCaptionClicked )
     274           0 :                     pView->UnlockInternalLayer();
     275             : 
     276             :                 // try to select the clicked object
     277           0 :                 if ( pView->MarkObj( aMDPos, -2, false, rMEvt.IsMod1() ) )
     278             :                 {
     279             : 
     280             :                     //Objekt verschieben
     281             : 
     282           0 :                     if (pView->IsMarkedHit(aMDPos))
     283             :                     {
     284             :                         //  Don't start drag timer if inplace editing of an OLE object
     285             :                         //  was just ended with this mouse click - the view will be moved
     286             :                         //  (different tool bars) and the object that was clicked on would
     287             :                         //  be moved unintentionally.
     288           0 :                         if ( !bWasOleActive )
     289           0 :                             aDragTimer.Start();
     290             : 
     291           0 :                         pHdl=pView->PickHandle(aMDPos);
     292           0 :                         pView->BegDragObj(aMDPos, (OutputDevice*) NULL, pHdl);
     293           0 :                         bReturn = true;
     294             :                     }
     295             :                     else                                    // Objekt am Rand getroffen
     296           0 :                         if (pViewShell->IsDrawSelMode())
     297           0 :                             bReturn = true;
     298             :                 }
     299             :                 else
     300             :                 {
     301             :                     //      nichts getroffen
     302             : 
     303           0 :                     if (pViewShell->IsDrawSelMode())
     304             :                     {
     305             : 
     306             :                         //Objekt selektieren
     307             : 
     308           0 :                         pView->BegMarkObj(aMDPos);
     309           0 :                         bReturn = true;
     310             :                     }
     311           0 :                 }
     312             :             }
     313             :         }
     314             : 
     315             :     }
     316             : 
     317           0 :     if (!bIsInDragMode)
     318             :     {
     319           0 :         if (!bVCAction)                 // VC rufen selber CaptureMouse
     320           0 :             pWindow->CaptureMouse();
     321           0 :         ForcePointer(&rMEvt);
     322             :     }
     323             : 
     324           0 :     return bReturn;
     325             : }
     326             : 
     327             : /*************************************************************************
     328             : |*
     329             : |* MouseMove-event
     330             : |*
     331             : \************************************************************************/
     332             : 
     333           0 : bool FuSelection::MouseMove(const MouseEvent& rMEvt)
     334             : {
     335           0 :     bool bReturn = FuDraw::MouseMove(rMEvt);
     336             : 
     337           0 :     if (aDragTimer.IsActive() )
     338             :     {
     339           0 :         Point aOldPixel = pWindow->LogicToPixel( aMDPos );
     340           0 :         Point aNewPixel = rMEvt.GetPosPixel();
     341           0 :         if ( std::abs( aOldPixel.X() - aNewPixel.X() ) > SC_MAXDRAGMOVE ||
     342           0 :              std::abs( aOldPixel.Y() - aNewPixel.Y() ) > SC_MAXDRAGMOVE )
     343           0 :             aDragTimer.Stop();
     344             :     }
     345             : 
     346           0 :     if ( pView->IsAction() )
     347             :     {
     348           0 :         Point aPix(rMEvt.GetPosPixel());
     349           0 :         Point aPnt(pWindow->PixelToLogic(aPix));
     350             : 
     351           0 :         ForceScroll(aPix);
     352           0 :         pView->MovAction(aPnt);
     353           0 :         bReturn = true;
     354             :     }
     355             : 
     356             :     // Ein VCControl ist aktiv
     357             :     // Event an den Manager weiterleiten
     358           0 :     if( bVCAction )
     359             :     {
     360           0 :         bReturn = true;
     361             :     }
     362             : 
     363           0 :     ForcePointer(&rMEvt);
     364             : 
     365           0 :     return bReturn;
     366             : }
     367             : 
     368             : /*************************************************************************
     369             : |*
     370             : |* MouseButtonUp-event
     371             : |*
     372             : \************************************************************************/
     373             : 
     374           0 : bool FuSelection::MouseButtonUp(const MouseEvent& rMEvt)
     375             : {
     376             :     // remember button state for creation of own MouseEvents
     377           0 :     SetMouseButtonCode(rMEvt.GetButtons());
     378             : 
     379           0 :     bool bReturn = FuDraw::MouseButtonUp(rMEvt);
     380           0 :     bool bOle = pViewShell && pViewShell->GetViewFrame()->GetFrame().IsInPlace();
     381             : 
     382           0 :     SdrObject* pObj = NULL;
     383           0 :     SdrPageView* pPV = NULL;
     384           0 :     if (aDragTimer.IsActive() )
     385             :     {
     386           0 :         aDragTimer.Stop();
     387             :     }
     388             : 
     389           0 :     sal_uInt16 nDrgLog = sal_uInt16 ( pWindow->PixelToLogic(Size(SC_MINDRAGMOVE,0)).Width() );
     390           0 :     Point aPnt( pWindow->PixelToLogic( rMEvt.GetPosPixel() ) );
     391             : 
     392           0 :     bool bCopy = false;
     393           0 :     ScViewData* pViewData = ( pViewShell ? &pViewShell->GetViewData() : NULL );
     394           0 :     ScDocument* pDocument = ( pViewData ? pViewData->GetDocument() : NULL );
     395           0 :     SdrPageView* pPageView = ( pView ? pView->GetSdrPageView() : NULL );
     396           0 :     SdrPage* pPage = ( pPageView ? pPageView->GetPage() : NULL );
     397           0 :     ::std::vector< OUString > aExcludedChartNames;
     398           0 :     ScRangeListVector aProtectedChartRangesVector;
     399             : 
     400           0 :     if (pView && rMEvt.IsLeft())
     401             :     {
     402           0 :         if ( pView->IsDragObj() )
     403             :         {
     404             :             /******************************************************************
     405             :             * Objekt wurde verschoben
     406             :             ******************************************************************/
     407           0 :             if ( rMEvt.IsMod1() )
     408             :             {
     409           0 :                 if ( pPage )
     410             :                 {
     411           0 :                     ScChartHelper::GetChartNames( aExcludedChartNames, pPage );
     412             :                 }
     413           0 :                 if ( pView && pDocument )
     414             :                 {
     415           0 :                     const SdrMarkList& rSdrMarkList = pView->GetMarkedObjectList();
     416           0 :                     const size_t nMarkCount = rSdrMarkList.GetMarkCount();
     417           0 :                     for ( size_t i = 0; i < nMarkCount; ++i )
     418             :                     {
     419           0 :                         SdrMark* pMark = rSdrMarkList.GetMark( i );
     420           0 :                         pObj = ( pMark ? pMark->GetMarkedSdrObj() : NULL );
     421           0 :                         if ( pObj )
     422             :                         {
     423           0 :                             ScChartHelper::AddRangesIfProtectedChart( aProtectedChartRangesVector, pDocument, pObj );
     424             :                         }
     425             :                     }
     426             :                 }
     427           0 :                 bCopy = true;
     428             :             }
     429             : 
     430           0 :             if (!rMEvt.IsShift() && !rMEvt.IsMod1() && !rMEvt.IsMod2() &&
     431           0 :                 std::abs(aPnt.X() - aMDPos.X()) < nDrgLog &&
     432           0 :                 std::abs(aPnt.Y() - aMDPos.Y()) < nDrgLog)
     433             :             {
     434             :                 /*************************************************************
     435             :                 * If a user wants to click on an object in front of a marked
     436             :                 * one, he releases the mouse button immediately
     437             :                 **************************************************************/
     438           0 :                 if (pView->PickObj(aMDPos, pView->getHitTolLog(), pObj, pPV, SDRSEARCH_ALSOONMASTER | SDRSEARCH_BEFOREMARK))
     439             :                 {
     440           0 :                     pView->UnmarkAllObj();
     441           0 :                     pView->MarkObj(pObj,pPV,false,false);
     442           0 :                     return true;
     443             :                 }
     444             :             }
     445           0 :             pView->EndDragObj( rMEvt.IsMod1() );
     446           0 :             pView->ForceMarkedToAnotherPage();
     447             : 
     448           0 :             const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
     449           0 :             if (rMarkList.GetMarkCount() == 1)
     450             :             {
     451           0 :                   SdrMark* pMark = rMarkList.GetMark(0);
     452           0 :                   pObj = pMark->GetMarkedSdrObj();
     453           0 :                   FuPoor* pPoor = pViewShell->GetViewData().GetView()->GetDrawFuncPtr();
     454           0 :                   FuText* pText = static_cast<FuText*>(pPoor);
     455           0 :                 pText->StopDragMode(pObj );
     456             :             }
     457           0 :             bReturn = true;
     458             :         }
     459           0 :         else if (pView->IsAction() )
     460             :         {
     461             :             // unlock internal layer to include note captions
     462           0 :             pView->UnlockInternalLayer();
     463           0 :             pView->EndAction();
     464           0 :             if ( pView->AreObjectsMarked() )
     465             :             {
     466           0 :                 bReturn = true;
     467             : 
     468             :                 /*  if multi-selection contains a note caption object, remove
     469             :                     all other objects from selection. */
     470           0 :                 const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
     471           0 :                 const size_t nCount = rMarkList.GetMarkCount();
     472           0 :                 if( nCount > 1 )
     473             :                 {
     474           0 :                     bool bFound = false;
     475           0 :                     for( size_t nIdx = 0; !bFound && (nIdx < nCount); ++nIdx )
     476             :                     {
     477           0 :                         pObj = rMarkList.GetMark( nIdx )->GetMarkedSdrObj();
     478           0 :                         bFound = ScDrawLayer::IsNoteCaption( pObj );
     479           0 :                         if( bFound )
     480             :                         {
     481           0 :                             pView->UnMarkAll();
     482           0 :                             pView->MarkObj( pObj, pView->GetSdrPageView() );
     483             :                         }
     484             :                     }
     485             :                 }
     486             :             }
     487             :         }
     488             :     }
     489             : 
     490             :     /**************************************************************************
     491             :     * Ggf. OLE-Objekt beruecksichtigen
     492             :     **************************************************************************/
     493           0 :     SfxInPlaceClient* pIPClient = pViewShell ? pViewShell->GetIPClient() : NULL;
     494             : 
     495           0 :     if (pIPClient)
     496             :     {
     497           0 :         ScModule* pScMod = SC_MOD();
     498           0 :         bool bUnoRefDialog = pScMod->IsRefDialogOpen() && pScMod->GetCurRefDlgId() == WID_SIMPLE_REF;
     499             : 
     500           0 :         if ( pIPClient->IsObjectInPlaceActive() && !bUnoRefDialog )
     501           0 :             pIPClient->DeactivateObject();
     502             :     }
     503             : 
     504           0 :     sal_uInt16 nClicks = rMEvt.GetClicks();
     505           0 :     if (pView && nClicks == 2 && rMEvt.IsLeft())
     506             :     {
     507           0 :         if ( pView->AreObjectsMarked() )
     508             :         {
     509           0 :             const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
     510           0 :             if (rMarkList.GetMarkCount() == 1)
     511             :             {
     512           0 :                 SdrMark* pMark = rMarkList.GetMark(0);
     513           0 :                 pObj = pMark->GetMarkedSdrObj();
     514             : 
     515             :                 //  aktivieren nur, wenn die Maus auch (noch) ueber dem
     516             :                 //  selektierten Objekt steht
     517             : 
     518           0 :                 SdrViewEvent aVEvt;
     519           0 :                 SdrHitKind eHit = pView->PickAnything( rMEvt, SDRMOUSEBUTTONDOWN, aVEvt );
     520           0 :                 if (eHit != SDRHIT_NONE && aVEvt.pObj == pObj &&  pViewShell)
     521             :                 {
     522           0 :                     sal_uInt16 nSdrObjKind = pObj->GetObjIdentifier();
     523             : 
     524             :                     //  OLE: aktivieren
     525             : 
     526           0 :                     if (nSdrObjKind == OBJ_OLE2)
     527             :                     {
     528           0 :                         if (!bOle)
     529             :                         {
     530           0 :                             if (static_cast<SdrOle2Obj*>(pObj)->GetObjRef().is())
     531             :                             {
     532           0 :                                 pViewShell->ActivateObject( static_cast<SdrOle2Obj*>(pObj), 0 );
     533             :                             }
     534             :                         }
     535             :                     }
     536             : 
     537             :                     //  Edit text
     538             :                     //  not in UNO controls
     539             :                     //  #i32352# not in media objects
     540             : 
     541           0 :                     else if ( pObj->ISA(SdrTextObj) && !pObj->ISA(SdrUnoObj) && !pObj->ISA(SdrMediaObj) )
     542             :                     {
     543           0 :                         OutlinerParaObject* pOPO = pObj->GetOutlinerParaObject();
     544           0 :                         bool bVertical = ( pOPO && pOPO->IsVertical() );
     545           0 :                         sal_uInt16 nTextSlotId = bVertical ? SID_DRAW_TEXT_VERTICAL : SID_DRAW_TEXT;
     546             : 
     547           0 :                         pViewShell->GetViewData().GetDispatcher().
     548           0 :                             Execute(nTextSlotId, SfxCallMode::SYNCHRON | SfxCallMode::RECORD);
     549             : 
     550             :                         // jetzt den erzeugten FuText holen und in den EditModus setzen
     551           0 :                         FuPoor* pPoor = pViewShell->GetViewData().GetView()->GetDrawFuncPtr();
     552           0 :                         if ( pPoor && pPoor->GetSlotID() == nTextSlotId )    // hat keine RTTI
     553             :                         {
     554           0 :                             FuText* pText = static_cast<FuText*>(pPoor);
     555           0 :                             Point aMousePixel = rMEvt.GetPosPixel();
     556           0 :                             pText->SetInEditMode( pObj, &aMousePixel );
     557             :                         }
     558           0 :                         bReturn = true;
     559             :                     }
     560           0 :                 }
     561             :             }
     562             :         }
     563           0 :         else if ( TestDetective( pView->GetSdrPageView(), aPnt ) )
     564           0 :             bReturn = true;
     565             :     }
     566             : 
     567             :     // Ein VCControl ist aktiv
     568             :     // Event an den Manager weiterleiten
     569           0 :     if( bVCAction )
     570             :     {
     571           0 :         bVCAction = false;
     572           0 :         bReturn = true;
     573             :     }
     574             : 
     575           0 :     ForcePointer(&rMEvt);
     576             : 
     577           0 :     pWindow->ReleaseMouse();
     578             : 
     579             :     //  Command-Handler fuer Kontext-Menue kommt erst nach MouseButtonUp,
     580             :     //  darum hier die harte IsLeft-Abfrage
     581           0 :     if ( !bReturn && rMEvt.IsLeft() )
     582           0 :         if (pViewShell->IsDrawSelMode())
     583           0 :             pViewShell->GetViewData().GetDispatcher().
     584           0 :                 Execute(SID_OBJECT_SELECT, SfxCallMode::SLOT | SfxCallMode::RECORD);
     585             : 
     586           0 :     if ( bCopy && pViewData && pDocument && pPage )
     587             :     {
     588           0 :         ScDocShell* pDocShell = pViewData->GetDocShell();
     589           0 :         ScModelObj* pModelObj = ( pDocShell ? ScModelObj::getImplementation( pDocShell->GetModel() ) : NULL );
     590           0 :         if ( pModelObj )
     591             :         {
     592           0 :             SCTAB nTab = pViewData->GetTabNo();
     593             :             ScChartHelper::CreateProtectedChartListenersAndNotify( pDocument, pPage, pModelObj, nTab,
     594           0 :                 aProtectedChartRangesVector, aExcludedChartNames );
     595             :         }
     596             :     }
     597             : 
     598           0 :     return bReturn;
     599             : }
     600             : 
     601             : /*************************************************************************
     602             : |*
     603             : |* Tastaturereignisse bearbeiten
     604             : |*
     605             : |* Wird ein KeyEvent bearbeitet, so ist der Return-Wert sal_True, andernfalls
     606             : |* FALSE.
     607             : |*
     608             : \************************************************************************/
     609             : 
     610           0 : bool FuSelection::KeyInput(const KeyEvent& rKEvt)
     611             : {
     612           0 :     return FuDraw::KeyInput(rKEvt);
     613             : }
     614             : 
     615             : /*************************************************************************
     616             : |*
     617             : |* Function aktivieren
     618             : |*
     619             : \************************************************************************/
     620             : 
     621           0 : void FuSelection::Activate()
     622             : {
     623           0 :     FuDraw::Activate();
     624           0 : }
     625             : 
     626             : /*************************************************************************
     627             : |*
     628             : |* Function deaktivieren
     629             : |*
     630             : \************************************************************************/
     631             : 
     632           0 : void FuSelection::Deactivate()
     633             : {
     634             :     /**************************************************************************
     635             :     * Hide Cursor
     636             :     **************************************************************************/
     637           0 :     FuDraw::Deactivate();
     638         228 : }
     639             : 
     640             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10