slideshow/source/inc/eventqueue.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: eventqueue.hxx,v $
  10  * $Revision: 1.10 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #ifndef INCLUDED_SLIDESHOW_EVENTQUEUE_HXX
  32 #define INCLUDED_SLIDESHOW_EVENTQUEUE_HXX
  33
  34 #include <canvas/elapsedtime.hxx>
  35 #include <osl/mutex.hxx>
  36
  37 #include "event.hxx"
  38
  39 #include <boost/noncopyable.hpp>
  40 #include <functional>
  41 #include <queue>
  42 #include <vector>
  43
  44
  45 /* Definition of ActivitiesQueue class */
  46
  47 namespace slideshow
  48 {
  49     namespace internal
  50     {
  51         /** This class handles events in a presentation. Events are
  52             time instants where e.g. effects start.
  53          */
  54         class EventQueue : private ::boost::noncopyable
  55         {
  56         public:
  57             EventQueue(
  58                 ::boost::shared_ptr< ::canvas::tools::ElapsedTime >
  59                 const & pPresTimer );
  60
  61             ~EventQueue();
  62
  63             /** Add the given event to the queue. The event is fired
  64                 at, or shortly after, its Event::getActivationTime instant.
  65              */
  66             bool addEvent( const EventSharedPtr& event );
  67
  68             /** Add the given event to the queue. The event is fired
  69                 at, or shortly after, its Event::getActivationTime instant.
  70                 The difference to addEvent() is that events added during
  71                 process() are postponed to next process().
  72              */
  73             bool addEventForNextRound( const EventSharedPtr& event );
  74
  75             /** Another way to control the order of asynchronous event
  76                 exeqution.  Use this method to schedule events that are to
  77                 be executed after all regular events that have no delay,
  78                 even when they schedule new regular events without delay.
  79             */
  80             bool addEventWhenQueueIsEmpty (const EventSharedPtr& rpEvent);
  81
  82             /** Process the event queue.
  83
  84                 This method executes all events whose timeout has
  85                 expired when calling this method (i.e. all events
  86                 whose scheduled time is less or equal the current
  87                 time).
  88
  89                 Check for the next available event's timeout via
  90                 nextTimeout(), or whether the queue is empty
  91                 altogether via isEmpty().
  92              */
  93             void process();
  94
  95             /** Query state of the queue
  96
  97                 @return false, if queue is empty, true otherwise
  98              */
  99             bool isEmpty() const;
 100
 101             /** Query timeout for the topmost event in the queue.
 102
 103                 @return Timeout in seconds, until the next event is
 104                 ready. The time returned here is relative to the pres
 105                 timer (i.e. the timer specified at the EventQueue
 106                 constructor). When the queue is empty (i.e. isEmpty()
 107                 returns true), the returned value is the highest
 108                 representable double value
 109                 (::std::numeric_limits<double>::max()). If the topmost
 110                 event in the queue is already pending, the timeout
 111                 returned here will actually be negative.
 112             */
 113             double nextTimeout() const;
 114
 115             /** Remove all pending events from the queue.
 116              */
 117             void clear();
 118
 119             /** Forces an empty queue, firing all events immediately
 120                 without minding any times.
 121                 @attention do only call from event loop, this calls process_()!
 122              */
 123             void forceEmpty();
 124
 125             /** Gets the queue's timer object.
 126              */
 127             ::boost::shared_ptr< ::canvas::tools::ElapsedTime > const &
 128             getTimer() const { return mpTimer; }
 129
 130         private:
 131             mutable ::osl::Mutex      maMutex;
 132
 133             struct EventEntry : public ::std::unary_function<EventEntry, bool>
 134             {
 135                 EventSharedPtr  pEvent;
 136                 double                  nTime;
 137
 138                 bool operator<( const EventEntry& ) const; // to leverage priority_queue's default compare
 139
 140                 EventEntry( EventSharedPtr const& p, double t )
 141                     : pEvent(p), nTime(t) {}
 142             };
 143
 144             typedef ::std::priority_queue< EventEntry > ImplQueueType;
 145             ImplQueueType                                       maEvents;
 146             typedef ::std::vector<EventEntry> EventEntryVector;
 147             EventEntryVector                maNextEvents;
 148             ImplQueueType                   maNextNextEvents;
 149             void process_( bool bFireAllEvents );
 150
 151             // perform timing of events via relative time
 152             // measurements. The world time starts, when the
 153             // EventQueue object is created
 154             ::boost::shared_ptr< ::canvas::tools::ElapsedTime > mpTimer;
 155         };
 156
 157     }
 158 }
 159 #endif /* INCLUDED_SLIDESHOW_EVENTQUEUE_HXX */