1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 #ifndef INCLUDED_SLIDESHOW_EVENTQUEUE_HXX 25 #define INCLUDED_SLIDESHOW_EVENTQUEUE_HXX 26 27 #include <canvas/elapsedtime.hxx> 28 #include <osl/mutex.hxx> 29 30 #include "event.hxx" 31 32 #include <boost/noncopyable.hpp> 33 #include <functional> 34 #include <queue> 35 #include <vector> 36 37 38 /* Definition of ActivitiesQueue class */ 39 40 namespace slideshow 41 { 42 namespace internal 43 { 44 /** This class handles events in a presentation. Events are 45 time instants where e.g. effects start. 46 */ 47 class EventQueue : private ::boost::noncopyable 48 { 49 public: 50 EventQueue( 51 ::boost::shared_ptr< ::canvas::tools::ElapsedTime > 52 const & pPresTimer ); 53 54 ~EventQueue(); 55 56 /** Add the given event to the queue. The event is fired 57 at, or shortly after, its Event::getActivationTime instant. 58 */ 59 bool addEvent( const EventSharedPtr& event ); 60 61 /** Add the given event to the queue. The event is fired 62 at, or shortly after, its Event::getActivationTime instant. 63 The difference to addEvent() is that events added during 64 process() are postponed to next process(). 65 */ 66 bool addEventForNextRound( const EventSharedPtr& event ); 67 68 /** Another way to control the order of asynchronous event 69 exeqution. Use this method to schedule events that are to 70 be executed after all regular events that have no delay, 71 even when they schedule new regular events without delay. 72 */ 73 bool addEventWhenQueueIsEmpty (const EventSharedPtr& rpEvent); 74 75 /** Process the event queue. 76 77 This method executes all events whose timeout has 78 expired when calling this method (i.e. all events 79 whose scheduled time is less or equal the current 80 time). 81 82 Check for the next available event's timeout via 83 nextTimeout(), or whether the queue is empty 84 altogether via isEmpty(). 85 */ 86 void process(); 87 88 /** Query state of the queue 89 90 @return false, if queue is empty, true otherwise 91 */ 92 bool isEmpty() const; 93 94 /** Query timeout for the topmost event in the queue. 95 96 @return Timeout in seconds, until the next event is 97 ready. The time returned here is relative to the pres 98 timer (i.e. the timer specified at the EventQueue 99 constructor). When the queue is empty (i.e. isEmpty() 100 returns true), the returned value is the highest 101 representable double value 102 (::std::numeric_limits<double>::max()). If the topmost 103 event in the queue is already pending, the timeout 104 returned here will actually be negative. 105 */ 106 double nextTimeout() const; 107 108 /** Remove all pending events from the queue. 109 */ 110 void clear(); 111 112 /** Forces an empty queue, firing all events immediately 113 without minding any times. 114 @attention do only call from event loop, this calls process_()! 115 */ 116 void forceEmpty(); 117 118 /** Gets the queue's timer object. 119 */ 120 ::boost::shared_ptr< ::canvas::tools::ElapsedTime > const & getTimer() const121 getTimer() const { return mpTimer; } 122 123 private: 124 mutable ::osl::Mutex maMutex; 125 126 struct EventEntry : public ::std::unary_function<EventEntry, bool> 127 { 128 EventSharedPtr pEvent; 129 double nTime; 130 131 bool operator<( const EventEntry& ) const; // to leverage priority_queue's default compare 132 EventEntryslideshow::internal::EventQueue::EventEntry133 EventEntry( EventSharedPtr const& p, double t ) 134 : pEvent(p), nTime(t) {} 135 }; 136 137 typedef ::std::priority_queue< EventEntry > ImplQueueType; 138 ImplQueueType maEvents; 139 typedef ::std::vector<EventEntry> EventEntryVector; 140 EventEntryVector maNextEvents; 141 ImplQueueType maNextNextEvents; 142 void process_( bool bFireAllEvents ); 143 144 // perform timing of events via relative time 145 // measurements. The world time starts, when the 146 // EventQueue object is created 147 ::boost::shared_ptr< ::canvas::tools::ElapsedTime > mpTimer; 148 }; 149 150 } 151 } 152 #endif /* INCLUDED_SLIDESHOW_EVENTQUEUE_HXX */ 153