LCOV - code coverage report
Current view: top level - slideshow/source/engine - rehearsetimingsactivity.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 1 236 0.4 %
Date: 2015-06-13 12:38:46 Functions: 2 44 4.5 %
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 <boost/current_function.hpp>
      22             : #include <rtl/ustrbuf.hxx>
      23             : #include <vcl/svapp.hxx>
      24             : #include <vcl/gdimtf.hxx>
      25             : #include <vcl/virdev.hxx>
      26             : #include <vcl/metric.hxx>
      27             : #include <vcl/settings.hxx>
      28             : 
      29             : #include <cppcanvas/vclfactory.hxx>
      30             : #include <cppcanvas/basegfxfactory.hxx>
      31             : #include <basegfx/range/b2drange.hxx>
      32             : 
      33             : #include <comphelper/anytostring.hxx>
      34             : #include <cppuhelper/exc_hlp.hxx>
      35             : 
      36             : #include <com/sun/star/awt/MouseButton.hpp>
      37             : #include <com/sun/star/awt/MouseEvent.hpp>
      38             : #include <com/sun/star/rendering/XBitmap.hpp>
      39             : 
      40             : #include "eventqueue.hxx"
      41             : #include "screenupdater.hxx"
      42             : #include "eventmultiplexer.hxx"
      43             : #include "activitiesqueue.hxx"
      44             : #include "slideshowcontext.hxx"
      45             : #include "mouseeventhandler.hxx"
      46             : #include "rehearsetimingsactivity.hxx"
      47             : 
      48             : #include <boost/bind.hpp>
      49             : #include <o3tl/compat_functional.hxx>
      50             : #include <algorithm>
      51             : 
      52             : using namespace com::sun::star;
      53             : using namespace com::sun::star::uno;
      54             : 
      55             : namespace slideshow {
      56             : namespace internal {
      57             : 
      58           0 : class RehearseTimingsActivity::WakeupEvent : public Event,
      59             :                                              private ::boost::noncopyable
      60             : {
      61             : public:
      62           0 :     WakeupEvent( boost::shared_ptr< ::canvas::tools::ElapsedTime > const& pTimeBase,
      63             :                  ActivitySharedPtr const&                                 rActivity,
      64             :                  ActivitiesQueue &                                        rActivityQueue ) :
      65             :         Event("WakeupEvent"),
      66             :         maTimer(pTimeBase),
      67             :         mnNextTime(0.0),
      68             :         mpActivity(rActivity),
      69           0 :         mrActivityQueue( rActivityQueue )
      70           0 :     {}
      71             : 
      72           0 :     virtual void dispose() SAL_OVERRIDE {}
      73           0 :     virtual bool fire() SAL_OVERRIDE
      74             :     {
      75           0 :         ActivitySharedPtr pActivity( mpActivity.lock() );
      76           0 :         if( !pActivity )
      77           0 :             return false;
      78             : 
      79           0 :         return mrActivityQueue.addActivity( pActivity );
      80             :     }
      81             : 
      82           0 :     virtual bool isCharged() const SAL_OVERRIDE { return true; }
      83           0 :     virtual double getActivationTime( double nCurrentTime ) const SAL_OVERRIDE
      84             :     {
      85           0 :         const double nElapsedTime( maTimer.getElapsedTime() );
      86             : 
      87             :         return ::std::max( nCurrentTime,
      88           0 :                            nCurrentTime - nElapsedTime + mnNextTime );
      89             :     }
      90             : 
      91             :     /// Start the internal timer
      92           0 :     void start() { maTimer.reset(); }
      93             : 
      94             :     /** Set the next timeout this object should generate.
      95             : 
      96             :         @param nextTime
      97             :         Absolute time, measured from the last start() call,
      98             :         when this event should wakeup the Activity again. If
      99             :         your time is relative, simply call start() just before
     100             :         every setNextTimeout() call.
     101             :     */
     102           0 :     void setNextTimeout( double nextTime ) { mnNextTime = nextTime; }
     103             : 
     104             : private:
     105             :     ::canvas::tools::ElapsedTime    maTimer;
     106             :     double                          mnNextTime;
     107             :     boost::weak_ptr<Activity>       mpActivity;
     108             :     ActivitiesQueue&                mrActivityQueue;
     109             : };
     110             : 
     111           0 : class RehearseTimingsActivity::MouseHandler : public MouseEventHandler,
     112             :                                               private boost::noncopyable
     113             : {
     114             : public:
     115             :     explicit MouseHandler( RehearseTimingsActivity& rta );
     116             : 
     117             :     void reset();
     118           0 :     bool hasBeenClicked() const { return mbHasBeenClicked; }
     119             : 
     120             :     // MouseEventHandler
     121             :     virtual bool handleMousePressed( awt::MouseEvent const & evt ) SAL_OVERRIDE;
     122             :     virtual bool handleMouseReleased( awt::MouseEvent const & evt ) SAL_OVERRIDE;
     123             :     virtual bool handleMouseEntered( awt::MouseEvent const & evt ) SAL_OVERRIDE;
     124             :     virtual bool handleMouseExited( awt::MouseEvent const & evt ) SAL_OVERRIDE;
     125             :     virtual bool handleMouseDragged( awt::MouseEvent const & evt ) SAL_OVERRIDE;
     126             :     virtual bool handleMouseMoved( awt::MouseEvent const & evt ) SAL_OVERRIDE;
     127             : 
     128             : private:
     129             :     bool isInArea( com::sun::star::awt::MouseEvent const & evt ) const;
     130             :     void updatePressedState( const bool pressedState ) const;
     131             : 
     132             :     RehearseTimingsActivity& mrActivity;
     133             :     bool                     mbHasBeenClicked;
     134             :     bool                     mbMouseStartedInArea;
     135             : };
     136             : 
     137             : const sal_Int32 LEFT_BORDER_SPACE  = 10;
     138             : const sal_Int32 LOWER_BORDER_SPACE = 30;
     139             : 
     140           0 : RehearseTimingsActivity::RehearseTimingsActivity( const SlideShowContext& rContext ) :
     141             :     mrEventQueue(rContext.mrEventQueue),
     142             :     mrScreenUpdater(rContext.mrScreenUpdater),
     143             :     mrEventMultiplexer(rContext.mrEventMultiplexer),
     144             :     mrActivitiesQueue(rContext.mrActivitiesQueue),
     145           0 :     maElapsedTime( rContext.mrEventQueue.getTimer() ),
     146             :     maViews(),
     147             :     maSpriteRectangle(),
     148           0 :     maFont( Application::GetSettings().GetStyleSettings().GetInfoFont() ),
     149             :     mpWakeUpEvent(),
     150             :     mpMouseHandler(),
     151             :     maSpriteSizePixel(),
     152             :     mnYOffset(0),
     153             :     mbActive(false),
     154           0 :     mbDrawPressed(false)
     155             : {
     156           0 :     maFont.SetHeight( maFont.GetHeight() * 2 );
     157           0 :     maFont.SetWidth( maFont.GetWidth() * 2 );
     158           0 :     maFont.SetAlign( ALIGN_BASELINE );
     159           0 :     maFont.SetColor( COL_BLACK );
     160             : 
     161             :     // determine sprite size (in pixel):
     162           0 :     ScopedVclPtrInstance< VirtualDevice > blackHole;
     163           0 :     blackHole->EnableOutput(false);
     164           0 :     blackHole->SetFont( maFont );
     165           0 :     blackHole->SetMapMode( MAP_PIXEL );
     166           0 :     Rectangle rect;
     167           0 :     const FontMetric metric( blackHole->GetFontMetric() );
     168           0 :     blackHole->GetTextBoundRect( rect, OUString("XX:XX:XX") );
     169           0 :     maSpriteSizePixel.setX( rect.getWidth() * 12 / 10 );
     170           0 :     maSpriteSizePixel.setY( metric.GetLineHeight() * 11 / 10 );
     171           0 :     mnYOffset = (metric.GetAscent() + (metric.GetLineHeight() / 20));
     172             : 
     173             :     std::for_each( rContext.mrViewContainer.begin(),
     174             :                    rContext.mrViewContainer.end(),
     175             :                    boost::bind( &RehearseTimingsActivity::viewAdded,
     176             :                                 this,
     177           0 :                                 _1 ));
     178           0 : }
     179             : 
     180           0 : RehearseTimingsActivity::~RehearseTimingsActivity()
     181             : {
     182             :     try
     183             :     {
     184           0 :         stop();
     185             :     }
     186           0 :     catch (uno::Exception &)
     187             :     {
     188             :         OSL_FAIL( OUStringToOString(
     189             :                         comphelper::anyToString(
     190             :                             cppu::getCaughtException() ),
     191             :                         RTL_TEXTENCODING_UTF8 ).getStr() );
     192             :     }
     193           0 : }
     194             : 
     195           0 : boost::shared_ptr<RehearseTimingsActivity> RehearseTimingsActivity::create(
     196             :     const SlideShowContext& rContext )
     197             : {
     198             :     boost::shared_ptr<RehearseTimingsActivity> pActivity(
     199           0 :         new RehearseTimingsActivity( rContext ));
     200             : 
     201           0 :     pActivity->mpMouseHandler.reset(
     202           0 :         new MouseHandler(*pActivity.get()) );
     203           0 :     pActivity->mpWakeUpEvent.reset(
     204           0 :         new WakeupEvent( rContext.mrEventQueue.getTimer(),
     205             :                          pActivity,
     206           0 :                          rContext.mrActivitiesQueue ));
     207             : 
     208           0 :     rContext.mrEventMultiplexer.addViewHandler( pActivity );
     209             : 
     210           0 :     return pActivity;
     211             : }
     212             : 
     213           0 : void RehearseTimingsActivity::start()
     214             : {
     215           0 :     maElapsedTime.reset();
     216           0 :     mbDrawPressed = false;
     217           0 :     mbActive = true;
     218             : 
     219             :     // paint and show all sprites:
     220           0 :     paintAllSprites();
     221           0 :     for_each_sprite( boost::bind( &cppcanvas::Sprite::show, _1 ) );
     222             : 
     223           0 :     mrActivitiesQueue.addActivity( shared_from_this() );
     224             : 
     225           0 :     mpMouseHandler->reset();
     226             :     mrEventMultiplexer.addClickHandler(
     227           0 :         mpMouseHandler, 42 /* highest prio of all, > 3.0 */ );
     228             :     mrEventMultiplexer.addMouseMoveHandler(
     229           0 :         mpMouseHandler, 42 /* highest prio of all, > 3.0 */ );
     230           0 : }
     231             : 
     232           0 : double RehearseTimingsActivity::stop()
     233             : {
     234           0 :     mrEventMultiplexer.removeMouseMoveHandler( mpMouseHandler );
     235           0 :     mrEventMultiplexer.removeClickHandler( mpMouseHandler );
     236             : 
     237           0 :     mbActive = false; // will be removed from queue
     238             : 
     239           0 :     for_each_sprite( boost::bind( &cppcanvas::Sprite::hide, _1 ) );
     240             : 
     241           0 :     return maElapsedTime.getElapsedTime();
     242             : }
     243             : 
     244           0 : bool RehearseTimingsActivity::hasBeenClicked() const
     245             : {
     246           0 :     if (mpMouseHandler)
     247           0 :         return mpMouseHandler->hasBeenClicked();
     248           0 :     return false;
     249             : }
     250             : 
     251             : // Disposable:
     252           0 : void RehearseTimingsActivity::dispose()
     253             : {
     254           0 :     stop();
     255             : 
     256           0 :     mpWakeUpEvent.reset();
     257           0 :     mpMouseHandler.reset();
     258             : 
     259           0 :     ViewsVecT().swap( maViews );
     260           0 : }
     261             : 
     262             : // Activity:
     263           0 : double RehearseTimingsActivity::calcTimeLag() const
     264             : {
     265           0 :     return 0.0;
     266             : }
     267             : 
     268           0 : bool RehearseTimingsActivity::perform()
     269             : {
     270           0 :     if( !isActive() )
     271           0 :         return false;
     272             : 
     273           0 :     if( !mpWakeUpEvent )
     274           0 :         return false;
     275             : 
     276           0 :     mpWakeUpEvent->start();
     277           0 :     mpWakeUpEvent->setNextTimeout( 0.5 );
     278           0 :     mrEventQueue.addEvent( mpWakeUpEvent );
     279             : 
     280           0 :     paintAllSprites();
     281             : 
     282             :     // sprites changed, need screen update
     283           0 :     mrScreenUpdater.notifyUpdate();
     284             : 
     285           0 :     return false; // don't reinsert, WakeupEvent will perform
     286             :                   // that after the given timeout
     287             : }
     288             : 
     289           0 : bool RehearseTimingsActivity::isActive() const
     290             : {
     291           0 :     return mbActive;
     292             : }
     293             : 
     294           0 : void RehearseTimingsActivity::dequeued()
     295             : {
     296             :     // not used here
     297           0 : }
     298             : 
     299           0 : void RehearseTimingsActivity::end()
     300             : {
     301           0 :     if (isActive())
     302             :     {
     303           0 :         stop();
     304           0 :         mbActive = false;
     305             :     }
     306           0 : }
     307             : 
     308           0 : basegfx::B2DRange RehearseTimingsActivity::calcSpriteRectangle( UnoViewSharedPtr const& rView ) const
     309             : {
     310           0 :     const Reference<rendering::XBitmap> xBitmap( rView->getCanvas()->getUNOCanvas(),
     311           0 :                                                  UNO_QUERY );
     312           0 :     if( !xBitmap.is() )
     313           0 :         return basegfx::B2DRange();
     314             : 
     315           0 :     const geometry::IntegerSize2D realSize( xBitmap->getSize() );
     316             :     // pixel:
     317             :     basegfx::B2DPoint spritePos(
     318           0 :         std::min<sal_Int32>( realSize.Width, LEFT_BORDER_SPACE ),
     319           0 :         std::max<sal_Int32>( 0, realSize.Height - maSpriteSizePixel.getY()
     320           0 :                                                 - LOWER_BORDER_SPACE ) );
     321           0 :     basegfx::B2DHomMatrix transformation( rView->getTransformation() );
     322           0 :     transformation.invert();
     323           0 :     spritePos *= transformation;
     324           0 :     basegfx::B2DSize spriteSize( maSpriteSizePixel.getX(),
     325           0 :                                  maSpriteSizePixel.getY() );
     326           0 :     spriteSize *= transformation;
     327             :     return basegfx::B2DRange(
     328             :         spritePos.getX(), spritePos.getY(),
     329           0 :         spritePos.getX() + spriteSize.getX(),
     330           0 :         spritePos.getY() + spriteSize.getY() );
     331             : }
     332             : 
     333           0 : void RehearseTimingsActivity::viewAdded( const UnoViewSharedPtr& rView )
     334             : {
     335             :     cppcanvas::CustomSpriteSharedPtr sprite(
     336           0 :         rView->createSprite( basegfx::B2DSize(
     337           0 :                                  maSpriteSizePixel.getX()+2,
     338           0 :                                  maSpriteSizePixel.getY()+2 ),
     339           0 :                              1001.0 )); // sprite should be in front of all
     340             :                                         // other sprites
     341           0 :     sprite->setAlpha( 0.8 );
     342             :     const basegfx::B2DRange spriteRectangle(
     343           0 :         calcSpriteRectangle( rView ) );
     344           0 :     sprite->move( basegfx::B2DPoint(
     345             :                       spriteRectangle.getMinX(),
     346           0 :                       spriteRectangle.getMinY() ) );
     347             : 
     348           0 :     if( maViews.empty() )
     349           0 :         maSpriteRectangle = spriteRectangle;
     350             : 
     351           0 :     maViews.push_back( ViewsVecT::value_type( rView, sprite ) );
     352             : 
     353           0 :     if (isActive())
     354           0 :         sprite->show();
     355           0 : }
     356             : 
     357           0 : void RehearseTimingsActivity::viewRemoved( const UnoViewSharedPtr& rView )
     358             : {
     359             :     maViews.erase(
     360             :         std::remove_if(
     361             :             maViews.begin(), maViews.end(),
     362             :             boost::bind(
     363             :                 std::equal_to<UnoViewSharedPtr>(),
     364             :                 rView,
     365             :                 // select view:
     366             :                 boost::bind( o3tl::select1st<ViewsVecT::value_type>(), _1 ))),
     367           0 :         maViews.end() );
     368           0 : }
     369             : 
     370           0 : void RehearseTimingsActivity::viewChanged( const UnoViewSharedPtr& rView )
     371             : {
     372             :     // find entry corresponding to modified view
     373             :     ViewsVecT::iterator aModifiedEntry(
     374             :         std::find_if(
     375             :             maViews.begin(),
     376             :             maViews.end(),
     377             :             boost::bind(
     378             :                 std::equal_to<UnoViewSharedPtr>(),
     379             :                 rView,
     380             :                 // select view:
     381           0 :                 boost::bind( o3tl::select1st<ViewsVecT::value_type>(), _1 ))));
     382             : 
     383             :     OSL_ASSERT( aModifiedEntry != maViews.end() );
     384           0 :     if( aModifiedEntry == maViews.end() )
     385           0 :         return;
     386             : 
     387             :     // new sprite pos, transformation might have changed:
     388           0 :     maSpriteRectangle = calcSpriteRectangle( rView );
     389             : 
     390             :     // reposition sprite:
     391           0 :     aModifiedEntry->second->move( maSpriteRectangle.getMinimum() );
     392             : 
     393             :     // sprites changed, need screen update
     394           0 :     mrScreenUpdater.notifyUpdate( rView );
     395             : }
     396             : 
     397           0 : void RehearseTimingsActivity::viewsChanged()
     398             : {
     399           0 :     if( !maViews.empty() )
     400             :     {
     401             :         // new sprite pos, transformation might have changed:
     402           0 :         maSpriteRectangle = calcSpriteRectangle( maViews.front().first );
     403             : 
     404             :         // reposition sprites
     405             :         for_each_sprite( boost::bind( &cppcanvas::Sprite::move,
     406             :                                       _1,
     407           0 :                                       maSpriteRectangle.getMinimum()) );
     408             : 
     409             :         // sprites changed, need screen update
     410           0 :         mrScreenUpdater.notifyUpdate();
     411             :     }
     412           0 : }
     413             : 
     414           0 : void RehearseTimingsActivity::paintAllSprites() const
     415             : {
     416             :     for_each_sprite(
     417             :         boost::bind( &RehearseTimingsActivity::paint, this,
     418             :                      // call getContentCanvas() on each sprite:
     419             :                      boost::bind(
     420           0 :                          &cppcanvas::CustomSprite::getContentCanvas, _1 ) ) );
     421           0 : }
     422             : 
     423           0 : void RehearseTimingsActivity::paint( cppcanvas::CanvasSharedPtr const & canvas ) const
     424             : {
     425             :     // build timer string:
     426             :     const sal_Int32 nTimeSecs =
     427           0 :         static_cast<sal_Int32>(maElapsedTime.getElapsedTime());
     428           0 :     OUStringBuffer buf;
     429           0 :     sal_Int32 n = (nTimeSecs / 3600);
     430           0 :     if (n < 10)
     431           0 :         buf.append( '0' );
     432           0 :     buf.append( n );
     433           0 :     buf.append( ':' );
     434           0 :     n = ((nTimeSecs % 3600) / 60);
     435           0 :     if (n < 10)
     436           0 :         buf.append( '0' );
     437           0 :     buf.append( n );
     438           0 :     buf.append( ':' );
     439           0 :     n = (nTimeSecs % 60);
     440           0 :     if (n < 10)
     441           0 :         buf.append( '0' );
     442           0 :     buf.append( n );
     443           0 :     const OUString time = buf.makeStringAndClear();
     444             : 
     445             :     // create the MetaFile:
     446           0 :     GDIMetaFile metaFile;
     447           0 :     ScopedVclPtrInstance< VirtualDevice > blackHole;
     448           0 :     metaFile.Record( blackHole );
     449           0 :     metaFile.SetPrefSize( Size( 1, 1 ) );
     450           0 :     blackHole->EnableOutput(false);
     451           0 :     blackHole->SetMapMode( MAP_PIXEL );
     452           0 :     blackHole->SetFont( maFont );
     453             :     Rectangle rect = Rectangle( 0,0,
     454           0 :                                 maSpriteSizePixel.getX(),
     455           0 :                                 maSpriteSizePixel.getY());
     456           0 :     if (mbDrawPressed)
     457             :     {
     458           0 :         blackHole->SetTextColor( COL_BLACK );
     459           0 :         blackHole->SetFillColor( COL_LIGHTGRAY );
     460           0 :         blackHole->SetLineColor( COL_GRAY );
     461             :     }
     462             :     else
     463             :     {
     464           0 :         blackHole->SetTextColor( COL_BLACK );
     465           0 :         blackHole->SetFillColor( COL_WHITE );
     466           0 :         blackHole->SetLineColor( COL_GRAY );
     467             :     }
     468           0 :     blackHole->DrawRect( rect );
     469           0 :     blackHole->GetTextBoundRect( rect, time );
     470           0 :     blackHole->DrawText(
     471           0 :         Point( (maSpriteSizePixel.getX() - rect.getWidth()) / 2,
     472           0 :                mnYOffset ), time );
     473             : 
     474           0 :     metaFile.Stop();
     475           0 :     metaFile.WindStart();
     476             : 
     477             :     cppcanvas::RendererSharedPtr renderer(
     478             :         cppcanvas::VCLFactory::createRenderer(
     479           0 :             canvas, metaFile, cppcanvas::Renderer::Parameters() ) );
     480           0 :     const bool succ = renderer->draw();
     481             :     OSL_ASSERT( succ );
     482           0 :     (void)succ;
     483           0 : }
     484             : 
     485             : 
     486           0 : RehearseTimingsActivity::MouseHandler::MouseHandler( RehearseTimingsActivity& rta ) :
     487             :     mrActivity(rta),
     488             :     mbHasBeenClicked(false),
     489           0 :     mbMouseStartedInArea(false)
     490           0 : {}
     491             : 
     492           0 : void RehearseTimingsActivity::MouseHandler::reset()
     493             : {
     494           0 :     mbHasBeenClicked = false;
     495           0 :     mbMouseStartedInArea = false;
     496           0 : }
     497             : 
     498           0 : bool RehearseTimingsActivity::MouseHandler::isInArea(
     499             :     awt::MouseEvent const & evt ) const
     500             : {
     501             :     return mrActivity.maSpriteRectangle.isInside(
     502           0 :         basegfx::B2DPoint( evt.X, evt.Y ) );
     503             : }
     504             : 
     505           0 : void RehearseTimingsActivity::MouseHandler::updatePressedState(
     506             :     const bool pressedState ) const
     507             : {
     508           0 :     if( pressedState != mrActivity.mbDrawPressed )
     509             :     {
     510           0 :         mrActivity.mbDrawPressed = pressedState;
     511           0 :         mrActivity.paintAllSprites();
     512             : 
     513           0 :         mrActivity.mrScreenUpdater.notifyUpdate();
     514             :     }
     515           0 : }
     516             : 
     517             : // MouseEventHandler
     518           0 : bool RehearseTimingsActivity::MouseHandler::handleMousePressed(
     519             :     awt::MouseEvent const & evt )
     520             : {
     521           0 :     if( evt.Buttons == awt::MouseButton::LEFT && isInArea(evt) )
     522             :     {
     523           0 :         mbMouseStartedInArea = true;
     524           0 :         updatePressedState(true);
     525           0 :         return true; // consume event
     526             :     }
     527           0 :     return false;
     528             : }
     529             : 
     530           0 : bool RehearseTimingsActivity::MouseHandler::handleMouseReleased(
     531             :     awt::MouseEvent const & evt )
     532             : {
     533           0 :     if( evt.Buttons == awt::MouseButton::LEFT && mbMouseStartedInArea )
     534             :     {
     535           0 :         mbHasBeenClicked = isInArea(evt); // fini if in
     536           0 :         mbMouseStartedInArea = false;
     537           0 :         updatePressedState(false);
     538           0 :         if( !mbHasBeenClicked )
     539           0 :             return true; // consume event, else next slide (manual advance)
     540             :     }
     541           0 :     return false;
     542             : }
     543             : 
     544           0 : bool RehearseTimingsActivity::MouseHandler::handleMouseEntered(
     545             :     awt::MouseEvent const & /*evt*/ )
     546             : {
     547           0 :     return false;
     548             : }
     549             : 
     550           0 : bool RehearseTimingsActivity::MouseHandler::handleMouseExited(
     551             :     awt::MouseEvent const & /*evt*/ )
     552             : {
     553           0 :     return false;
     554             : }
     555             : 
     556           0 : bool RehearseTimingsActivity::MouseHandler::handleMouseDragged(
     557             :     awt::MouseEvent const & evt )
     558             : {
     559           0 :     if( mbMouseStartedInArea )
     560           0 :         updatePressedState( isInArea(evt) );
     561           0 :     return false;
     562             : }
     563             : 
     564           0 : bool RehearseTimingsActivity::MouseHandler::handleMouseMoved(
     565             :     awt::MouseEvent const & /*evt*/ )
     566             : {
     567           0 :     return false;
     568             : }
     569             : 
     570             : } // namespace internal
     571           3 : } // namespace presentation
     572             : 
     573             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11