| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_slideshow.hxx" | |
| // must be first | |
| #include <canvas/debug.hxx> | |
| #include <tools/diagnose_ex.h> | |
| #include <canvas/verbosetrace.hxx> | |
| #include "debug.hxx" | |
| #include <comphelper/anytostring.hxx> | |
| #include <cppuhelper/exc_hlp.hxx> | |
| #include <event.hxx> | |
| #include <eventqueue.hxx> | |
| #include <slideshowexceptions.hxx> | |
| #include <boost/shared_ptr.hpp> | |
| #include <limits> | |
| using namespace ::com::sun::star; | |
| namespace slideshow | |
| { | |
| namespace internal | |
| { | |
| bool EventQueue::EventEntry::operator<( const EventEntry& rEvent ) const | |
| { | |
| // negate comparison, we want priority queue to be sorted | |
| // in increasing order of activation times | |
| return this->nTime > rEvent.nTime; | |
| } | |
| EventQueue::EventQueue( | |
| boost::shared_ptr<canvas::tools::ElapsedTime> const & pPresTimer ) | |
| : maMutex(), | |
| maEvents(), | |
| maNextEvents(), | |
| maNextNextEvents(), | |
| mpTimer( pPresTimer ) | |
| { | |
| } | |
| EventQueue::~EventQueue() | |
| { | |
| // add in all that have been added explicitly for this round: | |
| EventEntryVector::const_iterator const iEnd( maNextEvents.end() ); | |
| for ( EventEntryVector::const_iterator iPos( maNextEvents.begin() ); | |
| iPos != iEnd; ++iPos ) | |
| { | |
| maEvents.push(*iPos); | |
| } | |
| EventEntryVector().swap( maNextEvents ); | |
| // dispose event queue | |
| while( !maEvents.empty() ) | |
| { | |
| try | |
| { | |
| maEvents.top().pEvent->dispose(); | |
| } | |
| catch (uno::Exception &) | |
| { | |
| OSL_ENSURE( false, rtl::OUStringToOString( | |
| comphelper::anyToString( | |
| cppu::getCaughtException() ), | |
| RTL_TEXTENCODING_UTF8 ).getStr() ); | |
| } | |
| maEvents.pop(); | |
| } | |
| } | |
| bool EventQueue::addEvent( const EventSharedPtr& rEvent ) | |
| { | |
| ::osl::MutexGuard aGuard( maMutex ); | |
| #if OSL_DEBUG_LEVEL > 1 && defined (SLIDESHOW_ADD_DESCRIPTIONS_TO_EVENTS) | |
| OSL_TRACE("adding at %f event [%s] at %x with delay %f\r", | |
| mpTimer->getElapsedTime(), | |
| OUStringToOString(rEvent->GetDescription(), RTL_TEXTENCODING_UTF8).getStr(), | |
| rEvent.get(), | |
| rEvent->getActivationTime(0.0)); | |
| #endif | |
| ENSURE_OR_RETURN_FALSE( rEvent, | |
| "EventQueue::addEvent: event ptr NULL" ); | |
| // prepare entry | |
| // A seemingly obvious optimization cannot be used here, | |
| // because it breaks assumed order of notification: zero | |
| // timeout events could be fired() immediately, but that | |
| // would not unwind the stack and furthermore changes | |
| // order of notification | |
| // add entry | |
| maEvents.push( EventEntry( rEvent, rEvent->getActivationTime( | |
| mpTimer->getElapsedTime()) ) ); | |
| return true; | |
| } | |
| bool EventQueue::addEventForNextRound( EventSharedPtr const& rEvent ) | |
| { | |
| ::osl::MutexGuard aGuard( maMutex ); | |
| #if OSL_DEBUG_LEVEL > 1 && defined (SLIDESHOW_ADD_DESCRIPTIONS_TO_EVENTS) | |
| OSL_TRACE("adding at %f event [%s] at %x for next round with delay %f\r", | |
| mpTimer->getElapsedTime(), | |
| OUStringToOString(rEvent->GetDescription(), RTL_TEXTENCODING_UTF8).getStr(), | |
| rEvent.get(), | |
| rEvent->getActivationTime(0.0)); | |
| #endif | |
| ENSURE_OR_RETURN_FALSE( rEvent.get() != NULL, | |
| "EventQueue::addEvent: event ptr NULL" ); | |
| maNextEvents.push_back( | |
| EventEntry( rEvent, rEvent->getActivationTime( | |
| mpTimer->getElapsedTime()) ) ); | |
| return true; | |
| } | |
| bool EventQueue::addEventWhenQueueIsEmpty (const EventSharedPtr& rpEvent) | |
| { | |
| ::osl::MutexGuard aGuard( maMutex ); | |
| #if OSL_DEBUG_LEVEL > 1 && defined (SLIDESHOW_ADD_DESCRIPTIONS_TO_EVENTS) | |
| OSL_TRACE("adding at %f event [%s] at %x for execution when queue is empty with delay %f\r", | |
| mpTimer->getElapsedTime(), | |
| OUStringToOString(rpEvent->GetDescription(), RTL_TEXTENCODING_UTF8).getStr(), | |
| rpEvent.get(), | |
| rpEvent->getActivationTime(0.0)); | |
| #endif | |
| ENSURE_OR_RETURN_FALSE( | |
| rpEvent.get() != NULL, | |
| "EventQueue::addEvent: event ptr NULL"); | |
| maNextNextEvents.push( | |
| EventEntry( | |
| rpEvent, | |
| rpEvent->getActivationTime(mpTimer->getElapsedTime()))); | |
| return true; | |
| } | |
| void EventQueue::forceEmpty() | |
| { | |
| ::osl::MutexGuard aGuard( maMutex ); | |
| process_(true); | |
| } | |
| void EventQueue::process() | |
| { | |
| ::osl::MutexGuard aGuard( maMutex ); | |
| process_(false); | |
| } | |
| void EventQueue::process_( bool bFireAllEvents ) | |
| { | |
| VERBOSE_TRACE( "EventQueue: heartbeat" ); | |
| // add in all that have been added explicitly for this round: | |
| EventEntryVector::const_iterator const iEnd( maNextEvents.end() ); | |
| for ( EventEntryVector::const_iterator iPos( maNextEvents.begin() ); | |
| iPos != iEnd; ++iPos ) { | |
| maEvents.push(*iPos); | |
| } | |
| EventEntryVector().swap( maNextEvents ); | |
| // perform topmost, ready-to-execute event | |
| // ======================================= | |
| const double nCurrTime( mpTimer->getElapsedTime() ); | |
| // When maEvents does not contain any events that are due now | |
| // then process one event from maNextNextEvents. | |
| if (!maNextNextEvents.empty() | |
| && !bFireAllEvents | |
| && (maEvents.empty() || maEvents.top().nTime > nCurrTime)) | |
| { | |
| const EventEntry aEvent (maNextNextEvents.top()); | |
| maNextNextEvents.pop(); | |
| maEvents.push(aEvent); | |
| } | |
| // process ready/elapsed events. Note that the 'perceived' | |
| // current time remains constant for this loop, thus we're | |
| // processing only those events which where ready when we | |
| // entered this method. | |
| while( !maEvents.empty() && | |
| (bFireAllEvents || maEvents.top().nTime <= nCurrTime) ) | |
| { | |
| EventEntry event( maEvents.top() ); | |
| maEvents.pop(); | |
| // only process event, if it is still 'charged', | |
| // i.e. the fire() call effects something. This is | |
| // used when e.g. having events registered at multiple | |
| // places, which should fire only once: after the | |
| // initial fire() call, those events become inactive | |
| // and return false on isCharged. This frees us from | |
| // the need to prune queues of those inactive shells. | |
| if( event.pEvent->isCharged() ) | |
| { | |
| try | |
| { | |
| #if OSL_DEBUG_LEVEL > 0 | |
| VERBOSE_TRACE( "Firing event: unknown (0x%X), timeout was: %f", | |
| event.pEvent.get(), | |
| event.pEvent->getActivationTime(0.0) ); | |
| #endif | |
| #if OSL_DEBUG_LEVEL > 1 && defined (SLIDESHOW_ADD_DESCRIPTIONS_TO_EVENTS) | |
| OSL_TRACE("firing at %f event [%s] at %x with delay %f\r", | |
| mpTimer->getElapsedTime(), | |
| OUStringToOString(event.pEvent->GetDescription(), | |
| RTL_TEXTENCODING_UTF8).getStr(), | |
| event.pEvent.get(), | |
| event.pEvent->getActivationTime(0.0)); | |
| #endif | |
| event.pEvent->fire(); | |
| } | |
| catch( uno::RuntimeException& ) | |
| { | |
| throw; | |
| } | |
| catch( uno::Exception& ) | |
| { | |
| // catch anything here, we don't want | |
| // to leave this scope under _any_ | |
| // circumstance. Although, do _not_ | |
| // reinsert an activity that threw | |
| // once. | |
| // NOTE: we explicitly don't catch(...) here, | |
| // since this will also capture segmentation | |
| // violations and the like. In such a case, we | |
| // still better let our clients now... | |
| OSL_ENSURE( false, | |
| rtl::OUStringToOString( | |
| comphelper::anyToString( cppu::getCaughtException() ), | |
| RTL_TEXTENCODING_UTF8 ).getStr() ); | |
| } | |
| catch( SlideShowException& ) | |
| { | |
| // catch anything here, we don't want | |
| // to leave this scope under _any_ | |
| // circumstance. Although, do _not_ | |
| // reinsert an activity that threw | |
| // once. | |
| // NOTE: we explicitly don't catch(...) here, | |
| // since this will also capture segmentation | |
| // violations and the like. In such a case, we | |
| // still better let our clients now... | |
| OSL_TRACE( "::presentation::internal::EventQueue: Event threw a SlideShowException, action might not have been fully performed" ); | |
| } | |
| } | |
| else | |
| { | |
| #if OSL_DEBUG_LEVEL > 0 | |
| VERBOSE_TRACE( "Ignoring discharged event: unknown (0x%X), timeout was: %f", | |
| event.pEvent.get(), | |
| event.pEvent->getActivationTime(0.0) ); | |
| #endif | |
| } | |
| } | |
| } | |
| bool EventQueue::isEmpty() const | |
| { | |
| ::osl::MutexGuard aGuard( maMutex ); | |
| return maEvents.empty() && maNextEvents.empty() && maNextNextEvents.empty(); | |
| } | |
| double EventQueue::nextTimeout() const | |
| { | |
| ::osl::MutexGuard aGuard( maMutex ); | |
| // return time for next entry (if any) | |
| double nTimeout (::std::numeric_limits<double>::max()); | |
| const double nCurrentTime (mpTimer->getElapsedTime()); | |
| if ( ! maEvents.empty()) | |
| nTimeout = maEvents.top().nTime - nCurrentTime; | |
| if ( ! maNextEvents.empty()) | |
| nTimeout = ::std::min(nTimeout, maNextEvents.front().nTime - nCurrentTime); | |
| if ( ! maNextNextEvents.empty()) | |
| nTimeout = ::std::min(nTimeout, maNextNextEvents.top().nTime - nCurrentTime); | |
| return nTimeout; | |
| } | |
| void EventQueue::clear() | |
| { | |
| ::osl::MutexGuard aGuard( maMutex ); | |
| // TODO(P1): Maybe a plain vector and vector.swap will | |
| // be faster here. Profile. | |
| maEvents = ImplQueueType(); | |
| maNextEvents.clear(); | |
| maNextNextEvents = ImplQueueType(); | |
| } | |
| } | |
| } |