← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/cadxcore/main/tools/herramientamarcado.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/tools/herramientamarcado.cpp
 
1
/*
 
2
 *  
 
3
 *  $Id: herramientamarcado.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
//#define _GINKGO_TRACE
 
15
#include <api/globals.h>
 
16
#include <wx/wx.h>
 
17
#include <wx/aui/aui.h>
 
18
 
 
19
 
 
20
#include <api/iwidgetsmanager.h>
 
21
#include "herramientamarcado.h"
 
22
#include <widgets/wflecha.h>
 
23
#include <widgets/welipse.h>
 
24
#include <widgets/wpunto.h>
 
25
#include <widgets/wtrapezoide.h>
 
26
#include <widgets/wpoligono.h>
 
27
#include <resources/ginkgoresourcemanager.h>
 
28
#include <api/internacionalizacion.h>
 
29
 
 
30
#include <iostream>
 
31
#ifdef __DEPRECATED
 
32
#undef __DEPRECATED
 
33
#endif
 
34
#include <vtk/vtkginkgoimageviewer.h>
 
35
#include <wx/xml/xml.h>
 
36
 
 
37
#define USAR_FLECHA     1451
 
38
#define USAR_ELIPSE     1452
 
39
#define USAR_TRAPEZOIDE 1453
 
40
#define USAR_POLIGONO   1454
 
41
#define USAR_PUNTO      1455
 
42
 
 
43
namespace GNC {
 
44
        namespace GUI {
 
45
                class HerramientaOpcionesMarcadoGUI : public AUI_NAMESPACE wxAuiToolBar {
 
46
                public:
 
47
                        HerramientaOpcionesMarcadoGUI(wxWindow* pParent, GNC::HerramientaMarcado* pHerramienta): AUI_NAMESPACE wxAuiToolBar(pParent,wxID_ANY, wxDefaultPosition, wxDefaultSize)
 
48
                        {
 
49
                                m_pHerramienta = pHerramienta;
 
50
 
 
51
                                SetToolBitmapSize( wxSize( 16,16 ) );
 
52
                                AddTool( USAR_PUNTO, _("Point"), GinkgoResourcesManager::BarraMarcado::GetIcoPunto(), _("Point"), wxITEM_CHECK);
 
53
                                ToggleTool(USAR_PUNTO,true);
 
54
                                AddTool( USAR_FLECHA, _("Arrow"), GinkgoResourcesManager::BarraMarcado::GetIcoFlecha(), _("Arrow"), wxITEM_CHECK);
 
55
                                AddTool( USAR_ELIPSE, _("Ellipse"), GinkgoResourcesManager::BarraMarcado::GetIcoElipse(), _("Ellipse"), wxITEM_CHECK);
 
56
                                AddTool( USAR_TRAPEZOIDE, _("Trapezoid"), GinkgoResourcesManager::BarraMarcado::GetIcoTrapezoide(), _("Trapezoid"), wxITEM_CHECK);
 
57
                                AddTool( USAR_POLIGONO, _("Poligono"), GinkgoResourcesManager::BarraMarcado::GetIcoPoligono(), _("Polygon"), wxITEM_CHECK);
 
58
 
 
59
                                Realize();
 
60
                                Layout();
 
61
 
 
62
                                // Connect Events
 
63
                                this->Connect( USAR_PUNTO, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( HerramientaOpcionesMarcadoGUI::OnHerramientaPuntoClick ) );
 
64
                                this->Connect( USAR_FLECHA, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( HerramientaOpcionesMarcadoGUI::OnHerramientaFlechaClick ) );
 
65
                                this->Connect( USAR_ELIPSE, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( HerramientaOpcionesMarcadoGUI::OnHerramientaElipseClick ) );
 
66
                                this->Connect( USAR_TRAPEZOIDE, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( HerramientaOpcionesMarcadoGUI::OnHerramientaTrapezoideClick ) );
 
67
                                this->Connect( USAR_POLIGONO, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( HerramientaOpcionesMarcadoGUI::OnHerramientaPoligonoClick ) );
 
68
                        }
 
69
 
 
70
                        ~HerramientaOpcionesMarcadoGUI(){
 
71
                                // Disconnect Events
 
72
                                this->Disconnect( USAR_PUNTO, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( HerramientaOpcionesMarcadoGUI::OnHerramientaPuntoClick ) );
 
73
                                this->Disconnect( USAR_FLECHA, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( HerramientaOpcionesMarcadoGUI::OnHerramientaFlechaClick ) );
 
74
                                this->Disconnect( USAR_ELIPSE, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( HerramientaOpcionesMarcadoGUI::OnHerramientaElipseClick ) );
 
75
                                this->Disconnect( USAR_TRAPEZOIDE, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( HerramientaOpcionesMarcadoGUI::OnHerramientaTrapezoideClick ) );
 
76
                                this->Disconnect( USAR_POLIGONO, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( HerramientaOpcionesMarcadoGUI::OnHerramientaPoligonoClick ) );
 
77
                        }
 
78
 
 
79
 
 
80
                        virtual void OnHerramientaPuntoClick( wxCommandEvent& event ){
 
81
                                ToggleTool(USAR_PUNTO, true);
 
82
                                ToggleTool(USAR_FLECHA, false);
 
83
                                ToggleTool(USAR_ELIPSE, false);
 
84
                                ToggleTool(USAR_TRAPEZOIDE, false);
 
85
                                ToggleTool(USAR_POLIGONO, false);
 
86
                                m_pHerramienta->SetTipoMarcado(GNC::HerramientaMarcado::TW_Punto);
 
87
                                event.Skip(false);
 
88
                        }
 
89
 
 
90
                        virtual void OnHerramientaFlechaClick( wxCommandEvent& event ){
 
91
                                ToggleTool(USAR_PUNTO, false);
 
92
                                ToggleTool(USAR_FLECHA, true);
 
93
                                ToggleTool(USAR_ELIPSE, false);
 
94
                                ToggleTool(USAR_TRAPEZOIDE, false);
 
95
                                ToggleTool(USAR_POLIGONO, false);
 
96
                                m_pHerramienta->SetTipoMarcado(GNC::HerramientaMarcado::TW_Flecha);
 
97
                                event.Skip(false);
 
98
                        }
 
99
 
 
100
                        virtual void OnHerramientaElipseClick( wxCommandEvent& event ){
 
101
                                ToggleTool(USAR_PUNTO, false);
 
102
                                ToggleTool(USAR_FLECHA, false);
 
103
                                ToggleTool(USAR_ELIPSE, true);
 
104
                                ToggleTool(USAR_TRAPEZOIDE, false);
 
105
                                ToggleTool(USAR_POLIGONO, false);
 
106
                                m_pHerramienta->SetTipoMarcado(GNC::HerramientaMarcado::TW_Elipse);
 
107
                                event.Skip(false);
 
108
                        }
 
109
 
 
110
                        virtual void OnHerramientaTrapezoideClick( wxCommandEvent& event ){
 
111
                                ToggleTool(USAR_PUNTO, false);
 
112
                                ToggleTool(USAR_FLECHA, false);
 
113
                                ToggleTool(USAR_ELIPSE, false);
 
114
                                ToggleTool(USAR_TRAPEZOIDE, true);
 
115
                                ToggleTool(USAR_POLIGONO, false);
 
116
                                m_pHerramienta->SetTipoMarcado(GNC::HerramientaMarcado::TW_Trapezoide);
 
117
                                event.Skip(false);
 
118
                        }
 
119
 
 
120
                        virtual void OnHerramientaPoligonoClick( wxCommandEvent& event ){
 
121
                                ToggleTool(USAR_PUNTO, false);
 
122
                                ToggleTool(USAR_FLECHA, false);
 
123
                                ToggleTool(USAR_ELIPSE, false);
 
124
                                ToggleTool(USAR_TRAPEZOIDE, false);
 
125
                                ToggleTool(USAR_POLIGONO, true);
 
126
                                m_pHerramienta->SetTipoMarcado(GNC::HerramientaMarcado::TW_Poligono);
 
127
                                event.Skip(false);
 
128
                        }
 
129
 
 
130
                        GNC::HerramientaMarcado* m_pHerramienta;
 
131
 
 
132
                };
 
133
        }
 
134
}
 
135
 
 
136
GNC::HerramientaMarcado::HerramientaMarcado() {
 
137
        m_Activa = false;
 
138
        m_pContratoActivo = NULL;
 
139
        m_pBuilder = NULL;
 
140
        m_MarcadoActivo = TW_Punto;
 
141
        m_Descripcion = _Std("Marking Tools");
 
142
        m_Icono = GinkgoResourcesManager::IconosHerramientas::GetIcoMarcado();
 
143
}
 
144
 
 
145
GNC::HerramientaMarcado::~HerramientaMarcado()
 
146
{
 
147
}
 
148
 
 
149
wxXmlNode* GNC::HerramientaMarcado::Serializar(GNC::GCS::IVista* pVista, long vid, const std::string nombreMedicoSerializa)
 
150
{
 
151
        //se cogen todas los widgets regla de los contratos con ese vid
 
152
        typedef  GNC::GCS::IContratable<GNC::GCS::IContratoWidgets> ICConcreto;
 
153
        //se cogen todas los widgets regla de los contratos con ese vid
 
154
        GNC::GCS::ListaWidgets listaWidgets;
 
155
        for (ICConcreto::IteradorMapaContratos it = ICConcreto::m_Contratos.begin(); it != ICConcreto::m_Contratos.end(); it++) {
 
156
                if((*it).first == pVista){
 
157
                        for (ICConcreto::IteradorListaContratos it2 = (*it).second->begin(); it2 != (*it).second->end(); it2++) {
 
158
                                GNC::GCS::IContratoWidgets* pC = (*it2);
 
159
                                GNC::GCS::ListaWidgets listaWidgetsTmp;
 
160
                                if(pC->GetManager() != NULL){
 
161
                                        pC->GetManager()->GetListaWidgetsSubVista(vid,listaWidgetsTmp);
 
162
                                        listaWidgets.splice(listaWidgets.begin(),listaWidgetsTmp);
 
163
                                }
 
164
                        }
 
165
                }
 
166
        }
 
167
 
 
168
        wxXmlNode* resultado = NULL;
 
169
        if(listaWidgets.size()>0){
 
170
                resultado = new wxXmlNode(NULL,wxXML_ELEMENT_NODE,wxT("marcado"));
 
171
                resultado->AddProperty(wxT("id"),wxString::Format(wxT("%d"),this->ID));
 
172
                for (GNC::GCS::IWidgetsManager::IteradorListaWidgets it = listaWidgets.begin();  it!= listaWidgets.end(); it++){
 
173
                        GNC::GCS::Widgets::WPunto* pPunto = dynamic_cast<GNC::GCS::Widgets::WPunto*>((*it));
 
174
                        if( pPunto != NULL && pPunto->EsMarcador()){ //semillas
 
175
                                //se pillan las del grupo
 
176
                                if((*it)->GetGID() == (long)(this)){
 
177
                                        resultado->AddChild(pPunto->Serializar(nombreMedicoSerializa));
 
178
                                }
 
179
                        } else {
 
180
                                GNC::GCS::Widgets::WFlecha* pFlecha = dynamic_cast<GNC::GCS::Widgets::WFlecha*>((*it));
 
181
                                if( pFlecha != NULL && pFlecha->EsMarcador()){ //flechas
 
182
                                        resultado->AddChild(pFlecha->Serializar(nombreMedicoSerializa));
 
183
                                } else {
 
184
                                        GNC::GCS::Widgets::WElipse* pElipse = dynamic_cast<GNC::GCS::Widgets::WElipse*>((*it));
 
185
                                        if( pElipse != NULL && pElipse->EsMarcador()){ //elipse
 
186
                                                resultado->AddChild(pElipse->Serializar(nombreMedicoSerializa));
 
187
                                        } else {
 
188
                                                GNC::GCS::Widgets::WPoligono* pPoligono = dynamic_cast<GNC::GCS::Widgets::WPoligono*>((*it));
 
189
                                                if( pPoligono != NULL && pPoligono->EsMarcador()){ //poligono
 
190
                                                        resultado->AddChild(pPoligono->Serializar(nombreMedicoSerializa));
 
191
                                                } else {
 
192
                                                        GNC::GCS::Widgets::WTrapezoide* pTrapezoide = dynamic_cast<GNC::GCS::Widgets::WTrapezoide*>((*it));
 
193
                                                        if( pTrapezoide != NULL && pTrapezoide->EsMarcador()){ //trapezoide
 
194
                                                                resultado->AddChild(pTrapezoide->Serializar(nombreMedicoSerializa));
 
195
                                                        }
 
196
                                                }
 
197
                                        }
 
198
                                }
 
199
                        }
 
200
                }
 
201
        }
 
202
        return resultado;
 
203
}
 
204
 
 
205
void GNC::HerramientaMarcado::Deserializar(GNC::GCS::IVista* pVista, long vid, wxXmlNode* nodo)
 
206
{
 
207
        if(nodo->GetPropVal(wxT("id"),wxT("")) != wxString::Format(wxT("%d"),this->ID)){
 
208
                std::cerr<< "Ha ocurrido un error al desserializar la herramienta marcado"<<std::endl;
 
209
        }
 
210
 
 
211
        typedef  GNC::GCS::IContratable<GNC::GCS::IContratoWidgets> ICConcreto;
 
212
 
 
213
        for (ICConcreto::IteradorMapaContratos it = ICConcreto::m_Contratos.begin(); it != ICConcreto::m_Contratos.end(); it++) {
 
214
                if((*it).first == pVista){
 
215
 
 
216
                        for (ICConcreto::IteradorListaContratos it2 = (*it).second->begin(); it2 != (*it).second->end(); it2++) {
 
217
                                GNC::GCS::IContratoWidgets* pC = (*it2);
 
218
 
 
219
                                GNC::GCS::ListaWidgets listaWidgets;
 
220
 
 
221
                                wxXmlNode *child = nodo->GetChildren();
 
222
                                while (child) {
 
223
                                        if(child->GetName() == wxT("punto_widget")){
 
224
                                                GNC::GCS::Widgets::WPunto* pWidget = new GNC::GCS::Widgets::WPunto(pC->GetManager(), vid, (long)this, child);
 
225
                                                listaWidgets.push_back(pWidget);
 
226
                                        } else if (child->GetName() == wxT("flecha_widget")){
 
227
                                                GNC::GCS::Widgets::WFlecha* pWidget = new GNC::GCS::Widgets::WFlecha(pC->GetManager(), vid, child);
 
228
                                                listaWidgets.push_back(pWidget);
 
229
                                        } else if (child->GetName() == wxT("elipse_widget")){
 
230
                                                GNC::GCS::Widgets::WElipse* pWidget = new GNC::GCS::Widgets::WElipse(pC->GetManager(), vid, (long)this, child);
 
231
                                                listaWidgets.push_back(pWidget);
 
232
                                        } else if (child->GetName() == wxT("poligono_widget")){
 
233
                                                GNC::GCS::Widgets::WPoligono* pWidget = new GNC::GCS::Widgets::WPoligono(pC->GetManager(), vid, child);
 
234
                                                listaWidgets.push_back(pWidget);
 
235
                                        } else if (child->GetName() == wxT("trapezoide_widget")){
 
236
                                                GNC::GCS::Widgets::WTrapezoide* pWidget = new GNC::GCS::Widgets::WTrapezoide(pC->GetManager(), vid, (long)this, child);
 
237
                                                listaWidgets.push_back(pWidget);
 
238
                                        }
 
239
                                        child = child->GetNext();
 
240
                                }
 
241
 
 
242
                                for (GNC::GCS::IWidgetsManager::IteradorListaWidgets itWidgets = listaWidgets.begin();  itWidgets!= listaWidgets.end(); itWidgets++){
 
243
                                        pC->GetManager()->InsertarWidget((*itWidgets),false);
 
244
                                }
 
245
                        }
 
246
                }
 
247
        }
 
248
}
 
249
 
 
250
//region "Realizacion de la interfaz IHerramienta"
 
251
 
 
252
void GNC::HerramientaMarcado::CrearPaneles( wxPanel* panel ) {
 
253
        m_pAbstractPanelHerramientaOpciones = new GNC::GUI::HerramientaOpcionesMarcadoGUI(panel, this);
 
254
}
 
255
 
 
256
void GNC::HerramientaMarcado::ConectarContratoFalso(bool activar) {
 
257
        typedef  GNC::GCS::IContratable<GNC::GCS::IContratoWidgets> ICConcreto;
 
258
        if (ICConcreto::m_pListaActiva == NULL) {
 
259
                //std::cerr << "Error: Se trato de activar el modo deshabilitado de una vista sin haber asignado la vista activa. Error en la logica de activacion. Accion ignorada" << std::endl;
 
260
                return;
 
261
        }
 
262
 
 
263
        for (ICConcreto::IteradorListaContratos it = ICConcreto::m_pListaActiva->begin(); it != ICConcreto::m_pListaActiva->end(); it++) {
 
264
                GNC::GCS::IContratoWidgets* pC = (*it);
 
265
                if (pC->Inicializado()) {
 
266
                        if (activar) {
 
267
                                GTRACE("HerramientaMarcado: Conectando contrato falso de vista " << ICConcreto::m_pVistaActiva);
 
268
                                pC->GetViewer()->SetInteractionStyle(vtkGinkgoImageViewer::ZOOM_INTERACTION);
 
269
                                pC->GetManager()->SetCursor(GNC::GCS::Widgets::CUR_FLECHA);
 
270
 
 
271
                        } else {
 
272
                                GTRACE("HerramientaMarcado: Desconectando contrato falso de vista " << ICConcreto::m_pVistaActiva);
 
273
                                pC->GetViewer()->SetInteractionStyle(vtkGinkgoImageViewer::ZOOM_INTERACTION);
 
274
                                pC->GetManager()->SetCursor(GNC::GCS::Widgets::CUR_FLECHA);
 
275
                        }
 
276
                }
 
277
        }
 
278
}
 
279
 
 
280
void GNC::HerramientaMarcado::SetVistaActiva(GNC::GCS::IVista* pVista) {
 
281
        GNC::GCS::IContratable<GNC::GCS::IContratoWidgets>::EstablecerVistaActiva(pVista);
 
282
        GTRACE("GNC::HerramientaMarcado::SetVistaActiva(" <<  pVista << ")");
 
283
}
 
284
 
 
285
void GNC::HerramientaMarcado::ConectarContratos(bool activar) {
 
286
 
 
287
        if (ICConcreto::m_pListaActiva == NULL) {
 
288
                if (activar) {
 
289
                        std::cerr << "Error: Se trataron de conectar contratos sin haber asignado la vista activa. Error en la logica de activacion. Accion ignorada" << std::endl;
 
290
                } else {
 
291
                        if (m_pBuilder != NULL) {
 
292
                                delete m_pBuilder;
 
293
                                m_pBuilder = NULL;
 
294
                        }
 
295
                }
 
296
                return;
 
297
        }
 
298
 
 
299
        for (ICConcreto::IteradorListaContratos it = ICConcreto::m_pListaActiva->begin(); it != ICConcreto::m_pListaActiva->end(); it++) {
 
300
                GNC::GCS::IContratoWidgets* pC = (*it);
 
301
                if (pC->Inicializado()) {
 
302
                        if (activar) {
 
303
                                GTRACE("HerramientaMarcado: Conectando contratos de vista " << ICConcreto::m_pVistaActiva);
 
304
                                m_pContratoActivo = pC;
 
305
                                SetTipoMarcado(m_MarcadoActivo);
 
306
                                pC->GetViewer()->SetInteractionStyle(vtkGinkgoImageViewer::ZOOM_INTERACTION);
 
307
                                if (m_pBuilder != NULL) {
 
308
                                        pC->GetManager()->SetCursor(m_pBuilder->GetCursor());
 
309
                                }
 
310
                                else {
 
311
                                        pC->GetManager()->SetCursor(GNC::GCS::Widgets::CUR_FLECHA);
 
312
                                }
 
313
 
 
314
                        } else {
 
315
                                m_pContratoActivo = NULL;
 
316
                                GTRACE( "HerramientaMarcado: Desconectando contratos de vista " << ICConcreto::m_pVistaActiva );
 
317
                                pC->GetViewer()->SetInteractionStyle(vtkGinkgoImageViewer::ZOOM_INTERACTION);
 
318
                                pC->GetManager()->SetCursor(GNC::GCS::Widgets::CUR_FLECHA);
 
319
                                if (m_pBuilder != NULL) {
 
320
                                        delete m_pBuilder;
 
321
                                        m_pBuilder = NULL;
 
322
                                }
 
323
                        }
 
324
                }
 
325
        }
 
326
}
 
327
 
 
328
//endregion
 
329
 
 
330
//region "Eventos refinados desde los paneles"
 
331
void GNC::HerramientaMarcado::SetTipoMarcado(TipoMarcado tipo)
 
332
{
 
333
        if (m_MarcadoActivo == tipo && m_pBuilder != NULL) {
 
334
                return;
 
335
        }
 
336
        else {
 
337
                if (m_pBuilder != NULL) {
 
338
                        delete m_pBuilder;
 
339
                        m_pBuilder = NULL;
 
340
                }
 
341
                m_MarcadoActivo = tipo;
 
342
                switch (m_MarcadoActivo) {
 
343
                        case TW_Flecha:
 
344
                                m_pBuilder = new GNC::GCS::Widgets::WFlechaBuilder(m_pContratoActivo->GetManager());
 
345
                                break;
 
346
                        case TW_Elipse:
 
347
                                m_pBuilder = new GNC::GCS::Widgets::WElipseBuilder(m_pContratoActivo->GetManager(), (unsigned long)this);
 
348
                                break;
 
349
                        case TW_Trapezoide:
 
350
                                m_pBuilder = new GNC::GCS::Widgets::WTrapezoideBuilder(m_pContratoActivo->GetManager(), (unsigned long)this);
 
351
                                break;
 
352
                        case TW_Poligono:
 
353
                                m_pBuilder = new GNC::GCS::Widgets::WPoligonoBuilder(GNC::GCS::Widgets::MP_Normal, m_pContratoActivo->GetManager());
 
354
                                break;
 
355
                        case TW_Punto:
 
356
                                {
 
357
                                        GNC::GCS::Widgets::WPuntoBuilder* pPuntoBuilder = new GNC::GCS::Widgets::WPuntoBuilder(m_pContratoActivo->GetManager(), (unsigned long)this);
 
358
                                        m_pBuilder = pPuntoBuilder;
 
359
                                }
 
360
                                break;
 
361
                        default:
 
362
                                std::cerr << "Error, Elemento de marcado no soportado." << std::endl;
 
363
                                break;
 
364
                        }
 
365
                        if (m_pBuilder != NULL) {
 
366
                                m_pContratoActivo->GetManager()->SetCursor(m_pBuilder->GetCursor());
 
367
                        }
 
368
                        else {
 
369
                                m_pContratoActivo->GetManager()->SetCursor(GNC::GCS::Widgets::CUR_FLECHA);
 
370
                        }
 
371
        }
 
372
}
 
373
//endregion