/**************************************************************
*
* 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 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<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();
}
}
}