Cleanup: remove redundant doxygen \file argument
[blender.git] / intern / ghost / intern / GHOST_EventManager.cpp
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file \ingroup GHOST
21  */
22
23
24 /**
25  * Copyright (C) 2001 NaN Technologies B.V.
26  */
27
28 #include "GHOST_EventManager.h"
29 #include <algorithm>
30 #include "GHOST_Debug.h"
31 #include <stdio.h> // [mce] temp debug
32
33 GHOST_EventManager::GHOST_EventManager()
34 {
35 }
36
37
38 GHOST_EventManager::~GHOST_EventManager()
39 {
40         disposeEvents();
41
42         TConsumerVector::iterator iter = m_consumers.begin();
43         while (iter != m_consumers.end()) {
44                 GHOST_IEventConsumer *consumer = *iter;
45                 delete consumer;
46                 iter = m_consumers.erase(iter);
47         }
48 }
49
50
51 GHOST_TUns32 GHOST_EventManager::getNumEvents()
52 {
53         return (GHOST_TUns32) m_events.size();
54 }
55
56
57 GHOST_TUns32 GHOST_EventManager::getNumEvents(GHOST_TEventType type)
58 {
59         GHOST_TUns32 numEvents = 0;
60         TEventStack::iterator p;
61         for (p = m_events.begin(); p != m_events.end(); ++p) {
62                 if ((*p)->getType() == type) {
63                         numEvents++;
64                 }
65         }
66         return numEvents;
67 }
68
69
70 GHOST_TSuccess GHOST_EventManager::pushEvent(GHOST_IEvent *event)
71 {
72         GHOST_TSuccess success;
73         GHOST_ASSERT(event, "invalid event");
74         if (m_events.size() < m_events.max_size()) {
75                 m_events.push_front(event);
76                 success = GHOST_kSuccess;
77         }
78         else {
79                 success = GHOST_kFailure;
80         }
81         return success;
82 }
83
84
85 void GHOST_EventManager::dispatchEvent(GHOST_IEvent *event)
86 {
87         TConsumerVector::iterator iter;
88
89         for (iter = m_consumers.begin(); iter != m_consumers.end(); ++iter) {
90                 (*iter)->processEvent(event);
91         }
92 }
93
94
95 void GHOST_EventManager::dispatchEvent()
96 {
97         GHOST_IEvent *event = m_events.back();
98         m_events.pop_back();
99         m_handled_events.push_back(event);
100
101         dispatchEvent(event);
102 }
103
104
105 void GHOST_EventManager::dispatchEvents()
106 {
107         while (!m_events.empty()) {
108                 dispatchEvent();
109         }
110
111         disposeEvents();
112 }
113
114
115 GHOST_TSuccess GHOST_EventManager::addConsumer(GHOST_IEventConsumer *consumer)
116 {
117         GHOST_TSuccess success;
118         GHOST_ASSERT(consumer, "invalid consumer");
119
120         // Check to see whether the consumer is already in our list
121         TConsumerVector::const_iterator iter = std::find(m_consumers.begin(), m_consumers.end(), consumer);
122
123         if (iter == m_consumers.end()) {
124                 // Add the consumer
125                 m_consumers.push_back(consumer);
126                 success = GHOST_kSuccess;
127         }
128         else {
129                 success = GHOST_kFailure;
130         }
131         return success;
132 }
133
134
135 GHOST_TSuccess GHOST_EventManager::removeConsumer(GHOST_IEventConsumer *consumer)
136 {
137         GHOST_TSuccess success;
138         GHOST_ASSERT(consumer, "invalid consumer");
139
140         // Check to see whether the consumer is in our list
141         TConsumerVector::iterator iter = std::find(m_consumers.begin(), m_consumers.end(), consumer);
142
143         if (iter != m_consumers.end()) {
144                 // Remove the consumer
145                 m_consumers.erase(iter);
146                 success = GHOST_kSuccess;
147         }
148         else {
149                 success = GHOST_kFailure;
150         }
151         return success;
152 }
153
154
155 void GHOST_EventManager::removeWindowEvents(GHOST_IWindow *window)
156 {
157         TEventStack::iterator iter;
158         iter = m_events.begin();
159         while (iter != m_events.end()) {
160                 GHOST_IEvent *event = *iter;
161                 if (event->getWindow() == window) {
162                         GHOST_PRINT("GHOST_EventManager::removeWindowEvents(): removing event\n");
163                         /*
164                          * Found an event for this window, remove it.
165                          * The iterator will become invalid.
166                          */
167                         delete event;
168                         m_events.erase(iter);
169                         iter = m_events.begin();
170                 }
171                 else {
172                         ++iter;
173                 }
174         }
175 }
176
177 void GHOST_EventManager::removeTypeEvents(GHOST_TEventType type, GHOST_IWindow *window)
178 {
179         TEventStack::iterator iter;
180         iter = m_events.begin();
181         while (iter != m_events.end()) {
182                 GHOST_IEvent *event = *iter;
183                 if ((event->getType() == type) && (!window || (event->getWindow() == window))) {
184                         GHOST_PRINT("GHOST_EventManager::removeTypeEvents(): removing event\n");
185                         /*
186                          * Found an event of this type for the window, remove it.
187                          * The iterator will become invalid.
188                          */
189                         delete event;
190                         m_events.erase(iter);
191                         iter = m_events.begin();
192                 }
193                 else {
194                         ++iter;
195                 }
196         }
197 }
198
199
200 void GHOST_EventManager::disposeEvents()
201 {
202         while (m_handled_events.empty() == false) {
203                 GHOST_ASSERT(m_handled_events[0], "invalid event");
204                 delete m_handled_events[0];
205                 m_handled_events.pop_front();
206         }
207
208         while (m_events.empty() == false) {
209                 GHOST_ASSERT(m_events[0], "invalid event");
210                 delete m_events[0];
211                 m_events.pop_front();
212         }
213 }