← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/cadxcore/main/gui/export/parametrosprincipales.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/gui/export/parametrosprincipales.cpp
 
1
/*
 
2
 *  
 
3
 *  $Id: parametrosprincipales.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
#include <vector>
 
15
#include <sstream>
 
16
 
 
17
#include <wx/file.h>
 
18
#include <wx/dir.h>
 
19
#include <wx/dirdlg.h>
 
20
#include <wx/msgdlg.h>
 
21
#include <wx/confbase.h>
 
22
#include <wx/msgout.h>
 
23
#include <wx/filename.h>
 
24
#include <wx/propgrid/propgrid.h>
 
25
 
 
26
#include <api/ientorno.h>
 
27
#include <api/ivista.h>
 
28
#include <export/icontratoscore.h>
 
29
#include <api/icontextoestudio.h>
 
30
 
 
31
#include <wx/file.h>
 
32
#include <wx/dir.h>
 
33
#include <wx/dirdlg.h>
 
34
#include <wx/msgdlg.h>
 
35
#include <wx/confbase.h>
 
36
#include <wx/msgout.h>
 
37
#include <wx/filename.h>
 
38
#include <wx/propgrid/propgrid.h>
 
39
#include <api/internacionalizacion.h>
 
40
#include <wx/ginkgostyle/ginkgostyle.h>
 
41
 
 
42
#include <main/controllers/controladorhistorial.h>
 
43
#include <main/controllers/controladorcomandos.h>
 
44
#include <commands/comandoexportacion.h>
 
45
#include <commands/comandomergediagnosticwithimage.h>
 
46
#include "parametrosprincipales.h"
 
47
 
 
48
namespace GNC {
 
49
        namespace GUI {
 
50
 
 
51
                ParametrosPrincipales::ParametrosPrincipales(wxWindow* pParent,IWizard* pWizard,GnkPtr<TipoWizardExportacion> pDatosPersistentes, GNC::GCS::IEntorno* pEntorno):ParametrosPrincipalesBase(pParent),IPasoWizard(pWizard)
 
52
                {
 
53
                        m_pEntorno = pEntorno;
 
54
                        m_pDatosPersistentes = pDatosPersistentes;
 
55
                        //si es IContratoExportacionImages pues se deja a todos los formatos sino solo dicom
 
56
                        GNC::GCS::IContratoExportacionImages* pContratoImages = dynamic_cast<GNC::GCS::IContratoExportacionImages*>(m_pDatosPersistentes->m_pVista);
 
57
                        if(pContratoImages == NULL){
 
58
                                //solo DICOM
 
59
                                m_pFormatoDestino->Delete(3);
 
60
                                m_pFormatoDestino->Delete(2);
 
61
                                m_pFormatoDestino->Delete(1);
 
62
                        }
 
63
                        else{
 
64
                                //pillamos los mapas
 
65
                                typedef GNC::GCS::IContratoExportacionImages::MapaMapasValoracion MapaMapasValoracion;
 
66
                                m_pDatosPersistentes->m_mapasValoracion = pContratoImages->GetMapasValoracion();
 
67
                                if(m_pDatosPersistentes->m_mapasValoracion.size() == 0) {
 
68
                                        m_pTituloMapas->Show(false);
 
69
                                        m_pMapasCheck->Show(false);
 
70
                                } else {
 
71
                                        for(MapaMapasValoracion::iterator it= m_pDatosPersistentes->m_mapasValoracion.begin(); it!= m_pDatosPersistentes->m_mapasValoracion.end(); it++) {
 
72
                                                int item = m_pMapasCheck->Append(wxString::FromUTF8((*it).first.c_str()));
 
73
                                                m_pMapasCheck->Check(item,(*it).second);
 
74
                                        }
 
75
                                }
 
76
                        }
 
77
 
 
78
                        m_base = (*m_pDatosPersistentes->m_pVista->GetEstudio()->GetTagsImagenDeImagenActiva());
 
79
 
 
80
 
 
81
                        std::string pathActivo;
 
82
                        GIL::DICOM::IDICOMManager*      pDICOMManager= pEntorno->GetControladorImportacionPACS()->CrearInstanciaDeDICOMManager();
 
83
 
 
84
                
 
85
                        SetTags(m_base,m_pListaAtributos->GetRoot(),pDICOMManager);
 
86
 
 
87
                        pEntorno->GetControladorImportacionPACS()->LiberarInstanciaDeDICOMManager(pDICOMManager);
 
88
 
 
89
                        wxConfigBase * config = wxConfigBase::Get();
 
90
                        config->Read(wxT("/GinkgoCore/Exportacion/ValorDefectoAnonimizacion"),&m_valorAnonimizado,wxEmptyString);
 
91
 
 
92
                        //por defecto el check de configuracion esta checkeado
 
93
                        wxCommandEvent evt;
 
94
                        OnCheckConfiguracion(evt);
 
95
 
 
96
                        m_pPanelCampos->Enable(false);
 
97
                        m_pPanelCampos->Refresh(false);
 
98
                        m_pListaAtributos->Refresh(false);
 
99
 
 
100
                        //diagnosticos
 
101
                        std::vector<std::string> listaDiagnosticos = m_pDatosPersistentes->m_pVista->GetRutasDiagnosticos();
 
102
                        if(listaDiagnosticos.size()==0) {
 
103
                                m_pCheckExportarDiagnostico->SetValue(false);
 
104
                                m_pCheckExportarDiagnostico->Enable(false);
 
105
                        } else {
 
106
                                GNC::GCS::ControladorHistorial::ModeloDCM modelo = GNC::GCS::ControladorHistorial::Instance()->GetModeloDCM(listaDiagnosticos[0]);
 
107
                                std::ostringstream ostr;
 
108
                                ostr << "(" << modelo.m_nombreMedico << "; " << modelo.m_horaEstudio << "; " << modelo.m_fechaEstudio << "; " << modelo.m_descripcionEstudio << ")";
 
109
                                m_pDescripcionDiagnostico->SetLabel(wxString::FromUTF8(ostr.str().c_str()));
 
110
                        }
 
111
 
 
112
                        Layout();
 
113
 
 
114
                        m_pListaAtributos->Connect(wxEVT_PG_CHANGED,wxPropertyGridEventHandler(ParametrosPrincipales::OnPropertyChanged),NULL,this);
 
115
                        m_pListaAtributos->Connect(wxEVT_PG_DOUBLE_CLICK,wxPropertyGridEventHandler(ParametrosPrincipales::OnPropertyDobleClick),NULL,this);
 
116
                }
 
117
 
 
118
                ParametrosPrincipales::~ParametrosPrincipales()
 
119
                {
 
120
                        m_pListaAtributos->Disconnect(wxEVT_PG_CHANGED,wxPropertyGridEventHandler(ParametrosPrincipales::OnPropertyChanged),NULL,this);
 
121
                        m_pListaAtributos->Disconnect(wxEVT_PG_DOUBLE_CLICK,wxPropertyGridEventHandler(ParametrosPrincipales::OnPropertyDobleClick),NULL,this);
 
122
                        m_pEntorno = NULL;
 
123
                }
 
124
 
 
125
                void ParametrosPrincipales::SetTags(GIL::DICOM::TipoJerarquia & base,wxPGPropArg idPadre,GIL::DICOM::IDICOMManager*     pDICOMManager) {
 
126
                        for(GIL::DICOM::TipoJerarquia::ListaTags::iterator it = base.tags.begin(); it!= base.tags.end(); it++){
 
127
                                wxString helpString = wxString::FromUTF8(pDICOMManager->GetDescription((*it).first).c_str());
 
128
                                wxStringProperty* prop = NULL;
 
129
                                wxString valor;
 
130
                                if((*it).second.size()>100) {
 
131
                                        valor=wxT("Datos");
 
132
                                } else {
 
133
                                        valor = wxString::FromUTF8((*it).second.c_str());
 
134
                                }
 
135
 
 
136
                                if(helpString.size()>0){
 
137
                                        helpString = wxT("(") + wxString::FromUTF8((*it).first.c_str()) + wxT(") ") + helpString;
 
138
                                        prop = new wxStringProperty(helpString,
 
139
                                                wxPG_LABEL,valor);
 
140
                                }else{
 
141
                                        prop = new wxStringProperty(wxString::FromUTF8((*it).first.c_str()),
 
142
                                                wxPG_LABEL,valor);
 
143
                                }
 
144
                                prop->SetHelpString(wxString::FromUTF8((*it).first.c_str()));
 
145
                                m_pListaAtributos->AppendIn(idPadre, prop);
 
146
                        }
 
147
 
 
148
                        for(GIL::DICOM::TipoJerarquia::ListaJerarquias::iterator it = base.secuencias.begin(); it!=base.secuencias.end(); it++){
 
149
                                wxStringProperty* prop = NULL;
 
150
                                wxString helpString = wxString::FromUTF8(pDICOMManager->GetDescription((*it).tagName).c_str());
 
151
                                if(helpString.size()>0){
 
152
                                        helpString = wxT("(") + wxString::FromUTF8((*it).tagName.c_str()) + wxT(") ") + helpString;
 
153
                                        prop = new wxStringProperty(helpString,
 
154
                                                wxPG_LABEL,wxEmptyString);
 
155
                                }else{
 
156
                                        prop = new wxStringProperty(wxString::FromUTF8((*it).tagName.c_str()),
 
157
                                                wxPG_LABEL,wxEmptyString);
 
158
                                }
 
159
                                prop->SetHelpString(wxString::FromUTF8((*it).tagName.c_str()));
 
160
                                if(m_pListaAtributos->GetProperty(prop->GetName()) != NULL) {
 
161
                                        ////////////////////////////////////std::cout<<"hasdfasdf";
 
162
                                }
 
163
                                wxPGId pIdSequencia = m_pListaAtributos->AppendIn(idPadre,prop);
 
164
 
 
165
                                //recursion
 
166
                                int i=0;
 
167
                                for(GIL::DICOM::TipoJerarquia::ListaJerarquias::iterator it2 = (*it).items.begin(); it2!= (*it).items.end(); it2++, i++) {
 
168
                                        wxPGPropArg pIdItem = m_pListaAtributos->AppendIn(pIdSequencia,new wxStringProperty(wxString::Format(wxT("Item %d"),i),wxPG_LABEL,wxEmptyString));
 
169
                                        SetTags((*it2),pIdItem,pDICOMManager);
 
170
                                }
 
171
                        }
 
172
                }
 
173
 
 
174
                void ParametrosPrincipales::OnChoiceFormatoDestino(wxCommandEvent &)
 
175
                {
 
176
                        switch(m_pFormatoDestino->GetSelection()){
 
177
                                case 0:
 
178
                                        m_pPanelAnonimizar->Show(true);
 
179
                                        m_pCheckExportarDiagnostico->Show(true);
 
180
                                        m_pDescripcionDiagnostico->Show(true);
 
181
                                        m_pPanelContenido->Show(false);
 
182
                                        m_pSep1->Show(false);
 
183
                                        m_pPanelJpeg->Show(false);
 
184
                                        break;
 
185
                                case 1:
 
186
                                        m_pPanelAnonimizar->Show(false);
 
187
                                        m_pCheckExportarDiagnostico->Show(false);
 
188
                                        m_pDescripcionDiagnostico->Show(false);
 
189
                                        m_pPanelContenido->Show(true);
 
190
                                        m_pSep1->Show(true);
 
191
                                        m_pPanelJpeg->Show(true);
 
192
                                        break;
 
193
                                case 2:
 
194
                                case 3:
 
195
                                        m_pPanelAnonimizar->Show(false);
 
196
                                        m_pCheckExportarDiagnostico->Show(false);
 
197
                                        m_pDescripcionDiagnostico->Show(false);
 
198
                                        m_pPanelContenido->Show(true);
 
199
                                        m_pSep1->Show(false);
 
200
                                        m_pPanelJpeg->Show(false);
 
201
                                        break;
 
202
                        }
 
203
                        Layout();
 
204
                }
 
205
 
 
206
 
 
207
                //anonimizacion
 
208
                void ParametrosPrincipales::GetTagsAnonimizados(GIL::DICOM::TipoJerarquia & base)
 
209
                {
 
210
                        base.tags.clear();
 
211
                        for(wxPGProperty* it=m_pListaAtributos->GetFirst();it!=NULL;it=m_pListaAtributos->GetNextSiblingProperty(it)){
 
212
                                if(it->IsFlagSet(wxPG_PROP_MODIFIED)){
 
213
                                        std::string clave(it->GetHelpString().ToUTF8());
 
214
                                        std::string valor(it->GetValueAsString().ToUTF8());
 
215
                                        base.tags[clave] = valor;
 
216
                                }
 
217
                        }
 
218
                }
 
219
 
 
220
                void ParametrosPrincipales::OnCheckAnonimizar(wxCommandEvent &){
 
221
                        m_pPanelCampos->Enable(m_pCheckAnonimizar->GetValue());
 
222
                        Layout();
 
223
                }
 
224
 
 
225
                void ParametrosPrincipales::OnCheckNombreApellidos(wxCommandEvent &){
 
226
                        //se anonimiza 0010|0010 (nombre del paciente)
 
227
                        std::string clave("0010|0010");
 
228
                        Anonimizar(clave,m_pCheckNombrePaciente->IsChecked());
 
229
                }
 
230
 
 
231
                void ParametrosPrincipales::OnCheckIdPaciente(wxCommandEvent &){
 
232
                        //se anonimiza 0010|0020" (id del paciente)
 
233
                        std::string clave("0010|0020");
 
234
                        Anonimizar(clave,m_pCheckIdPaciente->IsChecked());
 
235
                }
 
236
 
 
237
                void ParametrosPrincipales::OnCheckInstituciones(wxCommandEvent &){
 
238
                        //se anonimiza (0008,0080) Institution Name
 
239
                        std::string clave("0008|0080");
 
240
                        Anonimizar(clave,m_pCheckInstituciones->IsChecked());
 
241
                }
 
242
 
 
243
                void ParametrosPrincipales::OnCheckComentarios(wxCommandEvent &){
 
244
                        //descripcion del estudio, serie e imagenes
 
245
                        //estudio
 
246
                        {
 
247
                                std::string clave("0008|1030");
 
248
                                Anonimizar(clave,m_pCheckComentarios->IsChecked());
 
249
                        }
 
250
                        //serie
 
251
                        {
 
252
                                std::string clave("0008|103e");
 
253
                                Anonimizar(clave,m_pCheckComentarios->IsChecked());
 
254
                        }
 
255
                        //imagen
 
256
                        {
 
257
                                std::string clave("0020|4000");
 
258
                                Anonimizar(clave,m_pCheckComentarios->IsChecked());
 
259
                        }
 
260
                }
 
261
 
 
262
                void ParametrosPrincipales::OnCheckConfiguracion(wxCommandEvent &){
 
263
                        //se cargan los tags y se anonimizan...
 
264
                        wxConfigBase * config = wxConfigBase::Get();
 
265
                        //se actualiza el fichero de configuracion
 
266
                        config->SetPath(wxT("/GinkgoCore/Exportacion/TagsAnonimizacion"));
 
267
                        wxString str;
 
268
                        long dummy;
 
269
 
 
270
                        bool bCont = config->GetFirstGroup(str, dummy);
 
271
                        while ( bCont ) {
 
272
                                config->SetPath(str);
 
273
                                wxString grupo;
 
274
                                wxString elemento;
 
275
                                config->Read(wxT("Grupo"),&grupo,wxEmptyString);
 
276
                                config->Read(wxT("Elemento"),&elemento,wxEmptyString);
 
277
 
 
278
                                wxString wxClave = grupo + wxT("|") + elemento;
 
279
                                std::string clave(wxClave.ToUTF8());
 
280
 
 
281
                                if(clave == std::string("0010|0010")){
 
282
                                        m_pCheckNombrePaciente->SetValue(m_pCheckConfiguracion->IsChecked());
 
283
                                }else if(clave == std::string("0010|0020")){
 
284
                                        m_pCheckIdPaciente->SetValue(m_pCheckConfiguracion->IsChecked());
 
285
                                } else if(clave == std::string("0008|0080")){
 
286
                                        m_pCheckIdPaciente->SetValue(m_pCheckInstituciones->IsChecked());
 
287
                                }
 
288
 
 
289
                                Anonimizar(clave,m_pCheckConfiguracion->IsChecked());
 
290
 
 
291
                                config->SetPath(wxT(".."));
 
292
                                bCont = config->GetNextGroup(str, dummy);
 
293
                        }
 
294
 
 
295
                }
 
296
 
 
297
                void ParametrosPrincipales::Anonimizar(std::string& clave, bool anonimizar)
 
298
                {
 
299
                        wxString value = m_valorAnonimizado;
 
300
 
 
301
                        if(!anonimizar){
 
302
                                std::string tmp;
 
303
                                if(m_base.getTag(clave,tmp)){
 
304
                                        value = wxString::FromUTF8(tmp.c_str());
 
305
                                }
 
306
                        }
 
307
 
 
308
                        for(wxPGProperty* it=m_pListaAtributos->GetFirst();it!=NULL;it=m_pListaAtributos->GetNextSiblingProperty(it)){
 
309
                                if(it->GetHelpString() == wxString::FromUTF8(clave.c_str())){
 
310
                                        it->SetValueFromString(value);
 
311
                                        if(anonimizar){
 
312
                                                m_pListaAtributos->SetPropertyCell(it->GetId(),0,it->GetLabel(),wxNullBitmap,*wxWHITE,*wxRED);
 
313
                                                m_pListaAtributos->SetPropertyCell(it->GetId(),1,it->GetValue(),wxNullBitmap,*wxWHITE,*wxRED);
 
314
                                        }else{
 
315
                                                m_pListaAtributos->SetPropertyCell(it->GetId(),0,it->GetLabel());
 
316
                                                m_pListaAtributos->SetPropertyCell(it->GetId(),1,it->GetValue());
 
317
                                        }
 
318
                                        it->ChangeFlag(wxPG_PROP_MODIFIED,anonimizar);
 
319
                                        m_pListaAtributos->RefreshProperty(it);
 
320
                                        return;
 
321
                                }
 
322
                        }
 
323
                }
 
324
 
 
325
                void ParametrosPrincipales::OnPropertyChanged(wxPropertyGridEvent& event) {
 
326
                        if(m_pCheckAnonimizar->IsChecked()){
 
327
                                wxPGProperty* selected= event.GetProperty();
 
328
                                m_pListaAtributos->SetPropertyCell(selected->GetId(),0,selected->GetLabel(),wxNullBitmap,*wxWHITE,*wxRED);
 
329
                                m_pListaAtributos->SetPropertyCell(selected->GetId(),1,selected->GetValue(),wxNullBitmap,*wxWHITE,*wxRED);
 
330
                        } else {
 
331
                                std::string clave(event.GetProperty()->GetHelpString().ToUTF8());
 
332
                                Anonimizar(clave,false);
 
333
                        }
 
334
                }
 
335
 
 
336
                void ParametrosPrincipales::OnPropertyDobleClick(wxPropertyGridEvent& event){
 
337
                        if(m_pCheckAnonimizar->IsChecked()){
 
338
                                std::string clave(event.GetProperty()->GetHelpString().ToUTF8());
 
339
                                Anonimizar(clave,!event.GetProperty()->IsFlagSet(wxPG_PROP_MODIFIED));
 
340
                        } 
 
341
                }
 
342
 
 
343
//region "Metodos heredados de Ipasowizard"
 
344
 
 
345
                void ParametrosPrincipales::Attach(wxSizer *sizer){
 
346
                        Show(true);
 
347
                        sizer->Add(this,10, wxEXPAND);
 
348
                        this->GetParent()->Layout();
 
349
                }
 
350
 
 
351
                void ParametrosPrincipales::Detach(wxSizer *sizer){
 
352
                        Hide();
 
353
                        sizer->Detach(this);
 
354
                        sizer->GetContainingWindow()->Layout();
 
355
                }
 
356
 
 
357
                std::string ParametrosPrincipales::GetTitle(){
 
358
                        return _Std("DICOM Export");
 
359
                }
 
360
 
 
361
                std::string ParametrosPrincipales::GetSubTitle(){
 
362
                        return _Std("Select the format and the images you want to export");
 
363
                }
 
364
 
 
365
                bool ParametrosPrincipales::Siguiente(){
 
366
                        return true;
 
367
                }
 
368
 
 
369
                bool ParametrosPrincipales::Anterior(){
 
370
                        return false;
 
371
                }
 
372
 
 
373
                bool ParametrosPrincipales::Cancelar(){
 
374
                        return true;
 
375
                }
 
376
 
 
377
                bool ParametrosPrincipales::Validar(){
 
378
                        switch(m_pFormatoDestino->GetSelection()){
 
379
                                case 0:
 
380
                                        m_pDatosPersistentes->m_formatoDestino = DICOM;
 
381
                                        GetTagsAnonimizados(m_pDatosPersistentes->m_base);
 
382
                                        m_pDatosPersistentes->m_incluirTagsGinkgo = !m_pCheckAtributosPrivadosGinkgo->IsChecked();
 
383
                                        m_pDatosPersistentes->m_exportarDiagnostico = m_pCheckExportarDiagnostico->IsChecked();
 
384
                                        break;
 
385
                                case 1:
 
386
                                        m_pDatosPersistentes->m_formatoDestino = JPEG;
 
387
                                        break;
 
388
                                case 2:
 
389
                                        m_pDatosPersistentes->m_formatoDestino = BMP;
 
390
                                        break;
 
391
                                case 3:
 
392
                                        m_pDatosPersistentes->m_formatoDestino = PNG;
 
393
                                        break;
 
394
                                default:
 
395
                                        m_pDatosPersistentes->m_formatoDestino = DICOM;
 
396
                        }
 
397
 
 
398
                        if(m_pOrigen->GetSelection() == 0 ){
 
399
                                m_pDatosPersistentes->m_ficheroActual=true;
 
400
                        }else{
 
401
                                m_pDatosPersistentes->m_ficheroActual=false;
 
402
                        }
 
403
 
 
404
                        //mapas de valoracion
 
405
                        if(m_pDatosPersistentes->m_formatoDestino != DICOM) {
 
406
                                for(unsigned int i = 0; i< m_pMapasCheck->GetCount(); i++) {
 
407
                                        std::string strTmp(m_pMapasCheck->GetString(i).ToUTF8());
 
408
                                        m_pDatosPersistentes->m_mapasValoracion[strTmp] = m_pMapasCheck->IsChecked(i);
 
409
                                }
 
410
                        }
 
411
                        m_pDatosPersistentes->m_incluirWidgets = m_pIncluirWidgets->IsChecked();
 
412
 
 
413
                        if(m_pDatosPersistentes->m_formatoDestino == JPEG){
 
414
                                m_pDatosPersistentes->m_jpegCalidad = m_pSliderCalidad->GetValue();
 
415
                        }
 
416
 
 
417
                        //pillamos el directorio...
 
418
                        return Seleccionardirectorio();
 
419
 
 
420
                }
 
421
        //endregion
 
422
 
 
423
                bool ParametrosPrincipales::Seleccionardirectorio()
 
424
                {
 
425
                        //se pregunta al usuario donde los quiere guardar
 
426
                        wxConfigBase * config = wxConfigBase::Get();
 
427
                        //se actualiza el fichero de configuracion
 
428
                        config->SetPath(wxT("/GinkgoCore/Exportacion"));
 
429
 
 
430
                        wxString wxPathDefecto;
 
431
                        config->Read(wxT("PathDefecto"),&wxPathDefecto,wxT(""));
 
432
                        wxDirDialog seleccionarDirectorio(this,_("Select the directory where the files will be stored"),wxPathDefecto,wxDD_DEFAULT_STYLE|wxDD_NEW_DIR_BUTTON);
 
433
                        int response = seleccionarDirectorio.ShowModal();
 
434
                        if (response == wxID_OK)
 
435
                        {
 
436
                                wxString wxPath = seleccionarDirectorio.GetPath();
 
437
 
 
438
                                if( !wxDirExists(wxPath) ){
 
439
                                        wxMessageDialog dialog(NULL,_("The selected directory does not exist\nWould you like to create?"),_("Info"),wxYES_NO|wxICON_INFORMATION);
 
440
                                        if ( dialog.ShowModal() == wxID_NO)
 
441
                                        {
 
442
                                                return false;;
 
443
                                        }
 
444
                                        if(!wxFileName::Mkdir(wxPath)){
 
445
                                                wxMessageBox(_("There was an error creating directory"), _("Info"),
 
446
                                                        wxOK | wxICON_INFORMATION, this);
 
447
                                                return false;
 
448
                                        }
 
449
                                }
 
450
 
 
451
                                m_pDatosPersistentes->m_pathDestino = TOPATH(wxPath);
 
452
 
 
453
                                if (m_pDatosPersistentes->m_exportarDiagnostico && m_pDatosPersistentes->m_formatoDestino == GNC::GUI::DICOM) {
 
454
                                        GADAPI::ComandoMergeDiagnosticWithImageParams* pParams = new GADAPI::ComandoMergeDiagnosticWithImageParams(m_pDatosPersistentes->m_pathDestino, m_pDatosPersistentes->m_pVista->GetEstudio(), m_pDatosPersistentes->m_base, m_pDatosPersistentes->m_incluirTagsGinkgo, m_pDatosPersistentes->m_ficheroActual);
 
455
                                        GADAPI::ComandoMergeDiagnosticWithImage* pCmd = new GADAPI::ComandoMergeDiagnosticWithImage(pParams);
 
456
                                        GNC::GCS::ControladorComandos::Instance()->ProcessAsync(_Std("Exporting images ..."), pCmd, m_pDatosPersistentes->m_pVista);
 
457
                                } else {
 
458
                                        GADAPI::ComandoExportacionParams* pParams = new GADAPI::ComandoExportacionParams(m_pDatosPersistentes);
 
459
                                        GADAPI::ComandoExportacion* pCmd = new GADAPI::ComandoExportacion(pParams);
 
460
                                        GNC::GCS::ControladorComandos::Instance()->ProcessAsync(_Std("Exporting images ..."), pCmd, m_pDatosPersistentes->m_pVista);
 
461
                                }
 
462
 
 
463
                                wxConfigBase * config = wxConfigBase::Get();
 
464
                                //se actualiza el fichero de configuracion
 
465
                                config->SetPath(wxT("/GinkgoCore/Exportacion"));
 
466
                                config->Write(wxT("PathDefecto"),wxPath);
 
467
                                config->Flush();
 
468
                                return true;
 
469
                        } else {
 
470
                                return false;
 
471
                        }
 
472
                }
 
473
        };
 
474
 
 
475
};