diff -r 000000000000 -r 4e91876724a2 photosgallery/slideshow/engine/controlsrc/shweventrouter.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/photosgallery/slideshow/engine/controlsrc/shweventrouter.cpp	Thu Dec 17 08:45:44 2009 +0200
@@ -0,0 +1,200 @@
+/*
+* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:    The scheduler for the slideshow
+ *
+*/
+
+
+
+
+#include "shweventrouter.h"
+#include "shweventobserver.h"
+#include "shweventpublisher.h"
+#include "shwevent.h"
+#include "shwslideshowenginepanic.h"
+
+#include <glxlog.h>
+#include <glxtracer.h>
+
+// constants
+namespace
+	{
+	// the typical amount of observers. In current design six, 
+	// increase if there is more observers in future
+	const TInt KEventObserverGranularity = 7;
+	const TInt KMaxNumberOfConcurrentEvents = 10;
+	}
+
+// -----------------------------------------------------------------------------
+// C++ Constructor. Save a few bits of rom with inlining
+// -----------------------------------------------------------------------------
+inline CShwEventRouter::CShwEventRouter()
+	: iObservers( KEventObserverGranularity ), 
+	iEvents( KMaxNumberOfConcurrentEvents )
+	{
+	// No implementation required
+	}
+
+// -----------------------------------------------------------------------------
+// NewL. Static construction
+// -----------------------------------------------------------------------------
+CShwEventRouter* CShwEventRouter::NewL()
+	{
+	TRACER("CShwEventRouter::NewL()");
+	CShwEventRouter* self = new( ELeave ) CShwEventRouter;
+	CleanupStack::PushL( self );
+	self->ConstructL();
+	CleanupStack::Pop( self );
+	return self;
+	}
+
+// -----------------------------------------------------------------------------
+// Destructor.
+// -----------------------------------------------------------------------------
+CShwEventRouter::~CShwEventRouter()
+	{
+	TRACER("CShwEventRouter::~CShwEventRouter");
+	GLX_LOG_INFO("CShwEventRouter::~CShwEventRouter");
+	// need to cleanup cloned events if we did get run down
+	if( iEvents.Count() > 0 )
+		{
+		for( int i = 0; i < iEvents.Count(); i++ )
+			{
+			// call the destructor
+			delete iEvents[ i ];
+			}
+		}
+	// close the event array itself, this frees the memory
+	iEvents.Close();
+	// close the observer array itself, this frees the memory
+	// NOTE! we did not have ownership of the observers
+	iObservers.Close();
+	}
+
+// -----------------------------------------------------------------------------
+// ConstructL.
+// -----------------------------------------------------------------------------
+void CShwEventRouter::ConstructL()
+	{
+	TRACER("CShwEventRouter::ConstructL");
+	GLX_LOG_INFO("CShwEventRouter::ConstructL");
+	// reserve space for the events so we should never leave in event handling
+	iEvents.ReserveL( KMaxNumberOfConcurrentEvents );
+	iInsideEventLoop = EFalse;
+	}
+
+// -----------------------------------------------------------------------------
+// AddObserversL.
+// -----------------------------------------------------------------------------
+void CShwEventRouter::AddObserversL( TArray<MShwEventObserver*> aObservers )
+	{
+	TRACER("CShwEventRouter::AddObserversL");
+    GLX_LOG_INFO( "CShwEventRouter::AddObserversL" );
+	// add each observer
+	for( TInt i = 0; i < aObservers.Count(); i++ )
+		{
+		AddObserverL( aObservers[ i ] );
+		}
+	}
+
+// -----------------------------------------------------------------------------
+// AddObserverL.
+// -----------------------------------------------------------------------------
+void CShwEventRouter::AddObserverL( MShwEventObserver* aObserver )
+	{
+	TRACER("CShwEventRouter::AddObserverL( MShwEventObserver* aObserver )");
+    GLX_LOG_INFO("CShwEventRouter::AddObserverL(MShwEventObserver* aObserver)");
+	__ASSERT_DEBUG( aObserver, User::Panic( _L("Null observer not allowed"), 1 ) );
+	iObservers.AppendL( aObserver );
+	}
+
+// -----------------------------------------------------------------------------
+// AddProducers.
+// -----------------------------------------------------------------------------
+void CShwEventRouter::AddProducers( TArray< MShwEventPublisher* > aPublishers )
+	{
+	TRACER("CShwEventRouter::AddProducers");
+    GLX_LOG_INFO( "CShwEventRouter::AddProducers" );
+	// add each publisher
+	for( TInt i = 0; i < aPublishers.Count(); i++ )
+		{
+		AddProducer( aPublishers[ i ] );
+		}
+	}
+
+// -----------------------------------------------------------------------------
+// AddProducer.
+// -----------------------------------------------------------------------------
+void CShwEventRouter::AddProducer( MShwEventPublisher* aPublisher )
+	{
+	TRACER("CShwEventRouter::AddProducers(MShwEventPublisher* aPublisher)");
+    GLX_LOG_INFO( "CShwEventRouter::AddProducer" );
+	// give the publisher the event queue so they can start calling us
+	aPublisher->SetEventQueue( this );
+	}
+
+// -----------------------------------------------------------------------------
+// SendEventL. The method that handles the event dispatching.
+// The events are dispatched in same order as they are sent, so if an event 
+// is sent while previous is beeing dispatched we queue the event and 
+// send it after the previous is dispatched to all observers
+// -----------------------------------------------------------------------------
+void CShwEventRouter::SendEventL( MShwEvent* aEvent )
+	{
+	TRACER("CShwEventRouter::SendEventL( MShwEvent* aEvent )");
+    GLX_LOG_INFO( "CShwEventRouter::SendEvent" );
+	__ASSERT_DEBUG( aEvent, User::Panic( _L("Null event not allowed"), 2 ) );
+
+	// add the event to the queue
+	// need to clone the event as the calling code may get out of scope
+	// before we have time to deliver the event
+	// this should never leave as we have reserved space in the array
+	MShwEvent* clone = aEvent->CloneLC();
+	iEvents.AppendL( clone );
+	// we take ownership of the clone so pop it off the stack
+	CleanupStack::Pop( clone );
+	
+	// are we inside event loop: when an event is beeing sent we may be 
+	// delivering an earlier event
+	if( iInsideEventLoop )
+		{
+		// there is an event beeing served so queue the event and return
+		// the event will be served once previous one is served
+		return;
+		}
+	// ok, dwell into the event serving loop
+	// when we fall here we are just about to serve the one event
+	// we may get new events while processing the old ones however
+	iInsideEventLoop = ETrue;
+	do
+		{
+		// take the first event
+		MShwEvent* event = iEvents[ 0 ];
+		TInt i = 0;
+		// notify all observers
+		for( ; i < iObservers.Count(); i++ )
+			{
+			iObservers[ i ]->NotifyL( event );
+			}
+		// this event is served, remove it and delete it
+		iEvents.Remove( 0 );
+		// delete the clone
+		delete event;
+		// if there are new events, deliver them as well
+		}
+	while( iEvents.Count() > 0 );
+	// done processing events, safe to enter the loop again
+	iInsideEventLoop = EFalse;
+	}
+