LCOV - code coverage report
Current view: top level - libreoffice/sd/source/ui/func - smarttag.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 0 179 0.0 %
Date: 2012-12-27 Functions: 0 42 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             : 
      21             : #include "ViewShell.hxx"
      22             : #include "smarttag.hxx"
      23             : #include "Window.hxx"
      24             : #include "View.hxx"
      25             : 
      26             : namespace sd
      27             : {
      28             : 
      29             : // ====================================================================
      30             : 
      31           0 : SmartTag::SmartTag( ::sd::View& rView )
      32             : : mrView( rView )
      33           0 : , mbSelected( false )
      34             : {
      35           0 :     SmartTagReference xThis( this );
      36           0 :     mrView.getSmartTags().add( xThis );
      37           0 : }
      38             : 
      39             : // --------------------------------------------------------------------
      40             : 
      41           0 : SmartTag::~SmartTag()
      42             : {
      43           0 : }
      44             : 
      45             : // --------------------------------------------------------------------
      46             : 
      47           0 : bool SmartTag::MouseButtonDown( const MouseEvent&, SmartHdl&  )
      48             : {
      49           0 :     return false;
      50             : }
      51             : 
      52             : /** returns true if the SmartTag consumes this event. */
      53           0 : bool SmartTag::KeyInput( const KeyEvent& /*rKEvt*/ )
      54             : {
      55           0 :     return false;
      56             : }
      57             : 
      58             : /** returns true if the SmartTag consumes this event. */
      59           0 : bool SmartTag::RequestHelp( const HelpEvent& /*rHEvt*/ )
      60             : {
      61           0 :     return false;
      62             : }
      63             : 
      64             : /** returns true if the SmartTag consumes this event. */
      65           0 : bool SmartTag::Command( const CommandEvent& /*rCEvt*/ )
      66             : {
      67           0 :     return false;
      68             : }
      69             : 
      70             : // --------------------------------------------------------------------
      71             : 
      72           0 : void SmartTag::addCustomHandles( SdrHdlList& /*rHandlerList*/ )
      73             : {
      74           0 : }
      75             : 
      76             : // --------------------------------------------------------------------
      77             : 
      78           0 : void SmartTag::select()
      79             : {
      80           0 :     mbSelected = true;
      81           0 : }
      82             : 
      83             : // --------------------------------------------------------------------
      84             : 
      85           0 : void SmartTag::deselect()
      86             : {
      87           0 :     mbSelected = false;
      88           0 : }
      89             : 
      90             : // --------------------------------------------------------------------
      91             : 
      92           0 : bool SmartTag::isSelected() const
      93             : {
      94           0 :     return mbSelected;
      95             : }
      96             : 
      97             : // --------------------------------------------------------------------
      98             : 
      99           0 : void SmartTag::disposing()
     100             : {
     101           0 :     SmartTagReference xThis( this );
     102           0 :     mrView.getSmartTags().remove( xThis );
     103           0 : }
     104             : 
     105             : // --------------------------------------------------------------------
     106             : 
     107           0 : bool SmartTag::getContext( SdrViewContext& /*rContext*/ )
     108             : {
     109           0 :     return false;
     110             : }
     111             : 
     112             : // --------------------------------------------------------------------
     113             : 
     114           0 : sal_uLong SmartTag::GetMarkablePointCount() const
     115             : {
     116           0 :     return 0;
     117             : }
     118             : 
     119             : // --------------------------------------------------------------------
     120             : 
     121           0 : sal_uLong SmartTag::GetMarkedPointCount() const
     122             : {
     123           0 :     return 0;
     124             : }
     125             : 
     126             : // --------------------------------------------------------------------
     127             : 
     128           0 : sal_Bool SmartTag::MarkPoint(SdrHdl& /*rHdl*/, sal_Bool /*bUnmark*/ )
     129             : {
     130           0 :     return sal_False;
     131             : }
     132             : 
     133             : // --------------------------------------------------------------------
     134             : 
     135           0 : sal_Bool SmartTag::MarkPoints(const Rectangle* /*pRect*/, sal_Bool /*bUnmark*/ )
     136             : {
     137           0 :     return sal_False;
     138             : }
     139             : 
     140             : // --------------------------------------------------------------------
     141             : 
     142           0 : void SmartTag::CheckPossibilities()
     143             : {
     144           0 : }
     145             : 
     146             : // ====================================================================
     147             : 
     148           0 : SmartTagSet::SmartTagSet( View& rView )
     149           0 : : mrView( rView )
     150             : {
     151           0 : }
     152             : 
     153             : // --------------------------------------------------------------------
     154             : 
     155           0 : SmartTagSet::~SmartTagSet()
     156             : {
     157           0 : }
     158             : 
     159             : // --------------------------------------------------------------------
     160             : 
     161           0 : void SmartTagSet::add( const SmartTagReference& xTag )
     162             : {
     163           0 :     maSet.insert( xTag );
     164           0 :     mrView.InvalidateAllWin();
     165             : 
     166           0 :     if( xTag == mxMouseOverTag )
     167           0 :         mxMouseOverTag.clear();
     168             : 
     169           0 :     if( xTag == mxSelectedTag )
     170           0 :         mxSelectedTag.clear();
     171           0 : }
     172             : 
     173             : // --------------------------------------------------------------------
     174             : 
     175           0 : void SmartTagSet::remove( const SmartTagReference& xTag )
     176             : {
     177           0 :     std::set< SmartTagReference >::iterator aIter( maSet.find( xTag ) );
     178           0 :     if( aIter != maSet.end() )
     179           0 :         maSet.erase( aIter );
     180           0 :     mrView.InvalidateAllWin();
     181             : 
     182           0 :     if( xTag == mxMouseOverTag )
     183           0 :         mxMouseOverTag.clear();
     184             : 
     185           0 :     if( xTag == mxSelectedTag )
     186           0 :         mxSelectedTag.clear();
     187           0 : }
     188             : 
     189             : // --------------------------------------------------------------------
     190             : 
     191           0 : void SmartTagSet::Dispose()
     192             : {
     193           0 :     std::set< SmartTagReference > aSet;
     194           0 :     aSet.swap( maSet );
     195           0 :     for( std::set< SmartTagReference >::iterator aIter( aSet.begin() ); aIter != aSet.end(); )
     196           0 :         (*aIter++)->Dispose();
     197           0 :     mrView.InvalidateAllWin();
     198           0 :     mxMouseOverTag.clear();
     199           0 :     mxSelectedTag.clear();
     200           0 : }
     201             : 
     202             : // --------------------------------------------------------------------
     203             : 
     204           0 : void SmartTagSet::select( const SmartTagReference& xTag )
     205             : {
     206           0 :     if( mxSelectedTag != xTag )
     207             :     {
     208           0 :         if( mxSelectedTag.is() )
     209           0 :             mxSelectedTag->deselect();
     210             : 
     211           0 :         mxSelectedTag = xTag;
     212           0 :         mxSelectedTag->select();
     213           0 :         mrView.SetPossibilitiesDirty();
     214           0 :         if( mrView.GetMarkedObjectCount() > 0 )
     215           0 :             mrView.UnmarkAllObj();
     216             :         else
     217           0 :             mrView.updateHandles();
     218             :     }
     219           0 : }
     220             : 
     221             : // --------------------------------------------------------------------
     222             : 
     223           0 : void SmartTagSet::deselect()
     224             : {
     225           0 :     if( mxSelectedTag.is() )
     226             :     {
     227           0 :         mxSelectedTag->deselect();
     228           0 :         mxSelectedTag.clear();
     229           0 :         mrView.SetPossibilitiesDirty();
     230           0 :         mrView.updateHandles();
     231             :     }
     232           0 : }
     233             : 
     234             : // --------------------------------------------------------------------
     235             : 
     236           0 : bool SmartTagSet::MouseButtonDown( const MouseEvent& rMEvt )
     237             : {
     238           0 :     Point aMDPos( mrView.GetViewShell()->GetActiveWindow()->PixelToLogic( rMEvt.GetPosPixel() ) );
     239           0 :     SdrHdl* pHdl = mrView.PickHandle(aMDPos);
     240             : 
     241             :     // check if a smart tag is selected and no handle is hit
     242           0 :     if( mxSelectedTag.is() && !pHdl )
     243             :     {
     244             :         // deselect smart tag
     245           0 :         deselect();
     246           0 :         return false;
     247             :     }
     248             : 
     249             :     // if a smart tag handle is hit, foreward event to its smart tag
     250           0 :     SmartHdl* pSmartHdl = dynamic_cast< SmartHdl* >( pHdl );
     251           0 :     if(pSmartHdl && pSmartHdl->getTag().is() )
     252             :     {
     253           0 :         SmartTagReference xTag( pSmartHdl->getTag() );
     254           0 :         return xTag->MouseButtonDown( rMEvt, *pSmartHdl );
     255             :     }
     256             : 
     257           0 :     return false;
     258             : }
     259             : 
     260             : // --------------------------------------------------------------------
     261             : 
     262           0 : bool SmartTagSet::KeyInput( const KeyEvent& rKEvt )
     263             : {
     264           0 :     if( mxSelectedTag.is() )
     265           0 :         return mxSelectedTag->KeyInput( rKEvt );
     266           0 :     else if( rKEvt.GetKeyCode().GetCode() == KEY_SPACE )
     267             :     {
     268           0 :         SmartHdl* pSmartHdl = dynamic_cast< SmartHdl* >( mrView.GetHdlList().GetFocusHdl() );
     269           0 :         if( pSmartHdl )
     270             :         {
     271           0 :             const_cast< SdrHdlList& >( mrView.GetHdlList() ).ResetFocusHdl();
     272           0 :             SmartTagReference xTag( pSmartHdl->getTag() );
     273           0 :             select( xTag );
     274           0 :             return true;
     275             :         }
     276             :     }
     277             : 
     278             : 
     279           0 :     return false;
     280             : }
     281             : 
     282             : // --------------------------------------------------------------------
     283             : 
     284           0 : bool SmartTagSet::RequestHelp( const HelpEvent& rHEvt )
     285             : {
     286           0 :     Point aMDPos( mrView.GetViewShell()->GetActiveWindow()->PixelToLogic( rHEvt.GetMousePosPixel() ) );
     287           0 :     SdrHdl* pHdl = mrView.PickHandle(aMDPos);
     288             : 
     289           0 :     if( pHdl )
     290             :     {
     291             :         // if a smart tag handle is hit, foreward event to its smart tag
     292           0 :         SmartHdl* pSmartHdl = dynamic_cast< SmartHdl* >( pHdl );
     293           0 :         if(pSmartHdl && pSmartHdl->getTag().is() )
     294             :         {
     295           0 :             SmartTagReference xTag( pSmartHdl->getTag() );
     296           0 :             return xTag->RequestHelp( rHEvt );
     297             :         }
     298             :     }
     299             : 
     300           0 :     return false;
     301             : }
     302             : 
     303             : // --------------------------------------------------------------------
     304             : 
     305             : /** returns true if the SmartTag consumes this event. */
     306           0 : bool SmartTagSet::Command( const CommandEvent& rCEvt )
     307             : {
     308           0 :     if( rCEvt.IsMouseEvent() )
     309             :     {
     310           0 :         Point aMDPos( mrView.GetViewShell()->GetActiveWindow()->PixelToLogic( rCEvt.GetMousePosPixel() ) );
     311           0 :         SdrHdl* pHdl = mrView.PickHandle(aMDPos);
     312             : 
     313           0 :         if( pHdl )
     314             :         {
     315             :             // if a smart tag handle is hit, foreward event to its smart tag
     316           0 :             SmartHdl* pSmartHdl = dynamic_cast< SmartHdl* >( pHdl );
     317           0 :             if(pSmartHdl && pSmartHdl->getTag().is() )
     318             :             {
     319           0 :                 SmartTagReference xTag( pSmartHdl->getTag() );
     320           0 :                 return xTag->Command( rCEvt );
     321             :             }
     322             :         }
     323             :     }
     324             :     else
     325             :     {
     326           0 :         if( mxSelectedTag.is() )
     327           0 :             return mxSelectedTag->Command( rCEvt );
     328             : 
     329             :     }
     330             : 
     331           0 :     return false;
     332             : }
     333             : 
     334             : // --------------------------------------------------------------------
     335             : 
     336           0 : void SmartTagSet::addCustomHandles( SdrHdlList& rHandlerList )
     337             : {
     338           0 :     if( !maSet.empty() )
     339             :     {
     340           0 :         for( std::set< SmartTagReference >::iterator aIter( maSet.begin() ); aIter != maSet.end(); )
     341           0 :             (*aIter++)->addCustomHandles( rHandlerList );
     342             :     }
     343           0 : }
     344             : 
     345             : // --------------------------------------------------------------------
     346             : 
     347             : /** returns true if the currently selected smart tag has
     348             :     a special context, returned in rContext. */
     349           0 : bool SmartTagSet::getContext( SdrViewContext& rContext ) const
     350             : {
     351           0 :     if( mxSelectedTag.is() )
     352           0 :         return mxSelectedTag->getContext( rContext );
     353             :     else
     354           0 :         return false;
     355             : }
     356             : 
     357             : // --------------------------------------------------------------------
     358             : // support point editing
     359             : // --------------------------------------------------------------------
     360             : 
     361           0 : sal_Bool SmartTagSet::HasMarkablePoints() const
     362             : {
     363           0 :     return GetMarkablePointCount() != 0 ? sal_True : sal_False;
     364             : }
     365             : 
     366             : // --------------------------------------------------------------------
     367             : 
     368           0 : sal_uLong SmartTagSet::GetMarkablePointCount() const
     369             : {
     370           0 :     if( mxSelectedTag.is() )
     371           0 :         return mxSelectedTag->GetMarkablePointCount();
     372           0 :     return 0;
     373             : }
     374             : 
     375             : // --------------------------------------------------------------------
     376             : 
     377           0 : sal_Bool SmartTagSet::HasMarkedPoints() const
     378             : {
     379           0 :     return GetMarkedPointCount() != 0 ? sal_True : sal_False;
     380             : }
     381             : 
     382             : // --------------------------------------------------------------------
     383             : 
     384           0 : sal_uLong SmartTagSet::GetMarkedPointCount() const
     385             : {
     386           0 :     if( mxSelectedTag.is() )
     387           0 :         return mxSelectedTag->GetMarkedPointCount();
     388             :     else
     389           0 :         return 0;
     390             : }
     391             : 
     392             : // --------------------------------------------------------------------
     393             : 
     394           0 : sal_Bool SmartTagSet::IsPointMarkable(const SdrHdl& rHdl) const
     395             : {
     396           0 :     const SmartHdl* pSmartHdl = dynamic_cast< const SmartHdl* >( &rHdl );
     397             : 
     398           0 :     return pSmartHdl && pSmartHdl->isMarkable();
     399             : }
     400             : 
     401             : // --------------------------------------------------------------------
     402             : 
     403           0 : sal_Bool SmartTagSet::MarkPoint(SdrHdl& rHdl, sal_Bool bUnmark )
     404             : {
     405           0 :     if( mxSelectedTag.is() )
     406           0 :         return mxSelectedTag->MarkPoint( rHdl, bUnmark );
     407             : 
     408           0 :     return sal_False;
     409             : }
     410             : 
     411             : // --------------------------------------------------------------------
     412             : 
     413           0 : sal_Bool SmartTagSet::MarkPoints(const Rectangle* pRect, sal_Bool bUnmark)
     414             : {
     415           0 :     if( mxSelectedTag.is() )
     416           0 :         return mxSelectedTag->MarkPoints( pRect, bUnmark );
     417           0 :     return sal_False;
     418             : }
     419             : 
     420             : // --------------------------------------------------------------------
     421             : 
     422           0 : void SmartTagSet::CheckPossibilities()
     423             : {
     424           0 :     if( mxSelectedTag.is() )
     425           0 :         mxSelectedTag->CheckPossibilities();
     426           0 : }
     427             : 
     428             : // ====================================================================
     429             : 
     430           0 : SmartHdl::SmartHdl( const SmartTagReference& xTag, SdrObject* pObject, const Point& rPnt, SdrHdlKind eNewKind /*=HDL_MOVE*/ )
     431             : : SdrHdl( rPnt, eNewKind )
     432           0 : , mxTag( xTag )
     433             : {
     434           0 :     SetObj( pObject );
     435           0 : }
     436             : 
     437             : // --------------------------------------------------------------------
     438             : 
     439           0 : SmartHdl::SmartHdl( const SmartTagReference& xTag, const Point& rPnt, SdrHdlKind eNewKind /*=HDL_MOVE*/ )
     440             : : SdrHdl( rPnt, eNewKind )
     441           0 : , mxTag( xTag )
     442             : {
     443           0 : }
     444             : 
     445             : // --------------------------------------------------------------------
     446             : 
     447           0 : bool SmartHdl::isMarkable() const
     448             : {
     449           0 :     return false;
     450             : }
     451             : 
     452             : } // end of namespace sd
     453             : 
     454             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10