← Back to branch summary

~ubuntu-dev/wxwidgets2.6/upstream-debian

« back to all changes in this revision

Viewing changes to src/common/prntbase.cpp

  • Committer: Daniel T Chen
  • Date: 2006-06-26 10:15:11 UTC
  • Revision ID: crimsun@ubuntu.com-20060626101511-a4436cec4c6d9b35
Import Debian 2.6.3.2.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/common/prntbase.cpp
 
1
/////////////////////////////////////////////////////////////////////////////
 
2
// Name:        prntbase.cpp
 
3
// Purpose:     Printing framework base class implementation
 
4
// Author:      Julian Smart
 
5
// Modified by:
 
6
// Created:     04/01/98
 
7
// RCS-ID:      $Id: prntbase.cpp,v 1.89 2005/07/28 22:20:03 VZ Exp $
 
8
// Copyright:   (c) Julian Smart
 
9
// Licence:     wxWindows licence
 
10
/////////////////////////////////////////////////////////////////////////////
 
11
 
 
12
#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
 
13
  #pragma implementation "prntbase.h"
 
14
  #pragma implementation "printdlg.h"
 
15
#endif
 
16
 
 
17
// For compilers that support precompilation, includes "wx.h".
 
18
#include "wx/wxprec.h"
 
19
 
 
20
#ifdef __BORLANDC__
 
21
#pragma hdrstop
 
22
#endif
 
23
 
 
24
#include "wx/defs.h"
 
25
 
 
26
#if wxUSE_PRINTING_ARCHITECTURE
 
27
 
 
28
#ifndef WX_PRECOMP
 
29
#include "wx/utils.h"
 
30
#include "wx/dc.h"
 
31
#include "wx/app.h"
 
32
#include "wx/msgdlg.h"
 
33
#include "wx/layout.h"
 
34
#include "wx/choice.h"
 
35
#include "wx/button.h"
 
36
#include "wx/settings.h"
 
37
#include "wx/dcmemory.h"
 
38
#include "wx/stattext.h"
 
39
#include "wx/intl.h"
 
40
#include "wx/textdlg.h"
 
41
#include "wx/sizer.h"
 
42
#endif // !WX_PRECOMP
 
43
 
 
44
#include "wx/prntbase.h"
 
45
#include "wx/dcprint.h"
 
46
#include "wx/printdlg.h"
 
47
#include "wx/print.h"
 
48
#include "wx/module.h"
 
49
 
 
50
#include <stdlib.h>
 
51
#include <string.h>
 
52
 
 
53
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 
54
#include "wx/msw/printdlg.h"
 
55
#elif defined(__WXMAC__)
 
56
#include "wx/mac/printdlg.h"
 
57
#include "wx/mac/private/print.h"
 
58
#else
 
59
#include "wx/generic/prntdlgg.h"
 
60
#endif
 
61
 
 
62
#ifdef __WXMSW__
 
63
    #include "wx/msw/wrapcdlg.h"
 
64
    #ifndef __WIN32__
 
65
        #include <print.h>
 
66
    #endif
 
67
#endif // __WXMSW__
 
68
 
 
69
//----------------------------------------------------------------------------
 
70
// wxPrintFactory
 
71
//----------------------------------------------------------------------------
 
72
 
 
73
wxPrintFactory *wxPrintFactory::m_factory = NULL;
 
74
 
 
75
void wxPrintFactory::SetPrintFactory( wxPrintFactory *factory )
 
76
{
 
77
    if (wxPrintFactory::m_factory)
 
78
        delete wxPrintFactory::m_factory;
 
79
 
 
80
    wxPrintFactory::m_factory = factory;
 
81
}
 
82
 
 
83
wxPrintFactory *wxPrintFactory::GetFactory()
 
84
{
 
85
    if (!wxPrintFactory::m_factory)
 
86
        wxPrintFactory::m_factory = new wxNativePrintFactory;
 
87
 
 
88
    return wxPrintFactory::m_factory;
 
89
}
 
90
 
 
91
//----------------------------------------------------------------------------
 
92
// wxNativePrintFactory
 
93
//----------------------------------------------------------------------------
 
94
 
 
95
wxPrinterBase *wxNativePrintFactory::CreatePrinter( wxPrintDialogData *data )
 
96
{
 
97
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 
98
    return new wxWindowsPrinter( data );
 
99
#elif defined(__WXMAC__)
 
100
    return new wxMacPrinter( data );
 
101
#elif defined(__WXPM__)
 
102
    return new wxOS2Printer( data );
 
103
#else
 
104
    return new wxPostScriptPrinter( data );
 
105
#endif
 
106
};
 
107
 
 
108
wxPrintPreviewBase *wxNativePrintFactory::CreatePrintPreview( wxPrintout *preview,
 
109
    wxPrintout *printout, wxPrintDialogData *data )
 
110
{
 
111
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 
112
    return new wxWindowsPrintPreview( preview, printout, data );
 
113
#elif defined(__WXMAC__)
 
114
    return new wxMacPrintPreview( preview, printout, data );
 
115
#elif defined(__WXPM__)
 
116
    return new wxOS2PrintPreview( preview, printout, data );
 
117
#else
 
118
    return new wxPostScriptPrintPreview( preview, printout, data );
 
119
#endif
 
120
}
 
121
 
 
122
wxPrintPreviewBase *wxNativePrintFactory::CreatePrintPreview( wxPrintout *preview,
 
123
    wxPrintout *printout, wxPrintData *data )
 
124
{
 
125
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 
126
    return new wxWindowsPrintPreview( preview, printout, data );
 
127
#elif defined(__WXMAC__)
 
128
    return new wxMacPrintPreview( preview, printout, data );
 
129
#elif defined(__WXPM__)
 
130
    return new wxOS2PrintPreview( preview, printout, data );
 
131
#else
 
132
    return new wxPostScriptPrintPreview( preview, printout, data );
 
133
#endif
 
134
}
 
135
 
 
136
wxPrintDialogBase *wxNativePrintFactory::CreatePrintDialog( wxWindow *parent,
 
137
                                                  wxPrintDialogData *data )
 
138
{
 
139
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 
140
    return new wxWindowsPrintDialog( parent, data );
 
141
#elif defined(__WXMAC__)
 
142
    return new wxMacPrintDialog( parent, data );
 
143
#else
 
144
    return new wxGenericPrintDialog( parent, data );
 
145
#endif
 
146
}
 
147
 
 
148
wxPrintDialogBase *wxNativePrintFactory::CreatePrintDialog( wxWindow *parent,
 
149
                                                  wxPrintData *data )
 
150
{
 
151
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 
152
    return new wxWindowsPrintDialog( parent, data );
 
153
#elif defined(__WXMAC__)
 
154
    return new wxMacPrintDialog( parent, data );
 
155
#else
 
156
    return new wxGenericPrintDialog( parent, data );
 
157
#endif
 
158
}
 
159
 
 
160
wxPageSetupDialogBase *wxNativePrintFactory::CreatePageSetupDialog( wxWindow *parent,
 
161
                                                  wxPageSetupDialogData *data )
 
162
{
 
163
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 
164
    return new wxWindowsPageSetupDialog( parent, data );
 
165
#elif defined(__WXMAC__)
 
166
    return new wxMacPageSetupDialog( parent, data );
 
167
#else
 
168
    return new wxGenericPageSetupDialog( parent, data );
 
169
#endif
 
170
}
 
171
 
 
172
bool wxNativePrintFactory::HasPrintSetupDialog()
 
173
{
 
174
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 
175
    return false;
 
176
#elif defined(__WXMAC__)
 
177
    return false;
 
178
#else
 
179
    // Only here do we need to provide the print setup
 
180
    // dialog ourselves, the other platforms either have
 
181
    // none, don't make it accessible or let you configure
 
182
    // the printer from the wxPrintDialog anyway.
 
183
    return true;
 
184
#endif
 
185
 
 
186
}
 
187
 
 
188
wxDialog *wxNativePrintFactory::CreatePrintSetupDialog( wxWindow *parent,
 
189
                                                        wxPrintData *data )
 
190
{
 
191
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 
192
    wxUnusedVar(parent);
 
193
    wxUnusedVar(data);
 
194
    return NULL;
 
195
#elif defined(__WXMAC__)
 
196
    wxUnusedVar(parent);
 
197
    wxUnusedVar(data);
 
198
    return NULL;
 
199
#else
 
200
    // Only here do we need to provide the print setup
 
201
    // dialog ourselves, the other platforms either have
 
202
    // none, don't make it accessible or let you configure
 
203
    // the printer from the wxPrintDialog anyway.
 
204
    return new wxGenericPrintSetupDialog( parent, data );
 
205
#endif
 
206
}
 
207
 
 
208
bool wxNativePrintFactory::HasOwnPrintToFile()
 
209
{
 
210
    // Only relevant for PostScript and here the
 
211
    // setup dialog provides no "print to file"
 
212
    // option. In the GNOME setup dialog, the
 
213
    // setup dialog has its own print to file.
 
214
    return false;
 
215
}
 
216
 
 
217
bool wxNativePrintFactory::HasPrinterLine()
 
218
{
 
219
    // Only relevant for PostScript for now
 
220
    return true;
 
221
}
 
222
 
 
223
wxString wxNativePrintFactory::CreatePrinterLine()
 
224
{
 
225
    // Only relevant for PostScript for now
 
226
 
 
227
    // We should query "lpstat -d" here
 
228
    return _("Generic PostScript");
 
229
}
 
230
 
 
231
bool wxNativePrintFactory::HasStatusLine()
 
232
{
 
233
    // Only relevant for PostScript for now
 
234
    return true;
 
235
}
 
236
 
 
237
wxString wxNativePrintFactory::CreateStatusLine()
 
238
{
 
239
    // Only relevant for PostScript for now
 
240
 
 
241
    // We should query "lpstat -r" or "lpstat -p" here
 
242
    return _("Ready");
 
243
}
 
244
 
 
245
wxPrintNativeDataBase *wxNativePrintFactory::CreatePrintNativeData()
 
246
{
 
247
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 
248
    return new wxWindowsPrintNativeData;
 
249
#elif defined(__WXMAC__)
 
250
    return new wxMacCarbonPrintData;
 
251
#else
 
252
    return new wxPostScriptPrintNativeData;
 
253
#endif
 
254
}
 
255
 
 
256
//----------------------------------------------------------------------------
 
257
// wxPrintNativeDataBase
 
258
//----------------------------------------------------------------------------
 
259
 
 
260
IMPLEMENT_ABSTRACT_CLASS(wxPrintNativeDataBase, wxObject)
 
261
 
 
262
wxPrintNativeDataBase::wxPrintNativeDataBase()
 
263
{
 
264
    m_ref = 1;
 
265
}
 
266
 
 
267
//----------------------------------------------------------------------------
 
268
// wxPrintFactoryModule
 
269
//----------------------------------------------------------------------------
 
270
 
 
271
class wxPrintFactoryModule: public wxModule
 
272
{
 
273
public:
 
274
    wxPrintFactoryModule() {}
 
275
    bool OnInit() { return true; }
 
276
    void OnExit() { wxPrintFactory::SetPrintFactory( NULL ); }
 
277
 
 
278
private:
 
279
    DECLARE_DYNAMIC_CLASS(wxPrintFactoryModule)
 
280
};
 
281
 
 
282
IMPLEMENT_DYNAMIC_CLASS(wxPrintFactoryModule, wxModule)
 
283
 
 
284
//----------------------------------------------------------------------------
 
285
// wxPrinterBase
 
286
//----------------------------------------------------------------------------
 
287
 
 
288
IMPLEMENT_CLASS(wxPrinterBase, wxObject)
 
289
 
 
290
wxPrinterBase::wxPrinterBase(wxPrintDialogData *data)
 
291
{
 
292
    m_currentPrintout = (wxPrintout *) NULL;
 
293
    sm_abortWindow = (wxWindow *) NULL;
 
294
    sm_abortIt = false;
 
295
    if (data)
 
296
        m_printDialogData = (*data);
 
297
    sm_lastError = wxPRINTER_NO_ERROR;
 
298
}
 
299
 
 
300
wxWindow *wxPrinterBase::sm_abortWindow = (wxWindow *) NULL;
 
301
bool wxPrinterBase::sm_abortIt = false;
 
302
wxPrinterError wxPrinterBase::sm_lastError = wxPRINTER_NO_ERROR;
 
303
 
 
304
wxPrinterBase::~wxPrinterBase()
 
305
{
 
306
}
 
307
 
 
308
wxWindow *wxPrinterBase::CreateAbortWindow(wxWindow *parent, wxPrintout * printout)
 
309
{
 
310
    wxPrintAbortDialog *dialog = new wxPrintAbortDialog(parent, _("Printing ") , wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE);
 
311
 
 
312
    wxBoxSizer *button_sizer = new wxBoxSizer( wxVERTICAL );
 
313
    button_sizer->Add( new wxStaticText(dialog, wxID_ANY, _("Please wait while printing\n") + printout->GetTitle() ), 0, wxALL, 10 );
 
314
    button_sizer->Add( new wxButton( dialog, wxID_CANCEL, wxT("Cancel") ), 0, wxALL | wxALIGN_CENTER, 10 );
 
315
 
 
316
    dialog->SetAutoLayout( true );
 
317
    dialog->SetSizer( button_sizer );
 
318
 
 
319
    button_sizer->Fit(dialog);
 
320
    button_sizer->SetSizeHints (dialog) ;
 
321
 
 
322
    return dialog;
 
323
}
 
324
 
 
325
void wxPrinterBase::ReportError(wxWindow *parent, wxPrintout *WXUNUSED(printout), const wxString& message)
 
326
{
 
327
    wxMessageBox(message, _("Printing Error"), wxOK, parent);
 
328
}
 
329
 
 
330
wxPrintDialogData& wxPrinterBase::GetPrintDialogData() const
 
331
{
 
332
    return (wxPrintDialogData&) m_printDialogData;
 
333
}
 
334
 
 
335
//----------------------------------------------------------------------------
 
336
// wxPrinter
 
337
//----------------------------------------------------------------------------
 
338
 
 
339
IMPLEMENT_CLASS(wxPrinter, wxPrinterBase)
 
340
 
 
341
wxPrinter::wxPrinter(wxPrintDialogData *data)
 
342
{
 
343
    m_pimpl = wxPrintFactory::GetFactory()->CreatePrinter( data );
 
344
}
 
345
 
 
346
wxPrinter::~wxPrinter()
 
347
{
 
348
    delete m_pimpl;
 
349
}
 
350
 
 
351
wxWindow *wxPrinter::CreateAbortWindow(wxWindow *parent, wxPrintout *printout)
 
352
{
 
353
    return m_pimpl->CreateAbortWindow( parent, printout );
 
354
}
 
355
 
 
356
void wxPrinter::ReportError(wxWindow *parent, wxPrintout *printout, const wxString& message)
 
357
{
 
358
    m_pimpl->ReportError( parent, printout, message );
 
359
}
 
360
 
 
361
bool wxPrinter::Setup(wxWindow *parent)
 
362
{
 
363
    return m_pimpl->Setup( parent );
 
364
}
 
365
 
 
366
bool wxPrinter::Print(wxWindow *parent, wxPrintout *printout, bool prompt)
 
367
{
 
368
    return m_pimpl->Print( parent, printout, prompt );
 
369
}
 
370
 
 
371
wxDC* wxPrinter::PrintDialog(wxWindow *parent)
 
372
{
 
373
    return m_pimpl->PrintDialog( parent );
 
374
}
 
375
 
 
376
wxPrintDialogData& wxPrinter::GetPrintDialogData() const
 
377
{
 
378
    return m_pimpl->GetPrintDialogData();
 
379
}
 
380
 
 
381
// ---------------------------------------------------------------------------
 
382
// wxPrintDialogBase: the dialog for printing.
 
383
// ---------------------------------------------------------------------------
 
384
 
 
385
IMPLEMENT_ABSTRACT_CLASS(wxPrintDialogBase, wxDialog)
 
386
 
 
387
wxPrintDialogBase::wxPrintDialogBase(wxWindow *parent,
 
388
                                     wxWindowID id,
 
389
                                     const wxString &title,
 
390
                                     const wxPoint &pos,
 
391
                                     const wxSize &size,
 
392
                                     long style)
 
393
    : wxDialog( parent, id, title.empty() ? wxString(_("Print")) : title,
 
394
                pos, size, style )
 
395
{
 
396
}
 
397
 
 
398
// ---------------------------------------------------------------------------
 
399
// wxPrintDialog: the dialog for printing
 
400
// ---------------------------------------------------------------------------
 
401
 
 
402
IMPLEMENT_CLASS(wxPrintDialog, wxObject)
 
403
 
 
404
wxPrintDialog::wxPrintDialog(wxWindow *parent, wxPrintDialogData* data)
 
405
{
 
406
    m_pimpl = wxPrintFactory::GetFactory()->CreatePrintDialog( parent, data );
 
407
}
 
408
 
 
409
wxPrintDialog::wxPrintDialog(wxWindow *parent, wxPrintData* data)
 
410
{
 
411
    m_pimpl = wxPrintFactory::GetFactory()->CreatePrintDialog( parent, data );
 
412
}
 
413
 
 
414
wxPrintDialog::~wxPrintDialog()
 
415
{
 
416
    delete m_pimpl;
 
417
}
 
418
 
 
419
int wxPrintDialog::ShowModal()
 
420
{
 
421
    return m_pimpl->ShowModal();
 
422
}
 
423
 
 
424
wxPrintDialogData& wxPrintDialog::GetPrintDialogData()
 
425
{
 
426
    return m_pimpl->GetPrintDialogData();
 
427
}
 
428
 
 
429
wxPrintData& wxPrintDialog::GetPrintData()
 
430
{
 
431
    return m_pimpl->GetPrintData();
 
432
}
 
433
 
 
434
wxDC *wxPrintDialog::GetPrintDC()
 
435
{
 
436
    return m_pimpl->GetPrintDC();
 
437
}
 
438
 
 
439
// ---------------------------------------------------------------------------
 
440
// wxPageSetupDialogBase: the page setup dialog
 
441
// ---------------------------------------------------------------------------
 
442
 
 
443
IMPLEMENT_ABSTRACT_CLASS(wxPageSetupDialogBase, wxDialog)
 
444
 
 
445
wxPageSetupDialogBase::wxPageSetupDialogBase(wxWindow *parent,
 
446
                                     wxWindowID id,
 
447
                                     const wxString &title,
 
448
                                     const wxPoint &pos,
 
449
                                     const wxSize &size,
 
450
                                     long style)
 
451
    : wxDialog( parent, id, title.empty() ? wxString(_("Page setup")) : title,
 
452
                pos, size, style )
 
453
{
 
454
}
 
455
 
 
456
// ---------------------------------------------------------------------------
 
457
// wxPageSetupDialog: the page setup dialog
 
458
// ---------------------------------------------------------------------------
 
459
 
 
460
IMPLEMENT_CLASS(wxPageSetupDialog, wxObject)
 
461
 
 
462
wxPageSetupDialog::wxPageSetupDialog(wxWindow *parent, wxPageSetupDialogData *data )
 
463
{
 
464
    m_pimpl = wxPrintFactory::GetFactory()->CreatePageSetupDialog( parent, data );
 
465
}
 
466
 
 
467
wxPageSetupDialog::~wxPageSetupDialog()
 
468
{
 
469
    delete m_pimpl;
 
470
}
 
471
 
 
472
int wxPageSetupDialog::ShowModal()
 
473
{
 
474
    return m_pimpl->ShowModal();
 
475
}
 
476
 
 
477
wxPageSetupDialogData& wxPageSetupDialog::GetPageSetupDialogData()
 
478
{
 
479
    return m_pimpl->GetPageSetupDialogData();
 
480
}
 
481
 
 
482
// old name
 
483
wxPageSetupDialogData& wxPageSetupDialog::GetPageSetupData()
 
484
{
 
485
    return m_pimpl->GetPageSetupDialogData();
 
486
}
 
487
 
 
488
//----------------------------------------------------------------------------
 
489
// wxPrintAbortDialog
 
490
//----------------------------------------------------------------------------
 
491
 
 
492
BEGIN_EVENT_TABLE(wxPrintAbortDialog, wxDialog)
 
493
    EVT_BUTTON(wxID_CANCEL, wxPrintAbortDialog::OnCancel)
 
494
END_EVENT_TABLE()
 
495
 
 
496
void wxPrintAbortDialog::OnCancel(wxCommandEvent& WXUNUSED(event))
 
497
{
 
498
    wxPrinterBase::sm_abortIt = true;
 
499
    wxPrinterBase::sm_abortWindow->Show(false);
 
500
    wxPrinterBase::sm_abortWindow->Close(true);
 
501
    wxPrinterBase::sm_abortWindow = (wxWindow *) NULL;
 
502
}
 
503
 
 
504
//----------------------------------------------------------------------------
 
505
// wxPrintout
 
506
//----------------------------------------------------------------------------
 
507
 
 
508
IMPLEMENT_ABSTRACT_CLASS(wxPrintout, wxObject)
 
509
 
 
510
wxPrintout::wxPrintout(const wxString& title)
 
511
{
 
512
    m_printoutTitle = title ;
 
513
    m_printoutDC = (wxDC *) NULL;
 
514
    m_pageWidthMM = 0;
 
515
    m_pageHeightMM = 0;
 
516
    m_pageWidthPixels = 0;
 
517
    m_pageHeightPixels = 0;
 
518
    m_PPIScreenX = 0;
 
519
    m_PPIScreenY = 0;
 
520
    m_PPIPrinterX = 0;
 
521
    m_PPIPrinterY = 0;
 
522
    m_isPreview = false;
 
523
}
 
524
 
 
525
wxPrintout::~wxPrintout()
 
526
{
 
527
}
 
528
 
 
529
bool wxPrintout::OnBeginDocument(int WXUNUSED(startPage), int WXUNUSED(endPage))
 
530
{
 
531
    return GetDC()->StartDoc(_("Printing ") + m_printoutTitle);
 
532
}
 
533
 
 
534
void wxPrintout::OnEndDocument()
 
535
{
 
536
    GetDC()->EndDoc();
 
537
}
 
538
 
 
539
void wxPrintout::OnBeginPrinting()
 
540
{
 
541
}
 
542
 
 
543
void wxPrintout::OnEndPrinting()
 
544
{
 
545
}
 
546
 
 
547
bool wxPrintout::HasPage(int page)
 
548
{
 
549
    return (page == 1);
 
550
}
 
551
 
 
552
void wxPrintout::GetPageInfo(int *minPage, int *maxPage, int *fromPage, int *toPage)
 
553
{
 
554
    *minPage = 1;
 
555
    *maxPage = 32000;
 
556
    *fromPage = 1;
 
557
    *toPage = 1;
 
558
}
 
559
 
 
560
//----------------------------------------------------------------------------
 
561
// wxPreviewCanvas
 
562
//----------------------------------------------------------------------------
 
563
 
 
564
IMPLEMENT_CLASS(wxPreviewCanvas, wxWindow)
 
565
 
 
566
BEGIN_EVENT_TABLE(wxPreviewCanvas, wxScrolledWindow)
 
567
    EVT_PAINT(wxPreviewCanvas::OnPaint)
 
568
    EVT_CHAR(wxPreviewCanvas::OnChar)
 
569
    EVT_SYS_COLOUR_CHANGED(wxPreviewCanvas::OnSysColourChanged)
 
570
#if wxUSE_MOUSEWHEEL
 
571
    EVT_MOUSEWHEEL(wxPreviewCanvas::OnMouseWheel)
 
572
#endif
 
573
END_EVENT_TABLE()
 
574
 
 
575
// VZ: the current code doesn't refresh properly without
 
576
//     wxFULL_REPAINT_ON_RESIZE, this must be fixed as otherwise we have
 
577
//     really horrible flicker when resizing the preview frame, but without
 
578
//     this style it simply doesn't work correctly at all...
 
579
wxPreviewCanvas::wxPreviewCanvas(wxPrintPreviewBase *preview, wxWindow *parent,
 
580
                                 const wxPoint& pos, const wxSize& size, long style, const wxString& name):
 
581
wxScrolledWindow(parent, wxID_ANY, pos, size, style | wxFULL_REPAINT_ON_RESIZE, name)
 
582
{
 
583
    m_printPreview = preview;
 
584
#ifdef __WXMAC__
 
585
    // The app workspace colour is always white, but we should have
 
586
    // a contrast with the page.
 
587
    wxSystemColour colourIndex = wxSYS_COLOUR_3DDKSHADOW;
 
588
#else
 
589
    wxSystemColour colourIndex = wxSYS_COLOUR_APPWORKSPACE;
 
590
#endif
 
591
    SetBackgroundColour(wxSystemSettings::GetColour(colourIndex));
 
592
 
 
593
    SetScrollbars(10, 10, 100, 100);
 
594
}
 
595
 
 
596
wxPreviewCanvas::~wxPreviewCanvas()
 
597
{
 
598
}
 
599
 
 
600
void wxPreviewCanvas::OnPaint(wxPaintEvent& WXUNUSED(event))
 
601
{
 
602
    wxPaintDC dc(this);
 
603
    PrepareDC( dc );
 
604
 
 
605
/*
 
606
#ifdef __WXGTK__
 
607
    if (!GetUpdateRegion().IsEmpty())
 
608
        dc.SetClippingRegion( GetUpdateRegion() );
 
609
#endif
 
610
*/
 
611
 
 
612
    if (m_printPreview)
 
613
    {
 
614
        m_printPreview->PaintPage(this, dc);
 
615
    }
 
616
}
 
617
 
 
618
// Responds to colour changes, and passes event on to children.
 
619
void wxPreviewCanvas::OnSysColourChanged(wxSysColourChangedEvent& event)
 
620
{
 
621
#ifdef __WXMAC__
 
622
    // The app workspace colour is always white, but we should have
 
623
    // a contrast with the page.
 
624
    wxSystemColour colourIndex = wxSYS_COLOUR_3DDKSHADOW;
 
625
#else
 
626
    wxSystemColour colourIndex = wxSYS_COLOUR_APPWORKSPACE;
 
627
#endif
 
628
    SetBackgroundColour(wxSystemSettings::GetColour(colourIndex));
 
629
    Refresh();
 
630
 
 
631
    // Propagate the event to the non-top-level children
 
632
    wxWindow::OnSysColourChanged(event);
 
633
}
 
634
 
 
635
void wxPreviewCanvas::OnChar(wxKeyEvent &event)
 
636
{
 
637
    wxPreviewControlBar* controlBar = ((wxPreviewFrame*) GetParent())->GetControlBar();
 
638
    if (event.GetKeyCode() == WXK_ESCAPE)
 
639
    {
 
640
        ((wxPreviewFrame*) GetParent())->Close(true);
 
641
        return;
 
642
    }
 
643
    else if (event.GetKeyCode() == WXK_TAB)
 
644
    {
 
645
        controlBar->OnGoto();
 
646
        return;
 
647
    }
 
648
    else if (event.GetKeyCode() == WXK_RETURN)
 
649
    {
 
650
        controlBar->OnPrint();
 
651
        return;
 
652
    }
 
653
 
 
654
    if (!event.ControlDown())
 
655
    {
 
656
        event.Skip();
 
657
        return;
 
658
    }
 
659
 
 
660
    switch(event.GetKeyCode())
 
661
    {
 
662
        case WXK_NEXT:
 
663
            controlBar->OnNext(); break;
 
664
        case WXK_PRIOR:
 
665
            controlBar->OnPrevious(); break;
 
666
        case WXK_HOME:
 
667
            controlBar->OnFirst(); break;
 
668
        case WXK_END:
 
669
            controlBar->OnLast(); break;
 
670
        default:
 
671
            event.Skip();
 
672
    }
 
673
}
 
674
 
 
675
#if wxUSE_MOUSEWHEEL
 
676
 
 
677
void wxPreviewCanvas::OnMouseWheel(wxMouseEvent& event)
 
678
{
 
679
    wxPreviewControlBar *
 
680
        controlBar = wxStaticCast(GetParent(), wxPreviewFrame)->GetControlBar();
 
681
 
 
682
    if ( controlBar )
 
683
    {
 
684
        if ( event.ControlDown() && event.GetWheelRotation() != 0 )
 
685
        {
 
686
            int currentZoom = controlBar->GetZoomControl();
 
687
 
 
688
            int delta;
 
689
            if ( currentZoom < 100 )
 
690
                delta = 5;
 
691
            else if ( currentZoom <= 120 )
 
692
                delta = 10;
 
693
            else
 
694
                delta = 50;
 
695
 
 
696
            if ( event.GetWheelRotation() > 0 )
 
697
                delta = -delta;
 
698
 
 
699
            int newZoom = currentZoom + delta;
 
700
            if ( newZoom < 10 )
 
701
                newZoom = 10;
 
702
            if ( newZoom > 200 )
 
703
                newZoom = 200;
 
704
            if ( newZoom != currentZoom )
 
705
            {
 
706
                controlBar->SetZoomControl(newZoom);
 
707
                m_printPreview->SetZoom(newZoom);
 
708
                Refresh();
 
709
            }
 
710
            return;
 
711
        }
 
712
    }
 
713
 
 
714
    event.Skip();
 
715
}
 
716
 
 
717
#endif // wxUSE_MOUSEWHEEL
 
718
 
 
719
//----------------------------------------------------------------------------
 
720
// wxPreviewControlBar
 
721
//----------------------------------------------------------------------------
 
722
 
 
723
IMPLEMENT_CLASS(wxPreviewControlBar, wxWindow)
 
724
 
 
725
BEGIN_EVENT_TABLE(wxPreviewControlBar, wxPanel)
 
726
    EVT_BUTTON(wxID_PREVIEW_CLOSE,    wxPreviewControlBar::OnWindowClose)
 
727
    EVT_BUTTON(wxID_PREVIEW_PRINT,    wxPreviewControlBar::OnPrintButton)
 
728
    EVT_BUTTON(wxID_PREVIEW_PREVIOUS, wxPreviewControlBar::OnPreviousButton)
 
729
    EVT_BUTTON(wxID_PREVIEW_NEXT,     wxPreviewControlBar::OnNextButton)
 
730
    EVT_BUTTON(wxID_PREVIEW_FIRST,    wxPreviewControlBar::OnFirstButton)
 
731
    EVT_BUTTON(wxID_PREVIEW_LAST,     wxPreviewControlBar::OnLastButton)
 
732
    EVT_BUTTON(wxID_PREVIEW_GOTO,     wxPreviewControlBar::OnGotoButton)
 
733
    EVT_CHOICE(wxID_PREVIEW_ZOOM,     wxPreviewControlBar::OnZoom)
 
734
    EVT_PAINT(wxPreviewControlBar::OnPaint)
 
735
END_EVENT_TABLE()
 
736
 
 
737
wxPreviewControlBar::wxPreviewControlBar(wxPrintPreviewBase *preview, long buttons,
 
738
                                         wxWindow *parent, const wxPoint& pos, const wxSize& size,
 
739
                                         long style, const wxString& name):
 
740
wxPanel(parent, wxID_ANY, pos, size, style, name)
 
741
{
 
742
    m_printPreview = preview;
 
743
    m_closeButton = (wxButton *) NULL;
 
744
    m_nextPageButton = (wxButton *) NULL;
 
745
    m_previousPageButton = (wxButton *) NULL;
 
746
    m_printButton = (wxButton *) NULL;
 
747
    m_zoomControl = (wxChoice *) NULL;
 
748
    m_buttonFlags = buttons;
 
749
}
 
750
 
 
751
wxPreviewControlBar::~wxPreviewControlBar()
 
752
{
 
753
}
 
754
 
 
755
void wxPreviewControlBar::OnPaint(wxPaintEvent& WXUNUSED(event))
 
756
{
 
757
    wxPaintDC dc(this);
 
758
 
 
759
    int w, h;
 
760
    GetSize(&w, &h);
 
761
    dc.SetPen(*wxBLACK_PEN);
 
762
    dc.SetBrush(*wxTRANSPARENT_BRUSH);
 
763
    dc.DrawLine( 0, h-1, w, h-1 );
 
764
}
 
765
 
 
766
void wxPreviewControlBar::OnWindowClose(wxCommandEvent& WXUNUSED(event))
 
767
{
 
768
    wxPreviewFrame *frame = (wxPreviewFrame *)GetParent();
 
769
    frame->Close(true);
 
770
}
 
771
 
 
772
void wxPreviewControlBar::OnPrint(void)
 
773
{
 
774
    wxPrintPreviewBase *preview = GetPrintPreview();
 
775
    preview->Print(true);
 
776
}
 
777
 
 
778
void wxPreviewControlBar::OnNext(void)
 
779
{
 
780
    wxPrintPreviewBase *preview = GetPrintPreview();
 
781
    if (preview)
 
782
    {
 
783
        int currentPage = preview->GetCurrentPage();
 
784
        if ((preview->GetMaxPage() > 0) &&
 
785
            (currentPage < preview->GetMaxPage()) &&
 
786
            preview->GetPrintout()->HasPage(currentPage + 1))
 
787
        {
 
788
            preview->SetCurrentPage(currentPage + 1);
 
789
        }
 
790
    }
 
791
}
 
792
 
 
793
void wxPreviewControlBar::OnPrevious(void)
 
794
{
 
795
    wxPrintPreviewBase *preview = GetPrintPreview();
 
796
    if (preview)
 
797
    {
 
798
        int currentPage = preview->GetCurrentPage();
 
799
        if ((preview->GetMinPage() > 0) &&
 
800
            (currentPage > preview->GetMinPage()) &&
 
801
            preview->GetPrintout()->HasPage(currentPage - 1))
 
802
        {
 
803
            preview->SetCurrentPage(currentPage - 1);
 
804
        }
 
805
    }
 
806
}
 
807
 
 
808
void wxPreviewControlBar::OnFirst(void)
 
809
{
 
810
    wxPrintPreviewBase *preview = GetPrintPreview();
 
811
    if (preview)
 
812
    {
 
813
        int currentPage = preview->GetMinPage();
 
814
        if (preview->GetPrintout()->HasPage(currentPage))
 
815
        {
 
816
            preview->SetCurrentPage(currentPage);
 
817
        }
 
818
    }
 
819
}
 
820
 
 
821
void wxPreviewControlBar::OnLast(void)
 
822
{
 
823
    wxPrintPreviewBase *preview = GetPrintPreview();
 
824
    if (preview)
 
825
    {
 
826
        int currentPage = preview->GetMaxPage();
 
827
        if (preview->GetPrintout()->HasPage(currentPage))
 
828
        {
 
829
            preview->SetCurrentPage(currentPage);
 
830
        }
 
831
    }
 
832
}
 
833
 
 
834
void wxPreviewControlBar::OnGoto(void)
 
835
{
 
836
    wxPrintPreviewBase *preview = GetPrintPreview();
 
837
    if (preview)
 
838
    {
 
839
        long currentPage;
 
840
 
 
841
        if (preview->GetMinPage() > 0)
 
842
        {
 
843
            wxString strPrompt;
 
844
            wxString strPage;
 
845
 
 
846
            strPrompt.Printf( _("Enter a page number between %d and %d:"),
 
847
                preview->GetMinPage(), preview->GetMaxPage());
 
848
            strPage.Printf( wxT("%d"), preview->GetCurrentPage() );
 
849
 
 
850
            strPage =
 
851
                wxGetTextFromUser( strPrompt, _("Goto Page"), strPage, GetParent());
 
852
 
 
853
            if ( strPage.ToLong( &currentPage ) )
 
854
                if (preview->GetPrintout()->HasPage(currentPage))
 
855
                {
 
856
                    preview->SetCurrentPage(currentPage);
 
857
                }
 
858
        }
 
859
    }
 
860
}
 
861
 
 
862
void wxPreviewControlBar::OnZoom(wxCommandEvent& WXUNUSED(event))
 
863
{
 
864
    int zoom = GetZoomControl();
 
865
    if (GetPrintPreview())
 
866
        GetPrintPreview()->SetZoom(zoom);
 
867
}
 
868
 
 
869
void wxPreviewControlBar::CreateButtons()
 
870
{
 
871
    SetSize(0, 0, 400, 40);
 
872
 
 
873
    wxBoxSizer *item0 = new wxBoxSizer( wxHORIZONTAL );
 
874
 
 
875
    m_closeButton = new wxButton( this, wxID_PREVIEW_CLOSE, _("&Close"), wxDefaultPosition, wxDefaultSize, 0 );
 
876
    item0->Add( m_closeButton, 0, wxALIGN_CENTRE|wxALL, 5 );
 
877
 
 
878
    if (m_buttonFlags & wxPREVIEW_PRINT)
 
879
    {
 
880
        m_printButton = new wxButton( this, wxID_PREVIEW_PRINT, _("&Print..."), wxDefaultPosition, wxDefaultSize, 0 );
 
881
        item0->Add( m_printButton, 0, wxALIGN_CENTRE|wxALL, 5 );
 
882
    }
 
883
 
 
884
    if (m_buttonFlags & wxPREVIEW_FIRST)
 
885
    {
 
886
        m_firstPageButton = new wxButton( this, wxID_PREVIEW_FIRST, _("|<<"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT );
 
887
        item0->Add( m_firstPageButton, 0, wxALIGN_CENTRE|wxALL, 5 );
 
888
    }
 
889
 
 
890
    if (m_buttonFlags & wxPREVIEW_PREVIOUS)
 
891
    {
 
892
        m_previousPageButton = new wxButton( this, wxID_PREVIEW_PREVIOUS, _("<<"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT );
 
893
        item0->Add( m_previousPageButton, 0, wxALIGN_CENTRE|wxRIGHT|wxTOP|wxBOTTOM, 5 );
 
894
    }
 
895
 
 
896
    if (m_buttonFlags & wxPREVIEW_NEXT)
 
897
    {
 
898
        m_nextPageButton = new wxButton( this, wxID_PREVIEW_NEXT, _(">>"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT );
 
899
        item0->Add( m_nextPageButton, 0, wxALIGN_CENTRE|wxRIGHT|wxTOP|wxBOTTOM, 5 );
 
900
    }
 
901
 
 
902
    if (m_buttonFlags & wxPREVIEW_LAST)
 
903
    {
 
904
        m_lastPageButton = new wxButton( this, wxID_PREVIEW_LAST, _(">>|"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT );
 
905
        item0->Add( m_lastPageButton, 0, wxALIGN_CENTRE|wxRIGHT|wxTOP|wxBOTTOM, 5 );
 
906
    }
 
907
 
 
908
    if (m_buttonFlags & wxPREVIEW_GOTO)
 
909
    {
 
910
        m_gotoPageButton = new wxButton( this, wxID_PREVIEW_GOTO, _("&Goto..."), wxDefaultPosition, wxDefaultSize, 0 );
 
911
        item0->Add( m_gotoPageButton, 0, wxALIGN_CENTRE|wxALL, 5 );
 
912
    }
 
913
 
 
914
    if (m_buttonFlags & wxPREVIEW_ZOOM)
 
915
    {
 
916
        wxString choices[] =
 
917
        {
 
918
            wxT("10%"), wxT("15%"), wxT("20%"), wxT("25%"), wxT("30%"), wxT("35%"), wxT("40%"), wxT("45%"), wxT("50%"), wxT("55%"),
 
919
                wxT("60%"), wxT("65%"), wxT("70%"), wxT("75%"), wxT("80%"), wxT("85%"), wxT("90%"), wxT("95%"), wxT("100%"), wxT("110%"),
 
920
                wxT("120%"), wxT("150%"), wxT("200%")
 
921
        };
 
922
        int n = WXSIZEOF(choices);
 
923
 
 
924
        m_zoomControl = new wxChoice( this, wxID_PREVIEW_ZOOM, wxDefaultPosition, wxSize(70,wxDefaultCoord), n, choices, 0 );
 
925
        item0->Add( m_zoomControl, 0, wxALIGN_CENTRE|wxALL, 5 );
 
926
        SetZoomControl(m_printPreview->GetZoom());
 
927
    }
 
928
 
 
929
    SetSizer(item0);
 
930
    item0->Fit(this);
 
931
}
 
932
 
 
933
void wxPreviewControlBar::SetZoomControl(int zoom)
 
934
{
 
935
    if (m_zoomControl)
 
936
    {
 
937
        int n, count = m_zoomControl->GetCount();
 
938
        long val;
 
939
        for (n=0; n<count; n++)
 
940
        {
 
941
            if (m_zoomControl->GetString(n).BeforeFirst(wxT('%')).ToLong(&val) &&
 
942
                (val >= long(zoom)))
 
943
            {
 
944
                m_zoomControl->SetSelection(n);
 
945
                return;
 
946
            }
 
947
        }
 
948
 
 
949
        m_zoomControl->SetSelection(count-1);
 
950
    }
 
951
}
 
952
 
 
953
int wxPreviewControlBar::GetZoomControl()
 
954
{
 
955
    if (m_zoomControl && (m_zoomControl->GetStringSelection() != wxEmptyString))
 
956
    {
 
957
        long val;
 
958
        if (m_zoomControl->GetStringSelection().BeforeFirst(wxT('%')).ToLong(&val))
 
959
            return int(val);
 
960
    }
 
961
 
 
962
    return 0;
 
963
}
 
964
 
 
965
 
 
966
/*
 
967
* Preview frame
 
968
*/
 
969
 
 
970
IMPLEMENT_CLASS(wxPreviewFrame, wxFrame)
 
971
 
 
972
BEGIN_EVENT_TABLE(wxPreviewFrame, wxFrame)
 
973
    EVT_CLOSE(wxPreviewFrame::OnCloseWindow)
 
974
END_EVENT_TABLE()
 
975
 
 
976
wxPreviewFrame::wxPreviewFrame(wxPrintPreviewBase *preview, wxWindow *parent, const wxString& title,
 
977
                               const wxPoint& pos, const wxSize& size, long style, const wxString& name):
 
978
wxFrame(parent, wxID_ANY, title, pos, size, style, name)
 
979
{
 
980
    m_printPreview = preview;
 
981
    m_controlBar = NULL;
 
982
    m_previewCanvas = NULL;
 
983
    m_windowDisabler = NULL;
 
984
 
 
985
    // Give the application icon
 
986
#ifdef __WXMSW__
 
987
    wxFrame* topFrame = wxDynamicCast(wxTheApp->GetTopWindow(), wxFrame);
 
988
    if (topFrame)
 
989
        SetIcon(topFrame->GetIcon());
 
990
#endif
 
991
}
 
992
 
 
993
wxPreviewFrame::~wxPreviewFrame()
 
994
{
 
995
}
 
996
 
 
997
void wxPreviewFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
 
998
{
 
999
    if (m_windowDisabler)
 
1000
        delete m_windowDisabler;
 
1001
 
 
1002
    // Need to delete the printout and the print preview
 
1003
    wxPrintout *printout = m_printPreview->GetPrintout();
 
1004
    if (printout)
 
1005
    {
 
1006
        delete printout;
 
1007
        m_printPreview->SetPrintout(NULL);
 
1008
        m_printPreview->SetCanvas(NULL);
 
1009
        m_printPreview->SetFrame(NULL);
 
1010
    }
 
1011
    delete m_printPreview;
 
1012
 
 
1013
    Destroy();
 
1014
}
 
1015
 
 
1016
void wxPreviewFrame::Initialize()
 
1017
{
 
1018
#if wxUSE_STATUSBAR
 
1019
    CreateStatusBar();
 
1020
#endif
 
1021
    CreateCanvas();
 
1022
    CreateControlBar();
 
1023
 
 
1024
    m_printPreview->SetCanvas(m_previewCanvas);
 
1025
    m_printPreview->SetFrame(this);
 
1026
 
 
1027
    wxBoxSizer *item0 = new wxBoxSizer( wxVERTICAL );
 
1028
 
 
1029
    item0->Add( m_controlBar, 0, wxGROW|wxALIGN_CENTER_VERTICAL, 5 );
 
1030
    item0->Add( m_previewCanvas, 1, wxGROW|wxALIGN_CENTER_VERTICAL, 5 );
 
1031
 
 
1032
    SetAutoLayout( true );
 
1033
    SetSizer( item0 );
 
1034
 
 
1035
    m_windowDisabler = new wxWindowDisabler(this);
 
1036
 
 
1037
    Layout();
 
1038
 
 
1039
    m_printPreview->AdjustScrollbars(m_previewCanvas);
 
1040
    m_previewCanvas->SetFocus();
 
1041
    m_controlBar->SetFocus();
 
1042
}
 
1043
 
 
1044
void wxPreviewFrame::CreateCanvas()
 
1045
{
 
1046
    m_previewCanvas = new wxPreviewCanvas(m_printPreview, this);
 
1047
}
 
1048
 
 
1049
void wxPreviewFrame::CreateControlBar()
 
1050
{
 
1051
    long buttons = wxPREVIEW_DEFAULT;
 
1052
    if (m_printPreview->GetPrintoutForPrinting())
 
1053
        buttons |= wxPREVIEW_PRINT;
 
1054
 
 
1055
    m_controlBar = new wxPreviewControlBar(m_printPreview, buttons, this, wxPoint(0,0), wxSize(400, 40));
 
1056
    m_controlBar->CreateButtons();
 
1057
}
 
1058
 
 
1059
/*
 
1060
* Print preview
 
1061
*/
 
1062
 
 
1063
IMPLEMENT_CLASS(wxPrintPreviewBase, wxObject)
 
1064
 
 
1065
wxPrintPreviewBase::wxPrintPreviewBase(wxPrintout *printout,
 
1066
                                       wxPrintout *printoutForPrinting,
 
1067
                                       wxPrintData *data)
 
1068
{
 
1069
    if (data)
 
1070
        m_printDialogData = (*data);
 
1071
 
 
1072
    Init(printout, printoutForPrinting);
 
1073
}
 
1074
 
 
1075
wxPrintPreviewBase::wxPrintPreviewBase(wxPrintout *printout,
 
1076
                                       wxPrintout *printoutForPrinting,
 
1077
                                       wxPrintDialogData *data)
 
1078
{
 
1079
    if (data)
 
1080
        m_printDialogData = (*data);
 
1081
 
 
1082
    Init(printout, printoutForPrinting);
 
1083
}
 
1084
 
 
1085
void wxPrintPreviewBase::Init(wxPrintout *printout,
 
1086
                              wxPrintout *printoutForPrinting)
 
1087
{
 
1088
    m_isOk = true;
 
1089
    m_previewPrintout = printout;
 
1090
    if (m_previewPrintout)
 
1091
        m_previewPrintout->SetIsPreview(true);
 
1092
 
 
1093
    m_printPrintout = printoutForPrinting;
 
1094
 
 
1095
    m_previewCanvas = NULL;
 
1096
    m_previewFrame = NULL;
 
1097
    m_previewBitmap = NULL;
 
1098
    m_currentPage = 1;
 
1099
    m_currentZoom = 70;
 
1100
    m_topMargin = 40;
 
1101
    m_leftMargin = 40;
 
1102
    m_pageWidth = 0;
 
1103
    m_pageHeight = 0;
 
1104
    m_printingPrepared = false;
 
1105
    m_minPage = 1;
 
1106
    m_maxPage = 1;
 
1107
}
 
1108
 
 
1109
wxPrintPreviewBase::~wxPrintPreviewBase()
 
1110
{
 
1111
    if (m_previewPrintout)
 
1112
        delete m_previewPrintout;
 
1113
    if (m_previewBitmap)
 
1114
        delete m_previewBitmap;
 
1115
    if (m_printPrintout)
 
1116
        delete m_printPrintout;
 
1117
}
 
1118
 
 
1119
bool wxPrintPreviewBase::SetCurrentPage(int pageNum)
 
1120
{
 
1121
    if (m_currentPage == pageNum)
 
1122
        return true;
 
1123
 
 
1124
    m_currentPage = pageNum;
 
1125
    if (m_previewBitmap)
 
1126
    {
 
1127
        delete m_previewBitmap;
 
1128
        m_previewBitmap = NULL;
 
1129
    }
 
1130
 
 
1131
    if (m_previewCanvas)
 
1132
    {
 
1133
        AdjustScrollbars(m_previewCanvas);
 
1134
 
 
1135
        if (!RenderPage(pageNum))
 
1136
            return false;
 
1137
        m_previewCanvas->Refresh();
 
1138
        m_previewCanvas->SetFocus();
 
1139
    }
 
1140
    return true;
 
1141
}
 
1142
 
 
1143
int wxPrintPreviewBase::GetCurrentPage() const
 
1144
    { return m_currentPage; };
 
1145
void wxPrintPreviewBase::SetPrintout(wxPrintout *printout)
 
1146
    { m_previewPrintout = printout; };
 
1147
wxPrintout *wxPrintPreviewBase::GetPrintout() const
 
1148
    { return m_previewPrintout; };
 
1149
wxPrintout *wxPrintPreviewBase::GetPrintoutForPrinting() const
 
1150
    { return m_printPrintout; };
 
1151
void wxPrintPreviewBase::SetFrame(wxFrame *frame)
 
1152
    { m_previewFrame = frame; };
 
1153
void wxPrintPreviewBase::SetCanvas(wxPreviewCanvas *canvas)
 
1154
    { m_previewCanvas = canvas; };
 
1155
wxFrame *wxPrintPreviewBase::GetFrame() const
 
1156
    { return m_previewFrame; }
 
1157
wxPreviewCanvas *wxPrintPreviewBase::GetCanvas() const
 
1158
    { return m_previewCanvas; }
 
1159
 
 
1160
bool wxPrintPreviewBase::PaintPage(wxPreviewCanvas *canvas, wxDC& dc)
 
1161
{
 
1162
    DrawBlankPage(canvas, dc);
 
1163
 
 
1164
    if (!m_previewBitmap)
 
1165
        if (!RenderPage(m_currentPage))
 
1166
            return false;
 
1167
 
 
1168
    if (!m_previewBitmap)
 
1169
        return false;
 
1170
 
 
1171
    if (!canvas)
 
1172
        return false;
 
1173
 
 
1174
    int canvasWidth, canvasHeight;
 
1175
    canvas->GetSize(&canvasWidth, &canvasHeight);
 
1176
 
 
1177
    double zoomScale = ((float)m_currentZoom/(float)100);
 
1178
    double actualWidth = (zoomScale*m_pageWidth*m_previewScale);
 
1179
    //  float actualHeight = (float)(zoomScale*m_pageHeight*m_previewScale);
 
1180
 
 
1181
    int x = (int) ((canvasWidth - actualWidth)/2.0);
 
1182
    if (x < m_leftMargin)
 
1183
        x = m_leftMargin;
 
1184
    int y = m_topMargin;
 
1185
 
 
1186
    wxMemoryDC temp_dc;
 
1187
    temp_dc.SelectObject(*m_previewBitmap);
 
1188
 
 
1189
    dc.Blit(x, y, m_previewBitmap->GetWidth(), m_previewBitmap->GetHeight(), &temp_dc, 0, 0);
 
1190
 
 
1191
    temp_dc.SelectObject(wxNullBitmap);
 
1192
 
 
1193
    return true;
 
1194
}
 
1195
 
 
1196
// Adjusts the scrollbars for the current scale
 
1197
void wxPrintPreviewBase::AdjustScrollbars(wxPreviewCanvas *canvas)
 
1198
{
 
1199
    if (!canvas)
 
1200
        return ;
 
1201
 
 
1202
    int canvasWidth, canvasHeight;
 
1203
    canvas->GetSize(&canvasWidth, &canvasHeight);
 
1204
 
 
1205
    double zoomScale = ((float)m_currentZoom/(float)100);
 
1206
    double actualWidth = (zoomScale*m_pageWidth*m_previewScale);
 
1207
    double actualHeight = (zoomScale*m_pageHeight*m_previewScale);
 
1208
 
 
1209
    // Set the scrollbars appropriately
 
1210
    int totalWidth = (int)(actualWidth + 2*m_leftMargin);
 
1211
    int totalHeight = (int)(actualHeight + 2*m_topMargin);
 
1212
    int scrollUnitsX = totalWidth/10;
 
1213
    int scrollUnitsY = totalHeight/10;
 
1214
    wxSize virtualSize = canvas->GetVirtualSize();
 
1215
    if (virtualSize.GetWidth() != totalWidth || virtualSize.GetHeight() != totalHeight)
 
1216
        canvas->SetScrollbars(10, 10, scrollUnitsX, scrollUnitsY, 0, 0, true);
 
1217
}
 
1218
 
 
1219
bool wxPrintPreviewBase::RenderPage(int pageNum)
 
1220
{
 
1221
    wxBusyCursor busy;
 
1222
 
 
1223
    int canvasWidth, canvasHeight;
 
1224
 
 
1225
    if (!m_previewCanvas)
 
1226
    {
 
1227
        wxFAIL_MSG(_T("wxPrintPreviewBase::RenderPage: must use wxPrintPreviewBase::SetCanvas to let me know about the canvas!"));
 
1228
 
 
1229
        return false;
 
1230
    }
 
1231
    m_previewCanvas->GetSize(&canvasWidth, &canvasHeight);
 
1232
 
 
1233
    double zoomScale = (m_currentZoom/100.0);
 
1234
    int actualWidth = (int)(zoomScale*m_pageWidth*m_previewScale);
 
1235
    int actualHeight = (int)(zoomScale*m_pageHeight*m_previewScale);
 
1236
 
 
1237
    if (!m_previewBitmap)
 
1238
    {
 
1239
        m_previewBitmap = new wxBitmap((int)actualWidth, (int)actualHeight);
 
1240
        if (!m_previewBitmap || !m_previewBitmap->Ok())
 
1241
        {
 
1242
            if (m_previewBitmap) {
 
1243
                delete m_previewBitmap;
 
1244
                m_previewBitmap = NULL;
 
1245
            }
 
1246
            wxMessageBox(_("Sorry, not enough memory to create a preview."), _("Print Preview Failure"), wxOK);
 
1247
            return false;
 
1248
        }
 
1249
    }
 
1250
 
 
1251
    wxMemoryDC memoryDC;
 
1252
    memoryDC.SelectObject(*m_previewBitmap);
 
1253
 
 
1254
    memoryDC.Clear();
 
1255
 
 
1256
    m_previewPrintout->SetDC(&memoryDC);
 
1257
    m_previewPrintout->SetPageSizePixels(m_pageWidth, m_pageHeight);
 
1258
 
 
1259
    // Need to delay OnPreparePrinting until here, so we have enough information.
 
1260
    if (!m_printingPrepared)
 
1261
    {
 
1262
        m_previewPrintout->OnPreparePrinting();
 
1263
        int selFrom, selTo;
 
1264
        m_previewPrintout->GetPageInfo(&m_minPage, &m_maxPage, &selFrom, &selTo);
 
1265
        m_printingPrepared = true;
 
1266
    }
 
1267
 
 
1268
    m_previewPrintout->OnBeginPrinting();
 
1269
 
 
1270
    if (!m_previewPrintout->OnBeginDocument(m_printDialogData.GetFromPage(), m_printDialogData.GetToPage()))
 
1271
    {
 
1272
        wxMessageBox(_("Could not start document preview."), _("Print Preview Failure"), wxOK);
 
1273
 
 
1274
        memoryDC.SelectObject(wxNullBitmap);
 
1275
 
 
1276
        delete m_previewBitmap;
 
1277
        m_previewBitmap = NULL;
 
1278
        return false;
 
1279
    }
 
1280
 
 
1281
    m_previewPrintout->OnPrintPage(pageNum);
 
1282
    m_previewPrintout->OnEndDocument();
 
1283
    m_previewPrintout->OnEndPrinting();
 
1284
 
 
1285
    m_previewPrintout->SetDC(NULL);
 
1286
 
 
1287
    memoryDC.SelectObject(wxNullBitmap);
 
1288
 
 
1289
#if wxUSE_STATUSBAR
 
1290
    wxString status;
 
1291
    if (m_maxPage != 0)
 
1292
        status = wxString::Format(_("Page %d of %d"), pageNum, m_maxPage);
 
1293
    else
 
1294
        status = wxString::Format(_("Page %d"), pageNum);
 
1295
 
 
1296
    if (m_previewFrame)
 
1297
        m_previewFrame->SetStatusText(status);
 
1298
#endif
 
1299
 
 
1300
    return true;
 
1301
}
 
1302
 
 
1303
 
 
1304
bool wxPrintPreviewBase::DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc)
 
1305
{
 
1306
    int canvasWidth, canvasHeight;
 
1307
    canvas->GetSize(&canvasWidth, &canvasHeight);
 
1308
 
 
1309
    float zoomScale = (float)((float)m_currentZoom/(float)100);
 
1310
    float actualWidth = zoomScale*m_pageWidth*m_previewScale;
 
1311
    float actualHeight = zoomScale*m_pageHeight*m_previewScale;
 
1312
 
 
1313
    float x = (float)((canvasWidth - actualWidth)/2.0);
 
1314
    if (x < m_leftMargin)
 
1315
        x = (float)m_leftMargin;
 
1316
    float y = (float)m_topMargin;
 
1317
 
 
1318
    // Draw shadow, allowing for 1-pixel border AROUND the actual page
 
1319
    int shadowOffset = 4;
 
1320
    dc.SetPen(*wxBLACK_PEN);
 
1321
    dc.SetBrush(*wxBLACK_BRUSH);
 
1322
    /*
 
1323
    dc.DrawRectangle((int)(x-1 + shadowOffset), (int)(y-1 + shadowOffset), (int)(actualWidth+2), (int)(actualHeight+2));
 
1324
    */
 
1325
    dc.DrawRectangle((int)(x + shadowOffset), (int)(y + actualHeight+1), (int)(actualWidth), shadowOffset);
 
1326
    dc.DrawRectangle((int)(x + actualWidth), (int)(y + shadowOffset), shadowOffset, (int)(actualHeight));
 
1327
 
 
1328
    // Draw blank page allowing for 1-pixel border AROUND the actual page
 
1329
    dc.SetPen(*wxBLACK_PEN);
 
1330
    dc.SetBrush(*wxWHITE_BRUSH);
 
1331
 
 
1332
    /*
 
1333
    wxRegion update_region = canvas->GetUpdateRegion();
 
1334
    wxRect r = update_region.GetBox();
 
1335
 
 
1336
      printf( "x: %d y: %d w: %d h: %d.\n", (int)r.x, (int)r.y, (int)r.width, (int)r.height );
 
1337
    */
 
1338
 
 
1339
    dc.DrawRectangle((int)(x-2), (int)(y-1), (int)(actualWidth+3), (int)(actualHeight+2));
 
1340
 
 
1341
    return true;
 
1342
}
 
1343
 
 
1344
void wxPrintPreviewBase::SetZoom(int percent)
 
1345
{
 
1346
    if (m_currentZoom == percent)
 
1347
        return;
 
1348
 
 
1349
    m_currentZoom = percent;
 
1350
    if (m_previewBitmap)
 
1351
    {
 
1352
        delete m_previewBitmap;
 
1353
        m_previewBitmap = NULL;
 
1354
    }
 
1355
 
 
1356
    if (m_previewCanvas)
 
1357
    {
 
1358
        AdjustScrollbars(m_previewCanvas);
 
1359
        RenderPage(m_currentPage);
 
1360
        ((wxScrolledWindow *) m_previewCanvas)->Scroll(0, 0);
 
1361
        m_previewCanvas->ClearBackground();
 
1362
        m_previewCanvas->Refresh();
 
1363
        m_previewCanvas->SetFocus();
 
1364
    }
 
1365
}
 
1366
 
 
1367
wxPrintDialogData& wxPrintPreviewBase::GetPrintDialogData()
 
1368
{
 
1369
    return m_printDialogData;
 
1370
}
 
1371
 
 
1372
int wxPrintPreviewBase::GetZoom() const
 
1373
{ return m_currentZoom; }
 
1374
int wxPrintPreviewBase::GetMaxPage() const
 
1375
{ return m_maxPage; }
 
1376
int wxPrintPreviewBase::GetMinPage() const
 
1377
{ return m_minPage; }
 
1378
bool wxPrintPreviewBase::Ok() const
 
1379
{ return m_isOk; }
 
1380
void wxPrintPreviewBase::SetOk(bool ok)
 
1381
{ m_isOk = ok; }
 
1382
//----------------------------------------------------------------------------
 
1383
// wxPrintPreview
 
1384
//----------------------------------------------------------------------------
 
1385
 
 
1386
IMPLEMENT_CLASS(wxPrintPreview, wxPrintPreviewBase)
 
1387
 
 
1388
wxPrintPreview::wxPrintPreview(wxPrintout *printout,
 
1389
                   wxPrintout *printoutForPrinting,
 
1390
                   wxPrintDialogData *data) :
 
1391
    wxPrintPreviewBase( printout, printoutForPrinting, data )
 
1392
{
 
1393
    m_pimpl = wxPrintFactory::GetFactory()->
 
1394
        CreatePrintPreview( printout, printoutForPrinting, data );
 
1395
}
 
1396
 
 
1397
wxPrintPreview::wxPrintPreview(wxPrintout *printout,
 
1398
                   wxPrintout *printoutForPrinting,
 
1399
                   wxPrintData *data ) :
 
1400
    wxPrintPreviewBase( printout, printoutForPrinting, data )
 
1401
{
 
1402
    m_pimpl = wxPrintFactory::GetFactory()->
 
1403
        CreatePrintPreview( printout, printoutForPrinting, data );
 
1404
}
 
1405
 
 
1406
wxPrintPreview::~wxPrintPreview()
 
1407
{
 
1408
    delete m_pimpl;
 
1409
 
 
1410
    // don't delete twice
 
1411
    m_printPrintout = NULL;
 
1412
    m_previewPrintout = NULL;
 
1413
    m_previewBitmap = NULL;
 
1414
}
 
1415
 
 
1416
bool wxPrintPreview::SetCurrentPage(int pageNum)
 
1417
{
 
1418
    return m_pimpl->SetCurrentPage( pageNum );
 
1419
}
 
1420
 
 
1421
int wxPrintPreview::GetCurrentPage() const
 
1422
{
 
1423
    return m_pimpl->GetCurrentPage();
 
1424
}
 
1425
 
 
1426
void wxPrintPreview::SetPrintout(wxPrintout *printout)
 
1427
{
 
1428
    m_pimpl->SetPrintout( printout );
 
1429
}
 
1430
 
 
1431
wxPrintout *wxPrintPreview::GetPrintout() const
 
1432
{
 
1433
    return m_pimpl->GetPrintout();
 
1434
}
 
1435
 
 
1436
wxPrintout *wxPrintPreview::GetPrintoutForPrinting() const
 
1437
{
 
1438
    return m_pimpl->GetPrintoutForPrinting();
 
1439
}
 
1440
 
 
1441
void wxPrintPreview::SetFrame(wxFrame *frame)
 
1442
{
 
1443
    m_pimpl->SetFrame( frame );
 
1444
}
 
1445
 
 
1446
void wxPrintPreview::SetCanvas(wxPreviewCanvas *canvas)
 
1447
{
 
1448
    m_pimpl->SetCanvas( canvas );
 
1449
}
 
1450
 
 
1451
wxFrame *wxPrintPreview::GetFrame() const
 
1452
{
 
1453
    return m_pimpl->GetFrame();
 
1454
}
 
1455
 
 
1456
wxPreviewCanvas *wxPrintPreview::GetCanvas() const
 
1457
{
 
1458
    return m_pimpl->GetCanvas();
 
1459
}
 
1460
 
 
1461
bool wxPrintPreview::PaintPage(wxPreviewCanvas *canvas, wxDC& dc)
 
1462
{
 
1463
    return m_pimpl->PaintPage( canvas, dc );
 
1464
}
 
1465
 
 
1466
bool wxPrintPreview::DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc)
 
1467
{
 
1468
    return m_pimpl->DrawBlankPage( canvas, dc );
 
1469
}
 
1470
 
 
1471
void wxPrintPreview::AdjustScrollbars(wxPreviewCanvas *canvas)
 
1472
{
 
1473
    m_pimpl->AdjustScrollbars( canvas );
 
1474
}
 
1475
 
 
1476
bool wxPrintPreview::RenderPage(int pageNum)
 
1477
{
 
1478
    return m_pimpl->RenderPage( pageNum );
 
1479
}
 
1480
 
 
1481
void wxPrintPreview::SetZoom(int percent)
 
1482
{
 
1483
    m_pimpl->SetZoom( percent );
 
1484
}
 
1485
 
 
1486
wxPrintDialogData& wxPrintPreview::GetPrintDialogData()
 
1487
{
 
1488
    return m_pimpl->GetPrintDialogData();
 
1489
}
 
1490
 
 
1491
int wxPrintPreview::GetMaxPage() const
 
1492
{
 
1493
    return m_pimpl->GetMaxPage();
 
1494
}
 
1495
 
 
1496
int wxPrintPreview::GetMinPage() const
 
1497
{
 
1498
    return m_pimpl->GetMinPage();
 
1499
}
 
1500
 
 
1501
bool wxPrintPreview::Ok() const
 
1502
{
 
1503
    return m_pimpl->Ok();
 
1504
}
 
1505
 
 
1506
void wxPrintPreview::SetOk(bool ok)
 
1507
{
 
1508
    m_pimpl->SetOk( ok );
 
1509
}
 
1510
 
 
1511
bool wxPrintPreview::Print(bool interactive)
 
1512
{
 
1513
    return m_pimpl->Print( interactive );
 
1514
}
 
1515
 
 
1516
void wxPrintPreview::DetermineScaling()
 
1517
{
 
1518
    m_pimpl->DetermineScaling();
 
1519
}
 
1520
 
 
1521
 
 
1522
#endif // wxUSE_PRINTING_ARCHITECTURE