1

/* $Id$ */

     2

     3

#ifndef WINDOW_EVENT_BASE_H

     4

#define WINDOW_EVENT_BASE_H

     5

     6

struct BaseWindow;

     7

     8

namespace gui {

     9

    10

enum EventCode {

    11

	EVT_CREATE,

    12

	EVT_DESTROY,

    13

	EVT_PAINT,

    14

	EVT_KEYPRESS,

    18

	EVT_MOUSEOVER,

    19

	EVT_MOUSELOOP,

    20

	EVT_MOUSEWHEEL,

    21

	EVT_TICK,

    22

	EVT_4,

    23

	EVT_TIMEOUT,

    24

	EVT_PLACE_OBJ,

    25

	EVT_ABORT_PLACE_OBJ,

    26

	EVT_ON_EDIT_TEXT,

    27

	EVT_ON_EDIT_TEXT_CANCEL,

    28

	EVT_POPUPMENU_SELECT,

    29

	EVT_POPUPMENU_OVER,

    30

	EVT_DRAGDROP,

    31

	EVT_PLACE_DRAG,

    32

	EVT_PLACE_MOUSEUP,

    33

	EVT_PLACE_PRESIZE,

    34

	EVT_DROPDOWN_SELECT,

    35

	EVT_RESIZE,

    36

	EVT_RESIZE_PARENT,

    37

	EVT_MESSAGE,

    38

	EVT_SCROLL,

    39

	EVT_INVALIDATE_DATA,

    40

};

    41

    42

template <EventCode Tcode> struct EventT;

    43

    44

typedef EventT<EVT_CREATE             > EvtCreate;

    45

typedef EventT<EVT_DESTROY            > EvtDestroy;

    46

typedef EventT<EVT_PAINT              > EvtPaint;

    47

typedef EventT<EVT_KEYPRESS           > EvtKeyPress;

    51

typedef EventT<EVT_MOUSEOVER          > EvtMouseOver;

    52

typedef EventT<EVT_MOUSELOOP          > EvtMouseLoop;

    53

typedef EventT<EVT_MOUSEWHEEL         > EvtMouseWheel;

    54

typedef EventT<EVT_TICK               > EvtTick;

    55

typedef EventT<EVT_4                  > Evt4;

    56

typedef EventT<EVT_TIMEOUT            > EvtTimeout;

    57

typedef EventT<EVT_PLACE_OBJ          > EvtPlaceObj;

    58

typedef EventT<EVT_ABORT_PLACE_OBJ    > EvtAbortPlaceObj;

    59

typedef EventT<EVT_ON_EDIT_TEXT       > EvtOnEditText;

    60

typedef EventT<EVT_ON_EDIT_TEXT_CANCEL> EvtOnEditTextCancel;

    61

typedef EventT<EVT_POPUPMENU_SELECT   > EvtPopupMenuSelect;

    62

typedef EventT<EVT_POPUPMENU_OVER     > EvtPopupMenuOver;

    63

typedef EventT<EVT_DRAGDROP           > EvtDragDrop;

    64

typedef EventT<EVT_PLACE_DRAG         > EvtPlaceDrag;

    65

typedef EventT<EVT_PLACE_MOUSEUP      > EvtPlaceMouseUp;

    66

typedef EventT<EVT_PLACE_PRESIZE      > EvtPlacePresize;

    67

typedef EventT<EVT_DROPDOWN_SELECT    > EvtDropdownSelect;

    68

typedef EventT<EVT_RESIZE             > EvtResize;

    69

typedef EventT<EVT_RESIZE_PARENT      > EvtResizeParent;

    70

typedef EventT<EVT_MESSAGE            > EvtMessage;

    71

typedef EventT<EVT_SCROLL             > EvtScroll;

    72

typedef EventT<EVT_INVALIDATE_DATA    > EvtInvalidateData;

    73

    74

struct Widget;

    75

typedef CCountedPtr<Widget> WidgetPtr;

    76

    77

/** Base of all gui events. Never constructed directly. Used as base class

    78

 *  of event types */

    79

struct EventBase {

    80

protected:

    81

	EventCode m_code;

    82

	bool      m_handled;

    83

    84

public:

    85

	WidgetPtr m_widget;

    86

    87

protected:

    88

	/** protected constructor (called from subclasses only) */

    89

	EventBase(EventCode code)

    90

		: m_code(code)

    91

		, m_handled(false)

    92

	{}

    93

    94

public:

    95

	virtual ~EventBase() {}

    96

    97

	/** @return event code */

    98

	EventCode GetCode() const

    99

	{

   100

		return m_code;

   101

	}

   102

   103

	/** @return true if event was already handled */

   104

	bool IsHandled() const

   105

	{

   106

		return m_handled;

   107

	}

   108

   109

	void SetHandled(bool handled = true)

   110

	{

   111

		m_handled = handled;

   112

	}

   113

   114

	/** type-safe conversion operator */

   115

	//template <EventCode Tcode> operator EventT<Tcode>& ()

   116

	//{

   117

	//	assert(m_code == Tcode);

   118

	//	return *(EventT<Tcode>*)this;

   119

	//}

   120

   121

	virtual void Dispatch() = 0;

   122

};

   123

   124

/** Intermediate event base that calls EventBase constructor with the proper event type as parameter.

   125

 *  Used only by event subclasses */

   126

template <EventCode Tcode, void (Widget::*Tevt_method)(EventT<Tcode> &)> struct EventBaseT : public EventBase {

   127

	static const EventCode ID = Tcode; ///< allow access to event codes by class name (i.e. EvtCreate::ID)

   128

protected:

   129

	EventBaseT()

   130

		: EventBase(Tcode)

   131

	{}

   132

   133

	/*virtual*/ void Dispatch()

   134

	{

   135

		assert(!m_widget.IsNull());

   136

		assert(m_code == Tcode);

   137

		(m_widget->*Tevt_method)(*(EventT<Tcode>*)this);

   138

	}

   139

};

   140

   141

/**

   142

 * Base of all Event Handler Delegates - class that represents Event Handler object/method

   143

 * pair that can be called by widget when particular event is handled by a widget. Object

   144

 * of any type can register itself and its method as gui event callback handler by adding

   145

 * the appropriate delegate object into widget handler list.

   146

 */

   147

struct EventHandlerDelegate : public SimpleCountedObject {

   148

	EventCode m_code;     ///< event code this handler is registered for

   149

   150

	EventHandlerDelegate(EventCode code)

   151

		: m_code(code)

   152

	{}

   153

   154

	/**

   155

	 * The only method that delegate must provide. Called by widget if the appropriate event

   156

	 * is reflected.

   157

	 */

   158

	virtual void HandleEvent(BaseWindow *w, EventBase &e) = 0;

   159

};

   160

   161

/** Reference counting pointer to the event handler delegate. */

   162

typedef CCountedPtr<EventHandlerDelegate> EventHandlerDelegatePtr;

   163

   164

/**

   165

 * Delegate for handlers of events reflected back from widget to window.

   166

 */

   167

template <class Twnd_cls, EventCode Tevt_code> struct ReflectHandlerDelegateT : public EventHandlerDelegate {

   168

	void (Twnd_cls::*m_handler)(EventT<Tevt_code>&);

   169

   170

	ReflectHandlerDelegateT(void (Twnd_cls::*handler)(EventT<Tevt_code>&))

   171

		: EventHandlerDelegate(Tevt_code)

   172

		, m_handler(handler)

   173

	{}

   174

   175

	virtual void HandleEvent(BaseWindow *w, EventBase &e)

   176

	{

   177

		assert(e.GetCode() == Tevt_code);

   178

		assert(w != NULL);

   179

		Twnd_cls &wnd = *(Twnd_cls*)w;

   180

		EventT<Tevt_code> &ev = *(EventT<Tevt_code>*)&e;

   181

		(wnd.*m_handler)(ev);

   182

	}

   183

};

   184

   185

/**

   186

 * Delegate for capture handlers (inside widget)

   187

 */

   188

template <class Twd_cls, EventCode Tevt_code> struct CaptureHandlerDelegateT : public EventHandlerDelegate {

   189

	Twd_cls *m_widget;

   190

	void (Twd_cls::*m_handler)(EventT<Tevt_code>&);

   191

   192

	CaptureHandlerDelegateT(Twd_cls *wd, void (Twd_cls::*handler)(EventT<Tevt_code>&))

   193

		: EventHandlerDelegate(Tevt_code)

   194

		, m_widget(wd)

   195

		, m_handler(handler)

   196

	{

   197

		assert(wd != NULL);

   198

	}

   199

   200

	virtual void HandleEvent(BaseWindow *w, EventBase &e)

   201

	{

   202

		assert(e.GetCode() == Tevt_code);

   203

		EventT<Tevt_code> &ev = *(EventT<Tevt_code>*)&e;

   204

		(m_widget->*m_handler)(ev);

   205

	}

   206

};

   207

   208

   209

/**

   210

 * Event Capture Stack - widgets can register their Event Handler Delegates here

   211

 * to override default event processing dynamically. For example when moving window

   212

 * by dragging its caption bar, CaptionBar widget can capture mouse move events and

   213

 * process them until the mouse button is released.

   214

 * When gui event occurs, the stack is searched from front (last added delegate) to

   215

 * back and if the appropriate handler delegate (same event code) is found, it is

   216

 * called (given the event object). If this handler wants to prevent further event

   217

 * processing (by other handlers) it must set EventBase::m_handled to true by calling

   218

 * e->SetHandled();. Otherwise the next handler is taken from the stack or the event

   219

 * is processed by standard way.

   220

 */

   221

struct EventCaptureStack {

   222

	/** delegates are stored as a list of smart pointers to delegates */

   223

	typedef std::list<AdaptT<EventHandlerDelegatePtr> > Handlers;

   224

   225

	/**

   226

	 * Capture Ticket - issued by EventCaptureStack when new handler registers itself

   227

	 * in order to capture input events. Widget must save it in the safe place to keep

   228

	 * the input capture. When ticket gets destroyed, handler is automatically removed

   229

	 * from the capture stack.

   230

	 */

   231

	struct CaptureTicket {

   232

	protected:

   233

		mutable Handlers::iterator m_it;          ///< iterator to that stack (to know which handler it belongs to)

   234

	public:

   235

		CaptureTicket();                          ///< constructs clean ticket

   236

		CaptureTicket(Handlers::iterator it);     ///< constructs ticket from iterator

   237

		CaptureTicket(const CaptureTicket &src);  ///< takeover iterator (detach from src, attach to this)

   238

		~CaptureTicket();                         ///< call Release() and destroy ticket

   239

		bool IsActive() const;                    ///< determines whether the CaptureTicket is in use

   240

		void Attach(Handlers::iterator it);       ///< Attach iterator to the ticket

   241

		Handlers::iterator Detach() const;        ///< Detach iterator from ticket (give up ownership)

   242

		void Release();                           ///< remove Event Capture Delegate from the Stack

   243

		CaptureTicket& operator = (const CaptureTicket &src);

   244

	};

   245

   246

protected:

   247

   248

	Handlers m_handlers;   ///< handler delegates are stored here

   249

   250

	/** add new delegate into list and return its iterator - called from Add() */

   251

	Handlers::iterator InternalAdd(EventHandlerDelegate *delegate);

   252

	/** remove handler referenced by the given iterator - called from CaptureTicket::Release() */

   253

	void InternalRemove(Handlers::iterator it);

   254

	/** handle event and return true if event was captured */

   255

	bool InternalHandleEvent(EventBase &e);

   256

	/** return the instance of EventCaptureStack - assuming there is only one global instance */

   257

	static EventCaptureStack& GetInstance();

   258

   259

public:

   260

	/**

   261

	 * iterate through capture handler list and try to handle event

   262

	 * @return true if event was handled (no default processing is necessary)

   263

	 */

   264

	static bool HandleEvent(EventBase &e);

   265

   266

	/** use it to add your own capture handler */

   267

	static CaptureTicket AddHandler(EventHandlerDelegate *delegate);

   268

};

   269

   270

typedef EventCaptureStack::CaptureTicket CaptureTicket;

   271

   272

}; // namespace gui

   273

   274

#endif /* WINDOW_EVENT_BASE_H */