← 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/controladorextensiones.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/controladorextensiones.cpp
 
1
/*
 
2
 *  
 
3
 *  $Id: controladorextensiones.cpp 3668 2011-04-11 10:02:11Z tovar $
 
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
#include <main/entorno.h>
 
15
#include <main/controllers/controladorextensiones.h>
 
16
#include "controladorlog.h"
 
17
#include <api/internacionalizacion.h>
 
18
#include <string>
 
19
#include <map>
 
20
#include <cctype>
 
21
#include <algorithm>
 
22
#include <exception>
 
23
#include <wx/dir.h>
 
24
#include <wx/file.h>
 
25
#include <wx/filename.h>
 
26
#include <wx/config.h>
 
27
#include <wx/dynlib.h>
 
28
#include <algorithm>
 
29
#include <set>
 
30
 
 
31
#if defined(__WXOSX__)
 
32
        #include <dlfcn.h>
 
33
        #define DLLEXT wxT("*.dylib")
 
34
#elif defined(__WXGTK__)
 
35
        #include <dlfcn.h>
 
36
        #define DLLEXT wxT("*.so")
 
37
#elif defined(_WINDOWS)
 
38
        #define DLLEXT wxT("*.dll")
 
39
#else
 
40
        #error Plataforma no soportada
 
41
#endif
 
42
 
 
43
GNC::GCS::IControladorExtensiones::IControladorExtensiones() {}
 
44
GNC::GCS::IControladorExtensiones::~IControladorExtensiones() {}
 
45
 
 
46
GNC::ControladorExtensiones* GNC::ControladorExtensiones::m_pInstance = 0;
 
47
 
 
48
GNC::ControladorExtensiones::ControladorExtensiones()
 
49
{
 
50
        m_Manager.Load();
 
51
        for (GADVAPI::PrivateExtensionManager::iterator it= m_Manager.begin(); it != m_Manager.end(); ++it)
 
52
        {
 
53
                RegistrarModulo((*it).second->InitializeLibrary(GNC::Entorno::Instance()));
 
54
        }
 
55
}
 
56
 
 
57
GNC::ControladorExtensiones::~ControladorExtensiones()
 
58
{
 
59
        DesRegistrarModulos();
 
60
        m_SIDModulos.clear();
 
61
}
 
62
 
 
63
GNC::ControladorExtensiones* GNC::ControladorExtensiones::Instance()
 
64
{
 
65
        if (m_pInstance == NULL) {
 
66
                m_pInstance = new GNC::ControladorExtensiones();
 
67
        }
 
68
        return m_pInstance;
 
69
}
 
70
 
 
71
void GNC::ControladorExtensiones::FreeInstance()
 
72
{
 
73
        if (m_pInstance != NULL) {
 
74
                delete m_pInstance;
 
75
        }
 
76
        m_pInstance = 0;
 
77
}
 
78
 
 
79
void GNC::ControladorExtensiones::RegistrarModulo(GNC::GCS::IControladorModulo* pCtrlModulo)
 
80
{
 
81
 
 
82
        if (pCtrlModulo == NULL) {
 
83
                return;
 
84
        }
 
85
 
 
86
        pCtrlModulo->RegistrarConfiguracion();
 
87
 
 
88
        const std::string uid = pCtrlModulo->GetUID();
 
89
        m_Modulos[uid] = pCtrlModulo;
 
90
        std::string sidModulo = pCtrlModulo->GetSID();
 
91
        std::transform(sidModulo.begin(), sidModulo.end(), sidModulo.begin(), (int(*)(int)) std::tolower);
 
92
        m_SIDModulos[sidModulo] = uid;
 
93
        NotificarRegistro(pCtrlModulo);
 
94
}
 
95
 
 
96
void GNC::ControladorExtensiones::DesRegistrarModulo(GNC::GCS::IControladorModulo* pCtrlModulo)
 
97
{
 
98
        if (pCtrlModulo == NULL) {
 
99
                return;
 
100
        }
 
101
 
 
102
        NotificarDesRegistro(pCtrlModulo);
 
103
 
 
104
        m_Modulos.erase(pCtrlModulo->GetUID());
 
105
        std::string sidModulo = pCtrlModulo->GetSID();
 
106
        std::transform(sidModulo.begin(), sidModulo.end(), sidModulo.begin(), (int(*)(int)) std::tolower);
 
107
        m_SIDModulos.erase(sidModulo);
 
108
        delete pCtrlModulo;
 
109
}
 
110
 
 
111
void GNC::ControladorExtensiones::DesRegistrarModulos()
 
112
{
 
113
        GNC::ControladorExtensiones::IteradorListaModulos it;
 
114
 
 
115
        for (it = m_Modulos.begin(); it != m_Modulos.end(); it++) {
 
116
                GNC::GCS::IControladorModulo* item = (*it).second;
 
117
                NotificarDesRegistro(item);
 
118
                delete item;
 
119
        }
 
120
        m_SIDModulos.clear();
 
121
        m_Modulos.clear();
 
122
}
 
123
 
 
124
GNC::GCS::IControladorModulo* GNC::ControladorExtensiones::ObtenerModulo(const std::string& idModulo)
 
125
{
 
126
        GNC::GCS::IControladorModulo* cm = NULL;
 
127
        IteradorListaModulos it = m_Modulos.find(idModulo);
 
128
        if (it != m_Modulos.end()) {
 
129
                cm = (*it).second;
 
130
        }
 
131
        return cm;
 
132
}
 
133
 
 
134
GNC::GCS::IControladorModulo* GNC::ControladorExtensiones::ObtenerModuloSID(const std::string& sidModulo)
 
135
{
 
136
        GNC::GCS::IControladorModulo* cm = NULL;
 
137
        IteradorListaSIDModulos it = m_SIDModulos.find(sidModulo);
 
138
        if (it != m_SIDModulos.end()) {
 
139
                cm = ObtenerModulo((*it).second);
 
140
        }
 
141
        return cm;
 
142
}
 
143
 
 
144
 
 
145
  
 
146
bool compareListaModulos(GNC::GCS::IControladorModulo* s1, GNC::GCS::IControladorModulo* s2)
 
147
{
 
148
        return s1->GetPriority()< s2->GetPriority();
 
149
}
 
150
 
 
151
std::list<GNC::GCS::IControladorModulo*> GNC::ControladorExtensiones::ModulosOrdenados()
 
152
{
 
153
        std::list<GNC::GCS::IControladorModulo*> listaModulosPriorizados;
 
154
        for(ListaModulos::iterator it = m_Modulos.begin(); it!= m_Modulos.end(); ++it)
 
155
        {
 
156
                listaModulosPriorizados.push_back((*it).second);
 
157
        }
 
158
 
 
159
        listaModulosPriorizados.sort(compareListaModulos);      
 
160
 
 
161
        return listaModulosPriorizados;
 
162
}
 
163
 
 
164
const GNC::ControladorExtensiones::ListaModulos& GNC::ControladorExtensiones::Modulos() const
 
165
{
 
166
        return m_Modulos;
 
167
}
 
168
 
 
169
const GNC::ControladorExtensiones::ListaSIDModulos& GNC::ControladorExtensiones::SIDModulos() const
 
170
{
 
171
        return m_SIDModulos;
 
172
}
 
173
 
 
174
// Realización de la interfaz IControladorExtensiones
 
175
GADVAPI::PrivateExtensionManager& GNC::ControladorExtensiones::GetPrivateExtensionsManager()
 
176
{
 
177
        return m_Manager;
 
178
}
 
179
 
 
180
void GNC::ControladorExtensiones::NotificarRegistro(GNC::GCS::IControladorModulo* pModulo)
 
181
{
 
182
        GNC::Entorno* pEntorno = GNC::Entorno::Instance();
 
183
        Entorno::ListaObservadoresExtensiones::const_iterator it;
 
184
        for (it = pEntorno->ObservadoresExtensiones.begin(); it != pEntorno->ObservadoresExtensiones.end(); it++) {
 
185
                GNC::GCS::IObservadorExtensiones* ne = *it;
 
186
                ne->OnModuloCargado(pModulo);
 
187
        }
 
188
}
 
189
 
 
190
void GNC::ControladorExtensiones::NotificarDesRegistro(GNC::GCS::IControladorModulo* pModulo)
 
191
{
 
192
        GNC::Entorno* pEntorno = GNC::Entorno::Instance();
 
193
        Entorno::ListaObservadoresExtensiones::const_iterator it;
 
194
        for (it = pEntorno->ObservadoresExtensiones.begin(); it != pEntorno->ObservadoresExtensiones.end(); it++) {
 
195
                GNC::GCS::IObservadorExtensiones* ne = *it;
 
196
                ne->OnModuloDescargado(pModulo);
 
197
        }
 
198
}
 
199
 
 
200
//-------------------------------------------------------------------------------------------
 
201
// Helpers
 
202
 
 
203
inline std::wstring StringToWString(const std::string& str) {
 
204
        std::wstring temp(str.length(),L' ');
 
205
        std::copy(str.begin(), str.end(), temp.begin());
 
206
        return temp;
 
207
}
 
208
 
 
209
//-------------------------------------------------------------------------------------------
 
210
// PrivateExtensionManager
 
211
 
 
212
GADVAPI::PrivateExtensionManager::PrivateExtensionManager() : GADVAPI::PrivateExtensionManager::Base()
 
213
{
 
214
        m_Loaded = false;
 
215
}
 
216
 
 
217
GADVAPI::PrivateExtensionManager::~PrivateExtensionManager()
 
218
{
 
219
        UnLoad();
 
220
}
 
221
 
 
222
PrivateExtension* GADVAPI::PrivateExtensionManager::GetExtension(std::string nombre)
 
223
{
 
224
        Base& base = *this;
 
225
        if (base.find(nombre) != base.end()) {
 
226
                return base[nombre];
 
227
        } else {
 
228
                return NULL;
 
229
        }
 
230
}
 
231
 
 
232
void GADVAPI::PrivateExtensionManager::Load()
 
233
{
 
234
        if (!m_Loaded) {
 
235
                
 
236
                wxDir dir;
 
237
                wxString rutas[1] = {
 
238
                        FROMPATH(GNC::Entorno::Instance()->GetPluginsPath())
 
239
                };
 
240
 
 
241
                wxString fileName;
 
242
                wxString filePath;
 
243
                for (int i = 0; i < 1; i++) {
 
244
                        if (dir.Exists(rutas[i]) && dir.Open(rutas[i])) {
 
245
                                bool cont = dir.GetFirst(&fileName, DLLEXT, wxDIR_FILES);
 
246
                                while (cont) {
 
247
                                        filePath = rutas[i] + wxFileName::GetPathSeparator() + fileName;
 
248
 
 
249
                                        //se busca el punto de entrada...
 
250
                                        wxDynamicLibrary* dll = new wxDynamicLibrary();
 
251
                                        //std::cout << "Trying to load: " << std::string(TOPATH(filePath)).c_str() << std::endl;
 
252
                                        if (dll->Load(filePath)) {
 
253
                                                //std::cout << "Library loaded" << std::endl;
 
254
                                        }
 
255
                                        else {
 
256
                                                //std::cout << "Fallo al cargar" << std::endl;
 
257
                                        }
 
258
                                        if(!dll->IsLoaded())
 
259
                                        {
 
260
                                                //std::cout << "Lib not loaded!" << std::endl;
 
261
                                                delete dll;
 
262
                                        }
 
263
                                        else {
 
264
#if defined(_DEBUG)
 
265
                                                //Create a valid function pointer using the function pointer type in plugin.h
 
266
                                                wxDYNLIB_FUNCTION(CreatePrivateExtension_function,CreatePrivateExtensionDebug,*dll);
 
267
                                                //check if the function is found
 
268
                                                if(pfnCreatePrivateExtensionDebug)
 
269
                                                {
 
270
                                                        PrivateExtension* pExtension = pfnCreatePrivateExtensionDebug();
 
271
#else
 
272
                                                //Create a valid function pointer using the function pointer type in plugin.h
 
273
                                                wxDYNLIB_FUNCTION(CreatePrivateExtension_function,CreatePrivateExtension,*dll);
 
274
                                                //check if the function is found
 
275
                                                if(pfnCreatePrivateExtension)
 
276
                                                {
 
277
                                                        PrivateExtension* pExtension = pfnCreatePrivateExtension();
 
278
#endif
 
279
                                                        if (Registrar(pExtension)) {
 
280
                                                                pExtension->AsignPath(std::string(TOPATH(filePath)));
 
281
                                                                m_instancias.push_back(dll);
 
282
                                                        } else {
 
283
                                                                delete dll;
 
284
                                                        }
 
285
                                                } else {
 
286
                                                        delete dll;
 
287
                                                }
 
288
                                        }
 
289
 
 
290
                                        cont = dir.GetNext(&fileName);
 
291
                                }
 
292
                        }
 
293
                }
 
294
 
 
295
                m_Loaded = true;
 
296
        }
 
297
}
 
298
 
 
299
void GADVAPI::PrivateExtensionManager::UnLoad()
 
300
{
 
301
        if (m_Loaded) {
 
302
                //delete private extensions
 
303
                for (Base::iterator it = Base::begin(); it != Base::end(); ++it) {
 
304
                        delete (*it).second;
 
305
                }
 
306
                //delete dlls
 
307
                for(ListaInstancias::iterator it = m_instancias.begin(); it != m_instancias.end(); it++)
 
308
                {
 
309
                        delete (*it);                   
 
310
                }
 
311
                m_instancias.clear();
 
312
                
 
313
                m_Loaded = false;
 
314
        }
 
315
}
 
316
 
 
317
void GADVAPI::PrivateExtensionManager::Reload()
 
318
{
 
319
        UnLoad();
 
320
        Load();
 
321
}
 
322
 
 
323
GADVAPI::PrivateExtensionManager::iterator GADVAPI::PrivateExtensionManager::begin() {
 
324
        return Base::begin();
 
325
}
 
326
 
 
327
GADVAPI::PrivateExtensionManager::iterator GADVAPI::PrivateExtensionManager::end() {
 
328
        return Base::end();
 
329
}
 
330
 
 
331
bool GADVAPI::PrivateExtensionManager::Registrar(PrivateExtension* ext)
 
332
{
 
333
        if (ext->GetCoreVersion() != GINKGO_VERSION || ext->GetCoreSubVersion() != GINKGO_SUB_VERSION) 
 
334
        {
 
335
                LOG_WARN("Extensions", _Std("Extension ") << ext->GetSID() << "(" << ext->GetPath() << ")"<< _Std(" is compatible with Ginkgo CADx ") << ext->GetCoreVersion() << "." << ext->GetCoreSubVersion());
 
336
                return false;
 
337
        }
 
338
        Base& base = *this;
 
339
        const std::string& sid = ext->GetSID();
 
340
        Base::iterator it = base.find(sid);
 
341
        if (it == base.end()) {
 
342
                base[sid] = ext;
 
343
                return true;
 
344
        } else {
 
345
                //error extension registrada dos veces
 
346
                return false;
 
347
        }
 
348
}