← 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/print/printmanager.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/print/printmanager.cpp
 
1
/*
 
2
 *
 
3
 *  $Id: printmanager.cpp 3746 2011-04-19 10:41:32Z 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/string.h>
 
15
#include <wx/checkbox.h>
 
16
#include <wx/choice.h>
 
17
#include <wx/gdicmn.h>
 
18
#include <wx/font.h>
 
19
#include <wx/colour.h>
 
20
#include <wx/settings.h>
 
21
#include <wx/stattext.h>
 
22
#include <wx/checklst.h>
 
23
#include <wx/sizer.h>
 
24
#include <wx/statbox.h>
 
25
#include <wx/slider.h>
 
26
#include <wx/gbsizer.h>
 
27
#include <wx/statline.h>
 
28
#include <wx/button.h>
 
29
#include <wx/statusbr.h>
 
30
#include <wx/frame.h>
 
31
#include "printmanager.h"
 
32
#include <wx/image.h>
 
33
#include <wx/printdlg.h>
 
34
#include <api/math/geometria.h>
 
35
#include <main/entorno.h>
 
36
#include <sstream>
 
37
#include <wx/ginkgostyle/ginkgostyle.h>
 
38
#include <wx/dcclient.h>
 
39
 
 
40
#include <export/icontratoscore.h>
 
41
#include <api/icontextoestudio.h>
 
42
namespace GNC {
 
43
        namespace GCS {
 
44
                namespace Printing {
 
45
                        typedef struct MemoryBitmap
 
46
                        {
 
47
                                unsigned long  ancho;
 
48
                                unsigned long  alto;
 
49
                                unsigned char* data;
 
50
 
 
51
                                MemoryBitmap()
 
52
                                {
 
53
                                        ancho = 0;
 
54
                                        alto = 0;
 
55
                                        data = NULL;
 
56
                                }
 
57
 
 
58
                                ~MemoryBitmap()
 
59
                                {
 
60
                                        Clear();
 
61
                                }
 
62
 
 
63
                                void Clear()
 
64
                                {
 
65
                                        if (data != NULL) {
 
66
                                                delete[] data;
 
67
                                        }
 
68
                                        ancho = 0;
 
69
                                        alto = 0;
 
70
                                        data = NULL;
 
71
                                }
 
72
 
 
73
                        } MemoryBitmap;
 
74
 
 
75
                        typedef struct TipoWizardImprimir{
 
76
                                GNC::GCS::IVista* m_pVista;
 
77
 
 
78
                                //imagenes
 
79
                                bool m_incluirWidgets;
 
80
                                typedef GNC::GCS::IContratoExportacionImages::MapaMapasValoracion MapaMapasValoracion;
 
81
                                MapaMapasValoracion m_mapasValoracion;
 
82
                                int m_filas;
 
83
                                int m_columnas;
 
84
 
 
85
                                //jpeg
 
86
                                int m_jpegCalidad;
 
87
 
 
88
                                TipoWizardImprimir(){
 
89
                                        m_pVista=NULL;
 
90
                                        m_incluirWidgets = false;
 
91
                                        m_filas = 1;
 
92
                                        m_columnas = 1;
 
93
                                }
 
94
 
 
95
                                ~TipoWizardImprimir(){
 
96
                                        m_pVista=NULL;
 
97
                                        m_mapasValoracion.clear();
 
98
                                }
 
99
 
 
100
                        } TipoWizardImprimir;
 
101
 
 
102
                        //se hace solo para exponer el atributo m_printingPrepared para refrescar como dios manda
 
103
                        class MiPrintPreview: public wxPrintPreview
 
104
                        {
 
105
                        public:
 
106
                                MiPrintPreview(wxPrintout* pPrintOutPreview, wxPrintout* pPrintOutPrint,wxPrintData* pPrintData): wxPrintPreview(pPrintOutPreview,pPrintOutPrint,pPrintData)
 
107
                                {
 
108
                                }
 
109
                                ~MiPrintPreview()
 
110
                                {
 
111
                                }
 
112
 
 
113
                                void VolverAConsultarPaginas()
 
114
                                {
 
115
                                        #if defined(USE_PATCHED_LIBS)
 
116
                                        ((MiPrintPreview*) ((wxPrintPreviewBase*)(m_pimpl)))->m_printingPrepared = false;
 
117
                                        #endif
 
118
                                }
 
119
                                void InvalidarPreviewBitmap()
 
120
                                {
 
121
                                        #if defined(USE_PATCHED_LIBS)
 
122
                                        if(((MiPrintPreview*) ((wxPrintPreviewBase*)(m_pimpl)))->m_previewBitmap!=NULL)
 
123
                                        {
 
124
                                                delete ((MiPrintPreview*) ((wxPrintPreviewBase*)(m_pimpl)))->m_previewBitmap;
 
125
                                                ((MiPrintPreview*) ((wxPrintPreviewBase*)(m_pimpl)))->m_previewBitmap = NULL;
 
126
                                        }
 
127
                                        #endif
 
128
                                }
 
129
                        };
 
130
                        //////////////////////////
 
131
                        PrintManager::PrintManager(const wxString& titulo, wxPrintData* pPrintData ) : wxPrintout(titulo)
 
132
                        {
 
133
                                m_pPrintData = pPrintData;
 
134
                                m_pDatosExportacion = NULL;
 
135
                        }
 
136
 
 
137
                        PrintManager::~PrintManager()
 
138
                        {
 
139
                                m_pPrintData = NULL;
 
140
                                m_pDatosExportacion = NULL;
 
141
                        }
 
142
 
 
143
                        bool PrintManager::HasPage(int page)
 
144
                        {
 
145
                                if(m_pDatosExportacion != NULL) {
 
146
                                        int tmpMax = m_pDatosExportacion->m_pVista->GetRutasImagenes().size() / (m_pDatosExportacion->m_filas* m_pDatosExportacion->m_columnas);
 
147
                                        if(m_pDatosExportacion->m_pVista->GetRutasImagenes().size() % (m_pDatosExportacion->m_filas* m_pDatosExportacion->m_columnas) != 0) {
 
148
                                                tmpMax++;
 
149
                                        }
 
150
                                        if(page >=1 && page <= tmpMax)
 
151
                                        {
 
152
                                                return true;
 
153
                                        } else {
 
154
                                                return false;
 
155
                                        }
 
156
                                } else {
 
157
                                        return false;
 
158
                                }
 
159
                        }
 
160
 
 
161
                        bool PrintManager::OnBeginDocument(int startPage, int endPage)
 
162
                        {
 
163
                                if (!wxPrintout::OnBeginDocument(startPage, endPage))
 
164
                                {
 
165
                                        return false;
 
166
                                }
 
167
                                return true;
 
168
                        }
 
169
 
 
170
                        void PrintManager::GetPageInfo(int *minPage, int *maxPage, int *selPageFrom, int *selPageTo)
 
171
                        {
 
172
                                if(m_pDatosExportacion != NULL) {
 
173
 
 
174
                                        int tmpMax = m_pDatosExportacion->m_pVista->GetRutasImagenes().size() / (m_pDatosExportacion->m_filas* m_pDatosExportacion->m_columnas);
 
175
                                        if(m_pDatosExportacion->m_pVista->GetRutasImagenes().size() % (m_pDatosExportacion->m_filas* m_pDatosExportacion->m_columnas) != 0) {
 
176
                                                tmpMax++;
 
177
                                        }
 
178
                                        *minPage = 1;
 
179
                                        *maxPage = tmpMax;
 
180
                                        *selPageFrom = 1;
 
181
                                        *selPageTo = tmpMax;
 
182
                                } else {
 
183
                                        *minPage = 1;
 
184
                                        *maxPage = 1;
 
185
                                        *selPageFrom = 1;
 
186
                                        *selPageTo = 1;
 
187
                                }
 
188
                        }
 
189
 
 
190
                        bool PrintManager::OnPrintPage(int page){
 
191
                                wxDC *dc = GetDC();
 
192
                                if (dc && m_pDatosExportacion)
 
193
                                {
 
194
                                        //adapto el layout a la orientacion
 
195
                                        if(this->GetLogicalPageRect().GetSize().GetWidth() > this->GetLogicalPageRect().GetSize().GetHeight()//si ancho mayor que alto
 
196
                                                && m_pDatosExportacion->m_filas > m_pDatosExportacion->m_columnas)// y filas mayor que columnas se intercambian
 
197
                                        {
 
198
                                                int filasTemp = m_pDatosExportacion->m_filas;
 
199
                                                m_pDatosExportacion->m_filas = m_pDatosExportacion->m_columnas;
 
200
                                                m_pDatosExportacion->m_columnas = filasTemp;
 
201
                                        } else if (this->GetLogicalPageRect().GetSize().GetWidth() < this->GetLogicalPageRect().GetSize().GetHeight()//si alto mayor que ancho
 
202
                                                && m_pDatosExportacion->m_filas < m_pDatosExportacion->m_columnas)// y col mayor que filas se intercambian
 
203
                                        {
 
204
                                                int filasTemp = m_pDatosExportacion->m_filas;
 
205
                                                m_pDatosExportacion->m_filas = m_pDatosExportacion->m_columnas;
 
206
                                                m_pDatosExportacion->m_columnas = filasTemp;
 
207
                                        }
 
208
 
 
209
                                        //calculo tamaños
 
210
                                        int anchuraMM, alturaMM;
 
211
                                        this->GetPageSizeMM(&anchuraMM,&alturaMM);
 
212
                                        const int offSetImages = 5 * (this->GetLogicalPageRect().GetSize().GetWidth() / anchuraMM);
 
213
                                        int imagen = (page-1)*m_pDatosExportacion->m_filas*m_pDatosExportacion->m_columnas;
 
214
                                        const int anchoTotal = this->GetLogicalPageRect().GetSize().GetWidth()- (offSetImages * m_pDatosExportacion->m_columnas) - offSetImages;
 
215
                                        const int altoTotal = this->GetLogicalPageRect().GetSize().GetHeight()- (offSetImages * m_pDatosExportacion->m_filas) - offSetImages;
 
216
                                        const int anchoImagen = anchoTotal / m_pDatosExportacion->m_columnas;
 
217
                                        const int altoImagen = altoTotal / m_pDatosExportacion->m_filas;
 
218
 
 
219
                                        //limpioi
 
220
                                        dc->SetBackground(*wxWHITE_BRUSH);
 
221
                                        dc->Clear();
 
222
 
 
223
                                        for(int fila = 0; fila < m_pDatosExportacion->m_filas; fila++)
 
224
                                        {
 
225
                                                for(int columna = 0; columna < m_pDatosExportacion->m_columnas && imagen < (int)m_pDatosExportacion->m_pVista->GetRutasImagenes().size(); columna++, imagen++)
 
226
                                                {
 
227
                                                        MemoryBitmap* m_MemoryBitmap = new MemoryBitmap();
 
228
                                                        //pasamos los datos al helper y ya tenemos la imagen en memoria
 
229
                                                        RenderizaImagen(imagen, m_MemoryBitmap, GNC::GCS::Vector(anchoImagen, altoImagen));
 
230
                                                        if(m_MemoryBitmap->data != NULL) {
 
231
                                                                wxImage img(  m_MemoryBitmap->ancho, m_MemoryBitmap->alto, m_MemoryBitmap->data, true );
 
232
 
 
233
                                                                if(img.IsOk()) {
 
234
                                                                        const int xImg = (anchoImagen + offSetImages) * columna + offSetImages;
 
235
                                                                        const int yImg = (altoImagen + offSetImages) * fila +offSetImages;
 
236
                                                                        dc->DrawBitmap( img, xImg, yImg );
 
237
                                                                }
 
238
                                                        }
 
239
                                                        delete m_MemoryBitmap;
 
240
                                                }
 
241
                                        }
 
242
 
 
243
                                        return true;
 
244
                                }
 
245
                                else {
 
246
                                        return false;
 
247
                                }
 
248
                        }
 
249
 
 
250
                        void PrintManager::SetDatosExportacion(TipoWizardImprimir* pDatosExportacion)
 
251
                        {
 
252
                                m_pDatosExportacion = pDatosExportacion;
 
253
                        }
 
254
 
 
255
                        void PrintManager::RenderizaImagen(int imagen, MemoryBitmap* pMemoryBitmap, const GNC::GCS::Vector& size)
 
256
                        {
 
257
                                GNC::GCS::IContratoExportacionImages* pContratoImages = dynamic_cast<GNC::GCS::IContratoExportacionImages*>(m_pDatosExportacion->m_pVista);
 
258
                                if(pContratoImages != NULL){
 
259
                                        GNC::GCS::IContratoExportacionImages::ImageType::Pointer img;
 
260
                                        pContratoImages->GetImage(img, imagen, m_pDatosExportacion->m_mapasValoracion, m_pDatosExportacion->m_incluirWidgets, size);
 
261
                                        pMemoryBitmap->Clear();
 
262
                                        if(img.IsNotNull())
 
263
                                        {
 
264
                                                GNC::GCS::IContratoExportacionImages::ImageType::PixelType* pixelPointer = img->GetPixelContainer()->GetImportPointer();
 
265
                                                pMemoryBitmap->Clear();
 
266
                                                pMemoryBitmap->data = (unsigned char*) ((void*)pixelPointer);
 
267
                                                img->GetPixelContainer()->SetContainerManageMemory(false);
 
268
                                                GNC::GCS::IContratoExportacionImages::ImageType::SizeType imgSize;
 
269
                                                imgSize = img->GetLargestPossibleRegion().GetSize();
 
270
                                                pMemoryBitmap->ancho = imgSize[0];
 
271
                                                pMemoryBitmap->alto = imgSize[1];
 
272
                                        }
 
273
                                }
 
274
                        }
 
275
 
 
276
 
 
277
                        /////////////////////////////////////////////////////////
 
278
                        DialogoImpresion::DialogoImpresion(wxWindow *parent, GNC::GCS::IVista* pVista,const wxString& titulo, wxPrintData* pPrintData):
 
279
                        wxPreviewFrame(new MiPrintPreview(new GNC::GCS::Printing::PrintManager(titulo,pPrintData),new GNC::GCS::Printing::PrintManager(titulo,pPrintData),pPrintData),parent,_("Print"))
 
280
                        {
 
281
                                m_pPrintData = pPrintData;
 
282
                                //a 300 dpi
 
283
                                m_pPrintData->SetQuality(300);
 
284
                                #if defined(__WXGTK__)
 
285
                                m_pPrintData->SetPaperId(wxPAPER_A4);
 
286
                                #endif
 
287
                                m_pVista = pVista;
 
288
                                //zooms
 
289
                                for(int i = 10 ; i<=100; i+= 5){
 
290
                                        m_zooms.push_back(i);
 
291
                                }
 
292
                                m_zooms.push_back(110);
 
293
                                m_zooms.push_back(120);
 
294
                                m_zooms.push_back(150);
 
295
                                m_zooms.push_back(200);
 
296
                                //
 
297
 
 
298
                                m_printManagerPreview = (PrintManager*) m_printPreview->GetPrintout();
 
299
                                m_printManagerImpresion = (PrintManager*) m_printPreview->GetPrintoutForPrinting();
 
300
 
 
301
                                this->SetSizeHints( wxDefaultSize, wxDefaultSize );
 
302
 
 
303
                                wxBoxSizer* bSizer9;
 
304
                                bSizer9 = new wxBoxSizer( wxVERTICAL );
 
305
 
 
306
                                HeaderPanel* pPanelHeader = new HeaderPanel(this);
 
307
                                pPanelHeader->SetToolTip(_("Print"));
 
308
                                bSizer9->Add(pPanelHeader,0,wxEXPAND);
 
309
 
 
310
                                BodyPanel* pPanelFondo = new BodyPanel(this);
 
311
 
 
312
                                wxGridBagSizer* gbSizerPpal;
 
313
                                gbSizerPpal = new wxGridBagSizer( 0, 0 );
 
314
                                gbSizerPpal->AddGrowableCol( 2 );
 
315
                                gbSizerPpal->AddGrowableRow( 3 );
 
316
                                gbSizerPpal->SetFlexibleDirection( wxBOTH );
 
317
                                gbSizerPpal->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
 
318
 
 
319
                                SubTitledPanel* pPanelContenido = new SubTitledPanel(pPanelFondo, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
 
320
                                pPanelContenido->SetToolTip(_("Content"));
 
321
                                wxBoxSizer* sizerContenido;
 
322
                                sizerContenido = new wxBoxSizer( wxVERTICAL );
 
323
 
 
324
                                m_pIncluirWidgets = new wxCheckBox( pPanelContenido, wxID_ANY, _("Include Annotations"), wxDefaultPosition, wxDefaultSize, 0 );
 
325
                                sizerContenido->Add( m_pIncluirWidgets, 0, wxALL, 5 );
 
326
                                m_pIncluirWidgets->SetValue(true);
 
327
 
 
328
                                m_pTituloMapas = new wxStaticText( pPanelContenido, wxID_ANY, _("Evaluation Maps"), wxDefaultPosition, wxDefaultSize, 0 );
 
329
                                m_pTituloMapas->Wrap( -1 );
 
330
                                sizerContenido->Add( m_pTituloMapas, 0, wxALL, 5 );
 
331
 
 
332
                                wxArrayString m_pMapasCheckChoices;
 
333
                                m_pMapasCheck = new wxCheckListBox( pPanelContenido, wxID_ANY, wxDefaultPosition, wxDefaultSize, m_pMapasCheckChoices, wxLB_MULTIPLE );
 
334
                                sizerContenido->Add( m_pMapasCheck, 1, wxALL|wxEXPAND, 5 );
 
335
 
 
336
                                pPanelContenido->SetSizer(sizerContenido);
 
337
 
 
338
                                gbSizerPpal->Add( pPanelContenido, wxGBPosition( 0, 0 ), wxGBSpan( 1, 1 ), wxEXPAND );
 
339
 
 
340
                                SubTitledPanelSeparator* pSepVertical = new SubTitledPanelSeparator(pPanelFondo);
 
341
                                gbSizerPpal->Add( pSepVertical, wxGBPosition( 1, 0 ), wxGBSpan( 1, 1 ), wxEXPAND );
 
342
 
 
343
                                SubTitledPanelSeparator* pSepHorizontal = new SubTitledPanelSeparator(pPanelFondo);
 
344
                                gbSizerPpal->Add( pSepHorizontal, wxGBPosition( 0, 1 ), wxGBSpan( 1, 1 ), wxEXPAND );
 
345
 
 
346
                                m_pPanelPrevisualizacion = new SubTitledPanel(pPanelFondo, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
 
347
                                m_pPanelPrevisualizacion->SetToolTip(_("Preview"));
 
348
                                wxBoxSizer* sizerPrevisualizacion;
 
349
                                sizerPrevisualizacion = new wxBoxSizer( wxVERTICAL );
 
350
 
 
351
                                m_pSizerPrevisualizacion = new wxBoxSizer( wxVERTICAL );
 
352
 
 
353
                                sizerPrevisualizacion->Add( m_pSizerPrevisualizacion, 1, wxEXPAND );
 
354
 
 
355
                                wxBoxSizer* sizerZoomScroll;
 
356
                                sizerZoomScroll = new wxBoxSizer( wxHORIZONTAL );
 
357
 
 
358
                                m_pLabelPagina = new wxStaticText( m_pPanelPrevisualizacion, wxID_ANY, wxT("1/8"), wxDefaultPosition, wxDefaultSize, 0 );
 
359
                                m_pLabelPagina->Wrap( -1 );
 
360
                                sizerZoomScroll->Add( m_pLabelPagina, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
 
361
 
 
362
                                m_pSliderScroll = new wxSlider( m_pPanelPrevisualizacion, wxID_ANY, 5, 0, 10, wxDefaultPosition, wxDefaultSize, wxSL_AUTOTICKS|wxSL_HORIZONTAL|wxSL_TOP );
 
363
                                m_pSliderScroll->SetMinSize( wxSize( 150,-1 ) );
 
364
 
 
365
                                sizerZoomScroll->Add( m_pSliderScroll, 0, wxALL, 3 );
 
366
 
 
367
                                sizerZoomScroll->Add( 0, 0, 1, wxEXPAND, 5 );
 
368
 
 
369
                                wxStaticText* staticText5 = new wxStaticText( m_pPanelPrevisualizacion, wxID_ANY, _("Zoom"), wxDefaultPosition, wxDefaultSize, 0 );
 
370
                                staticText5->Wrap( -1 );
 
371
                                sizerZoomScroll->Add( staticText5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
 
372
 
 
373
                                wxArrayString m_pZoomsChoices;
 
374
                                for(std::vector<int>::iterator it = m_zooms.begin(); it!= m_zooms.end(); it++)
 
375
                                {
 
376
                                        m_pZoomsChoices.push_back(wxString::Format(wxT("%d %%"),(*it)));
 
377
                                }
 
378
                                m_pZooms = new wxChoice( m_pPanelPrevisualizacion, wxID_ANY, wxDefaultPosition, wxDefaultSize, m_pZoomsChoices, 0 );
 
379
                                m_pZooms->SetSelection( 0 );
 
380
                                //se oculta el zoom
 
381
                                m_pZooms->Hide();
 
382
                                staticText5->Hide();
 
383
                                //
 
384
                                sizerZoomScroll->Add( m_pZooms, 0, wxALL, 5 );
 
385
 
 
386
                                sizerPrevisualizacion->Add( sizerZoomScroll, 0, wxEXPAND, 5 );
 
387
 
 
388
                                m_pPanelPrevisualizacion->SetSizer(sizerPrevisualizacion);
 
389
 
 
390
                                gbSizerPpal->Add( m_pPanelPrevisualizacion, wxGBPosition( 0, 2 ), wxGBSpan( 4, 1 ), wxEXPAND );
 
391
 
 
392
 
 
393
                                SubTitledPanel* pPanelOptions = new SubTitledPanel(pPanelFondo, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
 
394
                                pPanelOptions->SetToolTip(_("Options"));
 
395
                                wxBoxSizer* sizerOpciones;
 
396
                                sizerOpciones = new wxBoxSizer( wxHORIZONTAL );
 
397
 
 
398
                                wxStaticText* m_staticText7 = new wxStaticText( pPanelOptions, wxID_ANY, _("Images per sheet"), wxDefaultPosition, wxDefaultSize, 0 );
 
399
                                m_staticText7->Wrap( -1 );
 
400
                                sizerOpciones->Add( m_staticText7, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 );
 
401
 
 
402
                                wxString m_pPaginasHojaChoices[] = { wxT("1"), wxT("2"), wxT("4"), wxT("6") };
 
403
                                int m_pPaginasHojaNChoices = sizeof( m_pPaginasHojaChoices ) / sizeof( wxString );
 
404
                                m_pPaginasHoja = new wxChoice( pPanelOptions, wxID_ANY, wxDefaultPosition, wxDefaultSize, m_pPaginasHojaNChoices, m_pPaginasHojaChoices, 0 );
 
405
                                m_pPaginasHoja->SetSelection( 0 );
 
406
                                sizerOpciones->Add( m_pPaginasHoja, 0 );
 
407
 
 
408
                                pPanelOptions->SetSizer(sizerOpciones);
 
409
 
 
410
                                gbSizerPpal->Add( pPanelOptions, wxGBPosition( 2, 0 ), wxGBSpan( 1, 1 ), wxEXPAND );
 
411
 
 
412
                                pPanelFondo->SetSizer(gbSizerPpal);
 
413
                                pPanelFondo->Layout();
 
414
 
 
415
                                bSizer9->Add( pPanelFondo, 1, wxEXPAND, 5 );
 
416
 
 
417
                                FooterPanel* pPanelBotones = new FooterPanel(this);
 
418
                                wxBoxSizer* bSizer13;
 
419
                                bSizer13 = new wxBoxSizer( wxHORIZONTAL );
 
420
 
 
421
                                bSizer13->Add( 0, 0, 1, wxEXPAND, 5 );
 
422
 
 
423
                                m_pBotonConfigurarPagina = new wxButton( pPanelBotones, wxID_ANY, _("Page Setup ..."), wxDefaultPosition, wxDefaultSize, 0 );
 
424
                                m_pBotonConfigurarPagina->SetDefault();
 
425
                                bSizer13->Add( m_pBotonConfigurarPagina, 0, wxRIGHT, 5 );
 
426
 
 
427
                                m_pBotonImprimir = new wxButton( pPanelBotones, wxID_ANY, _("Print ..."), wxDefaultPosition, wxDefaultSize, 0 );
 
428
                                m_pBotonImprimir->SetDefault();
 
429
                                bSizer13->Add( m_pBotonImprimir, 0, wxRIGHT|wxLEFT, 5 );
 
430
 
 
431
                                m_pBotonCancelar = new wxButton( pPanelBotones, wxID_CANCEL, _("Cancel"), wxDefaultPosition, wxDefaultSize, 0 );
 
432
                                bSizer13->Add( m_pBotonCancelar, 0, wxLEFT, 5 );
 
433
 
 
434
                                pPanelBotones->SetSizer(bSizer13);
 
435
                                bSizer13->Fit(pPanelBotones);
 
436
 
 
437
                                bSizer9->Add( pPanelBotones, 0, wxEXPAND );
 
438
 
 
439
                                this->SetSizer( bSizer9 );
 
440
                                this->SetMinSize(wxSize(900,600));
 
441
                                this->SetSize(wxSize(900,600));
 
442
 
 
443
                                Initialize();
 
444
 
 
445
                                this->Layout();
 
446
 
 
447
                                this->Centre( wxBOTH );
 
448
 
 
449
                                m_pMapasCheck->Connect( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, wxCommandEventHandler( DialogoImpresion::OnCheckCapasToggled ), NULL, this );
 
450
                                m_pIncluirWidgets->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DialogoImpresion::OnCheckWidgetsAnotacion ), NULL, this );
 
451
 
 
452
                                m_pBotonConfigurarPagina->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DialogoImpresion::OnConfigurarPaginaClick ), NULL, this );
 
453
                                m_pBotonImprimir->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DialogoImpresion::OnImprimirClick ), NULL, this );
 
454
                                m_pBotonCancelar->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DialogoImpresion::OnCancelarClick ), NULL, this );
 
455
 
 
456
                                m_pSliderScroll->Connect( wxEVT_SCROLL_TOP, wxScrollEventHandler( DialogoImpresion::OnScrollPage ), NULL, this );
 
457
                                m_pSliderScroll->Connect( wxEVT_SCROLL_BOTTOM, wxScrollEventHandler( DialogoImpresion::OnScrollPage ), NULL, this );
 
458
                                m_pSliderScroll->Connect( wxEVT_SCROLL_LINEUP, wxScrollEventHandler( DialogoImpresion::OnScrollPage ), NULL, this );
 
459
                                m_pSliderScroll->Connect( wxEVT_SCROLL_LINEDOWN, wxScrollEventHandler( DialogoImpresion::OnScrollPage ), NULL, this );
 
460
                                m_pSliderScroll->Connect( wxEVT_SCROLL_PAGEUP, wxScrollEventHandler( DialogoImpresion::OnScrollPage ), NULL, this );
 
461
                                m_pSliderScroll->Connect( wxEVT_SCROLL_PAGEDOWN, wxScrollEventHandler( DialogoImpresion::OnScrollPage ), NULL, this );
 
462
                                m_pSliderScroll->Connect( wxEVT_SCROLL_THUMBTRACK, wxScrollEventHandler( DialogoImpresion::OnScrollPage ), NULL, this );
 
463
                                m_pSliderScroll->Connect( wxEVT_SCROLL_THUMBRELEASE, wxScrollEventHandler( DialogoImpresion::OnScrollPage ), NULL, this );
 
464
                                m_pSliderScroll->Connect( wxEVT_SCROLL_CHANGED, wxScrollEventHandler( DialogoImpresion::OnScrollPage ), NULL, this );
 
465
 
 
466
                                m_pZooms->Connect( wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler( DialogoImpresion::OnZoomChoice ), NULL, this );
 
467
 
 
468
                                m_pPaginasHoja->Connect( wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler( DialogoImpresion::OnPaginasHoja ), NULL, this );
 
469
 
 
470
                                RefrescarParametros();
 
471
                        }
 
472
 
 
473
                        DialogoImpresion::~DialogoImpresion()
 
474
                        {
 
475
                                m_pVista = NULL;
 
476
                                m_pPrintData = NULL;
 
477
                                if(m_pDatosExportacion != NULL)
 
478
                                {
 
479
                                        delete m_pDatosExportacion;
 
480
                                        m_pDatosExportacion = NULL;
 
481
                                }
 
482
                                m_pMapasCheck->Disconnect( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, wxCommandEventHandler( DialogoImpresion::OnCheckCapasToggled ), NULL, this );
 
483
                                m_pIncluirWidgets->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DialogoImpresion::OnCheckWidgetsAnotacion ), NULL, this );
 
484
 
 
485
                                m_pBotonConfigurarPagina->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DialogoImpresion::OnConfigurarPaginaClick ), NULL, this );
 
486
                                m_pBotonImprimir->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DialogoImpresion::OnImprimirClick ), NULL, this );
 
487
                                m_pBotonCancelar->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DialogoImpresion::OnCancelarClick ), NULL, this );
 
488
 
 
489
                                m_pSliderScroll->Disconnect( wxEVT_SCROLL_TOP, wxScrollEventHandler( DialogoImpresion::OnScrollPage ), NULL, this );
 
490
                                m_pSliderScroll->Disconnect( wxEVT_SCROLL_BOTTOM, wxScrollEventHandler( DialogoImpresion::OnScrollPage ), NULL, this );
 
491
                                m_pSliderScroll->Disconnect( wxEVT_SCROLL_LINEUP, wxScrollEventHandler( DialogoImpresion::OnScrollPage ), NULL, this );
 
492
                                m_pSliderScroll->Disconnect( wxEVT_SCROLL_LINEDOWN, wxScrollEventHandler( DialogoImpresion::OnScrollPage ), NULL, this );
 
493
                                m_pSliderScroll->Disconnect( wxEVT_SCROLL_PAGEUP, wxScrollEventHandler( DialogoImpresion::OnScrollPage ), NULL, this );
 
494
                                m_pSliderScroll->Disconnect( wxEVT_SCROLL_PAGEDOWN, wxScrollEventHandler( DialogoImpresion::OnScrollPage ), NULL, this );
 
495
                                m_pSliderScroll->Disconnect( wxEVT_SCROLL_THUMBTRACK, wxScrollEventHandler( DialogoImpresion::OnScrollPage ), NULL, this );
 
496
                                m_pSliderScroll->Disconnect( wxEVT_SCROLL_THUMBRELEASE, wxScrollEventHandler( DialogoImpresion::OnScrollPage ), NULL, this );
 
497
                                m_pSliderScroll->Disconnect( wxEVT_SCROLL_CHANGED, wxScrollEventHandler( DialogoImpresion::OnScrollPage ), NULL, this );
 
498
 
 
499
                                m_pZooms->Disconnect( wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler( DialogoImpresion::OnZoomChoice ), NULL, this );
 
500
 
 
501
                                m_pPaginasHoja->Disconnect( wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler( DialogoImpresion::OnPaginasHoja ), NULL, this );
 
502
                        }
 
503
 
 
504
                        void DialogoImpresion::CreateCanvas()
 
505
                        {
 
506
                                
 
507
                                
 
508
                                #if defined(USE_PATCHED_LIBS)                           
 
509
                                m_previewCanvas = new wxPreviewCanvas(m_printPreview, m_pPanelPrevisualizacion,this);
 
510
                                m_pSizerPrevisualizacion->Add(m_previewCanvas,1,wxEXPAND|wxALL,3);
 
511
                                m_pPanelPrevisualizacion->Layout();
 
512
                                #else
 
513
                                m_previewCanvas = NULL;
 
514
                                #warning "PRINT NOT SUPPORTED"
 
515
                                #endif
 
516
                        }
 
517
                        void DialogoImpresion::Initialize()
 
518
                        {
 
519
                                
 
520
#if wxUSE_STATUSBAR
 
521
                                CreateStatusBar();
 
522
#endif
 
523
 
 
524
                                CreateCanvas();
 
525
 
 
526
                                m_printPreview->SetCanvas(m_previewCanvas);
 
527
                                m_printPreview->SetFrame(this);
 
528
 
 
529
                                SetAutoLayout( true );
 
530
 
 
531
                                m_windowDisabler = new wxWindowDisabler(this);
 
532
 
 
533
                                m_printPreview->AdjustScrollbars(m_previewCanvas);
 
534
                                m_previewCanvas->SetFocus();
 
535
                        }
 
536
 
 
537
                        void DialogoImpresion::RefrescarParametros()
 
538
                        {
 
539
                                m_pDatosExportacion = new TipoWizardImprimir();
 
540
                                m_pDatosExportacion->m_incluirWidgets = true;
 
541
                                m_pDatosExportacion->m_pVista = m_pVista;
 
542
                                //mapas...
 
543
                                GNC::GCS::IContratoExportacionImages* pContratoImages = dynamic_cast<GNC::GCS::IContratoExportacionImages*>(m_pVista);
 
544
                                if(pContratoImages != NULL){
 
545
                                        //pillamos los mapas
 
546
                                        typedef GNC::GCS::IContratoExportacionImages::MapaMapasValoracion MapaMapasValoracion;
 
547
                                        m_pDatosExportacion->m_mapasValoracion= pContratoImages->GetMapasValoracion();
 
548
                                        if(m_pDatosExportacion->m_mapasValoracion.size() == 0) {
 
549
                                                m_pTituloMapas->Show(false);
 
550
                                                m_pMapasCheck->Show(false);
 
551
                                        } else {
 
552
                                                for(MapaMapasValoracion::iterator it= m_pDatosExportacion->m_mapasValoracion.begin(); it!= m_pDatosExportacion->m_mapasValoracion.end(); it++) {
 
553
                                                        int item = m_pMapasCheck->Append(wxString::FromUTF8((*it).first.c_str()));
 
554
                                                        m_pMapasCheck->Check(item,(*it).second);
 
555
                                                }
 
556
                                        }
 
557
                                }
 
558
                                m_printManagerPreview->SetDatosExportacion(m_pDatosExportacion);
 
559
                                m_printManagerImpresion->SetDatosExportacion(m_pDatosExportacion);
 
560
                                RefrescarSliders();
 
561
                        }
 
562
 
 
563
                        void DialogoImpresion::RefrescarSliders()
 
564
                        {
 
565
 
 
566
                                MiPrintPreview* pPrintPreview = dynamic_cast<MiPrintPreview*>(m_printPreview);
 
567
                                if(pPrintPreview!=NULL) {
 
568
                                        pPrintPreview->VolverAConsultarPaginas();
 
569
                                }
 
570
                                m_printPreview->RenderPage(1);
 
571
 
 
572
                                //barras
 
573
                                //scroll
 
574
                                if(m_printPreview->GetMaxPage() == m_printPreview->GetMinPage()) {
 
575
                                        m_pSliderScroll->Show(false);
 
576
                                        m_pLabelPagina->SetLabel(wxT("1/1"));
 
577
                                } else {
 
578
                                        m_pSliderScroll->Show(true);
 
579
                                        m_pSliderScroll->SetMin(m_printPreview->GetMinPage());
 
580
                                        m_pSliderScroll->SetMax(m_printPreview->GetMaxPage());
 
581
                                        m_pSliderScroll->SetValue(m_printPreview->GetCurrentPage());
 
582
                                        std::ostringstream ostr;
 
583
                                        ostr << m_pSliderScroll->GetValue() << "/" << m_pSliderScroll->GetMax();
 
584
                                        m_pLabelPagina->SetLabel(wxString::FromUTF8(ostr.str().c_str()));
 
585
                                }
 
586
                                //zooms
 
587
                                m_pZooms->Select(18);
 
588
                                SetZoom(18);
 
589
                                Refresh();
 
590
                        }
 
591
 
 
592
                        void DialogoImpresion::OnConfigurarPaginaClick( wxCommandEvent& )
 
593
                        {
 
594
                                wxPageSetupDialogData data(*m_pPrintData);
 
595
                                wxPageSetupDialog pageSetupDialog(this,&data);
 
596
                                pageSetupDialog.ShowModal();
 
597
 
 
598
                                (*m_pPrintData) = pageSetupDialog.GetPageSetupDialogData().GetPrintData();
 
599
                                //se refresca el preview
 
600
                                m_printPreview->GetPrintDialogData().SetPrintData(*m_pPrintData);
 
601
                                m_printPreview->DetermineScaling();
 
602
                                MiPrintPreview* pPrintPreview = dynamic_cast<MiPrintPreview*>(m_printPreview);
 
603
                                if(pPrintPreview!=NULL) {
 
604
                                        pPrintPreview->InvalidarPreviewBitmap();
 
605
                                }
 
606
                                pPrintPreview->AdjustScrollbars(m_previewCanvas);
 
607
                                m_printPreview->RenderPage(m_printPreview->GetCurrentPage());
 
608
                                Refresh();
 
609
                        }
 
610
 
 
611
                        void DialogoImpresion::OnImprimirClick( wxCommandEvent& )
 
612
                        {
 
613
                                m_printPreview->GetPrintDialogData().SetFromPage(m_printPreview->GetMinPage());
 
614
                                m_printPreview->GetPrintDialogData().SetToPage(m_printPreview->GetMaxPage());
 
615
                                m_printPreview->GetPrintDialogData().SetMinPage(m_printPreview->GetMinPage());
 
616
                                m_printPreview->GetPrintDialogData().SetMaxPage(m_printPreview->GetMaxPage());
 
617
                                m_printPreview->GetPrintDialogData().GetPrintData().SetQuality(300);
 
618
                                m_printPreview->GetPrintDialogData().GetPrintData().SetPaperId(m_pPrintData->GetPaperId());
 
619
                                m_printPreview->Print(true);
 
620
                        }
 
621
 
 
622
 
 
623
 
 
624
                        void DialogoImpresion::OnCancelarClick( wxCommandEvent& )
 
625
                        {
 
626
                                Close();
 
627
                        }
 
628
 
 
629
                        void DialogoImpresion::OnScrollPage ( wxScrollEvent& event)
 
630
                        {
 
631
                                GoToPage(event.GetPosition());
 
632
                        }
 
633
 
 
634
                        void DialogoImpresion::OnZoomChoice( wxCommandEvent& )
 
635
                        {
 
636
                                SetZoom(m_pZooms->GetSelection());
 
637
                        }
 
638
 
 
639
                        void DialogoImpresion::GoToPage(int page)
 
640
                        {
 
641
                                if (m_printPreview->GetPrintout()->HasPage(page))
 
642
                                {
 
643
                                        m_printPreview->SetCurrentPage(page);
 
644
 
 
645
                                        std::ostringstream ostr;
 
646
                                        ostr << m_pSliderScroll->GetValue() << "/" << m_pSliderScroll->GetMax();
 
647
                                        m_pLabelPagina->SetLabel(wxString::FromUTF8(ostr.str().c_str()));
 
648
                                }
 
649
                        }
 
650
 
 
651
                        void DialogoImpresion::SetZoom(int position)
 
652
                        {
 
653
                                if(position >=0 && position < (int)m_zooms.size()) {
 
654
                                        if(m_zooms[position] != m_printPreview->GetZoom()) {
 
655
                                                m_printPreview->SetZoom(m_zooms[position]);
 
656
                                        }
 
657
                                }
 
658
                        }
 
659
 
 
660
                        void DialogoImpresion::OnPaginasHoja( wxCommandEvent& )
 
661
                        {
 
662
                                switch(m_pPaginasHoja->GetSelection())
 
663
                                {
 
664
                                default:
 
665
                                case 0://una imagen
 
666
                                        m_pDatosExportacion->m_filas = 1;
 
667
                                        m_pDatosExportacion->m_columnas = 1;
 
668
                                        break;
 
669
                                case 1://dos
 
670
                                        m_pDatosExportacion->m_filas = 1;
 
671
                                        m_pDatosExportacion->m_columnas = 2;
 
672
                                        break;
 
673
                                case 2://cuatro
 
674
                                        m_pDatosExportacion->m_filas = 2;
 
675
                                        m_pDatosExportacion->m_columnas = 2;
 
676
                                        break;
 
677
                                case 3://seis
 
678
                                        m_pDatosExportacion->m_filas = 2;
 
679
                                        m_pDatosExportacion->m_columnas = 3;
 
680
                                        break;
 
681
                                }
 
682
                                RefrescarSliders();
 
683
                        }
 
684
 
 
685
                        void DialogoImpresion::OnCheckCapasToggled( wxCommandEvent&  )
 
686
                        {
 
687
                                for(unsigned int i = 0; i< m_pMapasCheck->GetCount(); i++) {
 
688
                                        std::string strTmp(m_pMapasCheck->GetString(i).ToUTF8());
 
689
                                        m_pDatosExportacion->m_mapasValoracion[strTmp] = m_pMapasCheck->IsChecked(i);
 
690
                                }
 
691
                                m_printPreview->RenderPage(m_printPreview->GetCurrentPage());
 
692
                                m_previewCanvas->Refresh();
 
693
                        }
 
694
 
 
695
                        void DialogoImpresion::OnCheckWidgetsAnotacion( wxCommandEvent&  )
 
696
                        {
 
697
                                m_pDatosExportacion->m_incluirWidgets = m_pIncluirWidgets->IsChecked();
 
698
                                m_printPreview->RenderPage(m_printPreview->GetCurrentPage());
 
699
                                m_previewCanvas->Refresh();
 
700
                        }
 
701
                }
 
702
        }
 
703
}