← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/cadxcore/commands/comandoincluirhistorial.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/commands/comandoincluirhistorial.cpp
 
1
/*
 
2
*  
 
3
*  $Id: comandoincluirhistorial.cpp 3630 2011-03-29 11:28:08Z 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
//#define _GINKGO_TRACE
 
14
#include <wx/filename.h>
 
15
#include <wx/file.h>
 
16
#include <wx/dir.h>
 
17
#include <wx/msgdlg.h>
 
18
 
 
19
#include <api/globals.h>
 
20
#include <api/ivista.h>
 
21
#include <api/icontroladorvistas.h>
 
22
#include <api/imodelointegracion.h>
 
23
#include <api/icontroladorcarga.h>
 
24
#include <api/icontextoestudio.h>
 
25
#include <main/entorno.h>
 
26
#include "comandoincluirhistorial.h"
 
27
#include <main/controllers/controladorcomandos.h>
 
28
#include <main/controllers/controladorhistorial.h>
 
29
#include <main/controllers/controladoreventos.h>
 
30
#include <main/controllers/controladorimportacionpacs.h>
 
31
#include <main/gui/history/ipanelhistorial.h>
 
32
#include <api/internacionalizacion.h>
 
33
#include "dialogopathssobreescribirbase.h"
 
34
 
 
35
#define IDC_INCLUIR       101
 
36
#define IDC_AVISAR                102
 
37
 
 
38
class SubComandoAvisarModelosParams : public GNC::GCS::IComandoParams
 
39
{
 
40
public:
 
41
        typedef std::list<std::string> TipoListaFicheros;
 
42
 
 
43
        SubComandoAvisarModelosParams(const GNC::GCS::ControladorHistorial::ListaModelosDCM& listaModelos, bool abrirDespues, GnkPtr<GIL::IModeloIntegracion> pModeloIntegracion)
 
44
        {
 
45
                m_modelosDCM = listaModelos;
 
46
                m_abrirDespuesDeCargar= abrirDespues;
 
47
                m_pModeloIntegracion = pModeloIntegracion;
 
48
        }
 
49
 
 
50
        ~SubComandoAvisarModelosParams()
 
51
        {
 
52
                m_modelosDCM.clear();
 
53
        }
 
54
 
 
55
        GNC::GCS::ControladorHistorial::ListaModelosDCM m_modelosDCM;
 
56
        GnkPtr<GIL::IModeloIntegracion> m_pModeloIntegracion;
 
57
        bool m_abrirDespuesDeCargar;
 
58
};
 
59
 
 
60
class SubComandoAvisarModelos : public GNC::GCS::IComando {
 
61
public:
 
62
        SubComandoAvisarModelos(SubComandoAvisarModelosParams* pParams) : IComando(pParams)
 
63
        {
 
64
                SetId(IDC_AVISAR);
 
65
                m_pAvisarParams = pParams;
 
66
        }
 
67
 
 
68
        virtual void Execute()
 
69
        {
 
70
        }
 
71
 
 
72
        virtual void Update()
 
73
        {
 
74
                if (m_pAvisarParams->m_modelosDCM.size() > 0) {
 
75
                        GNC::GCS::ControladorEventos::Instance()->ProcesarEvento(new GNC::GUI::Eventos::EventoAddModeloHistorial(&m_pAvisarParams->m_modelosDCM,m_pAvisarParams->m_abrirDespuesDeCargar, m_pAvisarParams->m_pModeloIntegracion));
 
76
                }
 
77
        }
 
78
 
 
79
        virtual void LiberarRecursos()
 
80
        {
 
81
        }
 
82
 
 
83
protected:
 
84
        SubComandoAvisarModelosParams* m_pAvisarParams;
 
85
};
 
86
 
 
87
namespace GADAPI {
 
88
 
 
89
        //lee un directorio en profundidad y lo incluye en el dicomdir
 
90
        namespace ComandoIncluirHistorial {
 
91
                ComandoIncluirHistorialParams::ComandoIncluirHistorialParams(const std::string& path, bool recursivo, bool forzarSobreescribir)
 
92
                {
 
93
                        m_path = path;
 
94
                        m_recursivo = recursivo;
 
95
                        m_abrirDespuesDeCargar = false;
 
96
                        m_forzarSobreescribir = forzarSobreescribir;
 
97
                        m_borrarDespuesDeIncluir = false;
 
98
                        m_informar = true;
 
99
                }
 
100
 
 
101
                ComandoIncluirHistorialParams::ComandoIncluirHistorialParams(const std::list<std::string>& listaPaths, bool abrirDespuesDeCargar, bool forzarSobreescribir, GnkPtr<GIL::IModeloIntegracion> pModeloIntegracion)
 
102
                {
 
103
                        if (listaPaths.size() == 1) {
 
104
                                m_path = listaPaths.front();
 
105
                        } else {
 
106
                                m_listaPaths = listaPaths;
 
107
                        }
 
108
                        m_abrirDespuesDeCargar = abrirDespuesDeCargar;
 
109
                        m_pModeloIntegracion = pModeloIntegracion;
 
110
                        m_forzarSobreescribir = forzarSobreescribir;
 
111
                        m_borrarDespuesDeIncluir = false;
 
112
                        m_informar = true;
 
113
                }
 
114
 
 
115
                ComandoIncluirHistorialParams::~ComandoIncluirHistorialParams()
 
116
                {
 
117
                }
 
118
 
 
119
 
 
120
                ComandoIncluirHistorial::ComandoIncluirHistorial(ComandoIncluirHistorialParams* pParams) : IComando(pParams)
 
121
                {
 
122
                        GTRACE(">> ComandoCarga::ComandoCarga(): " << this);
 
123
                        m_pIncluirParams = pParams;
 
124
                        SetId(IDC_INCLUIR);
 
125
                        GTRACE("<< ComandoCarga::ComandoCarga(): " << this);
 
126
                }
 
127
 
 
128
                void ComandoIncluirHistorial::Execute()
 
129
                {
 
130
                        NotificarProgreso(0.0f,_Std("Exploring directory ..."));
 
131
                        if(m_pIncluirParams->m_path != "") {
 
132
                                GNC::GCS::ControladorHistorial::ListaPaths listaFicheros;
 
133
                                wxString wxPath = FROMPATH(m_pIncluirParams->m_path);
 
134
                                if(wxFileExists(wxPath)) {
 
135
                                        wxFileName filename(wxPath);
 
136
                                        if(filename.GetExt().Lower() == wxT("dcm") || GIL::DICOM::ControladorImportacionPACS::Instance()->EsDICOM(std::string(wxPath.ToUTF8()), false, true) ) {
 
137
                                                listaFicheros.push_back(m_pIncluirParams->m_path);
 
138
                                        }
 
139
                                        GNC::GCS::ControladorHistorial::Instance()->AddFiles(listaFicheros,m_pIncluirParams->m_modelosDCM,m_pIncluirParams->m_listaPathsSobreescriben,m_pIncluirParams->m_forzarSobreescribir,this,false,m_pIncluirParams->m_borrarDespuesDeIncluir);
 
140
                                        for(GNC::GCS::ControladorHistorial::ListaModelosDCM::iterator it = m_pIncluirParams->m_modelosDCM.begin(); it != m_pIncluirParams->m_modelosDCM.end(); ++it)
 
141
                                        {
 
142
                                                m_pIncluirParams->m_listaEstudios.insert((*it).m_uidEstudio);
 
143
                                                m_pIncluirParams->m_listaSeries.insert((*it).m_uidSerie);
 
144
                                                m_pIncluirParams->m_listaImagenes.insert((*it).m_uidImagen);
 
145
                                        }
 
146
                                } else if (wxDirExists(wxPath) && m_pIncluirParams->m_recursivo) {
 
147
                                        //caso especial en el que se va avisando poco a poco...
 
148
                                        TListaListas listaListas;
 
149
                                        LeerDirectorioRecursivo(wxPath,listaListas);
 
150
                                        for (TListaListas::iterator it = listaListas.begin(); it != listaListas.end(); it++) {
 
151
                                                //se incluyen "por paquetes los ficheros"
 
152
                                                GNC::GCS::ControladorHistorial::Instance()->AddFiles((*it),m_pIncluirParams->m_modelosDCM,m_pIncluirParams->m_listaPathsSobreescriben,m_pIncluirParams->m_forzarSobreescribir,this,false,m_pIncluirParams->m_borrarDespuesDeIncluir);
 
153
                                                SubComandoAvisarModelosParams * pParams = new SubComandoAvisarModelosParams(m_pIncluirParams->m_modelosDCM,m_pIncluirParams->m_abrirDespuesDeCargar,m_pIncluirParams->m_pModeloIntegracion);
 
154
                                                SubComandoAvisarModelos * pCmd = new SubComandoAvisarModelos(pParams);
 
155
                                                GNC::GCS::ControladorComandos::Instance()->ProcessAsync(_Std("Including files in the history .."),pCmd,NULL);
 
156
                                                for(GNC::GCS::ControladorHistorial::ListaModelosDCM::iterator it = m_pIncluirParams->m_modelosDCM.begin(); it != m_pIncluirParams->m_modelosDCM.end(); ++it)
 
157
                                                {
 
158
                                                        m_pIncluirParams->m_listaEstudios.insert((*it).m_uidEstudio);
 
159
                                                        m_pIncluirParams->m_listaSeries.insert((*it).m_uidSerie);
 
160
                                                        m_pIncluirParams->m_listaImagenes.insert((*it).m_uidImagen);
 
161
                                                }
 
162
                                                m_pIncluirParams->m_modelosDCM.clear();
 
163
                                        }
 
164
                                } else if(wxDirExists(wxPath)){
 
165
                                        //leer el directorio normal
 
166
                                        wxDir dir;
 
167
                                        if (dir.Open(wxPath)) {
 
168
                                                wxString wxPathFich;
 
169
                                                bool cont = dir.GetFirst(&wxPathFich,wxEmptyString, wxDIR_FILES | wxDIR_DIRS);
 
170
                                                while (cont) {
 
171
                                                        wxPathFich = dir.GetName()+ wxFileName::GetPathSeparator(wxPATH_NATIVE) + wxPathFich;
 
172
                                                        wxFileName filename(wxPathFich);
 
173
                                                        if(filename.GetExt().Lower() == wxT("dcm") || GIL::DICOM::ControladorImportacionPACS::Instance()->EsDICOM(std::string(wxPathFich.ToUTF8()), false, true) ) {
 
174
                                                                std::string pathStd(TOPATH(wxPathFich));
 
175
                                                                listaFicheros.push_back(pathStd);
 
176
                                                        }
 
177
                                                        cont = dir.GetNext(&wxPathFich);
 
178
                                                }
 
179
                                        }
 
180
                                        GNC::GCS::ControladorHistorial::Instance()->AddFiles(listaFicheros,m_pIncluirParams->m_modelosDCM,m_pIncluirParams->m_listaPathsSobreescriben,m_pIncluirParams->m_forzarSobreescribir,this,false,m_pIncluirParams->m_borrarDespuesDeIncluir);
 
181
                                        SubComandoAvisarModelosParams * pParams = new SubComandoAvisarModelosParams(m_pIncluirParams->m_modelosDCM,m_pIncluirParams->m_abrirDespuesDeCargar,m_pIncluirParams->m_pModeloIntegracion);
 
182
                                        SubComandoAvisarModelos * pCmd = new SubComandoAvisarModelos(pParams);
 
183
                                        GNC::GCS::ControladorComandos::Instance()->ProcessAsync(_Std("Including files in the history .."),pCmd,NULL);
 
184
                                        for(GNC::GCS::ControladorHistorial::ListaModelosDCM::iterator it = m_pIncluirParams->m_modelosDCM.begin(); it != m_pIncluirParams->m_modelosDCM.end(); ++it)
 
185
                                        {
 
186
                                                m_pIncluirParams->m_listaEstudios.insert((*it).m_uidEstudio);
 
187
                                                m_pIncluirParams->m_listaSeries.insert((*it).m_uidSerie);
 
188
                                                m_pIncluirParams->m_listaImagenes.insert((*it).m_uidImagen);
 
189
                                        }
 
190
                                        m_pIncluirParams->m_modelosDCM.clear();
 
191
                                }
 
192
                        } else {
 
193
                                GNC::GCS::ControladorHistorial::Instance()->AddFiles(m_pIncluirParams->m_listaPaths,m_pIncluirParams->m_modelosDCM,m_pIncluirParams->m_listaPathsSobreescriben,m_pIncluirParams->m_forzarSobreescribir,this,false,m_pIncluirParams->m_borrarDespuesDeIncluir);
 
194
                                for(GNC::GCS::ControladorHistorial::ListaModelosDCM::iterator it = m_pIncluirParams->m_modelosDCM.begin(); it != m_pIncluirParams->m_modelosDCM.end(); ++it)
 
195
                                {
 
196
                                        m_pIncluirParams->m_listaEstudios.insert((*it).m_uidEstudio);
 
197
                                        m_pIncluirParams->m_listaSeries.insert((*it).m_uidSerie);
 
198
                                        m_pIncluirParams->m_listaImagenes.insert((*it).m_uidImagen);
 
199
                                }
 
200
                        }
 
201
                }
 
202
 
 
203
                void  ComandoIncluirHistorial::LeerDirectorioRecursivo(wxString& dirPath, TListaListas& listaListasPaths, int profundidadMaxima, const int profundidadActual)
 
204
                {
 
205
                        TListaPaths listaCurrentPaths;
 
206
                        wxArrayString listaDirectoriosCurrent;
 
207
                        bool dicomEncontrado = false;
 
208
                        if(wxDirExists(dirPath)) {
 
209
                                //vaciar
 
210
                                wxDir dir;
 
211
                                if (dir.Open(dirPath)) {
 
212
                                        wxString fileName;
 
213
                                        //no se listan los ocultos
 
214
                                        bool cont = dir.GetFirst(&fileName,wxEmptyString,wxDIR_FILES | wxDIR_DIRS);
 
215
                                        while (cont) {
 
216
                                                fileName=dir.GetName()+ wxFileName::GetPathSeparator(wxPATH_NATIVE) + fileName;
 
217
                                                if(wxDir::Exists(fileName) ){
 
218
                                                        listaDirectoriosCurrent.push_back(fileName);
 
219
                                                }else if (wxFileExists(fileName)) {
 
220
                                                        wxFileName filename(fileName);
 
221
                                                        if(filename.GetExt().Lower() == wxT("dcm") || GIL::DICOM::ControladorImportacionPACS::Instance()->EsDICOM(std::string(fileName.ToUTF8()), false, true) ) {
 
222
                                                                std::string pathStd(TOPATH(fileName));
 
223
                                                                listaCurrentPaths.push_back(pathStd);
 
224
                                                                dicomEncontrado = true;
 
225
                                                        }
 
226
                                                }
 
227
                                                cont = dir.GetNext(&fileName);
 
228
                                        }
 
229
                                }
 
230
                        } else if (wxFileExists(dirPath)) {
 
231
                                wxFileName filename(dirPath);
 
232
                                if(filename.GetExt().Lower() == wxT("dcm") || GIL::DICOM::ControladorImportacionPACS::Instance()->EsDICOM(std::string(dirPath.ToUTF8()), false, true)) {
 
233
                                        std::string pathStd(TOPATH(dirPath));
 
234
                                        listaCurrentPaths.push_back(pathStd);
 
235
                                        dicomEncontrado = true;
 
236
                                }
 
237
                        }
 
238
 
 
239
                        int siguienteProfundidad = profundidadActual;
 
240
                        if(dicomEncontrado) {
 
241
                                //se resetea la profundidad actual
 
242
                                siguienteProfundidad = 0;
 
243
                        } else {
 
244
                                siguienteProfundidad ++;
 
245
                        }
 
246
                        if(siguienteProfundidad <= profundidadMaxima) {
 
247
                                for(wxArrayString::iterator it =listaDirectoriosCurrent.begin(); it != listaDirectoriosCurrent.end(); ++it) {
 
248
                                        LeerDirectorioRecursivo((*it),listaListasPaths,profundidadMaxima,siguienteProfundidad);
 
249
                                }
 
250
                        }
 
251
 
 
252
                        listaListasPaths.push_back(listaCurrentPaths);
 
253
                }
 
254
 
 
255
                void ComandoIncluirHistorial::Update()
 
256
                {
 
257
                        //se abre o porque nos lo dicen o porque solo hay una serie y tenemos que informar, en ese caso en vez de informar lo abrimos
 
258
                        bool abrir = m_pIncluirParams->m_abrirDespuesDeCargar ||  ( m_pIncluirParams->m_listaSeries.size() == 1 && m_pIncluirParams->m_informar);
 
259
                        //si hay paths que se han sobreeescrito se pregunta si quiere sobreescribir
 
260
                        if(m_pIncluirParams->m_listaPathsSobreescriben.size() > 0) {
 
261
                                GNC::GUI::OverwriteDialogBase overwriteDialog(GNC::Entorno::Instance()->GetVentanaRaiz());
 
262
                                for(std::list<std::string>::iterator it = m_pIncluirParams->m_listaPathsSobreescriben.begin(); it != m_pIncluirParams->m_listaPathsSobreescriben.end(); it++) {
 
263
                                        overwriteDialog.m_pPathList->Append(FROMPATH((*it)));
 
264
                                }
 
265
                                int answer = overwriteDialog.ShowModal();
 
266
                                if(answer == wxID_OK) {
 
267
                                        //overwrite
 
268
                                        ComandoIncluirHistorialParams* pParams = new ComandoIncluirHistorialParams(m_pIncluirParams->m_listaPathsSobreescriben,m_pIncluirParams->m_abrirDespuesDeCargar, true, m_pIncluirParams->m_pModeloIntegracion);
 
269
                                        pParams->m_borrarDespuesDeIncluir = m_pIncluirParams->m_borrarDespuesDeIncluir;
 
270
                                        ComandoIncluirHistorial* pCmd = new ComandoIncluirHistorial(pParams);
 
271
                                        GNC::GCS::ControladorComandos::Instance()->ProcessAsync(_Std("Including files in the history .."),pCmd,NULL);
 
272
                                }
 
273
                        } else {
 
274
                                //si no hay paths sobreeescritos y hay que informar se pregunta si quiere abrir
 
275
                                if (!abrir && m_pIncluirParams->m_informar) {
 
276
                                        wxString message = wxT("");
 
277
                                        message += _("Image adquisition finished.");
 
278
                                        message += wxString::Format(_("\nThere have been included %d studies, %d series and %d images"),m_pIncluirParams->m_listaEstudios.size(), m_pIncluirParams->m_listaSeries.size(), m_pIncluirParams->m_listaImagenes.size());
 
279
                                        wxMessageBox(message,_("Finished .."), wxOK );
 
280
                                } 
 
281
                        }
 
282
                        if(m_pIncluirParams->m_modelosDCM.size() == 0) {
 
283
                        /*      wxMessageBox(wxT("No se han encontrado estudios nuevos"), wxT("Info"),
 
284
                                        wxOK | wxICON_INFORMATION, GNC::Entorno::Instance()->GetVentanaRaiz());*/
 
285
                        } else {
 
286
                                GNC::GCS::ControladorEventos::Instance()->ProcesarEvento(new GNC::GUI::Eventos::EventoAddModeloHistorial(&m_pIncluirParams->m_modelosDCM, abrir, m_pIncluirParams->m_pModeloIntegracion));
 
287
                        }
 
288
                }
 
289
        }
 
290
}
 
291