blob: 32666ff57c89851b417c70795072eb97b862e855 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
/* SPDX-License-Identifier: GPL-2.0-or-later
* Copyright 2001-2002 NaN Holding BV. All rights reserved. */
/** \file
* \ingroup GHOST
* Declaration of GHOST_EventManager class.
*/
#pragma once
#include <deque>
#include <vector>
#include "GHOST_IEventConsumer.h"
/**
* Manages an event stack and a list of event consumers.
* The stack works on a FIFO (First In First Out) basis.
* Events are pushed on the front of the stack and retrieved from the back.
* Ownership of the event is transferred to the event manager as soon as an event is pushed.
* Ownership of the event is transferred from the event manager as soon as an event is popped.
* Events can be dispatched to the event consumers.
*/
class GHOST_EventManager {
public:
/**
* Constructor.
*/
GHOST_EventManager();
/**
* Destructor.
*/
~GHOST_EventManager();
/**
* Returns the number of events currently on the stack.
* \return The number of events on the stack.
*/
uint32_t getNumEvents();
/**
* Returns the number of events of a certain type currently on the stack.
* \param type: The type of events to be counted.
* \return The number of events on the stack of this type.
*/
uint32_t getNumEvents(GHOST_TEventType type);
/**
* Pushes an event on the stack.
* To dispatch it, call dispatchEvent() or dispatchEvents().
* Do not delete the event!
* \param event: The event to push on the stack.
*/
GHOST_TSuccess pushEvent(GHOST_IEvent *event);
/**
* Dispatches the given event directly, bypassing the event stack.
*/
void dispatchEvent(GHOST_IEvent *event);
/**
* Dispatches the event at the back of the stack.
* The event will be removed from the stack.
*/
void dispatchEvent();
/**
* Dispatches all the events on the stack.
* The event stack will be empty afterwards.
*/
void dispatchEvents();
/**
* Adds a consumer to the list of event consumers.
* \param consumer: The consumer added to the list.
* \return Indication as to whether addition has succeeded.
*/
GHOST_TSuccess addConsumer(GHOST_IEventConsumer *consumer);
/**
* Removes a consumer from the list of event consumers.
* \param consumer: The consumer removed from the list.
* \return Indication as to whether removal has succeeded.
*/
GHOST_TSuccess removeConsumer(GHOST_IEventConsumer *consumer);
/**
* Removes all events for a window from the stack.
* \param window: The window to remove events for.
*/
void removeWindowEvents(GHOST_IWindow *window);
/**
* Removes all events of a certain type from the stack.
* The window parameter is optional.
* If non-null, the routine will remove events only associated with that window.
* \param type: The type of events to be removed.
* \param window: The window to remove the events for.
*/
void removeTypeEvents(GHOST_TEventType type, GHOST_IWindow *window = NULL);
protected:
/**
* Removes all events from the stack.
*/
void disposeEvents();
/** A stack with events. */
typedef std::deque<GHOST_IEvent *> TEventStack;
/** The event stack. */
std::deque<GHOST_IEvent *> m_events;
std::deque<GHOST_IEvent *> m_handled_events;
/** A vector with event consumers. */
typedef std::vector<GHOST_IEventConsumer *> TConsumerVector;
/** The list with event consumers. */
TConsumerVector m_consumers;
#ifdef WITH_CXX_GUARDEDALLOC
MEM_CXX_CLASS_ALLOC_FUNCS("GHOST:GHOST_EventManager")
#endif
};
|
