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