X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/f415cab9ef1433413a1a68a982ee9b17c5a8deda..b404a8f3b072129c107c6d9a5e0f6f53cd34807b:/src/common/prntbase.cpp diff --git a/src/common/prntbase.cpp b/src/common/prntbase.cpp index 3b7a963959..4aebfb1b51 100644 --- a/src/common/prntbase.cpp +++ b/src/common/prntbase.cpp @@ -27,12 +27,15 @@ #include "wx/utils.h" #include "wx/dc.h" #include "wx/app.h" + #include "wx/math.h" #include "wx/msgdlg.h" #include "wx/layout.h" #include "wx/choice.h" #include "wx/button.h" + #include "wx/bmpbuttn.h" #include "wx/settings.h" #include "wx/dcmemory.h" + #include "wx/dcclient.h" #include "wx/stattext.h" #include "wx/intl.h" #include "wx/textdlg.h" @@ -44,15 +47,21 @@ #include "wx/printdlg.h" #include "wx/print.h" #include "wx/dcprint.h" +#include "wx/artprov.h" #include #include #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__) #include "wx/msw/printdlg.h" +#include "wx/msw/dcprint.h" #elif defined(__WXMAC__) -#include "wx/mac/printdlg.h" -#include "wx/mac/private/print.h" +#include "wx/osx/printdlg.h" +#include "wx/osx/private/print.h" +#include "wx/osx/dcprint.h" +#elif defined(__WXPM__) +#include "wx/os2/dcprint.h" +#include "wx/generic/prntdlgg.h" #else #include "wx/generic/prntdlgg.h" #include "wx/dcps.h" @@ -203,14 +212,12 @@ wxDialog *wxNativePrintFactory::CreatePrintSetupDialog( wxWindow *parent, #endif } -wxDC* wxNativePrintFactory::CreatePrinterDC( const wxPrintData& data ) +wxDCImpl* wxNativePrintFactory::CreatePrinterDCImpl( wxPrinterDC *owner, const wxPrintData& data ) { -#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__) - return new wxPrinterDC(data); -#elif defined(__WXMAC__) - return new wxPrinterDC(data); +#if defined(__WXGTK__) || defined(__WXMOTIF__) || ( defined(__WXUNIVERSAL__) && !defined(__WXMAC__) ) + return new wxPostScriptDCImpl( owner, data ); #else - return new wxPostScriptDC(data); + return new wxPrinterDCImpl( owner, data ); #endif } @@ -256,7 +263,7 @@ wxPrintNativeDataBase *wxNativePrintFactory::CreatePrintNativeData() #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__) return new wxWindowsPrintNativeData; #elif defined(__WXMAC__) - return new wxMacCarbonPrintData; + return wxOSXCreatePrintData(); #else return new wxPostScriptPrintNativeData; #endif @@ -298,15 +305,15 @@ IMPLEMENT_CLASS(wxPrinterBase, wxObject) wxPrinterBase::wxPrinterBase(wxPrintDialogData *data) { - m_currentPrintout = (wxPrintout *) NULL; - sm_abortWindow = (wxWindow *) NULL; + m_currentPrintout = NULL; + sm_abortWindow = NULL; sm_abortIt = false; if (data) m_printDialogData = (*data); sm_lastError = wxPRINTER_NO_ERROR; } -wxWindow *wxPrinterBase::sm_abortWindow = (wxWindow *) NULL; +wxWindow *wxPrinterBase::sm_abortWindow = NULL; bool wxPrinterBase::sm_abortIt = false; wxPrinterError wxPrinterBase::sm_lastError = wxPRINTER_NO_ERROR; @@ -374,6 +381,19 @@ bool wxPrinter::Setup(wxWindow *parent) bool wxPrinter::Print(wxWindow *parent, wxPrintout *printout, bool prompt) { + if ( !prompt && m_printDialogData.GetToPage() == 0 ) + { + // If the dialog is not shown, set the pages range to print everything + // by default (as otherwise we wouldn't print anything at all which is + // certainly not a reasonable default behaviour). + int minPage, maxPage, selFrom, selTo; + printout->GetPageInfo(&minPage, &maxPage, &selFrom, &selTo); + + wxPrintDialogData& pdd = m_pimpl->GetPrintDialogData(); + pdd.SetFromPage(minPage); + pdd.SetToPage(maxPage); + } + return m_pimpl->Print( parent, printout, prompt ); } @@ -507,7 +527,8 @@ void wxPrintAbortDialog::OnCancel(wxCommandEvent& WXUNUSED(event)) wxPrinterBase::sm_abortIt = true; wxPrinterBase::sm_abortWindow->Show(false); wxPrinterBase::sm_abortWindow->Close(true); - wxPrinterBase::sm_abortWindow = (wxWindow *) NULL; + wxPrinterBase::sm_abortWindow->Destroy(); + wxPrinterBase::sm_abortWindow = NULL; } //---------------------------------------------------------------------------- @@ -519,7 +540,7 @@ IMPLEMENT_ABSTRACT_CLASS(wxPrintout, wxObject) wxPrintout::wxPrintout(const wxString& title) { m_printoutTitle = title ; - m_printoutDC = (wxDC *) NULL; + m_printoutDC = NULL; m_pageWidthMM = 0; m_pageHeightMM = 0; m_pageWidthPixels = 0; @@ -528,7 +549,7 @@ wxPrintout::wxPrintout(const wxString& title) m_PPIScreenY = 0; m_PPIPrinterX = 0; m_PPIPrinterY = 0; - m_isPreview = false; + m_preview = NULL; } wxPrintout::~wxPrintout() @@ -581,7 +602,7 @@ void wxPrintout::FitThisSizeToPaper(const wxSize& imageSize) float scaleX = ((float(paperRect.width) * w) / (float(pw) * imageSize.x)); float scaleY = ((float(paperRect.height) * h) / (float(ph) * imageSize.y)); float actualScale = wxMin(scaleX, scaleY); - m_printoutDC->SetUserScale(actualScale, actualScale); + m_printoutDC->SetUserScale(actualScale, actualScale); m_printoutDC->SetDeviceOrigin(0, 0); wxRect logicalPaperRect = GetLogicalPaperRect(); SetLogicalOrigin(logicalPaperRect.x, logicalPaperRect.y); @@ -598,7 +619,7 @@ void wxPrintout::FitThisSizeToPage(const wxSize& imageSize) float scaleX = float(w) / imageSize.x; float scaleY = float(h) / imageSize.y; float actualScale = wxMin(scaleX, scaleY); - m_printoutDC->SetUserScale(actualScale, actualScale); + m_printoutDC->SetUserScale(actualScale, actualScale); m_printoutDC->SetDeviceOrigin(0, 0); } @@ -617,16 +638,16 @@ void wxPrintout::FitThisSizeToPageMargins(const wxSize& imageSize, const wxPageS GetPageSizeMM(&mw, &mh); float mmToDeviceX = float(pw) / mw; float mmToDeviceY = float(ph) / mh; - wxRect pageMarginsRect(paperRect.x + wxCoord(mmToDeviceX * topLeft.x), - paperRect.y + wxCoord(mmToDeviceY * topLeft.y), - paperRect.width - wxCoord(mmToDeviceX * (topLeft.x + bottomRight.x)), - paperRect.height - wxCoord(mmToDeviceY * (topLeft.y + bottomRight.y))); + wxRect pageMarginsRect(paperRect.x + wxRound(mmToDeviceX * topLeft.x), + paperRect.y + wxRound(mmToDeviceY * topLeft.y), + paperRect.width - wxRound(mmToDeviceX * (topLeft.x + bottomRight.x)), + paperRect.height - wxRound(mmToDeviceY * (topLeft.y + bottomRight.y))); wxCoord w, h; m_printoutDC->GetSize(&w, &h); float scaleX = (float(pageMarginsRect.width) * w) / (float(pw) * imageSize.x); float scaleY = (float(pageMarginsRect.height) * h) / (float(ph) * imageSize.y); float actualScale = wxMin(scaleX, scaleY); - m_printoutDC->SetUserScale(actualScale, actualScale); + m_printoutDC->SetUserScale(actualScale, actualScale); m_printoutDC->SetDeviceOrigin(0, 0); wxRect logicalPageMarginsRect = GetLogicalPageMarginsRect(pageSetupData); SetLogicalOrigin(logicalPageMarginsRect.x, logicalPageMarginsRect.y); @@ -649,16 +670,16 @@ void wxPrintout::MapScreenSizeToPage() // Set the DC scale and origin so that an image on the screen is the same // size on the paper and the origin is at the top left of the printable area. if (!m_printoutDC) return; - int ppiScreenX, ppiScreenY; - GetPPIScreen(&ppiScreenX, &ppiScreenY); - int ppiPrinterX, ppiPrinterY; - GetPPIPrinter(&ppiPrinterX, &ppiPrinterY); - int w, h; - m_printoutDC->GetSize(&w, &h); - int pageSizePixelsX, pageSizePixelsY; - GetPageSizePixels(&pageSizePixelsX, &pageSizePixelsY); - float userScaleX = (float(ppiPrinterX) * w) / (float(ppiScreenX) * pageSizePixelsX); - float userScaleY = (float(ppiPrinterY) * h) / (float(ppiScreenY) * pageSizePixelsY); + int ppiScreenX, ppiScreenY; + GetPPIScreen(&ppiScreenX, &ppiScreenY); + int ppiPrinterX, ppiPrinterY; + GetPPIPrinter(&ppiPrinterX, &ppiPrinterY); + int w, h; + m_printoutDC->GetSize(&w, &h); + int pageSizePixelsX, pageSizePixelsY; + GetPageSizePixels(&pageSizePixelsX, &pageSizePixelsY); + float userScaleX = (float(ppiPrinterX) * w) / (float(ppiScreenX) * pageSizePixelsX); + float userScaleY = (float(ppiPrinterY) * h) / (float(ppiScreenY) * pageSizePixelsY); m_printoutDC->SetUserScale(userScaleX, userScaleY); m_printoutDC->SetDeviceOrigin(0, 0); } @@ -679,12 +700,12 @@ void wxPrintout::MapScreenSizeToDevice() // Set the DC scale so that a screen pixel is the same size as a device // pixel and the origin is at the top left of the printable area. if (!m_printoutDC) return; - int w, h; - m_printoutDC->GetSize(&w, &h); - int pageSizePixelsX, pageSizePixelsY; - GetPageSizePixels(&pageSizePixelsX, &pageSizePixelsY); - float userScaleX = float(w) / pageSizePixelsX; - float userScaleY = float(h) / pageSizePixelsY; + int w, h; + m_printoutDC->GetSize(&w, &h); + int pageSizePixelsX, pageSizePixelsY; + GetPageSizePixels(&pageSizePixelsX, &pageSizePixelsY); + float userScaleX = float(w) / pageSizePixelsX; + float userScaleY = float(h) / pageSizePixelsY; m_printoutDC->SetUserScale(userScaleX, userScaleY); m_printoutDC->SetDeviceOrigin(0, 0); } @@ -700,18 +721,18 @@ wxRect wxPrintout::GetLogicalPaperRect() const m_printoutDC->GetSize(&w, &h); if (w == pw && h == ph) { // this DC matches the printed page, so no scaling - return wxRect(m_printoutDC->DeviceToLogicalX(paperRect.x), - m_printoutDC->DeviceToLogicalY(paperRect.y), - m_printoutDC->DeviceToLogicalXRel(paperRect.width), + return wxRect(m_printoutDC->DeviceToLogicalX(paperRect.x), + m_printoutDC->DeviceToLogicalY(paperRect.y), + m_printoutDC->DeviceToLogicalXRel(paperRect.width), m_printoutDC->DeviceToLogicalYRel(paperRect.height)); } // This DC doesn't match the printed page, so we have to scale. float scaleX = float(w) / pw; float scaleY = float(h) / ph; - return wxRect(m_printoutDC->DeviceToLogicalX(wxCoord(paperRect.x * scaleX)), - m_printoutDC->DeviceToLogicalY(wxCoord(paperRect.y * scaleY)), - m_printoutDC->DeviceToLogicalXRel(wxCoord(paperRect.width * scaleX)), - m_printoutDC->DeviceToLogicalYRel(wxCoord(paperRect.height * scaleY))); + return wxRect(m_printoutDC->DeviceToLogicalX(wxRound(paperRect.x * scaleX)), + m_printoutDC->DeviceToLogicalY(wxRound(paperRect.y * scaleY)), + m_printoutDC->DeviceToLogicalXRel(wxRound(paperRect.width * scaleX)), + m_printoutDC->DeviceToLogicalYRel(wxRound(paperRect.height * scaleY))); } wxRect wxPrintout::GetLogicalPageRect() const @@ -720,9 +741,9 @@ wxRect wxPrintout::GetLogicalPageRect() const // area. int w, h; m_printoutDC->GetSize(&w, &h); - return wxRect(m_printoutDC->DeviceToLogicalX(0), - m_printoutDC->DeviceToLogicalY(0), - m_printoutDC->DeviceToLogicalXRel(w), + return wxRect(m_printoutDC->DeviceToLogicalX(0), + m_printoutDC->DeviceToLogicalY(0), + m_printoutDC->DeviceToLogicalXRel(w), m_printoutDC->DeviceToLogicalYRel(h)); } @@ -731,53 +752,68 @@ wxRect wxPrintout::GetLogicalPageMarginsRect(const wxPageSetupDialogData& pageSe // Return the rectangle in logical units that corresponds to the region // within the page margins as specified by the given wxPageSetupDialogData // object. - wxRect paperRect = GetPaperRectPixels(); + + // We get the paper size in device units and the margins in mm, + // so we need to calculate the conversion with this trick wxCoord pw, ph; GetPageSizePixels(&pw, &ph); - wxPoint topLeft = pageSetupData.GetMarginTopLeft(); - wxPoint bottomRight = pageSetupData.GetMarginBottomRight(); wxCoord mw, mh; GetPageSizeMM(&mw, &mh); float mmToDeviceX = float(pw) / mw; float mmToDeviceY = float(ph) / mh; - wxRect pageMarginsRect(paperRect.x + wxCoord(mmToDeviceX * topLeft.x), - paperRect.y + wxCoord(mmToDeviceY * topLeft.y), - paperRect.width - wxCoord(mmToDeviceX * (topLeft.x + bottomRight.x)), - paperRect.height - wxCoord(mmToDeviceY * (topLeft.y + bottomRight.y))); + + // paper size in device units + wxRect paperRect = GetPaperRectPixels(); + + // margins in mm + wxPoint topLeft = pageSetupData.GetMarginTopLeft(); + wxPoint bottomRight = pageSetupData.GetMarginBottomRight(); + + // calculate margins in device units + wxRect pageMarginsRect( + paperRect.x + wxRound(mmToDeviceX * topLeft.x), + paperRect.y + wxRound(mmToDeviceY * topLeft.y), + paperRect.width - wxRound(mmToDeviceX * (topLeft.x + bottomRight.x)), + paperRect.height - wxRound(mmToDeviceY * (topLeft.y + bottomRight.y))); + wxCoord w, h; m_printoutDC->GetSize(&w, &h); - if (w == pw && h == ph) { + if (w == pw && h == ph) + { // this DC matches the printed page, so no scaling - return wxRect(m_printoutDC->DeviceToLogicalX(pageMarginsRect.x), - m_printoutDC->DeviceToLogicalY(pageMarginsRect.y), - m_printoutDC->DeviceToLogicalXRel(pageMarginsRect.width), + return wxRect( + m_printoutDC->DeviceToLogicalX(pageMarginsRect.x), + m_printoutDC->DeviceToLogicalY(pageMarginsRect.y), + m_printoutDC->DeviceToLogicalXRel(pageMarginsRect.width), m_printoutDC->DeviceToLogicalYRel(pageMarginsRect.height)); } + // This DC doesn't match the printed page, so we have to scale. float scaleX = float(w) / pw; float scaleY = float(h) / ph; - return wxRect(m_printoutDC->DeviceToLogicalX(wxCoord(pageMarginsRect.x * scaleX)), - m_printoutDC->DeviceToLogicalY(wxCoord(pageMarginsRect.y * scaleY)), - m_printoutDC->DeviceToLogicalXRel(wxCoord(pageMarginsRect.width * scaleX)), - m_printoutDC->DeviceToLogicalYRel(wxCoord(pageMarginsRect.height * scaleY))); + return wxRect(m_printoutDC->DeviceToLogicalX(wxRound(pageMarginsRect.x * scaleX)), + m_printoutDC->DeviceToLogicalY(wxRound(pageMarginsRect.y * scaleY)), + m_printoutDC->DeviceToLogicalXRel(wxRound(pageMarginsRect.width * scaleX)), + m_printoutDC->DeviceToLogicalYRel(wxRound(pageMarginsRect.height * scaleY))); } void wxPrintout::SetLogicalOrigin(wxCoord x, wxCoord y) { // Set the device origin by specifying a point in logical coordinates. - m_printoutDC->SetDeviceOrigin(m_printoutDC->LogicalToDeviceX(x), - m_printoutDC->LogicalToDeviceY(y)); + m_printoutDC->SetDeviceOrigin( + m_printoutDC->LogicalToDeviceX(x), + m_printoutDC->LogicalToDeviceY(y) ); } - + void wxPrintout::OffsetLogicalOrigin(wxCoord xoff, wxCoord yoff) { // Offset the device origin by a specified distance in device coordinates. - wxCoord x = m_printoutDC->LogicalToDeviceX(0); - wxCoord y = m_printoutDC->LogicalToDeviceY(0); - m_printoutDC->SetDeviceOrigin(x + m_printoutDC->LogicalToDeviceXRel(xoff), - y + m_printoutDC->LogicalToDeviceYRel(yoff)); + wxPoint dev_org = m_printoutDC->GetDeviceOrigin(); + m_printoutDC->SetDeviceOrigin( + dev_org.x + m_printoutDC->LogicalToDeviceXRel(xoff), + dev_org.y + m_printoutDC->LogicalToDeviceYRel(yoff) ); } - + //---------------------------------------------------------------------------- // wxPreviewCanvas @@ -788,6 +824,7 @@ IMPLEMENT_CLASS(wxPreviewCanvas, wxWindow) BEGIN_EVENT_TABLE(wxPreviewCanvas, wxScrolledWindow) EVT_PAINT(wxPreviewCanvas::OnPaint) EVT_CHAR(wxPreviewCanvas::OnChar) + EVT_IDLE(wxPreviewCanvas::OnIdle) EVT_SYS_COLOUR_CHANGED(wxPreviewCanvas::OnSysColourChanged) #if wxUSE_MOUSEWHEEL EVT_MOUSEWHEEL(wxPreviewCanvas::OnMouseWheel) @@ -807,6 +844,8 @@ wxScrolledWindow(parent, wxID_ANY, pos, size, style | wxFULL_REPAINT_ON_RESIZE, // The app workspace colour is always white, but we should have // a contrast with the page. wxSystemColour colourIndex = wxSYS_COLOUR_3DDKSHADOW; +#elif defined(__WXGTK__) + wxSystemColour colourIndex = wxSYS_COLOUR_BTNFACE; #else wxSystemColour colourIndex = wxSYS_COLOUR_APPWORKSPACE; #endif @@ -837,6 +876,25 @@ void wxPreviewCanvas::OnPaint(wxPaintEvent& WXUNUSED(event)) } } +void wxPreviewCanvas::OnIdle(wxIdleEvent& event) +{ + event.Skip(); + + // prevent UpdatePageRendering() from being called recursively: + static bool s_inIdle = false; + if ( s_inIdle ) + return; + s_inIdle = true; + + if ( m_printPreview ) + { + if ( m_printPreview->UpdatePageRendering() ) + Refresh(); + } + + s_inIdle = false; +} + // Responds to colour changes, and passes event on to children. void wxPreviewCanvas::OnSysColourChanged(wxSysColourChangedEvent& event) { @@ -844,6 +902,8 @@ void wxPreviewCanvas::OnSysColourChanged(wxSysColourChangedEvent& event) // The app workspace colour is always white, but we should have // a contrast with the page. wxSystemColour colourIndex = wxSYS_COLOUR_3DDKSHADOW; +#elif defined(__WXGTK__) + wxSystemColour colourIndex = wxSYS_COLOUR_BTNFACE; #else wxSystemColour colourIndex = wxSYS_COLOUR_APPWORKSPACE; #endif @@ -857,20 +917,21 @@ void wxPreviewCanvas::OnSysColourChanged(wxSysColourChangedEvent& event) void wxPreviewCanvas::OnChar(wxKeyEvent &event) { wxPreviewControlBar* controlBar = ((wxPreviewFrame*) GetParent())->GetControlBar(); - if (event.GetKeyCode() == WXK_ESCAPE) - { - ((wxPreviewFrame*) GetParent())->Close(true); - return; - } - else if (event.GetKeyCode() == WXK_TAB) + switch (event.GetKeyCode()) { - controlBar->OnGoto(); - return; - } - else if (event.GetKeyCode() == WXK_RETURN) - { - controlBar->OnPrint(); - return; + case WXK_RETURN: + controlBar->OnPrint(); + return; + case (int)'+': + case WXK_NUMPAD_ADD: + case WXK_ADD: + controlBar->DoZoomIn(); + return; + case (int)'-': + case WXK_NUMPAD_SUBTRACT: + case WXK_SUBTRACT: + controlBar->DoZoomOut(); + return; } if (!event.ControlDown()) @@ -938,6 +999,188 @@ void wxPreviewCanvas::OnMouseWheel(wxMouseEvent& event) #endif // wxUSE_MOUSEWHEEL +namespace +{ + +// This is by the controls in the print preview as the maximal (and hence +// longest) page number we may have to display. +enum { MAX_PAGE_NUMBER = 99999 }; + +} // anonymous namespace + +// ---------------------------------------------------------------------------- +// wxPrintPageMaxCtrl +// ---------------------------------------------------------------------------- + +// A simple static control showing the maximal number of pages. +class wxPrintPageMaxCtrl : public wxStaticText +{ +public: + wxPrintPageMaxCtrl(wxWindow *parent) + : wxStaticText( + parent, + wxID_ANY, + wxString(), + wxDefaultPosition, + wxSize + ( + parent->GetTextExtent(MaxAsString(MAX_PAGE_NUMBER)).x, + wxDefaultCoord + ), + wxST_NO_AUTORESIZE | wxALIGN_CENTRE + ) + { + } + + // Set the maximal page to display once we really know what it is. + void SetMaxPage(int maxPage) + { + SetLabel(MaxAsString(maxPage)); + } + +private: + static wxString MaxAsString(int maxPage) + { + return wxString::Format("/ %d", maxPage); + } + + wxDECLARE_NO_COPY_CLASS(wxPrintPageMaxCtrl); +}; + +// ---------------------------------------------------------------------------- +// wxPrintPageTextCtrl +// ---------------------------------------------------------------------------- + +// This text control contains the page number in the specified interval. +// +// Invalid pages are not accepted and the control contents is validated when it +// loses focus. Conversely, if the user changes the page to another valid one +// or presses Enter, OnGotoPage() method of the preview object will be called. +class wxPrintPageTextCtrl : public wxTextCtrl +{ +public: + wxPrintPageTextCtrl(wxPreviewControlBar *preview) + : wxTextCtrl(preview, + wxID_PREVIEW_GOTO, + wxString(), + wxDefaultPosition, + // We use hardcoded maximal page number for the width + // instead of fitting it to the values we can show because + // the control looks uncomfortably narrow if the real page + // number is just one or two digits. + wxSize + ( + preview->GetTextExtent(PageAsString(MAX_PAGE_NUMBER)).x, + wxDefaultCoord + ), + wxTE_PROCESS_ENTER +#if wxUSE_VALIDATORS + , wxTextValidator(wxFILTER_DIGITS) +#endif // wxUSE_VALIDATORS + ), + m_preview(preview) + { + m_minPage = + m_maxPage = + m_page = 1; + + Connect(wxEVT_KILL_FOCUS, + wxFocusEventHandler(wxPrintPageTextCtrl::OnKillFocus)); + Connect(wxEVT_COMMAND_TEXT_ENTER, + wxCommandEventHandler(wxPrintPageTextCtrl::OnTextEnter)); + } + + // Update the pages range, must be called after OnPreparePrinting() as + // these values are not known before. + void SetPageInfo(int minPage, int maxPage) + { + m_minPage = minPage; + m_maxPage = maxPage; + + // Show the first page by default. + SetPageNumber(minPage); + } + + // Helpers to conveniently set or get the current page number. Return value + // is 0 if the current controls contents is invalid. + void SetPageNumber(int page) + { + wxASSERT( IsValidPage(page) ); + + SetValue(PageAsString(page)); + } + + int GetPageNumber() const + { + long value; + if ( !GetValue().ToLong(&value) || !IsValidPage(value) ) + return 0; + + // Cast is safe because the value is less than (int) m_maxPage. + return static_cast(value); + } + +private: + static wxString PageAsString(int page) + { + return wxString::Format("%d", page); + } + + bool IsValidPage(int page) const + { + return page >= m_minPage && page <= m_maxPage; + } + + bool DoChangePage() + { + const int page = GetPageNumber(); + + if ( !page ) + return false; + + if ( page != m_page ) + { + // We have a valid page, remember it. + m_page = page; + + // And notify the owner about the change. + m_preview->OnGotoPage(); + } + //else: Nothing really changed. + + return true; + } + + void OnKillFocus(wxFocusEvent& event) + { + if ( !DoChangePage() ) + { + // The current contents is invalid so reset it back to the last + // known good page index. + SetPageNumber(m_page); + } + + event.Skip(); + } + + void OnTextEnter(wxCommandEvent& WXUNUSED(event)) + { + DoChangePage(); + } + + + wxPreviewControlBar * const m_preview; + + int m_minPage, + m_maxPage; + + // This is the last valid page value that we had, we revert to it if an + // invalid page is entered. + int m_page; + + wxDECLARE_NO_COPY_CLASS(wxPrintPageTextCtrl); +}; + //---------------------------------------------------------------------------- // wxPreviewControlBar //---------------------------------------------------------------------------- @@ -951,9 +1194,19 @@ BEGIN_EVENT_TABLE(wxPreviewControlBar, wxPanel) EVT_BUTTON(wxID_PREVIEW_NEXT, wxPreviewControlBar::OnNextButton) EVT_BUTTON(wxID_PREVIEW_FIRST, wxPreviewControlBar::OnFirstButton) EVT_BUTTON(wxID_PREVIEW_LAST, wxPreviewControlBar::OnLastButton) - EVT_BUTTON(wxID_PREVIEW_GOTO, wxPreviewControlBar::OnGotoButton) - EVT_CHOICE(wxID_PREVIEW_ZOOM, wxPreviewControlBar::OnZoom) + EVT_BUTTON(wxID_PREVIEW_ZOOM_IN, wxPreviewControlBar::OnZoomInButton) + EVT_BUTTON(wxID_PREVIEW_ZOOM_OUT, wxPreviewControlBar::OnZoomOutButton) + + EVT_UPDATE_UI(wxID_PREVIEW_PREVIOUS, wxPreviewControlBar::OnUpdatePreviousButton) + EVT_UPDATE_UI(wxID_PREVIEW_NEXT, wxPreviewControlBar::OnUpdateNextButton) + EVT_UPDATE_UI(wxID_PREVIEW_FIRST, wxPreviewControlBar::OnUpdateFirstButton) + EVT_UPDATE_UI(wxID_PREVIEW_LAST, wxPreviewControlBar::OnUpdateLastButton) + EVT_UPDATE_UI(wxID_PREVIEW_ZOOM_IN, wxPreviewControlBar::OnUpdateZoomInButton) + EVT_UPDATE_UI(wxID_PREVIEW_ZOOM_OUT, wxPreviewControlBar::OnUpdateZoomOutButton) + + EVT_CHOICE(wxID_PREVIEW_ZOOM, wxPreviewControlBar::OnZoomChoice) EVT_PAINT(wxPreviewControlBar::OnPaint) + END_EVENT_TABLE() wxPreviewControlBar::wxPreviewControlBar(wxPrintPreviewBase *preview, long buttons, @@ -962,11 +1215,10 @@ wxPreviewControlBar::wxPreviewControlBar(wxPrintPreviewBase *preview, long butto wxPanel(parent, wxID_ANY, pos, size, style, name) { m_printPreview = preview; - m_closeButton = (wxButton *) NULL; - m_nextPageButton = (wxButton *) NULL; - m_previousPageButton = (wxButton *) NULL; - m_printButton = (wxButton *) NULL; - m_zoomControl = (wxChoice *) NULL; + m_closeButton = NULL; + m_zoomControl = NULL; + m_currentPageText = NULL; + m_maxPageText = NULL; m_buttonFlags = buttons; } @@ -997,155 +1249,281 @@ void wxPreviewControlBar::OnPrint(void) preview->Print(true); } -void wxPreviewControlBar::OnNext(void) +void wxPreviewControlBar::OnNext() +{ + if ( IsNextEnabled() ) + DoGotoPage(GetPrintPreview()->GetCurrentPage() + 1); +} + +void wxPreviewControlBar::OnPrevious() +{ + if ( IsPreviousEnabled() ) + DoGotoPage(GetPrintPreview()->GetCurrentPage() - 1); +} + +void wxPreviewControlBar::OnFirst() +{ + if ( IsFirstEnabled() ) + DoGotoPage(GetPrintPreview()->GetMinPage()); +} + +void wxPreviewControlBar::OnLast() +{ + if ( IsLastEnabled() ) + DoGotoPage(GetPrintPreview()->GetMaxPage()); +} + +bool wxPreviewControlBar::IsNextEnabled() const { wxPrintPreviewBase *preview = GetPrintPreview(); - if (preview) - { - int currentPage = preview->GetCurrentPage(); - if ((preview->GetMaxPage() > 0) && - (currentPage < preview->GetMaxPage()) && - preview->GetPrintout()->HasPage(currentPage + 1)) - { - preview->SetCurrentPage(currentPage + 1); - } - } + if ( !preview ) + return false; + + const int currentPage = preview->GetCurrentPage(); + return currentPage < preview->GetMaxPage() && + preview->GetPrintout()->HasPage(currentPage + 1); } -void wxPreviewControlBar::OnPrevious(void) +bool wxPreviewControlBar::IsPreviousEnabled() const { wxPrintPreviewBase *preview = GetPrintPreview(); - if (preview) - { - int currentPage = preview->GetCurrentPage(); - if ((preview->GetMinPage() > 0) && - (currentPage > preview->GetMinPage()) && - preview->GetPrintout()->HasPage(currentPage - 1)) - { - preview->SetCurrentPage(currentPage - 1); - } - } + if ( !preview ) + return false; + + const int currentPage = preview->GetCurrentPage(); + return currentPage > preview->GetMinPage() && + preview->GetPrintout()->HasPage(currentPage - 1); } -void wxPreviewControlBar::OnFirst(void) +bool wxPreviewControlBar::IsFirstEnabled() const { wxPrintPreviewBase *preview = GetPrintPreview(); - if (preview) - { - int currentPage = preview->GetMinPage(); - if (preview->GetPrintout()->HasPage(currentPage)) - { - preview->SetCurrentPage(currentPage); - } - } + if (!preview) + return false; + + return preview->GetPrintout()->HasPage(preview->GetMinPage()); } -void wxPreviewControlBar::OnLast(void) +bool wxPreviewControlBar::IsLastEnabled() const { wxPrintPreviewBase *preview = GetPrintPreview(); - if (preview) - { - int currentPage = preview->GetMaxPage(); - if (preview->GetPrintout()->HasPage(currentPage)) - { - preview->SetCurrentPage(currentPage); - } - } + if (!preview) + return false; + + return preview->GetPrintout()->HasPage(preview->GetMaxPage()); } -void wxPreviewControlBar::OnGoto(void) +void wxPreviewControlBar::DoGotoPage(int page) +{ + wxPrintPreviewBase *preview = GetPrintPreview(); + wxCHECK_RET( preview, "Shouldn't be called if there is no preview." ); + + preview->SetCurrentPage(page); + + if ( m_currentPageText ) + m_currentPageText->SetPageNumber(page); +} + +void wxPreviewControlBar::OnGotoPage() { wxPrintPreviewBase *preview = GetPrintPreview(); if (preview) { - long currentPage; - if (preview->GetMinPage() > 0) { - wxString strPrompt; - wxString strPage; - - strPrompt.Printf( _("Enter a page number between %d and %d:"), - preview->GetMinPage(), preview->GetMaxPage()); - strPage.Printf( wxT("%d"), preview->GetCurrentPage() ); - - strPage = - wxGetTextFromUser( strPrompt, _("Goto Page"), strPage, GetParent()); - - if ( strPage.ToLong( ¤tPage ) ) + long currentPage = m_currentPageText->GetPageNumber(); + if ( currentPage ) + { if (preview->GetPrintout()->HasPage(currentPage)) { preview->SetCurrentPage(currentPage); } + } } } } -void wxPreviewControlBar::OnZoom(wxCommandEvent& WXUNUSED(event)) +void wxPreviewControlBar::DoZoom() { int zoom = GetZoomControl(); if (GetPrintPreview()) GetPrintPreview()->SetZoom(zoom); } -void wxPreviewControlBar::CreateButtons() +bool wxPreviewControlBar::IsZoomInEnabled() const { - SetSize(0, 0, 400, 40); + if ( !m_zoomControl ) + return false; - wxBoxSizer *item0 = new wxBoxSizer( wxHORIZONTAL ); + const unsigned sel = m_zoomControl->GetSelection(); + return sel < m_zoomControl->GetCount() - 1; +} - m_closeButton = new wxButton( this, wxID_PREVIEW_CLOSE, _("&Close"), wxDefaultPosition, wxDefaultSize, 0 ); - item0->Add( m_closeButton, 0, wxALIGN_CENTRE|wxALL, 5 ); +bool wxPreviewControlBar::IsZoomOutEnabled() const +{ + return m_zoomControl && m_zoomControl->GetSelection() > 0; +} - if (m_buttonFlags & wxPREVIEW_PRINT) +void wxPreviewControlBar::DoZoomIn() +{ + if (IsZoomInEnabled()) { - m_printButton = new wxButton( this, wxID_PREVIEW_PRINT, _("&Print..."), wxDefaultPosition, wxDefaultSize, 0 ); - item0->Add( m_printButton, 0, wxALIGN_CENTRE|wxALL, 5 ); + m_zoomControl->SetSelection(m_zoomControl->GetSelection() + 1); + DoZoom(); } +} - // Exact-fit buttons are too tiny on wxUniversal - int navButtonStyle; - wxSize navButtonSize; -#ifdef __WXUNIVERSAL__ - navButtonStyle = 0; - navButtonSize = wxSize(40, m_closeButton->GetSize().y); -#else - navButtonStyle = wxBU_EXACTFIT; - navButtonSize = wxDefaultSize; -#endif +void wxPreviewControlBar::DoZoomOut() +{ + if (IsZoomOutEnabled()) + { + m_zoomControl->SetSelection(m_zoomControl->GetSelection() - 1); + DoZoom(); + } +} + +namespace +{ + +// Helper class used by wxPreviewControlBar::CreateButtons() to add buttons +// sequentially to it in the simplest way possible. +class SizerWithButtons +{ +public: + // Constructor creates the sizer that will hold the buttons and stores the + // parent that will be used for their creation. + SizerWithButtons(wxWindow *parent) + : m_sizer(new wxBoxSizer(wxHORIZONTAL)), + m_parent(parent) + { + m_hasContents = + m_needsSeparator = false; + } + + // Destructor associates the sizer with the parent window. + ~SizerWithButtons() + { + m_parent->SetSizer(m_sizer); + m_sizer->Fit(m_parent); + } + + + // Add an arbitrary window to the sizer. + void Add(wxWindow *win) + { + if ( m_needsSeparator ) + { + m_needsSeparator = false; + + m_sizer->AddSpacer(2*wxSizerFlags::GetDefaultBorder()); + } + + m_hasContents = true; + + m_sizer->Add(win, + wxSizerFlags().Border(wxLEFT | wxTOP | wxBOTTOM).Center()); + } + + // Add a button with the specified id, bitmap and tooltip. + void AddButton(wxWindowID btnId, + const wxArtID& artId, + const wxString& tooltip) + { + // We don't use (smaller) images inside a button with a text label but + // rather toolbar-like bitmap buttons hence use wxART_TOOLBAR and not + // wxART_BUTTON here. + wxBitmap bmp = wxArtProvider::GetBitmap(artId, wxART_TOOLBAR); + wxBitmapButton * const btn = new wxBitmapButton(m_parent, btnId, bmp); + btn->SetToolTip(tooltip); + + Add(btn); + } + + // Add a control at the right end of the window. This should be called last + // as everything else added after it will be added on the right side too. + void AddAtEnd(wxWindow *win) + { + m_sizer->AddStretchSpacer(); + m_sizer->Add(win, + wxSizerFlags().Border(wxTOP | wxBOTTOM | wxRIGHT).Center()); + } + + // Indicates the end of a group of buttons, a separator will be added after + // it. + void EndOfGroup() + { + if ( m_hasContents ) + { + m_needsSeparator = true; + m_hasContents = false; + } + } + +private: + wxSizer * const m_sizer; + wxWindow * const m_parent; + + // If true, we have some controls since the last group beginning. This is + // used to avoid inserting two consecutive separators if EndOfGroup() is + // called twice. + bool m_hasContents; + + // If true, a separator should be inserted before adding the next button. + bool m_needsSeparator; + + wxDECLARE_NO_COPY_CLASS(SizerWithButtons); +}; + +} // anonymous namespace + +void wxPreviewControlBar::CreateButtons() +{ + SizerWithButtons sizer(this); + + // Print button group (a single button). + if (m_buttonFlags & wxPREVIEW_PRINT) + { + sizer.AddButton(wxID_PREVIEW_PRINT, wxART_PRINT, _("Print")); + sizer.EndOfGroup(); + } + // Page selection buttons group. if (m_buttonFlags & wxPREVIEW_FIRST) { - m_firstPageButton = new wxButton( this, wxID_PREVIEW_FIRST, _("|<<"), wxDefaultPosition, navButtonSize, navButtonStyle ); - item0->Add( m_firstPageButton, 0, wxALIGN_CENTRE|wxALL, 5 ); + sizer.AddButton(wxID_PREVIEW_FIRST, wxART_GOTO_FIRST, _("First page")); } if (m_buttonFlags & wxPREVIEW_PREVIOUS) { - m_previousPageButton = new wxButton( this, wxID_PREVIEW_PREVIOUS, _("<<"), wxDefaultPosition, navButtonSize, navButtonStyle ); - item0->Add( m_previousPageButton, 0, wxALIGN_CENTRE|wxRIGHT|wxTOP|wxBOTTOM, 5 ); + sizer.AddButton(wxID_PREVIEW_PREVIOUS, wxART_GO_BACK, _("Previous page")); } - if (m_buttonFlags & wxPREVIEW_NEXT) + if (m_buttonFlags & wxPREVIEW_GOTO) { - m_nextPageButton = new wxButton( this, wxID_PREVIEW_NEXT, _(">>"), wxDefaultPosition, navButtonSize, navButtonStyle ); - item0->Add( m_nextPageButton, 0, wxALIGN_CENTRE|wxRIGHT|wxTOP|wxBOTTOM, 5 ); + m_currentPageText = new wxPrintPageTextCtrl(this); + sizer.Add(m_currentPageText); + + m_maxPageText = new wxPrintPageMaxCtrl(this); + sizer.Add(m_maxPageText); } - if (m_buttonFlags & wxPREVIEW_LAST) + if (m_buttonFlags & wxPREVIEW_NEXT) { - m_lastPageButton = new wxButton( this, wxID_PREVIEW_LAST, _(">>|"), wxDefaultPosition, navButtonSize, navButtonStyle ); - item0->Add( m_lastPageButton, 0, wxALIGN_CENTRE|wxRIGHT|wxTOP|wxBOTTOM, 5 ); + sizer.AddButton(wxID_PREVIEW_NEXT, wxART_GO_FORWARD, _("Next page")); } - if (m_buttonFlags & wxPREVIEW_GOTO) + if (m_buttonFlags & wxPREVIEW_LAST) { - m_gotoPageButton = new wxButton( this, wxID_PREVIEW_GOTO, _("&Goto..."), wxDefaultPosition, wxDefaultSize, 0 ); - item0->Add( m_gotoPageButton, 0, wxALIGN_CENTRE|wxALL, 5 ); + sizer.AddButton(wxID_PREVIEW_LAST, wxART_GOTO_LAST, _("Last page")); } + sizer.EndOfGroup(); + + // Zoom controls group. if (m_buttonFlags & wxPREVIEW_ZOOM) { + sizer.AddButton(wxID_PREVIEW_ZOOM_OUT, wxART_MINUS, _("Zoom Out")); + wxString choices[] = { wxT("10%"), wxT("15%"), wxT("20%"), wxT("25%"), wxT("30%"), wxT("35%"), wxT("40%"), wxT("45%"), wxT("50%"), wxT("55%"), @@ -1155,12 +1533,26 @@ void wxPreviewControlBar::CreateButtons() int n = WXSIZEOF(choices); m_zoomControl = new wxChoice( this, wxID_PREVIEW_ZOOM, wxDefaultPosition, wxSize(70,wxDefaultCoord), n, choices, 0 ); - item0->Add( m_zoomControl, 0, wxALIGN_CENTRE|wxALL, 5 ); + sizer.Add(m_zoomControl); SetZoomControl(m_printPreview->GetZoom()); + + sizer.AddButton(wxID_PREVIEW_ZOOM_IN, wxART_PLUS, _("Zoom In")); + + sizer.EndOfGroup(); } - SetSizer(item0); - item0->Fit(this); + // Close button group (single button again). + m_closeButton = new wxButton(this, wxID_PREVIEW_CLOSE, _("&Close")); + sizer.AddAtEnd(m_closeButton); +} + +void wxPreviewControlBar::SetPageInfo(int minPage, int maxPage) +{ + if ( m_currentPageText ) + m_currentPageText->SetPageInfo(minPage, maxPage); + + if ( m_maxPageText ) + m_maxPageText->SetMaxPage(maxPage); } void wxPreviewControlBar::SetZoomControl(int zoom) @@ -1203,9 +1595,22 @@ int wxPreviewControlBar::GetZoomControl() IMPLEMENT_CLASS(wxPreviewFrame, wxFrame) BEGIN_EVENT_TABLE(wxPreviewFrame, wxFrame) + EVT_CHAR_HOOK(wxPreviewFrame::OnChar) EVT_CLOSE(wxPreviewFrame::OnCloseWindow) END_EVENT_TABLE() +void wxPreviewFrame::OnChar(wxKeyEvent &event) +{ + if ( event.GetKeyCode() == WXK_ESCAPE ) + { + Close(true); + } + else + { + event.Skip(); + } +} + wxPreviewFrame::wxPreviewFrame(wxPrintPreviewBase *preview, wxWindow *parent, const wxString& title, const wxPoint& pos, const wxSize& size, long style, const wxString& name): wxFrame(parent, wxID_ANY, title, pos, size, style, name) @@ -1214,25 +1619,18 @@ wxFrame(parent, wxID_ANY, title, pos, size, style, name) m_controlBar = NULL; m_previewCanvas = NULL; m_windowDisabler = NULL; + m_modalityKind = wxPreviewFrame_NonModal; // Give the application icon #ifdef __WXMSW__ wxFrame* topFrame = wxDynamicCast(wxTheApp->GetTopWindow(), wxFrame); if (topFrame) - SetIcon(topFrame->GetIcon()); + SetIcons(topFrame->GetIcons()); #endif } wxPreviewFrame::~wxPreviewFrame() { -} - -void wxPreviewFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event)) -{ - if (m_windowDisabler) - delete m_windowDisabler; - - // Need to delete the printout and the print preview wxPrintout *printout = m_printPreview->GetPrintout(); if (printout) { @@ -1241,12 +1639,35 @@ void wxPreviewFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event)) m_printPreview->SetCanvas(NULL); m_printPreview->SetFrame(NULL); } + + m_previewCanvas->SetPreview(NULL); delete m_printPreview; +} + +void wxPreviewFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event)) +{ + // Reenable any windows we disabled by undoing whatever we did in our + // Initialize(). + switch ( m_modalityKind ) + { + case wxPreviewFrame_AppModal: + delete m_windowDisabler; + m_windowDisabler = NULL; + break; + + case wxPreviewFrame_WindowModal: + if ( GetParent() ) + GetParent()->Enable(); + break; + + case wxPreviewFrame_NonModal: + break; + } Destroy(); } -void wxPreviewFrame::Initialize() +void wxPreviewFrame::InitializeWithModality(wxPreviewFrameModalityKind kind) { #if wxUSE_STATUSBAR CreateStatusBar(); @@ -1265,7 +1686,25 @@ void wxPreviewFrame::Initialize() SetAutoLayout( true ); SetSizer( item0 ); - m_windowDisabler = new wxWindowDisabler(this); + m_modalityKind = kind; + switch ( m_modalityKind ) + { + case wxPreviewFrame_AppModal: + // Disable everything. + m_windowDisabler = new wxWindowDisabler( this ); + break; + + case wxPreviewFrame_WindowModal: + // Disable our parent if we have one. + if ( GetParent() ) + GetParent()->Disable(); + break; + + case wxPreviewFrame_NonModal: + // Nothing to do, we don't need to disable any windows. + break; + } + Layout(); @@ -1285,7 +1724,7 @@ void wxPreviewFrame::CreateControlBar() if (m_printPreview->GetPrintoutForPrinting()) buttons |= wxPREVIEW_PRINT; - m_controlBar = new wxPreviewControlBar(m_printPreview, buttons, this, wxPoint(0,0), wxSize(400, 40)); + m_controlBar = new wxPreviewControlBar(m_printPreview, buttons, this); m_controlBar->CreateButtons(); } @@ -1321,17 +1760,18 @@ void wxPrintPreviewBase::Init(wxPrintout *printout, m_isOk = true; m_previewPrintout = printout; if (m_previewPrintout) - m_previewPrintout->SetIsPreview(true); + m_previewPrintout->SetPreview(static_cast(this)); m_printPrintout = printoutForPrinting; m_previewCanvas = NULL; m_previewFrame = NULL; m_previewBitmap = NULL; + m_previewFailed = false; m_currentPage = 1; m_currentZoom = 70; - m_topMargin = 40; - m_leftMargin = 40; + m_topMargin = + m_leftMargin = 2*wxSizerFlags::GetDefaultBorder(); m_pageWidth = 0; m_pageHeight = 0; m_printingPrepared = false; @@ -1355,18 +1795,13 @@ bool wxPrintPreviewBase::SetCurrentPage(int pageNum) return true; m_currentPage = pageNum; - if (m_previewBitmap) - { - delete m_previewBitmap; - m_previewBitmap = NULL; - } + + InvalidatePreviewBitmap(); if (m_previewCanvas) { AdjustScrollbars(m_previewCanvas); - if (!RenderPage(pageNum)) - return false; m_previewCanvas->Refresh(); m_previewCanvas->SetFocus(); } @@ -1423,13 +1858,35 @@ void wxPrintPreviewBase::CalcRects(wxPreviewCanvas *canvas, wxRect& pageRect, wx } +void wxPrintPreviewBase::InvalidatePreviewBitmap() +{ + wxDELETE(m_previewBitmap); + // if there was a problem with rendering the preview, try again now + // that it changed in some way (less memory may be needed, for example): + m_previewFailed = false; +} + +bool wxPrintPreviewBase::UpdatePageRendering() +{ + if ( m_previewBitmap ) + return false; + + if ( m_previewFailed ) + return false; + + if ( !RenderPage(m_currentPage) ) + { + m_previewFailed = true; // don't waste time failing again + return false; + } + + return true; +} + bool wxPrintPreviewBase::PaintPage(wxPreviewCanvas *canvas, wxDC& dc) { DrawBlankPage(canvas, dc); - if (!m_previewBitmap) - if (!RenderPage(m_currentPage)) - return false; if (!m_previewBitmap) return false; if (!canvas) @@ -1440,7 +1897,7 @@ bool wxPrintPreviewBase::PaintPage(wxPreviewCanvas *canvas, wxDC& dc) wxMemoryDC temp_dc; temp_dc.SelectObject(*m_previewBitmap); - dc.Blit(pageRect.x, pageRect.y, + dc.Blit(pageRect.x, pageRect.y, m_previewBitmap->GetWidth(), m_previewBitmap->GetHeight(), &temp_dc, 0, 0); temp_dc.SelectObject(wxNullBitmap); @@ -1464,13 +1921,64 @@ void wxPrintPreviewBase::AdjustScrollbars(wxPreviewCanvas *canvas) canvas->SetScrollbars(10, 10, scrollUnitsX, scrollUnitsY, 0, 0, true); } +bool wxPrintPreviewBase::RenderPageIntoDC(wxDC& dc, int pageNum) +{ + m_previewPrintout->SetDC(&dc); + m_previewPrintout->SetPageSizePixels(m_pageWidth, m_pageHeight); + + // Need to delay OnPreparePrinting() until here, so we have enough + // information and a wxDC. + if (!m_printingPrepared) + { + m_printingPrepared = true; + + m_previewPrintout->OnPreparePrinting(); + int selFrom, selTo; + m_previewPrintout->GetPageInfo(&m_minPage, &m_maxPage, &selFrom, &selTo); + + // Update the wxPreviewControlBar page range display. + if ( m_previewFrame ) + { + wxPreviewControlBar * const + controlBar = ((wxPreviewFrame*)m_previewFrame)->GetControlBar(); + if ( controlBar ) + controlBar->SetPageInfo(m_minPage, m_maxPage); + } + } + + m_previewPrintout->OnBeginPrinting(); + + if (!m_previewPrintout->OnBeginDocument(m_printDialogData.GetFromPage(), m_printDialogData.GetToPage())) + { + wxMessageBox(_("Could not start document preview."), _("Print Preview Failure"), wxOK); + return false; + } + + m_previewPrintout->OnPrintPage(pageNum); + m_previewPrintout->OnEndDocument(); + m_previewPrintout->OnEndPrinting(); + + m_previewPrintout->SetDC(NULL); + + return true; +} + +bool wxPrintPreviewBase::RenderPageIntoBitmap(wxBitmap& bmp, int pageNum) +{ + wxMemoryDC memoryDC; + memoryDC.SelectObject(bmp); + memoryDC.Clear(); + + return RenderPageIntoDC(memoryDC, pageNum); +} + bool wxPrintPreviewBase::RenderPage(int pageNum) { wxBusyCursor busy; if (!m_previewCanvas) { - wxFAIL_MSG(_T("wxPrintPreviewBase::RenderPage: must use wxPrintPreviewBase::SetCanvas to let me know about the canvas!")); + wxFAIL_MSG(wxT("wxPrintPreviewBase::RenderPage: must use wxPrintPreviewBase::SetCanvas to let me know about the canvas!")); return false; } @@ -1481,55 +1989,21 @@ bool wxPrintPreviewBase::RenderPage(int pageNum) { m_previewBitmap = new wxBitmap(pageRect.width, pageRect.height); - if (!m_previewBitmap || !m_previewBitmap->Ok()) + if (!m_previewBitmap || !m_previewBitmap->IsOk()) { - if (m_previewBitmap) { - delete m_previewBitmap; - m_previewBitmap = NULL; - } + InvalidatePreviewBitmap(); wxMessageBox(_("Sorry, not enough memory to create a preview."), _("Print Preview Failure"), wxOK); return false; } } - wxMemoryDC memoryDC; - memoryDC.SelectObject(*m_previewBitmap); - - memoryDC.Clear(); - - m_previewPrintout->SetDC(&memoryDC); - m_previewPrintout->SetPageSizePixels(m_pageWidth, m_pageHeight); - - // Need to delay OnPreparePrinting until here, so we have enough information. - if (!m_printingPrepared) - { - m_previewPrintout->OnPreparePrinting(); - int selFrom, selTo; - m_previewPrintout->GetPageInfo(&m_minPage, &m_maxPage, &selFrom, &selTo); - m_printingPrepared = true; - } - - m_previewPrintout->OnBeginPrinting(); - - if (!m_previewPrintout->OnBeginDocument(m_printDialogData.GetFromPage(), m_printDialogData.GetToPage())) + if ( !RenderPageIntoBitmap(*m_previewBitmap, pageNum) ) { - wxMessageBox(_("Could not start document preview."), _("Print Preview Failure"), wxOK); - - memoryDC.SelectObject(wxNullBitmap); - - delete m_previewBitmap; - m_previewBitmap = NULL; + InvalidatePreviewBitmap(); + wxMessageBox(_("Sorry, not enough memory to create a preview."), _("Print Preview Failure"), wxOK); return false; } - m_previewPrintout->OnPrintPage(pageNum); - m_previewPrintout->OnEndDocument(); - m_previewPrintout->OnEndPrinting(); - - m_previewPrintout->SetDC(NULL); - - memoryDC.SelectObject(wxNullBitmap); - #if wxUSE_STATUSBAR wxString status; if (m_maxPage != 0) @@ -1564,7 +2038,7 @@ bool wxPrintPreviewBase::DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc) // Draw blank page allowing for 1-pixel border AROUND the actual paper dc.SetPen(*wxBLACK_PEN); dc.SetBrush(*wxWHITE_BRUSH); - dc.DrawRectangle(paperRect.x - 2, paperRect.y - 1, + dc.DrawRectangle(paperRect.x - 2, paperRect.y - 1, paperRect.width + 3, paperRect.height + 2); return true; @@ -1576,16 +2050,12 @@ void wxPrintPreviewBase::SetZoom(int percent) return; m_currentZoom = percent; - if (m_previewBitmap) - { - delete m_previewBitmap; - m_previewBitmap = NULL; - } + + InvalidatePreviewBitmap(); if (m_previewCanvas) { AdjustScrollbars(m_previewCanvas); - RenderPage(m_currentPage); ((wxScrolledWindow *) m_previewCanvas)->Scroll(0, 0); m_previewCanvas->ClearBackground(); m_previewCanvas->Refresh(); @@ -1693,6 +2163,11 @@ bool wxPrintPreview::PaintPage(wxPreviewCanvas *canvas, wxDC& dc) return m_pimpl->PaintPage( canvas, dc ); } +bool wxPrintPreview::UpdatePageRendering() +{ + return m_pimpl->UpdatePageRendering(); +} + bool wxPrintPreview::DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc) { return m_pimpl->DrawBlankPage( canvas, dc ); @@ -1735,7 +2210,7 @@ int wxPrintPreview::GetMinPage() const bool wxPrintPreview::IsOk() const { - return m_pimpl->Ok(); + return m_pimpl->IsOk(); } void wxPrintPreview::SetOk(bool ok)