← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/visualizator/visualizator/controllers/visualizatorcontroller.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/visualizator/visualizator/controllers/visualizatorcontroller.cpp
 
1
/*
 
2
 *
 
3
 *  $Id: visualizatorcontroller.cpp 3685 2011-04-13 06:16:18Z 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 <wx/wx.h>
 
15
#include <wx/notebook.h>
 
16
#include <wx/dir.h>
 
17
#include <wx/file.h>
 
18
#include <wx/config.h>
 
19
#include <set>
 
20
#include "visualizatorcontroller.h"
 
21
 
 
22
#include "../herramientas/herramientamapacolor.h"
 
23
#include "../herramientas/herramientaoverlays.h"
 
24
#include "../herramientas/reconstructiontool.h"
 
25
 
 
26
#include "../../recursos/plantillas/plantillasaprimresourcemanager.h"
 
27
 
 
28
#include "../dialogos/contenedorherramientas.h"
 
29
#include "../dialogos/importacion/pasodatosgenerales.h"
 
30
#include "../dialogos/importacion/datospersistentesimportacion.h"
 
31
#include "../dialogos/seleccionardiagnostico/seleccionardiagnostico.h"
 
32
#include "../vistas/vista2d.h"
 
33
#include "../vistas/waveformview.h"
 
34
#include <visualizator/estudios/visualizatorstudy.h>
 
35
#include <visualizator/license.h>
 
36
 
 
37
#include <api/ientorno.h>
 
38
#include <api/ivista.h>
 
39
#include <api/imodelodicom.h>
 
40
#include <api/icontroladorcarga.h>
 
41
#include <api/icontroladorhistorial.h>
 
42
 
 
43
#include <api/icontroladorpermisos.h>
 
44
 
 
45
#include <api/icontroladorherramientas.h>
 
46
 
 
47
#include <api/icontroladorimportacionpacs.h>
 
48
#include <api/icontroladorvistas.h>
 
49
 
 
50
#include <api/icontroladorcarga.h>
 
51
#include <main/controllers/controladorcarga.h>
 
52
 
 
53
#include <vector>
 
54
#include <string>
 
55
#include <sstream>
 
56
#include <iostream>
 
57
#include <api/internacionalizacion.h>
 
58
#include <api/icontroladorinternacionalizacion.h>
 
59
#include "../../recursos/aprimresourcemanager.h"
 
60
#include "../exportacion/tagsprivados.h"
 
61
 
 
62
 
 
63
/* Constructor */
 
64
GNKVisualizator::ControladorAtencionPrimaria::ControladorAtencionPrimaria(GNC::GCS::IEntorno* pEntorno) : GNC::GCS::IControladorModulo(pEntorno, UID_APRIM,0, "atencionprimaria")
 
65
{
 
66
        //primero de todo registramos nuestro catalogo para la internacionalizacion de las cadenas
 
67
        {
 
68
                pEntorno->GetControladorInternacionalizacion()->AddCatalog("visualizator");
 
69
        }
 
70
 
 
71
        //registramos los permisos
 
72
        m_pEntorno->GetControladorPermisos()->AddDefinicionPermiso("atencionprimaria",_Std("Ginkgo CADx viewer"), "dicomizador",_Std("Simple importation of images"),false, "", true);
 
73
        m_pEntorno->GetControladorPermisos()->AddDefinicionPermiso("atencionprimaria",_Std("Ginkgo CADx viewer"),"plantillas",_Std("Basic templates"), false, "", true);
 
74
        m_pEntorno->GetControladorPermisos()->AddDefinicionPermiso("atencionprimaria",_Std("Ginkgo CADx viewer"),"vista2d",_Std("Medical viewer"), false, "", true);
 
75
        m_pEntorno->GetControladorPermisos()->AddDefinicionPermiso("atencionprimaria",_Std("Ginkgo CADx viewer"),"waveform",_Std("Waveform viewer"), false, "", true);
 
76
        m_pEntorno->GetControladorPermisos()->AddDefinicionPermiso("atencionprimaria",_Std("Ginkgo CADx viewer"),"reconstruction",_Std("3D Reconstruction"), false, "", true);
 
77
 
 
78
        m_pEntorno->GetControladorPermisos()->AddDefinicionPermiso("atencionprimaria.reconstruction",_Std("3D Reconstruction"),"orthogonalmpr3d",_Std("3D Orthogonal Multi-Planar Reconstruction (MPR)"), false, "", false);
 
79
        m_pEntorno->GetControladorPermisos()->AddDefinicionPermiso("atencionprimaria.reconstruction",_Std("3D Reconstruction"),"mip3d",_Std("3D Maximun Intensity Projection (MIP)"), false, "", false);
 
80
        m_pEntorno->GetControladorPermisos()->AddDefinicionPermiso("atencionprimaria.reconstruction",_Std("3D Reconstruction"),"volumerengering3d",_Std("3D Volume Rendering"), false, "", true);
 
81
        m_pEntorno->GetControladorPermisos()->AddDefinicionPermiso("atencionprimaria.reconstruction",_Std("3D Reconstruction"),"surfacerendering3d",_Std("3D Surface Rendering"), false, "", true);
 
82
        m_pEntorno->GetControladorPermisos()->AddDefinicionPermiso("atencionprimaria.reconstruction",_Std("3D Reconstruction"),"endoscopy3d",_Std("3D Endoscopy"), false, "", false);
 
83
 
 
84
        m_pEntorno->GetControladorPermisos()->AddDefinicionPermiso("atencionprimaria.vista2d",_Std("Medical viewer"),"guardar cambios",_Std("Save changes with Medical viewer"), true, "", true);
 
85
 
 
86
 
 
87
        m_pEntorno = pEntorno;
 
88
        m_Nombre = VISUALIZATOR_DESCRIPTION;
 
89
        m_CopyRight = "(c) 2009 MetaEmotion S.L.";
 
90
        m_Author = "MetaEmotion S.L.";
 
91
        m_VersionMayor   = VISUALIZATOR_VERSION;
 
92
        m_VersionMinor   = VISUALIZATOR_SUB_VERSION;
 
93
        m_VersionRelease = VISUALIZATOR_SUB_RELEASE;
 
94
        m_CodeName       = VISUALIZATOR_CODENAME;
 
95
        std::ostringstream oversion;
 
96
        oversion << VISUALIZATOR_VERSION << "."<< VISUALIZATOR_SUB_VERSION << "." << VISUALIZATOR_SUB_RELEASE;
 
97
        m_Version = oversion.str();
 
98
 
 
99
        // Codigos LOINC de los informes de A. Primaria.
 
100
        m_ListaInformes.push_back(GNC::GCS::IdHL7("TUID" + m_SID, "0", _Std("Ginkgo CADx visualizator Report"), "LN", "", "","v1.0"));
 
101
 
 
102
 
 
103
        // Codigos LOINC de los Estudios que genera A. Primaria
 
104
        m_ListaEstudios["EstudioOriginal"]= GNC::GCS::IdHL7("EstudioOriginal", "121018", "Study Instance UID", "DCM", "HD", "","v1.0");
 
105
        
 
106
        // Codigos LOINC de los registros HL7 que genera A. Primaria
 
107
        m_ListaRegistros["SerieOriginal"] = GNC::GCS::IdHL7("SerieOriginal", "112002", "Series Instance UID", "DCM", "HD", "","v1.0");
 
108
        m_ListaRegistros["IDPacs"] = GNC::GCS::IdHL7("IDPacs", "ARCHIVE", "IDPACS", "DCM", "HD", "","v1.0");
 
109
        m_ListaRegistros["Imagen"] = GNC::GCS::IdHL7("Imagen", "121126", "SOP Instance UID", "DCM", "HD", "","v1.0");
 
110
        m_ListaRegistros["SOPClass"] = GNC::GCS::IdHL7("SOPClass", "121127", "SOP Class ID", "DCM", "HD", "","v1.0");
 
111
 
 
112
        m_pPanelContenedorCustom = NULL;
 
113
 
 
114
        //registrar herramientas
 
115
        GNC::GCS::IControladorHerramientas* cH = m_pEntorno->GetControladorHerramientas();
 
116
        cH->RegistrarHerramienta(new GNKVisualizator::HerramientaMapaColor());
 
117
        cH->RegistrarHerramienta(new GNKVisualizator::HerramientaOverlays());
 
118
        cH->RegistrarHerramienta(new GNKVisualizator::ReconstructionTool(m_pEntorno->GetControladorPermisos()));
 
119
 
 
120
}
 
121
 
 
122
GNKVisualizator::ControladorAtencionPrimaria::~ControladorAtencionPrimaria()
 
123
{
 
124
        //desregistrar herramienta
 
125
        GNKVisualizator::IHerramientaMapaColor* hMapa;
 
126
        GNKVisualizator::IHerramientaOverlays*  hOverlays;
 
127
        GNKVisualizator::IReconstructionTool*   hReconstruction;
 
128
        GNC::GCS::IControladorHerramientas* cH = m_pEntorno->GetControladorHerramientas();
 
129
        try {
 
130
                hMapa = cH->ObtenerHerramientaConcreta<GNKVisualizator::IHerramientaMapaColor>(GNKVisualizator::IHerramientaMapaColor::ID);
 
131
                if (hMapa != NULL) {
 
132
                        cH->DesRegistrarHerramienta(hMapa);
 
133
                        delete hMapa;
 
134
                }
 
135
                hOverlays = cH->ObtenerHerramientaConcreta<GNKVisualizator::IHerramientaOverlays>(GNKVisualizator::IHerramientaOverlays::ID);
 
136
                if (hOverlays != NULL) {
 
137
                        cH->DesRegistrarHerramienta(hOverlays);
 
138
                        delete hOverlays;
 
139
                }
 
140
                hReconstruction = cH->ObtenerHerramientaConcreta<GNKVisualizator::IReconstructionTool>(GNKVisualizator::IReconstructionTool::ID);
 
141
                if (hReconstruction != NULL) {
 
142
                        cH->DesRegistrarHerramienta(hReconstruction);
 
143
                        delete hReconstruction;
 
144
                }
 
145
        }
 
146
        catch (GNC::GCS::ControladorHerramientasException& ex) {
 
147
                std::cerr << "Error al registrar herramientas de Oftal: No se pudo subscribir la herramienta: " << ex.getCause() << std::endl;
 
148
        }
 
149
 
 
150
 
 
151
        unsigned int i;
 
152
        for (i = 0; i < m_ListaModos.size(); ++i) {
 
153
                delete m_ListaModos[i];
 
154
        }
 
155
        m_ListaModos.clear();
 
156
 
 
157
        EliminarPaneles();
 
158
        if (m_pPanelContenedorCustom != NULL) {
 
159
                delete m_pPanelContenedorCustom;
 
160
                m_pPanelContenedorCustom = NULL;
 
161
        }
 
162
        #if defined(_GINKGO_DEBUG) && defined(_WINDOWS)
 
163
        //cairo_debug_reset_static_data();
 
164
        //_CrtDumpMemoryLeaks();
 
165
        #endif
 
166
}
 
167
 
 
168
void GNKVisualizator::ControladorAtencionPrimaria::RegistrarVistas()
 
169
{
 
170
        GNC::GCS::ModoControlador::TipoListaModalidades listaModalidades;
 
171
        //TODO meter las modalidades que soporta...
 
172
        listaModalidades.push_back(std::string("MR")); //resonancia
 
173
        listaModalidades.push_back(std::string("CR")); //computed radiography
 
174
        listaModalidades.push_back(std::string("US")); //ultrasonido
 
175
        listaModalidades.push_back(std::string("BI")); //biomagnetic image
 
176
        listaModalidades.push_back(std::string("CT")); //computed tomography
 
177
        listaModalidades.push_back(std::string("XA")); //XRAY angiografia
 
178
        listaModalidades.push_back(std::string("SC")); //secondary capture
 
179
        listaModalidades.push_back(std::string("NM")); //nuclear medicine
 
180
        listaModalidades.push_back(std::string("CD")); //Color flow doppler
 
181
        listaModalidades.push_back(std::string("DD")); //Duplex Doppler
 
182
        listaModalidades.push_back(std::string("DG")); //Diaphanography
 
183
        listaModalidades.push_back(std::string("ES")); //Endoscopy
 
184
        listaModalidades.push_back(std::string("LS")); //Laser surface scan
 
185
        listaModalidades.push_back(std::string("PT")); //Positron emission tomography (PET)
 
186
        listaModalidades.push_back(std::string("RG")); //Radiographic imaging
 
187
        listaModalidades.push_back(std::string("ST")); //Single-photon emission computed tomography (SPECT)
 
188
        listaModalidades.push_back(std::string("MG")); //Mammography
 
189
        listaModalidades.push_back(std::string("IO")); //Intra-Oral
 
190
        listaModalidades.push_back(std::string("TG")); //Thermography
 
191
        listaModalidades.push_back(std::string("RF")); //Radio Fluoroscopy
 
192
        listaModalidades.push_back(std::string("RTIMAGE")); //Radiotherapy Image
 
193
        listaModalidades.push_back(std::string("RTDOSE")); //Radiotherapy Dose
 
194
        listaModalidades.push_back(std::string("RTSTRUCT")); //Radiotherapy Structure Set
 
195
        listaModalidades.push_back(std::string("RTPLAN")); //Radiotherapy Plan
 
196
        listaModalidades.push_back(std::string("RTRECORD")); //RT Treatment Record
 
197
        listaModalidades.push_back(std::string("HC")); //Hard Copy
 
198
        listaModalidades.push_back(std::string("DX")); //Digital Radiography
 
199
        listaModalidades.push_back(std::string("PX")); //Panoramic X-Ray
 
200
        listaModalidades.push_back(std::string("GM")); //General Microscopy
 
201
        listaModalidades.push_back(std::string("SM")); //Slide Microscopy
 
202
        listaModalidades.push_back(std::string("XC")); //External-camera Photography
 
203
        listaModalidades.push_back(std::string("PR")); //Presentation State
 
204
        //listaModalidades.push_back(std::string("SR")); //SR Document
 
205
        listaModalidades.push_back(std::string("IVUS")); //Intravascular Ultrasound
 
206
        listaModalidades.push_back(std::string("OP")); //Stereometric Relationship
 
207
        listaModalidades.push_back(std::string("OT")); //Other
 
208
        listaModalidades.push_back(std::string("SMR")); //Intra-oral Radiography
 
209
        listaModalidades.push_back(std::string("OCT")); //Optical Coherence Tomography
 
210
        listaModalidades.push_back(std::string("OT"));  //Other
 
211
        listaModalidades.push_back(std::string("OPR")); //Ophthalmic Refraction
 
212
        listaModalidades.push_back(std::string("OPV")); //Ophthalmic Visual Field
 
213
        listaModalidades.push_back(std::string("OPM")); //Ophthalmic Mapping
 
214
        listaModalidades.push_back(std::string("KO"));  //Key Object Selection
 
215
        listaModalidades.push_back(std::string("SEG")); //Segmentation
 
216
        listaModalidades.push_back(std::string("REG")); //Registration
 
217
        listaModalidades.push_back(std::string("OPT")); //Ophthalmic Tomography
 
218
        listaModalidades.push_back(std::string("BDUS"));//Bone Densitometry (ultrasound)
 
219
        listaModalidades.push_back(std::string("BMD")); //Bone Densitometry (X-Ray)
 
220
 
 
221
        if(m_pEntorno->GetControladorPermisos()->Get("atencionprimaria", "vista2d")) {
 
222
                m_ListaModos.push_back(new GNC::GCS::ModoControlador(0, _Std("Medical Image Viewer"), listaModalidades, true));
 
223
        }
 
224
 
 
225
        listaModalidades.clear();
 
226
        listaModalidades.push_back(std::string("ECG")); //Electrocardiography
 
227
        listaModalidades.push_back(std::string("HD")); //Hemodynamic Waveform
 
228
        if(m_pEntorno->GetControladorPermisos()->Get("atencionprimaria", "waveform")) {
 
229
                m_ListaModos.push_back(new GNC::GCS::ModoControlador(1, _Std("Waveform viewer"), listaModalidades, true));
 
230
        }
 
231
}
 
232
 
 
233
/* Abre un estudio de manera no interactiva desde un directorio y devuelve su controlador específico */
 
234
GNC::GCS::IVista* GNKVisualizator::ControladorAtencionPrimaria::AbrirVista(int modo, ListaDescriptoresSerie& series, const std::string& uidEstudioDiagnostico)
 
235
{
 
236
        GNC::GCS::IVista* pVista = NULL;
 
237
 
 
238
        // TODO: El workflow de la vista PASI es el OPTIMO AHORA.
 
239
        if (modo < 0 || modo >= (int) m_ListaModos.size()) {
 
240
                //TODO: Excepción
 
241
                return NULL;
 
242
        }
 
243
 
 
244
        //si no se soporta alguna modalidad pues se ignora
 
245
        std::set<std::string> uidsSeries;
 
246
        GnkPtr<GIL::IModeloIntegracion> pModeloIntegracion;
 
247
        {
 
248
                for(ListaDescriptoresSerie::iterator it = series.begin(); it!= series.end(); it++){
 
249
                        if(m_ListaModos[modo]->SupportsModalityFile((*it).m_modalidad, (*it).m_uidTransferSyntax))
 
250
                        {
 
251
                                uidsSeries.insert((*it).m_uidSerie);
 
252
                        }
 
253
                }
 
254
        }
 
255
        //
 
256
 
 
257
        /*ESTO SIRVE PARA NO SEPARAR POR SERIES...
 
258
        std::list<std::string> listaUIDSerie;
 
259
        std::vector<std::string> rutas;
 
260
        GnkPtr<GIL::IModeloIntegracion> pModeloIntegracion = NULL;
 
261
        for(ListaDescriptoresSerie::iterator it = series.begin(); it!=series.end(); it++){
 
262
                listaUIDSerie.push_back((*it).m_uidSerie);
 
263
                if(!m_ListaModos[modo]->SoportaModalidad((*it).m_modalidad)){
 
264
                        //mensaje de error!!
 
265
                        wxMessageBox(_("Derma view does not support modality studies") + wxString::FromUTF8((*it).m_modalidad.c_str()), _("Error"), wxICON_ERROR);
 
266
                        return NULL;
 
267
                }
 
268
                if((*it).m_pModeloIntegracion.IsValid()) {
 
269
                        pModeloIntegracion = (*it).m_pModeloIntegracion;
 
270
                }
 
271
                std::vector<std::string> rutasSerie = m_pEntorno->GetControladorHistorial()->GetPathsSerieOrdenados((*it).m_uidSerie);
 
272
                for (std::vector<std::string>::iterator it = rutasSerie.begin(); it != rutasSerie.end(); ++it) {
 
273
                        rutas.push_back((*it));
 
274
                }
 
275
        }
 
276
        {
 
277
        */
 
278
 
 
279
        for(std::set<std::string>::iterator it = uidsSeries.begin(); it!= uidsSeries.end(); it++)
 
280
        {
 
281
                std::vector<std::string> rutas = m_pEntorno->GetControladorHistorial()->GetPathsSerieOrdenados((*it));
 
282
 
 
283
                GNC::GCS::IControladorVistas* pCtrlVistas = m_pEntorno->GetControladorVistas();
 
284
                wxWindow* pVentanaPadre = NULL;
 
285
 
 
286
                if (rutas.size() == 0)
 
287
                {
 
288
                        return NULL;
 
289
                }
 
290
 
 
291
                //primero de todo seleccionar diagnostico
 
292
                std::string uidDiagnosticoSeleccionado = uidEstudioDiagnostico;
 
293
                if(!SeleccionarDiagnostico(rutas[0],uidDiagnosticoSeleccionado))
 
294
                {
 
295
                        //no quiere continuar, se cancela la carga
 
296
                        return NULL;
 
297
                }
 
298
 
 
299
                {//comienza la deshabilitacion
 
300
                        pVentanaPadre = pCtrlVistas->GetRootWindow();
 
301
                        pCtrlVistas->Freeze();
 
302
                        try{
 
303
                                if (modo == m_ListaModos[0]->GetId()) {
 
304
                                        wxWindowDisabler disabler;
 
305
                                        InsertarPaneles();
 
306
                                        GnkPtr<GNKVisualizator::VisualizatorStudy> estudio = new GNKVisualizator::VisualizatorStudy();
 
307
                                        estudio->ListaUIDsSerie.push_back((*it));
 
308
                                        estudio->Entorno = m_pEntorno;
 
309
                                        estudio->Modulo = this;
 
310
                                        estudio->VentanaPadre = pVentanaPadre;
 
311
                                        estudio->InicializarContextoEstudio(rutas, uidDiagnosticoSeleccionado, GNC::GCS::IContextoEstudio::TMF_UNDiagnostico);
 
312
                                        pVista = new GNKVisualizator::Vista2D(estudio);
 
313
                                        pCtrlVistas->Registrar(pVista);
 
314
                                } else if (modo == m_ListaModos[1]->GetId()) {
 
315
                                        wxWindowDisabler disabler;
 
316
                                        InsertarPaneles();
 
317
                                        GnkPtr<GNKVisualizator::ECGStudy> estudio = new GNKVisualizator::ECGStudy();
 
318
                                        estudio->ListaUIDsSerie.push_back((*it));
 
319
                                        estudio->Entorno = m_pEntorno;
 
320
                                        estudio->Modulo = this;
 
321
                                        estudio->VentanaPadre = pVentanaPadre;
 
322
                                        estudio->InicializarContextoEstudio(rutas, uidDiagnosticoSeleccionado, GNC::GCS::IContextoEstudio::TMF_UNDiagnostico);
 
323
                                        pVista = new GNKVisualizator::WaveFormView(estudio);
 
324
                                        pCtrlVistas->Registrar(pVista);
 
325
                                }
 
326
                        }
 
327
                        catch(GNC::GCS::VistaException &ex){
 
328
                                if (pVista != NULL) {
 
329
                                        pCtrlVistas->Destruir(pVista);
 
330
                                }
 
331
                                pCtrlVistas->Thaw();
 
332
                                wxString mensaje = wxString::FromUTF8(ex.GetCause().c_str());
 
333
                                wxMessageDialog dialogo( m_pEntorno->GetVentanaRaiz(), mensaje, _("Error opening study"),  wxOK | wxICON_INFORMATION);
 
334
                                dialogo.ShowModal();
 
335
                                return NULL;
 
336
                        }
 
337
                        catch (...) {
 
338
                                if (pVista != NULL) {
 
339
                                        pCtrlVistas->Destruir(pVista);
 
340
                                }
 
341
                                pCtrlVistas->Thaw();
 
342
                                wxMessageDialog dialogo( m_pEntorno->GetVentanaRaiz(), _("Error opening study"), _("Error opening study"),  wxOK | wxICON_INFORMATION);
 
343
                                dialogo.ShowModal();
 
344
                                return NULL;
 
345
                        }
 
346
                        pCtrlVistas->Thaw();
 
347
                }//fin deshabilitacion
 
348
 
 
349
                if (pVista == NULL ) {
 
350
                        pCtrlVistas->Freeze();
 
351
                        EliminarPaneles();
 
352
                        pCtrlVistas->Destruir(pVista);
 
353
                        pCtrlVistas->Thaw();
 
354
                        return NULL;
 
355
                }
 
356
                else {
 
357
                        m_pEntorno->GetControladorCarga()->CargaAsincrona(pVista, pModeloIntegracion, uidDiagnosticoSeleccionado);
 
358
                }
 
359
        }
 
360
 
 
361
        return pVista;
 
362
}
 
363
 
 
364
 
 
365
// Selecciona el diagnostico. Metodo sincrono con la interfaz.
 
366
bool GNKVisualizator::ControladorAtencionPrimaria::SeleccionarDiagnostico(const std::string& rutaFichero, std::string& uidEstudioDiagnostico)
 
367
{
 
368
        bool continuar = true;
 
369
        if(uidEstudioDiagnostico == "")
 
370
        {
 
371
                GNKVisualizator::GUI::SeleccionarDiagnostico dialogSeleccionarDiagnostico(m_pEntorno->GetVentanaRaiz(),rutaFichero,m_pEntorno);
 
372
                if(dialogSeleccionarDiagnostico.Mostrar()) {
 
373
                        switch(dialogSeleccionarDiagnostico.ShowModal())
 
374
                        {
 
375
                                case wxID_OK:
 
376
                                        uidEstudioDiagnostico = dialogSeleccionarDiagnostico.GetUIDEstudioDiagnostico();
 
377
                                        break;
 
378
                                case wxID_CANCEL:
 
379
                                        continuar = false;
 
380
                                        break;
 
381
                        }
 
382
                }
 
383
        }
 
384
        return continuar;
 
385
}
 
386
 
 
387
 
 
388
bool GNKVisualizator::ControladorAtencionPrimaria::SoportaImportacion() const
 
389
{
 
390
        return m_pEntorno->GetControladorPermisos()->Get("atencionprimaria", "dicomizador");
 
391
}
 
392
 
 
393
GNKVisualizator::ControladorAtencionPrimaria::TipoListaPlantillas& GNKVisualizator::ControladorAtencionPrimaria::GetPlantillas(){
 
394
        if(m_pEntorno->GetControladorPermisos()->Get("dermatologia","plantillas")) {
 
395
                if(m_listaPlantillas.size() == 0){
 
396
                }
 
397
        } else {
 
398
                m_listaPlantillas.clear();
 
399
        }
 
400
        return m_listaPlantillas;
 
401
}
 
402
 
 
403
void GNKVisualizator::ControladorAtencionPrimaria::GetPasosImportacion(IWizard* pWizard,std::list<IPasoWizard*> &listaPasos, wxWindow* pParent, std::string &dirTemporal, GnkPtr<GIL::IModeloIntegracion> pModeloIntegracion){
 
404
        GNKVisualizator::GUI::TipoWizardImportacion* datosPersistentes = new GNKVisualizator::GUI::TipoWizardImportacion(pModeloIntegracion);
 
405
 
 
406
        IPasoWizard* paso=new GNKVisualizator::GUI::PasoDatosGenerales(pParent,pWizard,datosPersistentes,dirTemporal,m_pEntorno);
 
407
        listaPasos.push_back(paso);
 
408
}
 
409
 
 
410
//region "Manipulacion de paneles extra (Herramientas, etc.)"
 
411
 
 
412
void GNKVisualizator::ControladorAtencionPrimaria::InsertarPaneles()
 
413
{
 
414
        if (m_pPanelContenedorCustom == NULL) {
 
415
                m_pPanelContenedorCustom = new GNKVisualizator::GUI::ContenedorHerramientas(m_pEntorno->GetVentanaRaiz());
 
416
                m_pPanelContenedorCustom->Freeze();
 
417
                m_pPanelContenedorCustom->Show(false);
 
418
                m_pEntorno->GetControladorVistas()->InsertarPanelIzquierdo(m_pPanelContenedorCustom, _Std("DICOM Tags").c_str());
 
419
                m_pPanelContenedorCustom->Layout();
 
420
                m_pPanelContenedorCustom->ActualizarVirtualSize();
 
421
                m_pPanelContenedorCustom->Thaw();
 
422
        }
 
423
}
 
424
 
 
425
void GNKVisualizator::ControladorAtencionPrimaria::EliminarPaneles()
 
426
{
 
427
        m_pEntorno->GetControladorVistas()->EliminarPanel(m_pPanelContenedorCustom);
 
428
        m_pPanelContenedorCustom=NULL;
 
429
}
 
430
 
 
431
void GNKVisualizator::ControladorAtencionPrimaria::MostrarPaneles(bool izquierdo , bool derecho )
 
432
{
 
433
        if (m_pPanelContenedorCustom != NULL && izquierdo) {
 
434
                m_pPanelContenedorCustom->Freeze();
 
435
                m_pEntorno->GetControladorVistas()->MostrarPanel(m_pPanelContenedorCustom);
 
436
                m_pPanelContenedorCustom->Layout();
 
437
                m_pPanelContenedorCustom->ActualizarVirtualSize();
 
438
                m_pPanelContenedorCustom->Thaw();
 
439
        }
 
440
}
 
441
 
 
442
void GNKVisualizator::ControladorAtencionPrimaria::OcultarPaneles(bool izquierdo, bool derecho)
 
443
{
 
444
        if ( m_pPanelContenedorCustom != NULL && izquierdo) {
 
445
                m_pPanelContenedorCustom->Freeze();
 
446
                m_pEntorno->GetControladorVistas()->OcultarPanel(m_pPanelContenedorCustom);
 
447
                m_pPanelContenedorCustom->Layout();
 
448
                m_pPanelContenedorCustom->ActualizarVirtualSize();
 
449
                m_pPanelContenedorCustom->Thaw();
 
450
        }
 
451
}
 
452
//endregion
 
453