IEventDispatcher.h

//========================================================================================
// 
// $File$
// 
// Owner: ?
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
//========================================================================================

#ifndef __IEventDispatcher__
#define __IEventDispatcher__

#include "IPMUnknown.h"
#include "ShuksanID.h"
#include "IEvent.h"

class IEventHandler;
class IEventWatcher;

class IEventDispatcher : public IPMUnknown {
public:
 enum { kDefaultIID = IID_IEVENTDISPATCHER };
 
 enum PushWhere { kPushOnTop, kPushOnBottom };

 virtual void Push(IEventHandler *newHandler, PushWhere pushWhere = kPushOnTop ) = 0;
 
 virtual void Remove(IEventHandler *ehToRemove) = 0;

 virtual IEventHandler *Peek(int32 ehIndex = 0) const = 0;
 
 virtual int32 Depth() const = 0;
 
 virtual void Init() = 0;

 virtual void CleanUp() = 0;
 
 virtual bool16 DispatchEvent(IEvent *theEvent, IEvent::SystemHandledState initialState = IEvent::kShouldCall) = 0;
 
#define ITERATOR_ACCESS_TO_EventTypeList 0
#if 0 //VC can't cope with this
 //Essentially a way of declaring classes derived from IEventDispatcher as 
 //friends of class EventTypeList--Hence if class EventTypeList gets reimplemented
 //so must, e.g., CEventDispatcher.
 class EventTypeList;
 protected: static uint32 GetEventTypeListContents( EventTypeList l){ return l.fContents;}
#endif


public:
 class EventTypeList {
#if 0 //VC can't cope with this
 friend uint32 IEventDispatcher::GetEventTypeListContents( EventTypeList l);
#endif
 public:
 enum {kMaxEventTypeValue = 31};
 EventTypeList(){
 fContents = kAllEventTypes;
 }
 EventTypeList( IEvent::EventType t){
 fContents = 1<<t;
 }
 EventTypeList( IEvent::EventType t1, IEvent::EventType t2){
 fContents = 1<<t1 | 1<<t2;
 }
 EventTypeList( IEvent::EventType t1, IEvent::EventType t2, IEvent::EventType t3){
 fContents = 1<<t1 | 1<<t2 | 1<<t3;
 }
 EventTypeList& Add( IEvent::EventType t){ //you can chain Add calls if interested in more than 3 event types
 fContents |= 1<<t;
 return *this;
 }
 EventTypeList& operator|=(EventTypeList l){ fContents |= l.fContents; return *this;}
 EventTypeList& operator&=(EventTypeList l){ fContents &= l.fContents; return *this;}
 EventTypeList operator~() const { return EventTypeList(kAllEventTypes & ~fContents);}
 //could be nonmember friend inline EventTypeList operator~( const EventTypeList& l){ return EventTypeList(~l.fContents);}
 bool16 Contains(IEvent::EventType t){ return (fContents & (1<<t)) != 0;}
 bool16 Empty(){ return fContents == 0;}
#if ITERATOR_ACCESS_TO_EventTypeList
 class const_iterator {
 public:
 const_iterator() {}
 const_iterator(const EventTypeList::const_iterator& x) : next(x.next), rest(x.rest) {}
 IEvent::EventType operator * () const { return static_cast<IEvent::EventType>(next);}
 const_iterator& operator++()
 {
 do{
 ++next;
 }while( (rest >>= 1) && !(rest&1));
 return *this;
 }
 const_iterator operator++(int) {const_iterator old(*this); operator++(); return old;}
 friend bool operator==(const_iterator x, const_iterator y) { return x.rest == y.rest;}
 friend bool operator!=(const_iterator x, const_iterator y) { return x.rest != y.rest;}
 
 private:
 const_iterator(uint32 contents) : next(0), rest(contents)
 {
 if(!(rest&1))
 ++*this;
 }
 friend class EventTypeList;
 uint32 next;
 uint32 rest;
 
 };
 const_iterator begin() const { return const_iterator(fContents);}
 const_iterator end() const {return const_iterator(0);}
#endif

 private:
 EventTypeList(uint32 contents) : fContents(contents){}
//VC can't cope with this: static const uint32 kAllEventTypes = (uint32(1)<<IEvent::kEndOfEventTypes) - 2;// subtract 1 to turn on all the bits, subtract another 1 to turn off the low order one
 enum {kAllEventTypes = (uint32(1)<<IEvent::kEndOfEventTypes) - 2};// subtract 1 to turn on all the bits, subtract another 1 to turn off the low order one
 uint32 fContents;
 };

 virtual void AddEventWatcher( IEventWatcher *newWatcher, EventTypeList interest) = 0;
 virtual void AddEventWatcher( IEventWatcher *newWatcher, IEvent::EventType interest) = 0;
 virtual void RemoveEventWatcher( IEventWatcher *newWatcher, EventTypeList interest) = 0;
 virtual void RemoveEventWatcher( IEventWatcher *newWatcher, IEvent::EventType interest) = 0;
 virtual void StopAllEventWatchers() = 0;

};


#endif // __IEventDispatcher__