]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/prntbase.cpp
Use correct extensions in wxDynamicLibrary::CanonicalizeName() on OS X.
[wxWidgets.git] / src / common / prntbase.cpp
index 05d4d729a1b6d171ff9f736648dbae7cedf0cfd2..fee5f8d239e1e9a6932efc6ea0edd7c8b03d09bb 100644 (file)
@@ -32,6 +32,7 @@
     #include "wx/layout.h"
     #include "wx/choice.h"
     #include "wx/button.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/settings.h"
     #include "wx/dcmemory.h"
     #include "wx/dcclient.h"
@@ -46,6 +47,7 @@
 #include "wx/printdlg.h"
 #include "wx/print.h"
 #include "wx/dcprint.h"
 #include "wx/printdlg.h"
 #include "wx/print.h"
 #include "wx/dcprint.h"
+#include "wx/artprov.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <stdlib.h>
 #include <string.h>
@@ -319,21 +321,9 @@ wxPrinterBase::~wxPrinterBase()
 {
 }
 
 {
 }
 
-wxWindow *wxPrinterBase::CreateAbortWindow(wxWindow *parent, wxPrintout * printout)
+wxPrintAbortDialog *wxPrinterBase::CreateAbortWindow(wxWindow *parent, wxPrintout * printout)
 {
 {
-    wxPrintAbortDialog *dialog = new wxPrintAbortDialog(parent, _("Printing ") , wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE);
-
-    wxBoxSizer *button_sizer = new wxBoxSizer( wxVERTICAL );
-    button_sizer->Add( new wxStaticText(dialog, wxID_ANY, _("Please wait while printing\n") + printout->GetTitle() ), 0, wxALL, 10 );
-    button_sizer->Add( new wxButton( dialog, wxID_CANCEL, wxT("Cancel") ), 0, wxALL | wxALIGN_CENTER, 10 );
-
-    dialog->SetAutoLayout( true );
-    dialog->SetSizer( button_sizer );
-
-    button_sizer->Fit(dialog);
-    button_sizer->SetSizeHints (dialog) ;
-
-    return dialog;
+    return new wxPrintAbortDialog(parent, printout->GetTitle());
 }
 
 void wxPrinterBase::ReportError(wxWindow *parent, wxPrintout *WXUNUSED(printout), const wxString& message)
 }
 
 void wxPrinterBase::ReportError(wxWindow *parent, wxPrintout *WXUNUSED(printout), const wxString& message)
@@ -362,7 +352,7 @@ wxPrinter::~wxPrinter()
     delete m_pimpl;
 }
 
     delete m_pimpl;
 }
 
-wxWindow *wxPrinter::CreateAbortWindow(wxWindow *parent, wxPrintout *printout)
+wxPrintAbortDialog *wxPrinter::CreateAbortWindow(wxWindow *parent, wxPrintout *printout)
 {
     return m_pimpl->CreateAbortWindow( parent, printout );
 }
 {
     return m_pimpl->CreateAbortWindow( parent, printout );
 }
@@ -379,6 +369,19 @@ bool wxPrinter::Setup(wxWindow *parent)
 
 bool wxPrinter::Print(wxWindow *parent, wxPrintout *printout, bool prompt)
 {
 
 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 );
 }
 
     return m_pimpl->Print( parent, printout, prompt );
 }
 
@@ -507,11 +510,49 @@ BEGIN_EVENT_TABLE(wxPrintAbortDialog, wxDialog)
     EVT_BUTTON(wxID_CANCEL, wxPrintAbortDialog::OnCancel)
 END_EVENT_TABLE()
 
     EVT_BUTTON(wxID_CANCEL, wxPrintAbortDialog::OnCancel)
 END_EVENT_TABLE()
 
+wxPrintAbortDialog::wxPrintAbortDialog(wxWindow *parent,
+                                       const wxString& documentTitle,
+                                       const wxPoint& pos,
+                                       const wxSize& size,
+                                       long style,
+                                       const wxString& name)
+    : wxDialog(parent, wxID_ANY, _("Printing"), pos, size, style, name)
+{
+    wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
+    mainSizer->Add(new wxStaticText(this, wxID_ANY, _("Please wait while printing...")),
+                   wxSizerFlags().Expand().DoubleBorder());
+
+    wxFlexGridSizer *gridSizer = new wxFlexGridSizer(2, wxSize(20, 0));
+    gridSizer->Add(new wxStaticText(this, wxID_ANY, _("Document:")));
+    gridSizer->AddGrowableCol(1);
+    gridSizer->Add(new wxStaticText(this, wxID_ANY, documentTitle));
+    gridSizer->Add(new wxStaticText(this, wxID_ANY, _("Progress:")));
+    m_progress = new wxStaticText(this, wxID_ANY, _("Preparing"));
+    m_progress->SetMinSize(wxSize(250, -1));
+    gridSizer->Add(m_progress);
+    mainSizer->Add(gridSizer, wxSizerFlags().Expand().DoubleBorder(wxLEFT | wxRIGHT));
+
+    mainSizer->Add(CreateStdDialogButtonSizer(wxCANCEL),
+                   wxSizerFlags().Expand().DoubleBorder());
+
+    SetSizerAndFit(mainSizer);
+}
+
+void wxPrintAbortDialog::SetProgress(int currentPage, int totalPages,
+                                     int currentCopy, int totalCopies)
+{
+  wxString text;
+  text.Printf(_("Printing page %d of %d"), currentPage, totalPages);
+  if ( totalCopies > 1 )
+      text += wxString::Format(_(" (copy %d of %d)"), currentCopy, totalCopies);
+  m_progress->SetLabel(text);
+}
+
 void wxPrintAbortDialog::OnCancel(wxCommandEvent& WXUNUSED(event))
 {
 void wxPrintAbortDialog::OnCancel(wxCommandEvent& WXUNUSED(event))
 {
+    wxCHECK_RET( wxPrinterBase::sm_abortWindow != NULL, "OnCancel called twice" );
+
     wxPrinterBase::sm_abortIt = true;
     wxPrinterBase::sm_abortIt = true;
-    wxPrinterBase::sm_abortWindow->Show(false);
-    wxPrinterBase::sm_abortWindow->Close(true);
     wxPrinterBase::sm_abortWindow->Destroy();
     wxPrinterBase::sm_abortWindow = NULL;
 }
     wxPrinterBase::sm_abortWindow->Destroy();
     wxPrinterBase::sm_abortWindow = NULL;
 }
@@ -534,7 +575,7 @@ wxPrintout::wxPrintout(const wxString& title)
     m_PPIScreenY = 0;
     m_PPIPrinterX = 0;
     m_PPIPrinterY = 0;
     m_PPIScreenY = 0;
     m_PPIPrinterX = 0;
     m_PPIPrinterY = 0;
-    m_isPreview = false;
+    m_preview = NULL;
 }
 
 wxPrintout::~wxPrintout()
 }
 
 wxPrintout::~wxPrintout()
@@ -904,12 +945,19 @@ void wxPreviewCanvas::OnChar(wxKeyEvent &event)
     wxPreviewControlBar* controlBar = ((wxPreviewFrame*) GetParent())->GetControlBar();
     switch (event.GetKeyCode())
     {
     wxPreviewControlBar* controlBar = ((wxPreviewFrame*) GetParent())->GetControlBar();
     switch (event.GetKeyCode())
     {
-        case WXK_TAB:
-            controlBar->OnGoto();
-            return;
         case 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())
     }
 
     if (!event.ControlDown())
@@ -977,6 +1025,188 @@ void wxPreviewCanvas::OnMouseWheel(wxMouseEvent& event)
 
 #endif // wxUSE_MOUSEWHEEL
 
 
 #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_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<int>(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
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 // wxPreviewControlBar
 //----------------------------------------------------------------------------
@@ -990,9 +1220,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_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)
     EVT_PAINT(wxPreviewControlBar::OnPaint)
+
 END_EVENT_TABLE()
 
 wxPreviewControlBar::wxPreviewControlBar(wxPrintPreviewBase *preview, long buttons,
 END_EVENT_TABLE()
 
 wxPreviewControlBar::wxPreviewControlBar(wxPrintPreviewBase *preview, long buttons,
@@ -1002,10 +1242,9 @@ wxPanel(parent, wxID_ANY, pos, size, style, name)
 {
     m_printPreview = preview;
     m_closeButton = NULL;
 {
     m_printPreview = preview;
     m_closeButton = NULL;
-    m_nextPageButton = NULL;
-    m_previousPageButton = NULL;
-    m_printButton = NULL;
     m_zoomControl = NULL;
     m_zoomControl = NULL;
+    m_currentPageText = NULL;
+    m_maxPageText = NULL;
     m_buttonFlags = buttons;
 }
 
     m_buttonFlags = buttons;
 }
 
@@ -1036,155 +1275,281 @@ void wxPreviewControlBar::OnPrint(void)
     preview->Print(true);
 }
 
     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();
 {
     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();
 {
     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();
 {
     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();
 {
     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::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::OnGoto(void)
+void wxPreviewControlBar::OnGotoPage()
 {
     wxPrintPreviewBase *preview = GetPrintPreview();
     if (preview)
     {
 {
     wxPrintPreviewBase *preview = GetPrintPreview();
     if (preview)
     {
-        long currentPage;
-
         if (preview->GetMinPage() > 0)
         {
         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( &currentPage ) )
+            long currentPage = m_currentPageText->GetPageNumber();
+            if ( currentPage )
+            {
                 if (preview->GetPrintout()->HasPage(currentPage))
                 {
                     preview->SetCurrentPage(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);
 }
 
 {
     int zoom = GetZoomControl();
     if (GetPrintPreview())
         GetPrintPreview()->SetZoom(zoom);
 }
 
-void wxPreviewControlBar::CreateButtons()
+bool wxPreviewControlBar::IsZoomInEnabled() const
+{
+    if ( !m_zoomControl )
+        return false;
+
+    const unsigned sel = m_zoomControl->GetSelection();
+    return sel < m_zoomControl->GetCount() - 1;
+}
+
+bool wxPreviewControlBar::IsZoomOutEnabled() const
 {
 {
-    SetSize(0, 0, 400, 40);
+    return m_zoomControl && m_zoomControl->GetSelection() > 0;
+}
 
 
-    wxBoxSizer *item0 = new wxBoxSizer( wxHORIZONTAL );
+void wxPreviewControlBar::DoZoomIn()
+{
+    if (IsZoomInEnabled())
+    {
+        m_zoomControl->SetSelection(m_zoomControl->GetSelection() + 1);
+        DoZoom();
+    }
+}
 
 
-    m_closeButton = new wxButton( this, wxID_PREVIEW_CLOSE, _("&Close"), wxDefaultPosition, wxDefaultSize, 0 );
-    item0->Add( m_closeButton, 0, wxALIGN_CENTRE|wxALL, 5 );
+void wxPreviewControlBar::DoZoomOut()
+{
+    if (IsZoomOutEnabled())
+    {
+        m_zoomControl->SetSelection(m_zoomControl->GetSelection() - 1);
+        DoZoom();
+    }
+}
 
 
-    if (m_buttonFlags & wxPREVIEW_PRINT)
+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_printButton = new wxButton( this, wxID_PREVIEW_PRINT, _("&Print..."), wxDefaultPosition, wxDefaultSize, 0 );
-        item0->Add( m_printButton, 0, wxALIGN_CENTRE|wxALL, 5 );
+        m_hasContents =
+        m_needsSeparator = false;
     }
 
     }
 
-    // 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
+    // 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)
     {
     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)
     {
     }
 
     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)
     {
     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%"),
         wxString choices[] =
         {
             wxT("10%"), wxT("15%"), wxT("20%"), wxT("25%"), wxT("30%"), wxT("35%"), wxT("40%"), wxT("45%"), wxT("50%"), wxT("55%"),
@@ -1194,12 +1559,26 @@ void wxPreviewControlBar::CreateButtons()
         int n = WXSIZEOF(choices);
 
         m_zoomControl = new wxChoice( this, wxID_PREVIEW_ZOOM, wxDefaultPosition, wxSize(70,wxDefaultCoord), n, choices, 0 );
         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());
         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)
 }
 
 void wxPreviewControlBar::SetZoomControl(int zoom)
@@ -1266,6 +1645,7 @@ wxFrame(parent, wxID_ANY, title, pos, size, style, name)
     m_controlBar = NULL;
     m_previewCanvas = NULL;
     m_windowDisabler = NULL;
     m_controlBar = NULL;
     m_previewCanvas = NULL;
     m_windowDisabler = NULL;
+    m_modalityKind = wxPreviewFrame_NonModal;
 
     // Give the application icon
 #ifdef __WXMSW__
 
     // Give the application icon
 #ifdef __WXMSW__
@@ -1277,14 +1657,6 @@ wxFrame(parent, wxID_ANY, title, pos, size, style, name)
 
 wxPreviewFrame::~wxPreviewFrame()
 {
 
 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)
     {
     wxPrintout *printout = m_printPreview->GetPrintout();
     if (printout)
     {
@@ -1295,12 +1667,33 @@ void wxPreviewFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
     }
 
     m_previewCanvas->SetPreview(NULL);
     }
 
     m_previewCanvas->SetPreview(NULL);
-    wxDELETE(m_printPreview);
+    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();
 }
 
 
     Destroy();
 }
 
-void wxPreviewFrame::Initialize()
+void wxPreviewFrame::InitializeWithModality(wxPreviewFrameModalityKind kind)
 {
 #if wxUSE_STATUSBAR
     CreateStatusBar();
 {
 #if wxUSE_STATUSBAR
     CreateStatusBar();
@@ -1319,7 +1712,32 @@ void wxPreviewFrame::Initialize()
     SetAutoLayout( true );
     SetSizer( item0 );
 
     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;
+    }
+
+    if ( m_modalityKind != wxPreviewFrame_NonModal )
+    {
+        // Behave like modal dialogs, don't show in taskbar. This implies
+        // removing the minimize box, because minimizing windows without
+        // taskbar entry is confusing.
+        SetWindowStyle((GetWindowStyle() & ~wxMINIMIZE_BOX) | wxFRAME_NO_TASKBAR);
+    }
 
     Layout();
 
 
     Layout();
 
@@ -1339,7 +1757,7 @@ void wxPreviewFrame::CreateControlBar()
     if (m_printPreview->GetPrintoutForPrinting())
         buttons |= wxPREVIEW_PRINT;
 
     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();
 }
 
     m_controlBar->CreateButtons();
 }
 
@@ -1375,7 +1793,7 @@ void wxPrintPreviewBase::Init(wxPrintout *printout,
     m_isOk = true;
     m_previewPrintout = printout;
     if (m_previewPrintout)
     m_isOk = true;
     m_previewPrintout = printout;
     if (m_previewPrintout)
-        m_previewPrintout->SetIsPreview(true);
+        m_previewPrintout->SetPreview(static_cast<wxPrintPreview *>(this));
 
     m_printPrintout = printoutForPrinting;
 
 
     m_printPrintout = printoutForPrinting;
 
@@ -1385,8 +1803,8 @@ void wxPrintPreviewBase::Init(wxPrintout *printout,
     m_previewFailed = false;
     m_currentPage = 1;
     m_currentZoom = 70;
     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;
     m_pageWidth = 0;
     m_pageHeight = 0;
     m_printingPrepared = false;
@@ -1542,13 +1960,23 @@ bool wxPrintPreviewBase::RenderPageIntoDC(wxDC& dc, int pageNum)
     m_previewPrintout->SetPageSizePixels(m_pageWidth, m_pageHeight);
 
     // Need to delay OnPreparePrinting() until here, so we have enough
     m_previewPrintout->SetPageSizePixels(m_pageWidth, m_pageHeight);
 
     // Need to delay OnPreparePrinting() until here, so we have enough
-    // information.
+    // information and a wxDC.
     if (!m_printingPrepared)
     {
     if (!m_printingPrepared)
     {
+        m_printingPrepared = true;
+
         m_previewPrintout->OnPreparePrinting();
         int selFrom, selTo;
         m_previewPrintout->GetPageInfo(&m_minPage, &m_maxPage, &selFrom, &selTo);
         m_previewPrintout->OnPreparePrinting();
         int selFrom, selTo;
         m_previewPrintout->GetPageInfo(&m_minPage, &m_maxPage, &selFrom, &selTo);
-        m_printingPrepared = true;
+
+        // 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();
     }
 
     m_previewPrintout->OnBeginPrinting();
@@ -1594,7 +2022,7 @@ bool wxPrintPreviewBase::RenderPage(int pageNum)
     {
         m_previewBitmap = new wxBitmap(pageRect.width, pageRect.height);
 
     {
         m_previewBitmap = new wxBitmap(pageRect.width, pageRect.height);
 
-        if (!m_previewBitmap || !m_previewBitmap->Ok())
+        if (!m_previewBitmap || !m_previewBitmap->IsOk())
         {
             InvalidatePreviewBitmap();
             wxMessageBox(_("Sorry, not enough memory to create a preview."), _("Print Preview Failure"), wxOK);
         {
             InvalidatePreviewBitmap();
             wxMessageBox(_("Sorry, not enough memory to create a preview."), _("Print Preview Failure"), wxOK);
@@ -1815,7 +2243,7 @@ int wxPrintPreview::GetMinPage() const
 
 bool wxPrintPreview::IsOk() const
 {
 
 bool wxPrintPreview::IsOk() const
 {
-    return m_pimpl->Ok();
+    return m_pimpl->IsOk();
 }
 
 void wxPrintPreview::SetOk(bool ok)
 }
 
 void wxPrintPreview::SetOk(bool ok)