home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2233.zip / wxOS2-2_3_3.zip / wxWindows-2.3.3 / src / common / prntbase.cpp < prev    next >
C/C++ Source or Header  |  2002-08-17  |  24KB  |  898 lines
  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.46 2002/08/16 17:39:51 RR Exp $
  8. // Copyright:   (c) Julian Smart and Markus Holzem
  9. // Licence:       wxWindows license
  10. /////////////////////////////////////////////////////////////////////////////
  11.  
  12. #ifdef __GNUG__
  13. #pragma implementation "prntbase.h"
  14. #endif
  15.  
  16. // For compilers that support precompilation, includes "wx.h".
  17. #include "wx/wxprec.h"
  18.  
  19. #ifdef __BORLANDC__
  20. #pragma hdrstop
  21. #endif
  22.  
  23. #include "wx/defs.h"
  24.  
  25. #if wxUSE_PRINTING_ARCHITECTURE
  26.  
  27. #ifndef WX_PRECOMP
  28. #include "wx/utils.h"
  29. #include "wx/dc.h"
  30. #include "wx/app.h"
  31. #include "wx/msgdlg.h"
  32. #include "wx/layout.h"
  33. #include "wx/choice.h"
  34. #include "wx/button.h"
  35. #include "wx/settings.h"
  36. #include "wx/dcmemory.h"
  37. #include "wx/stattext.h"
  38. #include "wx/intl.h"
  39. #include "wx/textdlg.h"
  40. #endif
  41.  
  42. #include "wx/prntbase.h"
  43. #include "wx/dcprint.h"
  44. #include "wx/printdlg.h"
  45. #include "wx/module.h"
  46.  
  47. #include <stdlib.h>
  48. #include <string.h>
  49.  
  50. #include <wx/sizer.h>
  51.                                          
  52. #ifdef __WXMSW__
  53.     #include "wx/msw/private.h"
  54.     #include <commdlg.h>
  55.  
  56.     #ifndef __WIN32__
  57.         #include <print.h>
  58.     #endif
  59. #endif // __WXMSW__
  60.  
  61. IMPLEMENT_CLASS(wxPrinterBase, wxObject)
  62. IMPLEMENT_ABSTRACT_CLASS(wxPrintout, wxObject)
  63. IMPLEMENT_CLASS(wxPreviewCanvas, wxWindow)
  64. IMPLEMENT_CLASS(wxPreviewControlBar, wxWindow)
  65. IMPLEMENT_CLASS(wxPreviewFrame, wxFrame)
  66. IMPLEMENT_CLASS(wxPrintPreviewBase, wxObject)
  67.  
  68. BEGIN_EVENT_TABLE(wxPrintAbortDialog, wxDialog)
  69.     EVT_BUTTON(wxID_CANCEL, wxPrintAbortDialog::OnCancel)
  70. END_EVENT_TABLE()
  71.  
  72. BEGIN_EVENT_TABLE(wxPreviewCanvas, wxScrolledWindow)
  73.     EVT_PAINT(wxPreviewCanvas::OnPaint)
  74.     EVT_SYS_COLOUR_CHANGED(wxPreviewCanvas::OnSysColourChanged)
  75. END_EVENT_TABLE()
  76.  
  77. /*
  78. * Printer
  79. */
  80.  
  81. wxPrinterBase::wxPrinterBase(wxPrintDialogData *data)
  82. {
  83.     m_currentPrintout = (wxPrintout *) NULL;
  84.     sm_abortWindow = (wxWindow *) NULL;
  85.     sm_abortIt = FALSE;
  86.     if (data)
  87.         m_printDialogData = (*data);
  88.     sm_lastError = wxPRINTER_NO_ERROR;
  89. }
  90.  
  91. wxWindow *wxPrinterBase::sm_abortWindow = (wxWindow *) NULL;
  92. bool wxPrinterBase::sm_abortIt = FALSE;
  93. wxPrinterError wxPrinterBase::sm_lastError = wxPRINTER_NO_ERROR;
  94.  
  95. wxPrinterBase::~wxPrinterBase()
  96. {
  97. }
  98.  
  99. void wxPrintAbortDialog::OnCancel(wxCommandEvent& WXUNUSED(event))
  100. {
  101.     wxPrinterBase::sm_abortIt = TRUE;
  102.     wxPrinterBase::sm_abortWindow->Show(FALSE);
  103.     wxPrinterBase::sm_abortWindow->Close(TRUE);
  104.     wxPrinterBase::sm_abortWindow = (wxWindow *) NULL;
  105. }
  106.  
  107. wxWindow *wxPrinterBase::CreateAbortWindow(wxWindow *parent, wxPrintout * printout)
  108. {
  109.     wxPrintAbortDialog *dialog = new wxPrintAbortDialog(parent, _("Printing ") , wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE);
  110.  
  111.     wxBoxSizer *button_sizer = new wxBoxSizer( wxVERTICAL );
  112.     button_sizer->Add( new wxStaticText(dialog, -1, _("Please wait while printing\n") + printout->GetTitle() ), 0, wxALL, 10 );
  113.     button_sizer->Add( new wxButton( dialog, wxID_CANCEL, wxT("Cancel") ), 0, wxALL | wxALIGN_CENTER, 10 );
  114.  
  115.     dialog->SetAutoLayout( TRUE );
  116.     dialog->SetSizer( button_sizer );
  117.  
  118.     button_sizer->Fit(dialog);
  119.     button_sizer->SetSizeHints (dialog) ;
  120.  
  121.     return dialog;
  122. }
  123.  
  124. void wxPrinterBase::ReportError(wxWindow *parent, wxPrintout *WXUNUSED(printout), const wxString& message)
  125. {
  126.     wxMessageBox(message, _("Printing Error"), wxOK, parent);
  127. }
  128.  
  129. /*
  130. * Printout class
  131. */
  132.  
  133. wxPrintout::wxPrintout(const wxString& title)
  134. {
  135.     m_printoutTitle = title ;
  136.     m_printoutDC = (wxDC *) NULL;
  137.     m_pageWidthMM = 0;
  138.     m_pageHeightMM = 0;
  139.     m_pageWidthPixels = 0;
  140.     m_pageHeightPixels = 0;
  141.     m_PPIScreenX = 0;
  142.     m_PPIScreenY = 0;
  143.     m_PPIPrinterX = 0;
  144.     m_PPIPrinterY = 0;
  145.     m_isPreview = FALSE;
  146. }
  147.  
  148. wxPrintout::~wxPrintout()
  149. {
  150. }
  151.  
  152. bool wxPrintout::OnBeginDocument(int WXUNUSED(startPage), int WXUNUSED(endPage))
  153. {
  154.     return GetDC()->StartDoc(_("Printing ") + m_printoutTitle);
  155. }
  156.  
  157. void wxPrintout::OnEndDocument()
  158. {
  159.     GetDC()->EndDoc();
  160. }
  161.  
  162. void wxPrintout::OnBeginPrinting()
  163. {
  164. }
  165.  
  166. void wxPrintout::OnEndPrinting()
  167. {
  168. }
  169.  
  170. bool wxPrintout::HasPage(int page)
  171. {
  172.     return (page == 1);
  173. }
  174.  
  175. void wxPrintout::GetPageInfo(int *minPage, int *maxPage, int *fromPage, int *toPage)
  176. {
  177.     *minPage = 1;
  178.     *maxPage = 32000;
  179.     *fromPage = 1;
  180.     *toPage = 1;
  181. }
  182.  
  183. /*
  184. * Preview canvas
  185. */
  186.  
  187. wxPreviewCanvas::wxPreviewCanvas(wxPrintPreviewBase *preview, wxWindow *parent,
  188.                                  const wxPoint& pos, const wxSize& size, long style, const wxString& name):
  189. wxScrolledWindow(parent, -1, pos, size, style, name)
  190. {
  191.     m_printPreview = preview;
  192.     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
  193.  
  194.     SetScrollbars(15, 18, 100, 100);
  195. }
  196.  
  197. wxPreviewCanvas::~wxPreviewCanvas()
  198. {
  199. }
  200.  
  201. void wxPreviewCanvas::OnPaint(wxPaintEvent& WXUNUSED(event))
  202. {
  203.     wxPaintDC dc(this);
  204.     PrepareDC( dc );
  205.  
  206. /*
  207. #ifdef __WXGTK__
  208.     if (!GetUpdateRegion().IsEmpty())
  209.         dc.SetClippingRegion( GetUpdateRegion() );
  210. #endif
  211. */
  212.  
  213.     if (m_printPreview)
  214.     {
  215.         m_printPreview->PaintPage(this, dc);
  216.     }
  217. }
  218.  
  219. // Responds to colour changes, and passes event on to children.
  220. void wxPreviewCanvas::OnSysColourChanged(wxSysColourChangedEvent& event)
  221. {
  222.     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
  223.     Refresh();
  224.  
  225.     // Propagate the event to the non-top-level children
  226.     wxWindow::OnSysColourChanged(event);
  227. }
  228.  
  229. /*
  230. * Preview control bar
  231. */
  232.  
  233. BEGIN_EVENT_TABLE(wxPreviewControlBar, wxPanel)
  234.     EVT_BUTTON(wxID_PREVIEW_CLOSE,    wxPreviewControlBar::OnWindowClose)
  235.     EVT_BUTTON(wxID_PREVIEW_PRINT,    wxPreviewControlBar::OnPrint)
  236.     EVT_BUTTON(wxID_PREVIEW_PREVIOUS, wxPreviewControlBar::OnPreviousButton)
  237.     EVT_BUTTON(wxID_PREVIEW_NEXT,     wxPreviewControlBar::OnNextButton)
  238.     EVT_BUTTON(wxID_PREVIEW_FIRST,    wxPreviewControlBar::OnFirstButton)
  239.     EVT_BUTTON(wxID_PREVIEW_LAST,     wxPreviewControlBar::OnLastButton)
  240.     EVT_BUTTON(wxID_PREVIEW_GOTO,     wxPreviewControlBar::OnGotoButton)
  241.     EVT_CHAR(wxPreviewControlBar::OnChar)
  242.     EVT_CHOICE(wxID_PREVIEW_ZOOM,     wxPreviewControlBar::OnZoom)
  243.     EVT_PAINT(wxPreviewControlBar::OnPaint)
  244. END_EVENT_TABLE()
  245.  
  246. wxPreviewControlBar::wxPreviewControlBar(wxPrintPreviewBase *preview, long buttons,
  247.                                          wxWindow *parent, const wxPoint& pos, const wxSize& size,
  248.                                          long style, const wxString& name):
  249. wxPanel(parent, -1, pos, size, style, name)
  250. {
  251.     m_printPreview = preview;
  252.     m_closeButton = (wxButton *) NULL;
  253.     m_nextPageButton = (wxButton *) NULL;
  254.     m_previousPageButton = (wxButton *) NULL;
  255.     m_printButton = (wxButton *) NULL;
  256.     m_zoomControl = (wxChoice *) NULL;
  257.     m_buttonFlags = buttons;
  258. }
  259.  
  260. wxPreviewControlBar::~wxPreviewControlBar()
  261. {
  262. }
  263.  
  264. void wxPreviewControlBar::OnPaint(wxPaintEvent& WXUNUSED(event))
  265. {
  266.     wxPaintDC dc(this);
  267.  
  268.     int w, h;
  269.     GetSize(&w, &h);
  270.     dc.SetPen(*wxBLACK_PEN);
  271.     dc.SetBrush(*wxTRANSPARENT_BRUSH);
  272.     dc.DrawLine( 0, h-1, w, h-1 );
  273. }
  274.  
  275. void wxPreviewControlBar::OnWindowClose(wxCommandEvent& WXUNUSED(event))
  276. {
  277.     wxPreviewFrame *frame = (wxPreviewFrame *)GetParent();
  278.     frame->Close(TRUE);
  279. }
  280.  
  281. void wxPreviewControlBar::OnPrint(wxCommandEvent& WXUNUSED(event))
  282. {
  283.     wxPrintPreviewBase *preview = GetPrintPreview();
  284.     preview->Print(TRUE);
  285. }
  286.  
  287. void wxPreviewControlBar::OnChar(wxKeyEvent &event)
  288. {
  289.    switch(event.KeyCode())
  290.    {
  291.    case WXK_NEXT:
  292.       OnNext(); break;
  293.    case WXK_PRIOR:
  294.       OnPrevious(); break;
  295.    case WXK_HOME:
  296.       OnFirst(); break;
  297.    case WXK_END:
  298.       OnLast(); break;
  299.    case WXK_TAB:
  300.       OnGoto(); break;
  301.    default:
  302.       event.Skip();
  303.    }
  304. }
  305.  
  306. void wxPreviewControlBar::OnNext(void)
  307. {
  308.     wxPrintPreviewBase *preview = GetPrintPreview();
  309.     if (preview)
  310.     {
  311.         int currentPage = preview->GetCurrentPage();
  312.         if ((preview->GetMaxPage() > 0) &&
  313.             (currentPage < preview->GetMaxPage()) &&
  314.             preview->GetPrintout()->HasPage(currentPage + 1))
  315.         {
  316.             preview->SetCurrentPage(currentPage + 1);
  317.         }
  318.     }
  319. }
  320.  
  321. void wxPreviewControlBar::OnPrevious(void)
  322. {
  323.     wxPrintPreviewBase *preview = GetPrintPreview();
  324.     if (preview)
  325.     {
  326.         int currentPage = preview->GetCurrentPage();
  327.         if ((preview->GetMinPage() > 0) &&
  328.             (currentPage > preview->GetMinPage()) &&
  329.             preview->GetPrintout()->HasPage(currentPage - 1))
  330.         {
  331.             preview->SetCurrentPage(currentPage - 1);
  332.         }
  333.     }
  334. }
  335.  
  336. void wxPreviewControlBar::OnFirst(void)
  337. {
  338.     wxPrintPreviewBase *preview = GetPrintPreview();
  339.     if (preview)
  340.     {
  341.         int currentPage = preview->GetMinPage();
  342.         if (preview->GetPrintout()->HasPage(currentPage))
  343.         {
  344.             preview->SetCurrentPage(currentPage);
  345.         }
  346.     }
  347. }
  348.  
  349. void wxPreviewControlBar::OnLast(void)
  350. {
  351.     wxPrintPreviewBase *preview = GetPrintPreview();
  352.     if (preview)
  353.     {
  354.         int currentPage = preview->GetMaxPage();
  355.         if (preview->GetPrintout()->HasPage(currentPage))
  356.         {
  357.             preview->SetCurrentPage(currentPage);
  358.         }
  359.     }
  360. }
  361.  
  362. void wxPreviewControlBar::OnGoto(void)
  363. {
  364.     wxPrintPreviewBase *preview = GetPrintPreview();
  365.     if (preview)
  366.     {
  367.         long currentPage;
  368.  
  369.         if (preview->GetMinPage() > 0)
  370.         {
  371.             wxString strPrompt;
  372.             wxString strPage;
  373.  
  374.             strPrompt.Printf( _("%d...%d"),
  375.                 preview->GetMinPage(), preview->GetMaxPage());
  376.             strPage.Printf( _("%d"), preview->GetCurrentPage() );
  377.  
  378.             strPage =
  379.                 wxGetTextFromUser( strPrompt, _("Goto Page"), strPage);
  380.  
  381.             if ( strPage.ToLong( ¤tPage ) )
  382.                 if (preview->GetPrintout()->HasPage(currentPage))
  383.                 {
  384.                     preview->SetCurrentPage(currentPage);
  385.                 }
  386.         }
  387.     }
  388. }
  389.  
  390. void wxPreviewControlBar::OnZoom(wxCommandEvent& WXUNUSED(event))
  391. {
  392.     int zoom = GetZoomControl();
  393.     if (GetPrintPreview())
  394.         GetPrintPreview()->SetZoom(zoom);
  395. }
  396.  
  397. void wxPreviewControlBar::CreateButtons()
  398. {
  399.     SetSize(0, 0, 400, 40);
  400.  
  401.     /*
  402.     #ifdef __WXMSW__
  403.     int fontSize = 9;
  404.     #else
  405.     int fontSize = 10;
  406.     #endif
  407.  
  408.       wxFont buttonFont(fontSize, wxSWISS, wxNORMAL, wxBOLD);
  409.       SetFont(buttonFont);
  410.     */
  411.  
  412.     int buttonWidth = 60;
  413.     int buttonNavigation = 30;
  414. #ifdef __WXGTK__
  415.     int buttonHeight = -1;
  416. #else
  417.     int buttonHeight = 24;
  418. #endif
  419.  
  420.     int x = 5;
  421.     int y = 5;
  422.  
  423. #ifdef __WXMOTIF__
  424.     int gap = 15;
  425. #else
  426.     int gap = 5;
  427. #endif
  428.  
  429.     m_closeButton = new wxButton(this, wxID_PREVIEW_CLOSE, _("Close"),
  430.         wxPoint(x, y), wxSize(buttonWidth, buttonHeight));
  431.  
  432.     x += gap + buttonWidth;
  433.  
  434.     if (m_buttonFlags & wxPREVIEW_PRINT)
  435.     {
  436.         m_printButton =  new wxButton(this, wxID_PREVIEW_PRINT, _("Print..."), wxPoint(x, y),
  437.             wxSize(buttonWidth, buttonHeight));
  438.         x += gap + buttonWidth;
  439.     }
  440.  
  441.     if (m_buttonFlags & wxPREVIEW_FIRST)
  442.     {
  443.         m_firstPageButton = new wxButton(this, wxID_PREVIEW_FIRST, wxT("|<<"), wxPoint(x, y),
  444.             wxSize(buttonNavigation, buttonHeight));
  445.         x += gap + buttonNavigation;
  446.     }
  447.  
  448.     if (m_buttonFlags & wxPREVIEW_PREVIOUS)
  449.     {
  450.         m_previousPageButton = new wxButton(this, wxID_PREVIEW_PREVIOUS, wxT("<<"), wxPoint(x, y),
  451.             wxSize(buttonNavigation, buttonHeight));
  452.         x += gap + buttonNavigation;
  453.     }
  454.  
  455.     if (m_buttonFlags & wxPREVIEW_NEXT)
  456.     {
  457.         m_nextPageButton = new wxButton(this, wxID_PREVIEW_NEXT, wxT(">>"),
  458.             wxPoint(x, y), wxSize(buttonNavigation, buttonHeight));
  459.         x += gap + buttonNavigation;
  460.     }
  461.  
  462.     if (m_buttonFlags & wxPREVIEW_LAST)
  463.     {
  464.         m_lastPageButton = new wxButton(this, wxID_PREVIEW_LAST, wxT(">>|"), wxPoint(x, y),
  465.             wxSize(buttonNavigation, buttonHeight));
  466.         x += gap + buttonNavigation;
  467.     }
  468.  
  469.     if (m_buttonFlags & wxPREVIEW_GOTO)
  470.     {
  471.         m_gotoPageButton = new wxButton(this, wxID_PREVIEW_GOTO, wxT("Goto..."), wxPoint(x, y),
  472.             wxSize(buttonWidth, buttonHeight));
  473.         x += gap + buttonWidth;
  474.     }
  475.  
  476.     if (m_buttonFlags & wxPREVIEW_ZOOM)
  477.     {
  478.         static const char *choices[] =
  479.         {
  480.             "10%", "15%", "20%", "25%", "30%", "35%", "40%", "45%", "50%", "55%",
  481.             "60%", "65%", "70%", "75%", "80%", "85%", "90%", "95%", "100%", "110%",
  482.             "120%", "150%", "200%"
  483.         };
  484.  
  485.         int n = WXSIZEOF(choices);
  486.  
  487.         wxString* strings = new wxString[n];
  488.         int i;
  489.         for (i = 0; i < n; i++ )
  490.            strings[i] = choices[i];
  491.  
  492.         m_zoomControl = new wxChoice(this, wxID_PREVIEW_ZOOM,
  493.                                      wxPoint(x, y),
  494.                                      wxSize(100, -1),
  495.                                      n,
  496.                                      strings
  497.                                     );
  498.         delete[] strings;
  499.  
  500.         SetZoomControl(m_printPreview->GetZoom());
  501.     }
  502.  
  503.     //  m_closeButton->SetDefault();
  504. }
  505.  
  506. void wxPreviewControlBar::SetZoomControl(int zoom)
  507. {
  508.     char buf[20];
  509.     sprintf(buf, "%d%%", zoom);
  510. // Someone is calling methods that do no exist in wxChoice!! So I'll just comment out for VA for now
  511.     if (m_zoomControl)
  512.         m_zoomControl->SetStringSelection(buf);
  513. }
  514.  
  515. int wxPreviewControlBar::GetZoomControl()
  516. {
  517.     wxChar buf[20];
  518.     if (m_zoomControl && (m_zoomControl->GetStringSelection() != wxT("")))
  519.     {
  520.         wxStrcpy(buf, m_zoomControl->GetStringSelection());
  521.         buf[wxStrlen(buf) - 1] = 0;
  522.         return (int)wxAtoi(buf);
  523.     }
  524.     else return 0;
  525. }
  526.  
  527.  
  528. /*
  529. * Preview frame
  530. */
  531.  
  532. BEGIN_EVENT_TABLE(wxPreviewFrame, wxFrame)
  533.     EVT_CLOSE(wxPreviewFrame::OnCloseWindow)
  534. END_EVENT_TABLE()
  535.  
  536. wxPreviewFrame::wxPreviewFrame(wxPrintPreviewBase *preview, wxFrame *parent, const wxString& title,
  537.                                const wxPoint& pos, const wxSize& size, long style, const wxString& name):
  538. wxFrame(parent, -1, title, pos, size, style, name)
  539. {
  540.     m_printPreview = preview;
  541.     m_controlBar = NULL;
  542.     m_previewCanvas = NULL;
  543. }
  544.  
  545. wxPreviewFrame::~wxPreviewFrame()
  546. {
  547. }
  548.  
  549. void wxPreviewFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
  550. {
  551.     MakeModal(FALSE);
  552.  
  553.     // Need to delete the printout and the print preview
  554.     wxPrintout *printout = m_printPreview->GetPrintout();
  555.     if (printout)
  556.     {
  557.         delete printout;
  558.         m_printPreview->SetPrintout(NULL);
  559.         m_printPreview->SetCanvas(NULL);
  560.         m_printPreview->SetFrame(NULL);
  561.     }
  562.     delete m_printPreview;
  563.  
  564.     Destroy();
  565. }
  566.  
  567. void wxPreviewFrame::Initialize()
  568. {
  569.     CreateStatusBar();
  570.  
  571.     CreateCanvas();
  572.     CreateControlBar();
  573.  
  574.     m_printPreview->SetCanvas(m_previewCanvas);
  575.     m_printPreview->SetFrame(this);
  576.  
  577.     // Set layout constraints here
  578.  
  579.     // Control bar constraints
  580.     wxLayoutConstraints *c1 = new wxLayoutConstraints;
  581.     //  int w, h;
  582.     //  m_controlBar->GetSize(&w, &h);
  583.     int h;
  584. #if (defined(__WXMSW__) || defined(__WXGTK__))
  585.     h = 40;
  586. #else
  587.     h = 60;
  588. #endif
  589.  
  590.     c1->left.SameAs       (this, wxLeft);
  591.     c1->top.SameAs        (this, wxTop);
  592.     c1->right.SameAs      (this, wxRight);
  593.     c1->height.Absolute   (h);
  594.  
  595.     m_controlBar->SetConstraints(c1);
  596.  
  597.     // Canvas constraints
  598.     wxLayoutConstraints *c2 = new wxLayoutConstraints;
  599.  
  600.     c2->left.SameAs       (this, wxLeft);
  601.     c2->top.Below         (m_controlBar);
  602.     c2->right.SameAs      (this, wxRight);
  603.     c2->bottom.SameAs     (this, wxBottom);
  604.  
  605.     m_previewCanvas->SetConstraints(c2);
  606.  
  607.     SetAutoLayout(TRUE);
  608.  
  609.     MakeModal(TRUE);
  610.  
  611.     Layout();
  612. }
  613.  
  614. void wxPreviewFrame::CreateCanvas()
  615. {
  616.     m_previewCanvas = new wxPreviewCanvas(m_printPreview, this);
  617. }
  618.  
  619. void wxPreviewFrame::CreateControlBar()
  620. {
  621.     long buttons = wxPREVIEW_DEFAULT;
  622.     if (m_printPreview->GetPrintoutForPrinting())
  623.         buttons |= wxPREVIEW_PRINT;
  624.  
  625.     m_controlBar = new wxPreviewControlBar(m_printPreview, buttons, this, wxPoint(0, 0), wxSize(400, 40));
  626.     m_controlBar->CreateButtons();
  627. }
  628.  
  629. /*
  630. * Print preview
  631. */
  632.  
  633. wxPrintPreviewBase::wxPrintPreviewBase(wxPrintout *printout,
  634.                                        wxPrintout *printoutForPrinting,
  635.                                        wxPrintData *data)
  636. {
  637.     if (data)
  638.         m_printDialogData = (*data);
  639.  
  640.     Init(printout, printoutForPrinting);
  641. }
  642.  
  643. wxPrintPreviewBase::wxPrintPreviewBase(wxPrintout *printout,
  644.                                        wxPrintout *printoutForPrinting,
  645.                                        wxPrintDialogData *data)
  646. {
  647.     if (data)
  648.         m_printDialogData = (*data);
  649.  
  650.     Init(printout, printoutForPrinting);
  651. }
  652.  
  653. void wxPrintPreviewBase::Init(wxPrintout *printout,
  654.                               wxPrintout *printoutForPrinting)
  655. {
  656.     m_isOk = TRUE;
  657.     m_previewPrintout = printout;
  658.     if (m_previewPrintout)
  659.         m_previewPrintout->SetIsPreview(TRUE);
  660.  
  661.     m_printPrintout = printoutForPrinting;
  662.  
  663.     m_previewCanvas = NULL;
  664.     m_previewFrame = NULL;
  665.     m_previewBitmap = NULL;
  666.     m_currentPage = 1;
  667.     m_currentZoom = 70;
  668.     m_topMargin = 40;
  669.     m_leftMargin = 40;
  670.     m_pageWidth = 0;
  671.     m_pageHeight = 0;
  672.     m_printingPrepared = FALSE;
  673.  
  674.     // Too soon! Moved to RenderPage.
  675.     // printout->OnPreparePrinting();
  676.  
  677.     // Get some parameters from the printout, if defined
  678.     int selFrom, selTo;
  679.     printout->GetPageInfo(&m_minPage, &m_maxPage, &selFrom, &selTo);
  680. }
  681.  
  682. wxPrintPreviewBase::~wxPrintPreviewBase()
  683. {
  684.     if (m_previewPrintout)
  685.         delete m_previewPrintout;
  686.     if (m_previewBitmap)
  687.         delete m_previewBitmap;
  688.     if (m_printPrintout)
  689.         delete m_printPrintout;
  690. }
  691.  
  692. bool wxPrintPreviewBase::SetCurrentPage(int pageNum)
  693. {
  694.     if (m_currentPage == pageNum)
  695.         return TRUE;
  696.  
  697.     m_currentPage = pageNum;
  698.     if (m_previewBitmap)
  699.     {
  700.         delete m_previewBitmap;
  701.         m_previewBitmap = NULL;
  702.     }
  703.  
  704.     if (m_previewCanvas)
  705.     {
  706.         if (!RenderPage(pageNum))
  707.             return FALSE;
  708.         m_previewCanvas->Refresh();
  709.     }
  710.     return TRUE;
  711. }
  712.  
  713. bool wxPrintPreviewBase::PaintPage(wxWindow *canvas, wxDC& dc)
  714. {
  715.     DrawBlankPage(canvas, dc);
  716.  
  717.     if (!m_previewBitmap)
  718.         if (!RenderPage(m_currentPage))
  719.             return FALSE;
  720.  
  721.     if (!m_previewBitmap)
  722.         return FALSE;
  723.  
  724.     if (!canvas)
  725.         return FALSE;
  726.  
  727.     int canvasWidth, canvasHeight;
  728.     canvas->GetSize(&canvasWidth, &canvasHeight);
  729.  
  730.     double zoomScale = ((float)m_currentZoom/(float)100);
  731.     double actualWidth = (zoomScale*m_pageWidth*m_previewScale);
  732.     //  float actualHeight = (float)(zoomScale*m_pageHeight*m_previewScale);
  733.  
  734.     int x = (int) ((canvasWidth - actualWidth)/2.0);
  735.     if (x < m_leftMargin)
  736.         x = m_leftMargin;
  737.     int y = m_topMargin;
  738.  
  739.     wxMemoryDC temp_dc;
  740.     temp_dc.SelectObject(*m_previewBitmap);
  741.  
  742.     dc.Blit(x, y, m_previewBitmap->GetWidth(), m_previewBitmap->GetHeight(), &temp_dc, 0, 0);
  743.  
  744.     temp_dc.SelectObject(wxNullBitmap);
  745.  
  746.     return TRUE;
  747. }
  748.  
  749. bool wxPrintPreviewBase::RenderPage(int pageNum)
  750. {
  751.     wxBusyCursor busy;
  752.  
  753.     int canvasWidth, canvasHeight;
  754.  
  755.     if (!m_previewCanvas)
  756.     {
  757.         wxFAIL_MSG(_T("wxPrintPreviewBase::RenderPage: must use wxPrintPreviewBase::SetCanvas to let me know about the canvas!"));
  758.  
  759.         return FALSE;
  760.     }
  761.     m_previewCanvas->GetSize(&canvasWidth, &canvasHeight);
  762.  
  763.     double zoomScale = (m_currentZoom/100.0);
  764.     int actualWidth = (int)(zoomScale*m_pageWidth*m_previewScale);
  765.     int actualHeight = (int)(zoomScale*m_pageHeight*m_previewScale);
  766.  
  767.     int x = (int)((canvasWidth - actualWidth)/2.0);
  768.     if (x < m_leftMargin)
  769.         x = m_leftMargin;
  770.     //  int y = m_topMargin;
  771.  
  772.  
  773.     if (!m_previewBitmap)
  774.     {
  775.         m_previewBitmap = new wxBitmap((int)actualWidth, (int)actualHeight);
  776.         if (!m_previewBitmap || !m_previewBitmap->Ok())
  777.         {
  778.             if (m_previewBitmap) {
  779.                 delete m_previewBitmap;
  780.                 m_previewBitmap = NULL;
  781.             }
  782.             wxMessageBox(_("Sorry, not enough memory to create a preview."), _("Print Preview Failure"), wxOK);
  783.             return FALSE;
  784.         }
  785.     }
  786.  
  787.     wxMemoryDC memoryDC;
  788.     memoryDC.SelectObject(*m_previewBitmap);
  789.  
  790.     memoryDC.Clear();
  791.  
  792.     m_previewPrintout->SetDC(&memoryDC);
  793.     m_previewPrintout->SetPageSizePixels(m_pageWidth, m_pageHeight);
  794.  
  795.     // Need to delay OnPreparePrinting until here, so we have enough information.
  796.     if (!m_printingPrepared)
  797.     {
  798.         m_previewPrintout->OnPreparePrinting();
  799.         m_printingPrepared = TRUE;
  800.     }
  801.  
  802.     m_previewPrintout->OnBeginPrinting();
  803.  
  804.     if (!m_previewPrintout->OnBeginDocument(m_printDialogData.GetFromPage(), m_printDialogData.GetToPage()))
  805.     {
  806.         wxMessageBox(_("Could not start document preview."), _("Print Preview Failure"), wxOK);
  807.  
  808.         memoryDC.SelectObject(wxNullBitmap);
  809.  
  810.         delete m_previewBitmap;
  811.         m_previewBitmap = NULL;
  812.         return FALSE;
  813.     }
  814.  
  815.     m_previewPrintout->OnPrintPage(pageNum);
  816.     m_previewPrintout->OnEndDocument();
  817.     m_previewPrintout->OnEndPrinting();
  818.  
  819.     m_previewPrintout->SetDC(NULL);
  820.  
  821.     memoryDC.SelectObject(wxNullBitmap);
  822.  
  823.     wxChar buf[200];
  824.     if (m_maxPage != 0)
  825.         wxSprintf(buf, _("Page %d of %d"), pageNum, m_maxPage);
  826.     else
  827.         wxSprintf(buf, _("Page %d"), pageNum);
  828.  
  829.     if (m_previewFrame)
  830.         m_previewFrame->SetStatusText(buf);
  831.  
  832.     return TRUE;
  833. }
  834.  
  835.  
  836. bool wxPrintPreviewBase::DrawBlankPage(wxWindow *canvas, wxDC& dc)
  837. {
  838.     int canvasWidth, canvasHeight;
  839.     canvas->GetSize(&canvasWidth, &canvasHeight);
  840.  
  841.     float zoomScale = (float)((float)m_currentZoom/(float)100);
  842.     float actualWidth = zoomScale*m_pageWidth*m_previewScale;
  843.     float actualHeight = zoomScale*m_pageHeight*m_previewScale;
  844.  
  845.     float x = (float)((canvasWidth - actualWidth)/2.0);
  846.     if (x < m_leftMargin)
  847.         x = (float)m_leftMargin;
  848.     float y = (float)m_topMargin;
  849.  
  850.     // Draw shadow, allowing for 1-pixel border AROUND the actual page
  851.     int shadowOffset = 4;
  852.     dc.SetPen(*wxBLACK_PEN);
  853.     dc.SetBrush(*wxBLACK_BRUSH);
  854.     /*
  855.     dc.DrawRectangle((int)(x-1 + shadowOffset), (int)(y-1 + shadowOffset), (int)(actualWidth+2), (int)(actualHeight+2));
  856.     */
  857.     dc.DrawRectangle((int)(x + shadowOffset), (int)(y + actualHeight+1), (int)(actualWidth), shadowOffset);
  858.     dc.DrawRectangle((int)(x + actualWidth), (int)(y + shadowOffset), shadowOffset, (int)(actualHeight));
  859.  
  860.     // Draw blank page allowing for 1-pixel border AROUND the actual page
  861.     dc.SetPen(*wxBLACK_PEN);
  862.     dc.SetBrush(*wxWHITE_BRUSH);
  863.  
  864.     /*
  865.     wxRegion update_region = canvas->GetUpdateRegion();
  866.     wxRect r = update_region.GetBox();
  867.  
  868.       printf( "x: %d y: %d w: %d h: %d.\n", (int)r.x, (int)r.y, (int)r.width, (int)r.height );
  869.     */
  870.  
  871.     dc.DrawRectangle((int)(x-2), (int)(y-1), (int)(actualWidth+3), (int)(actualHeight+2));
  872.  
  873.     return TRUE;
  874. }
  875.  
  876. void wxPrintPreviewBase::SetZoom(int percent)
  877. {
  878.     if (m_currentZoom == percent)
  879.         return;
  880.  
  881.     m_currentZoom = percent;
  882.     if (m_previewBitmap)
  883.     {
  884.         delete m_previewBitmap;
  885.         m_previewBitmap = NULL;
  886.     }
  887.  
  888.     if (m_previewCanvas)
  889.     {
  890.         RenderPage(m_currentPage);
  891.         ((wxScrolledWindow *) m_previewCanvas)->Scroll(0, 0);
  892.         m_previewCanvas->Clear();
  893.         m_previewCanvas->Refresh();
  894.     }
  895. }
  896.  
  897. #endif // wxUSE_PRINTING_ARCHITECTURE
  898.