← 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/progress/statusbarprogreso.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/progress/statusbarprogreso.cpp
 
1
/*
 
2
 *  
 
3
 *  $Id: statusbarprogreso.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 <wx/app.h>
 
15
#include <wx/animate.h>
 
16
#include <wx/mstream.h>
 
17
#include <wx/gauge.h>
 
18
#include <wx/msgdlg.h>
 
19
#include <wx/statbmp.h>
 
20
#include <wx/thread.h>
 
21
#include <wx/ginkgostyle/ginkgostyle.h>
 
22
#include "statusbarprogreso.h"
 
23
 
 
24
#include <resources/ginkgoresourcemanager.h>
 
25
 
 
26
#include <main/controllers/controladoreventos.h>
 
27
#include <main/controllers/controladorvistas.h>
 
28
#include <eventos/eventosginkgo.h>
 
29
#include <iostream>
 
30
 
 
31
IMPLEMENT_DYNAMIC_CLASS(EventoMensajesUsuarioAsync, wxEvent)
 
32
 
 
33
//dialogo tareas
 
34
 
 
35
//
 
36
 
 
37
 
 
38
GNC::GUI::StatusBarProgreso::StatusBarProgreso( wxWindow* pPadre, wxWindow* pPadrePanel, bool listenMessages, wxWindowID id, long style) : wxStatusBar(pPadre, id, style)
 
39
{
 
40
        m_pPanelTareas = new PanelTareasBase(pPadrePanel);
 
41
        m_pPanelTareas->Show(false);
 
42
 
 
43
        SetFieldsCount(Field_Max); //uno para el texto y el otro para lo q yo quiera
 
44
        static const int widths[Field_Max] = { -1, 32, 250, 150};
 
45
        SetStatusWidths(Field_Max, widths);
 
46
 
 
47
        //mensaje tarea
 
48
        m_pMensajeTarea = new wxStaticText(this,wxID_ANY,wxT(""), wxDefaultPosition, wxSize(250, -1));
 
49
        m_pMensajeTarea->Connect(wxEVT_LEFT_DOWN, wxMouseEventHandler( StatusBarProgreso::OnMostrarOcultarDialogoProgreso),NULL,this);
 
50
 
 
51
        //botoncico de progreso
 
52
        m_pIconoProgreso = new wxAnimationCtrl(this,wxID_ANY,GinkgoResourcesManager::BarraProgreso::GetIcoLoading());
 
53
        m_pIconoProgreso->Hide();
 
54
 
 
55
        m_pProgresoTarea = new wxGauge(this, wxID_ANY, 100);
 
56
        m_pProgresoTarea->Hide();
 
57
 
 
58
        m_pIconoParado = new wxStaticBitmap(this,wxID_ANY,GinkgoResourcesManager::BarraProgreso::GetIcoStopped());
 
59
        m_pIconoParado->Show(true);
 
60
 
 
61
        ActualizarInterfaz();
 
62
 
 
63
        //escuchamos el evento de mensajes
 
64
        if (listenMessages) {
 
65
                GNC::GCS::Eventos::EventoMensajes evt(NULL);
 
66
                GNC::GCS::ControladorEventos::Instance()->Registrar(this,evt);
 
67
        }
 
68
 
 
69
        wxSizeEvent event(pPadre->GetSize());
 
70
        OnSize(event);
 
71
 
 
72
        //onsize
 
73
        this->Connect(wxEVT_SIZE,wxSizeEventHandler(StatusBarProgreso::OnSize),NULL,this);
 
74
        this->GetParent()->Connect(wxEVT_MOVE,wxMoveEventHandler(StatusBarProgreso::OnMove),NULL,this);
 
75
        this->Connect(wxEVT_MENSAJES_USUARIO_ASYNC, EventoMensajesUsuarioAsyncHandler(StatusBarProgreso::OnMensajeUsuario), NULL, this);
 
76
}
 
77
 
 
78
GNC::GUI::StatusBarProgreso::~StatusBarProgreso()
 
79
{
 
80
        m_pMensajeTarea->Disconnect(wxEVT_LEFT_DOWN, wxMouseEventHandler( StatusBarProgreso::OnMostrarOcultarDialogoProgreso),NULL,this);
 
81
 
 
82
        this->Disconnect(wxEVT_MENSAJES_USUARIO_ASYNC, EventoMensajesUsuarioAsyncHandler(StatusBarProgreso::OnMensajeUsuario), NULL, this);
 
83
        this->GetParent()->Disconnect(wxEVT_MOVE,wxMoveEventHandler(StatusBarProgreso::OnMove),NULL,this);
 
84
        this->Disconnect(wxEVT_SIZE,wxSizeEventHandler(StatusBarProgreso::OnSize),NULL,this);
 
85
 
 
86
        m_pIconoProgreso->Destroy();
 
87
        m_pIconoProgreso = NULL;
 
88
        m_pIconoParado->Destroy();
 
89
        m_pIconoParado = NULL;
 
90
        m_pProgresoTarea->Destroy();
 
91
        m_pProgresoTarea = NULL;
 
92
}
 
93
 
 
94
void GNC::GUI::StatusBarProgreso::InsertarTarea(long taskId, const std::string& text) {
 
95
 
 
96
 
 
97
        MapaTareasType::iterator it = m_MapaTareas.find(taskId);
 
98
        if (it == m_MapaTareas.end()) {
 
99
                m_pPanelTareas->Freeze();
 
100
 
 
101
                PanelTarea* pt = new PanelTarea(m_pPanelTareas, taskId);
 
102
                wxString str = wxString::FromUTF8(text.c_str());
 
103
                pt->m_pTareaLabel->SetLabel(str);
 
104
                pt->m_pTareaProgreso->SetValue(0);
 
105
                m_MapaTareas[taskId] = pt;
 
106
                pt->Show();
 
107
                m_pPanelTareas->m_pSizerTareas->Add(pt, 0, wxEXPAND | wxDOWN, 10);
 
108
                m_pPanelTareas->Layout();
 
109
 
 
110
                ActualizarInterfaz();
 
111
                m_pPanelTareas->Thaw();
 
112
        }
 
113
}
 
114
 
 
115
void GNC::GUI::StatusBarProgreso::EliminarTarea(long taskId) {
 
116
        PanelTarea* pt = NULL;
 
117
        MapaTareasType::iterator it = m_MapaTareas.find(taskId);
 
118
        if (it != m_MapaTareas.end()) {
 
119
                m_pPanelTareas->Freeze();
 
120
 
 
121
                pt = (*it).second;
 
122
 
 
123
                if (pt != NULL) {
 
124
                        m_pPanelTareas->m_pSizerTareas->Detach(pt);
 
125
                        pt->Destroy();
 
126
                        m_pPanelTareas->Layout();
 
127
                }
 
128
 
 
129
                m_MapaTareas.erase(it);
 
130
                ActualizarInterfaz();
 
131
                m_pPanelTareas->Thaw();
 
132
        }
 
133
 
 
134
}
 
135
 
 
136
void GNC::GUI::StatusBarProgreso::SetProgresoTarea(long taskId, float normalizedProgress, const std::string& text) {
 
137
 
 
138
        MapaTareasType::iterator it = m_MapaTareas.find(taskId);
 
139
 
 
140
        if (it != m_MapaTareas.end()) {
 
141
                m_pPanelTareas->Freeze();
 
142
                PanelTarea* pt = (*it).second;
 
143
                if (pt != NULL) {
 
144
                        int val = std::max<int>(0, std::min<int>(100, (int)(normalizedProgress * 100.0f)));
 
145
                        wxString str = wxString::FromUTF8(text.c_str());
 
146
                        pt->m_pTareaLabel->SetLabel(str);
 
147
                        pt->m_pTareaProgreso->SetValue(val);
 
148
                }
 
149
 
 
150
                ActualizarInterfaz();
 
151
                m_pPanelTareas->Thaw();
 
152
        }
 
153
}
 
154
 
 
155
void GNC::GUI::StatusBarProgreso::ActualizarInterfaz()
 
156
{
 
157
        if(m_MapaTareas.size() == 0){
 
158
                if(m_pIconoProgreso->IsPlaying()){
 
159
                        m_pIconoProgreso->Stop();
 
160
                }
 
161
                m_pIconoProgreso->Hide();
 
162
                m_pProgresoTarea->Hide();
 
163
                m_pIconoParado->Show(true);
 
164
                //SetStatusText(wxT(""),Field_TextoTarea);
 
165
                m_pMensajeTarea->SetLabel(_("0 running tasks."));
 
166
 
 
167
                if (!m_pPanelTareas->m_pSinTareas->IsShown()) {
 
168
                        m_pPanelTareas->m_pSinTareas->Show(true);
 
169
                        m_pPanelTareas->Layout();
 
170
                }
 
171
        } else {
 
172
                if (m_pPanelTareas->m_pSinTareas->IsShown()) {
 
173
                        m_pPanelTareas->m_pSinTareas->Show(false);
 
174
                        m_pPanelTareas->Layout();
 
175
                }
 
176
                m_pIconoParado->Hide();
 
177
                if(!m_pIconoProgreso->IsPlaying()) {
 
178
                        m_pIconoProgreso->Show();
 
179
                        m_pIconoProgreso->Play();
 
180
                }
 
181
                if(m_MapaTareas.size() == 1) {
 
182
                        m_pMensajeTarea->SetLabel((*m_MapaTareas.begin()).second->m_pTareaLabel->GetLabel());
 
183
                        m_pProgresoTarea->SetValue((*m_MapaTareas.begin()).second->m_pTareaProgreso->GetValue());
 
184
                        if (!m_pProgresoTarea->IsShown()) {
 
185
                                m_pProgresoTarea->Show();
 
186
                        }
 
187
                } else {
 
188
                        m_pMensajeTarea->SetLabel(wxString::Format(_("There are %d pending tasks"),m_MapaTareas.size()));
 
189
                        if (m_pProgresoTarea->IsShown()) {
 
190
                                m_pProgresoTarea->Hide();
 
191
                        }
 
192
                }
 
193
        }
 
194
        //Layout();
 
195
}
 
196
 
 
197
void GNC::GUI::StatusBarProgreso::OnMostrarOcultarDialogoProgreso(wxMouseEvent& )
 
198
{
 
199
        if (GNC::GCS::ControladorVistas::Instance()->EsVisible(m_pPanelTareas)) {
 
200
                GNC::GCS::ControladorVistas::Instance()->OcultarPanel(m_pPanelTareas);
 
201
        } else {
 
202
                wxPoint esquinaInferiorDerecha = GetParent()->GetPosition();
 
203
                esquinaInferiorDerecha.x += GetParent()->GetSize().x;
 
204
                esquinaInferiorDerecha.y += GetParent()->GetSize().y;
 
205
                wxPoint posicionDialogo(0,0);
 
206
                wxSize mejorSizeDialogo(400,170);
 
207
                #if defined (_WINDOWS)
 
208
                        posicionDialogo.x = esquinaInferiorDerecha.x - mejorSizeDialogo.x - 5;
 
209
                        posicionDialogo.y = esquinaInferiorDerecha.y - mejorSizeDialogo.y - 5 - GetSize().y;
 
210
                # else
 
211
                        posicionDialogo.x = esquinaInferiorDerecha.x - mejorSizeDialogo.x;
 
212
                        posicionDialogo.y = esquinaInferiorDerecha.y - mejorSizeDialogo.y;
 
213
                #endif
 
214
                GNC::GCS::ControladorVistas::Instance()->MostrarPanelFlotante(m_pPanelTareas, posicionDialogo.x, posicionDialogo.y);
 
215
        }
 
216
}
 
217
 
 
218
 
 
219
void GNC::GUI::StatusBarProgreso::OnSize(wxSizeEvent& event)
 
220
{
 
221
        Freeze();
 
222
        wxRect rect;
 
223
        GetFieldRect(Field_GifProgreso, rect);
 
224
        wxSize size = m_pIconoProgreso->GetSize();
 
225
 
 
226
        m_pIconoProgreso->Move(rect.x + (rect.width - size.x) / 2,
 
227
                                          rect.y + (rect.height - size.y) / 2);
 
228
        m_pIconoParado->Move(rect.x + (rect.width - size.x) / 2,
 
229
                                          rect.y + (rect.height - size.y) / 2);
 
230
 
 
231
        GetFieldRect(Field_ProgresoTarea, rect);
 
232
 
 
233
        wxPoint esquinaInferiorDerecha = GetParent()->GetPosition();
 
234
        esquinaInferiorDerecha.x += GetParent()->GetSize().x;
 
235
        esquinaInferiorDerecha.y += GetParent()->GetSize().y;
 
236
 
 
237
        m_pProgresoTarea->SetSize(rect.x + 2, rect.y + 2, rect.width - 4, rect.height - 4);
 
238
 
 
239
        GetFieldRect(Field_TextoTarea, rect);
 
240
        #if !defined(__WXOSX__)
 
241
        m_pMensajeTarea->SetSize(rect.x + 2, rect.y + 2, rect.width - 4, rect.height - 4);
 
242
#else
 
243
        m_pMensajeTarea->SetSize(rect.x , rect.y, rect.width, rect.height);
 
244
#endif
 
245
 
 
246
        Thaw();
 
247
        event.Skip();
 
248
}
 
249
 
 
250
void GNC::GUI::StatusBarProgreso::OnMove(wxMoveEvent& event)
 
251
{
 
252
        wxPoint esquinaInferiorDerecha = GetParent()->GetPosition();
 
253
        esquinaInferiorDerecha.x += GetParent()->GetSize().x;
 
254
        esquinaInferiorDerecha.y += GetParent()->GetSize().y;
 
255
        event.Skip();
 
256
}
 
257
 
 
258
 
 
259
void GNC::GUI::StatusBarProgreso::OnMensajeUsuario(EventoMensajesUsuarioAsync& event )
 
260
{
 
261
        switch (event.GetTipo()) {
 
262
                case EventoMensajesUsuarioAsync::StatusBar:
 
263
                        Freeze();
 
264
                        SetStatusText(event.GetTexto());
 
265
                        Thaw();
 
266
                        break;
 
267
                case EventoMensajesUsuarioAsync::PopUp:
 
268
                        switch(event.GetGravedad()) {
 
269
                                case EventoMensajesUsuarioAsync::Error:
 
270
                                        wxMessageBox(event.GetTexto(), _("Error"),wxICON_ERROR);
 
271
                                        break;
 
272
                                case EventoMensajesUsuarioAsync::Aviso:
 
273
                                        wxMessageBox(event.GetTexto(), _("Warning"),wxICON_WARNING);
 
274
                                        break;
 
275
                                case EventoMensajesUsuarioAsync::Informacion:
 
276
                                        wxMessageBox(event.GetTexto(), _("Info"),wxICON_INFORMATION);
 
277
                                        break;
 
278
                                default:
 
279
                                        wxMessageBox(event.GetTexto(), _("Info"),wxICON_INFORMATION);
 
280
                                        break;
 
281
                        }
 
282
                        break;
 
283
                default:
 
284
                        wxMessageBox(event.GetTexto(), _("Info"),wxICON_INFORMATION);
 
285
        }
 
286
 
 
287
}
 
288
 
 
289
 
 
290
void GNC::GUI::StatusBarProgreso::PreProcesarEvento(GNC::GCS::Eventos::IEvento* /*evt*/, GNC::GCS::IControladorEventos::TipoListaPunterosEventos& /*lista*/)
 
291
{
 
292
        //no se hace na
 
293
}
 
294
 
 
295
void GNC::GUI::StatusBarProgreso::ProcesarEvento(GNC::GCS::Eventos::IEvento *evt)
 
296
{
 
297
        switch (evt->GetCodigoEvento()) {
 
298
                case ginkgoEVT_Core_MensajesUsuario:
 
299
                        {
 
300
                                GNC::GCS::Eventos::EventoMensajes* pEvt = dynamic_cast<GNC::GCS::Eventos::EventoMensajes*>(evt);
 
301
                                if(pEvt!=NULL){
 
302
                                        switch(pEvt->GetTipo()) {
 
303
                                                case GNC::GCS::Eventos::EventoMensajes::StatusMessage :
 
304
                                                        {
 
305
                                                                switch (pEvt->GetGravedad()) {
 
306
                                                                        case GNC::GCS::Eventos::EventoMensajes::Error:
 
307
                                                                                {
 
308
                                                                                        EventoMensajesUsuarioAsync event(pEvt->GetMensaje(), EventoMensajesUsuarioAsync::StatusBar, EventoMensajesUsuarioAsync::Error);
 
309
                                                                                        this->AddPendingEvent(event);
 
310
                                                                                }
 
311
                                                                                break;
 
312
                                                                        case GNC::GCS::Eventos::EventoMensajes::Aviso:
 
313
                                                                                {
 
314
                                                                                        EventoMensajesUsuarioAsync event(pEvt->GetMensaje(), EventoMensajesUsuarioAsync::StatusBar,EventoMensajesUsuarioAsync::Aviso);
 
315
                                                                                        this->AddPendingEvent(event);
 
316
                                                                                }
 
317
                                                                                break;
 
318
                                                                        case GNC::GCS::Eventos::EventoMensajes::Informacion:
 
319
                                                                                {
 
320
                                                                                        EventoMensajesUsuarioAsync event(pEvt->GetMensaje(), EventoMensajesUsuarioAsync::StatusBar, EventoMensajesUsuarioAsync::Informacion);
 
321
                                                                                        this->AddPendingEvent(event);
 
322
                                                                                }
 
323
                                                                                break;
 
324
                                                                        default:
 
325
                                                                                {
 
326
                                                                                        EventoMensajesUsuarioAsync event(pEvt->GetMensaje(), EventoMensajesUsuarioAsync::StatusBar, EventoMensajesUsuarioAsync::Informacion);
 
327
                                                                                        this->AddPendingEvent(event);
 
328
                                                                                }
 
329
                                                                                break;
 
330
                                                                }
 
331
                                                        }
 
332
                                                break;
 
333
                                                case GNC::GCS::Eventos::EventoMensajes::PopUpMessage :
 
334
                                                        {
 
335
                                                                switch (pEvt->GetGravedad()) {
 
336
                                                                        case GNC::GCS::Eventos::EventoMensajes::Error:
 
337
                                                                                {
 
338
                                                                                        EventoMensajesUsuarioAsync event(pEvt->GetMensaje(),EventoMensajesUsuarioAsync::PopUp, EventoMensajesUsuarioAsync::Error);
 
339
                                                                                        this->AddPendingEvent(event);
 
340
                                                                                }
 
341
                                                                                break;
 
342
                                                                        case GNC::GCS::Eventos::EventoMensajes::Aviso:
 
343
                                                                                {
 
344
                                                                                        EventoMensajesUsuarioAsync event(pEvt->GetMensaje(),EventoMensajesUsuarioAsync::PopUp, EventoMensajesUsuarioAsync::Aviso);
 
345
                                                                                        this->AddPendingEvent(event);
 
346
                                                                                }
 
347
                                                                                break;
 
348
                                                                        case GNC::GCS::Eventos::EventoMensajes::Informacion:
 
349
                                                                                {
 
350
                                                                                        EventoMensajesUsuarioAsync event(pEvt->GetMensaje(),EventoMensajesUsuarioAsync::PopUp, EventoMensajesUsuarioAsync::Informacion);
 
351
                                                                                        this->AddPendingEvent(event);
 
352
                                                                                }
 
353
                                                                                break;
 
354
                                                                        default:
 
355
                                                                                {
 
356
                                                                                        EventoMensajesUsuarioAsync event(pEvt->GetMensaje(),EventoMensajesUsuarioAsync::PopUp, EventoMensajesUsuarioAsync::Informacion);
 
357
                                                                                        this->AddPendingEvent(event);
 
358
                                                                                }
 
359
                                                                                break;
 
360
                                                                }
 
361
                                                        }
 
362
                                                break;
 
363
                                        }
 
364
                                }
 
365
                        }
 
366
                        break;
 
367
                default:
 
368
                        break;
 
369
        }
 
370
}
 
371