/************************************************************** * * 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 #include #include #include "debug.hxx" #include #include #include #include #include #include #include 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 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 explicitely 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 explicitely 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::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(); } } }