← Back to branch summary

~ubuntu-branches/ubuntu/wily/ginkgocadx/wily-proposed

« back to all changes in this revision

Viewing changes to src/cadxcore/main/controllers/controladoreventos.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Andreas Tille
  • Date: 2011-05-02 08:09:26 UTC
  • Revision ID: james.westby@ubuntu.com-20110502080926-bql5wep49c7hg91t
Tags: upstream-2.4.1.1
Import upstream version 2.4.1.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cadxcore/main/controllers/controladoreventos.cpp
 
1
/*
 
2
 *  
 
3
 *  $Id: controladoreventos.cpp 3526 2011-03-16 19:56:19Z carlos $
 
4
 *  Ginkgo CADx Project
 
5
 *
 
6
 *  Copyright 2008-10 MetaEmotion S.L. All rights reserved.
 
7
 *  http://ginkgo-cadx.com
 
8
 *
 
9
 *  This file is licensed under LGPL v3 license.
 
10
 *  See License.txt for details
 
11
 *
 
12
 *
 
13
 */
 
14
//#define _GINKGO_TRACE
 
15
#include <api/globals.h>
 
16
#include "controladoreventos.h"
 
17
#include "controladorlog.h"
 
18
#include "../entorno.h"
 
19
 
 
20
namespace GNC {
 
21
        namespace GCS {
 
22
 
 
23
                ControladorEventos * ControladorEventos::m_psInstancia = NULL;
 
24
 
 
25
                ControladorEventos::ControladorEventos()
 
26
                {
 
27
                        GTRACE("ControladorEventos::ControladorEventos()");
 
28
                }
 
29
 
 
30
                ControladorEventos::~ControladorEventos()
 
31
                {
 
32
                        //se vacia el mapa de vistas
 
33
                        for(TipoMapaVistas::iterator itVistas = m_mapaVistas.begin(); itVistas != m_mapaVistas.end(); ++itVistas){
 
34
                                for(TipoMapaAmbito::iterator itAmbito =  (*itVistas).second.begin(); itAmbito != (*itVistas).second.end(); ++ itAmbito){
 
35
                                        for(TipoMapaCodigos::iterator itCodigos = (*itAmbito).second.begin(); itCodigos != (*itAmbito).second.end(); ++itCodigos){
 
36
                                                for(TipoListaObservadores::iterator itObservadores = (*itCodigos).second.begin(); itObservadores != (*itCodigos).second.end(); ++itObservadores){
 
37
                                                        (*itObservadores) = NULL;
 
38
                                                }
 
39
                                                (*itCodigos).second.clear();
 
40
                                        }
 
41
                                        (*itAmbito).second.clear();
 
42
                                }
 
43
                                (*itVistas).second.clear();
 
44
                        }
 
45
                        m_mapaVistas.clear();
 
46
 
 
47
                        //se vacia el mapa de eventos
 
48
                        for(TipoMapaEventos::iterator it = m_mapaEventos.begin(); it!= m_mapaEventos.end(); ++it){
 
49
                                (*it).second.clear();
 
50
                        }
 
51
                        m_mapaEventos.clear();
 
52
                }
 
53
 
 
54
 
 
55
                //se apunta a escuchar un evento
 
56
                void ControladorEventos::Registrar ( IObservador* pObservador, const GNC::GCS::Eventos::IEvento& evento)
 
57
                {
 
58
                        wxCriticalSectionLocker pLocker(m_eventosCriticalSection);
 
59
 
 
60
                        //se mete en el mapa observadores->eventos
 
61
                        {
 
62
                                TipoMapaEventos::iterator itEventos = m_mapaEventos.find(pObservador);
 
63
                                if(itEventos == m_mapaEventos.end()){
 
64
                                        TipoListaEventos lista;
 
65
                                        m_mapaEventos[pObservador] = lista;
 
66
                                        itEventos = m_mapaEventos.find(pObservador);
 
67
                                }
 
68
                                //se busca si ya esta el evento
 
69
                                for (TipoListaEventos::iterator it = (*itEventos).second.begin(); it != (*itEventos).second.end(); it++){
 
70
                                        if((*it).IsEqual(evento)){
 
71
                                                LOG_WARN("ControladorEventos", "Se está intentando registrar dos veces al mismo evento");
 
72
                                                return;
 
73
                                        }
 
74
                                }
 
75
                                (*itEventos).second.push_back(evento);
 
76
                        }
 
77
 
 
78
                        //se mete en el mapa vistas->eventos
 
79
                        {
 
80
                                TipoMapaVistas::iterator itVistas;
 
81
                                TipoMapaAmbito::iterator itAmbito;
 
82
                                TipoMapaCodigos::iterator itCodigos;
 
83
 
 
84
                                //se busca la entrada en el mapa de vistas
 
85
                                itVistas= m_mapaVistas.find(evento.GetVista());
 
86
                                if(itVistas == m_mapaVistas.end()){
 
87
                                        TipoMapaAmbito mapa;
 
88
                                        m_mapaVistas[evento.GetVista()] = mapa;
 
89
                                        itVistas = m_mapaVistas.find(evento.GetVista());
 
90
                                }
 
91
                                //se busca la entrada en el mapa de ambitos
 
92
                                itAmbito = (*itVistas).second.find(evento.GetCodigoAmbito());
 
93
                                if(itAmbito == (*itVistas).second.end()){
 
94
                                        TipoMapaCodigos mapa;
 
95
                                        (*itVistas).second[evento.GetCodigoAmbito()] = mapa;
 
96
                                        itAmbito = (*itVistas).second.find(evento.GetCodigoAmbito());
 
97
                                }
 
98
 
 
99
                                itCodigos = (*itAmbito).second.find(evento.GetCodigoEvento());
 
100
                                if(itCodigos == (*itAmbito).second.end()){
 
101
                                        TipoListaObservadores lista;
 
102
                                        (*itAmbito).second[evento.GetCodigoEvento()] = lista;
 
103
                                        itCodigos = (*itAmbito).second.find(evento.GetCodigoEvento());
 
104
                                }
 
105
 
 
106
                                (*itCodigos).second.push_back(pObservador);
 
107
                        }
 
108
 
 
109
                        pObservador->OnRegistrar(this);
 
110
                }
 
111
 
 
112
                //se desapunta de escuchar un evento
 
113
                void ControladorEventos::DesRegistrar (IObservador* pObservador, const GNC::GCS::Eventos::IEvento& evento)
 
114
                {
 
115
                        wxCriticalSectionLocker* pLocker = new wxCriticalSectionLocker(m_eventosCriticalSection);
 
116
 
 
117
                        TipoMapaVistas::iterator itVistas;
 
118
                        TipoMapaAmbito::iterator itAmbito;
 
119
                        TipoMapaCodigos::iterator itCodigos;
 
120
 
 
121
                        //se busca la entrada en el mapa de vistas
 
122
                        itVistas= m_mapaVistas.find(evento.GetVista());
 
123
                        if(itVistas != m_mapaVistas.end()){
 
124
                                //se busca la entrada en el mapa de ambitos
 
125
                                itAmbito = (*itVistas).second.find(evento.GetCodigoAmbito());
 
126
                                if(itAmbito != (*itVistas).second.end()){
 
127
                                        //se busca en el mapa de codigos
 
128
                                        itCodigos = (*itAmbito).second.find(evento.GetCodigoEvento());
 
129
                                        if(itCodigos != (*itAmbito).second.end()){
 
130
                                                (*itCodigos).second.remove(pObservador);
 
131
                                                //se purgan los mapas
 
132
                                                if((*itCodigos).second.size() == 0){
 
133
                                                        (*itAmbito).second.erase(itCodigos);
 
134
                                                        if((*itAmbito).second.size() == 0){
 
135
                                                                (*itVistas).second.erase(itAmbito);
 
136
                                                                if((*itVistas).second.size() == 0){
 
137
                                                                        m_mapaVistas.erase(itVistas);
 
138
                                                                }
 
139
                                                        }
 
140
                                                }
 
141
                                        }
 
142
 
 
143
                                }
 
144
                        }
 
145
 
 
146
                        //se elimina del mapa de eventos
 
147
                        TipoMapaEventos::iterator itEventos = m_mapaEventos.find(pObservador);
 
148
                        if(itEventos != m_mapaEventos.end()){
 
149
                                for(TipoListaEventos::iterator it = (*itEventos).second.begin(); it!= (*itEventos).second.end(); it++){
 
150
                                        if((*it).IsEqual(evento)){
 
151
                                                (*itEventos).second.erase(it);
 
152
                                                break;
 
153
                                        }
 
154
                                }
 
155
                                itEventos = m_mapaEventos.find(pObservador);
 
156
                                if((*itEventos).second.size() == 0){
 
157
                                        m_mapaEventos.erase(itEventos);
 
158
                                }
 
159
                        }
 
160
 
 
161
                        delete pLocker;
 
162
                }
 
163
 
 
164
                //se desapunta de todos los eventos a los que escucha
 
165
                void ControladorEventos::DesRegistrar (IObservador* pObservador)
 
166
                {
 
167
                        for(TipoMapaEventos::iterator itEventos = m_mapaEventos.find(pObservador); itEventos != m_mapaEventos.end(); itEventos = m_mapaEventos.find(pObservador)){
 
168
                                //desregistramos el primer evento de la lista
 
169
                                if((*itEventos).second.size() > 0){
 
170
                                        DesRegistrar(pObservador,(*itEventos).second.front());
 
171
                                }else {
 
172
                                        m_mapaEventos.erase(itEventos);
 
173
                                        break;
 
174
                                }
 
175
                        }
 
176
                }
 
177
 
 
178
                //procesado sincrono con la interfaz
 
179
                void ControladorEventos::ProcesarEvento(GNC::GCS::Eventos::IEvento *pEvt)
 
180
                {
 
181
                        wxCriticalSectionLocker* pLocker = new wxCriticalSectionLocker(m_eventosCriticalSection);
 
182
                        //Se buscan los notificadores
 
183
                        TipoListaObservadores listaObservadores;
 
184
                        TipoMapaVistas::iterator itVistas;
 
185
                        TipoMapaAmbito::iterator itAmbito;
 
186
                        TipoMapaCodigos::iterator itCodigos;
 
187
 
 
188
                        itVistas= m_mapaVistas.find(pEvt->GetVista());
 
189
                        if(itVistas != m_mapaVistas.end()){
 
190
                                //se busca la entrada en el mapa de ambitos
 
191
                                itAmbito = (*itVistas).second.find(pEvt->GetCodigoAmbito());
 
192
                                if(itAmbito != (*itVistas).second.end()){
 
193
                                        //se busca en el mapa de codigos
 
194
                                        itCodigos = (*itAmbito).second.find(pEvt->GetCodigoEvento());
 
195
                                        if(itCodigos != (*itAmbito).second.end()){
 
196
                                                listaObservadores = (*itCodigos).second;
 
197
                                        }
 
198
                                }
 
199
                        }
 
200
                        delete pLocker;
 
201
 
 
202
                        NotificarEvento(pEvt,listaObservadores);
 
203
                }
 
204
 
 
205
                //inyecta en la cola correspondiente el evento en cuestion
 
206
                void ControladorEventos::NotificarEvento(GNC::GCS::Eventos::IEvento *pEvt, TipoListaObservadores & listaObservadores)
 
207
                {
 
208
                        #ifdef _GINKGO_TRACE
 
209
                        std::cout << "<< Evento: " << pEvt << std::endl;
 
210
                        #endif
 
211
                        TipoListaPunterosEventos lista;
 
212
                        lista.push_back(pEvt);
 
213
                        for(TipoListaObservadores::iterator it = listaObservadores.begin(); it != listaObservadores.end(); ++it){
 
214
                                if((*it) != NULL){
 
215
                                        if(!(*it)->FiltrarEvento(pEvt)){
 
216
                                                        (*it)->PreProcesarEvento(pEvt,lista);
 
217
                                        }
 
218
                                }
 
219
                        }
 
220
                        #ifdef _GINKGO_TRACE
 
221
                        int i1 = 0;
 
222
                        for (TipoListaPunterosEventos::iterator it = lista.begin(); it != lista.end(); it++) {
 
223
                                std::cout << "Lista de eventos generada:" << std::endl;
 
224
                                std::cout << " " << i1++ << " Evento: " << *it << std::endl;
 
225
                        }
 
226
                        #endif
 
227
 
 
228
                        // Etapa de compactacion de eventos repetidos
 
229
 
 
230
                        TipoListaPunterosEventos duplicados;
 
231
                        unsigned int i = lista.size();
 
232
 
 
233
                        for(TipoListaPunterosEventos::reverse_iterator itCur = lista.rbegin(); itCur != lista.rend(); itCur++, i--){
 
234
                                GNC::GCS::Eventos::IEvento *pCur = *itCur;
 
235
                                unsigned int j = 1;
 
236
                                for (TipoListaPunterosEventos::iterator itPrev = lista.begin(); i != j; itPrev++, j++)
 
237
                                {
 
238
                                        GNC::GCS::Eventos::IEvento *pPrev = *itPrev;
 
239
                                        if (pPrev->IsEqual(*pCur)) {
 
240
                                                pPrev->Skip(true);
 
241
                                        }
 
242
                                }
 
243
                        }
 
244
 
 
245
                        for(TipoListaPunterosEventos::iterator itEventos = lista.begin(); itEventos!= lista.end(); itEventos++){
 
246
                                GNC::GCS::Eventos::IEvento* pE = (*itEventos);
 
247
                                for(TipoListaObservadores::iterator itObservadores = listaObservadores.begin(); pE->IsSkipped() && itObservadores != listaObservadores.end(); itObservadores++) {
 
248
                                        IObservador* pO = (*itObservadores);
 
249
                                        if( pO != NULL){
 
250
                                                if(!pO->FiltrarEvento(pE)) {
 
251
                                                        pO->ProcesarEvento(pE);
 
252
                                                }
 
253
                                        }
 
254
 
 
255
                                }
 
256
                        }
 
257
 
 
258
                        for(TipoListaPunterosEventos::iterator itEventos = lista.begin(); itEventos!= lista.end(); itEventos++){
 
259
                                delete *itEventos;
 
260
                        }
 
261
 
 
262
                        #ifdef _GINKGO_TRACE
 
263
                        std::cout << " --- " << std::endl;
 
264
                        #endif
 
265
                }
 
266
 
 
267
                ControladorEventos * ControladorEventos::Instance()
 
268
                {
 
269
                        if (m_psInstancia == NULL) {
 
270
                                m_psInstancia = new ControladorEventos();
 
271
                        }
 
272
                        return m_psInstancia;
 
273
                }
 
274
 
 
275
                void ControladorEventos::FreeInstance()
 
276
                {
 
277
                        if (m_psInstancia != NULL) {
 
278
                                delete m_psInstancia;
 
279
                                m_psInstancia = NULL;
 
280
                        }
 
281
                }
 
282
        }
 
283
}