{
DECLARE_DYNAMIC_CLASS(wxWindowsPrinter)
- private:
- WXFARPROC lpAbortProc;
public:
wxWindowsPrinter(wxPrintData *data = NULL);
~wxWindowsPrinter(void);
virtual bool Print(wxWindow *parent, wxPrintout *printout, bool prompt = TRUE);
virtual bool PrintDialog(wxWindow *parent);
virtual bool Setup(wxWindow *parent);
+
+ private:
+ WXFARPROC m_lpAbortProc;
};
/*
{
DECLARE_CLASS(wxPrinterBase)
- protected:
- wxPrintData printData;
- wxPrintout *currentPrintout;
- public:
- static wxWindow *abortWindow;
- static bool abortIt;
-
+public:
wxPrinterBase(wxPrintData *data = (wxPrintData *) NULL);
- ~wxPrinterBase(void);
+ ~wxPrinterBase();
virtual wxWindow *CreateAbortWindow(wxWindow *parent, wxPrintout *printout);
virtual void ReportError(wxWindow *parent, wxPrintout *printout, char *message);
- inline wxPrintData& GetPrintData(void) { return printData; };
- inline bool GetAbort(void) { return abortIt; }
+ inline wxPrintData& GetPrintData() { return m_printData; };
+ inline bool GetAbort() { return sm_abortIt; }
///////////////////////////////////////////////////////////////////////////
// OVERRIDES
virtual bool Setup(wxWindow *parent) = 0;
virtual bool Print(wxWindow *parent, wxPrintout *printout, bool prompt = TRUE) = 0;
virtual bool PrintDialog(wxWindow *parent) = 0;
+
+protected:
+ wxPrintData m_printData;
+ wxPrintout* m_currentPrintout;
+public:
+ static wxWindow* sm_abortWindow;
+ static bool sm_abortIt;
+
};
/*
{
DECLARE_ABSTRACT_CLASS(wxPrintout)
- private:
- char *printoutTitle;
- wxDC *printoutDC;
-
- int pageWidthPixels;
- int pageHeightPixels;
-
- int pageWidthMM;
- int pageHeightMM;
-
- int PPIScreenX;
- int PPIScreenY;
- int PPIPrinterX;
- int PPIPrinterY;
-
- bool isPreview;
- public:
- wxPrintout(const char *title = "Printout");
- ~wxPrintout(void);
+public:
+ wxPrintout(const wxString& title = "Printout");
+ ~wxPrintout();
virtual bool OnBeginDocument(int startPage, int endPage);
- virtual void OnEndDocument(void);
- virtual void OnBeginPrinting(void);
- virtual void OnEndPrinting(void);
+ virtual void OnEndDocument();
+ virtual void OnBeginPrinting();
+ virtual void OnEndPrinting();
// Guaranteed to be before any other functions are called
- inline virtual void OnPreparePrinting(void) { }
+ inline virtual void OnPreparePrinting() { }
virtual bool HasPage(int page);
virtual bool OnPrintPage(int page) = 0;
virtual void GetPageInfo(int *minPage, int *maxPage, int *pageFrom, int *pageTo);
- inline virtual char *GetTitle(void) { return printoutTitle; }
+ inline virtual wxString GetTitle() { return m_printoutTitle; }
+
+ inline wxDC *GetDC() { return m_printoutDC; }
+ inline void SetDC(wxDC *dc) { m_printoutDC = dc; }
+ inline void SetPageSizePixels(int w, int h) { m_pageWidthPixels = w; m_pageHeightPixels = h; }
+ inline void GetPageSizePixels(int *w, int *h) { *w = m_pageWidthPixels; *h = m_pageHeightPixels; }
+ inline void SetPageSizeMM(int w, int h) { m_pageWidthMM = w; m_pageHeightMM = h; }
+ inline void GetPageSizeMM(int *w, int *h) { *w = m_pageWidthMM; *h = m_pageHeightMM; }
+
+ inline void SetPPIScreen(int x, int y) { m_PPIScreenX = x; m_PPIScreenY = y; }
+ inline void GetPPIScreen(int *x, int *y) { *x = m_PPIScreenX; *y = m_PPIScreenY; }
+ inline void SetPPIPrinter(int x, int y) { m_PPIPrinterX = x; m_PPIPrinterY = y; }
+ inline void GetPPIPrinter(int *x, int *y) { *x = m_PPIPrinterX; *y = m_PPIPrinterY; }
+
+ inline virtual bool IsPreview() { return m_isPreview; }
+
+ inline virtual void SetIsPreview(bool p) { m_isPreview = p; }
+
+private:
+ wxString m_printoutTitle;
+ wxDC* m_printoutDC;
- inline wxDC *GetDC(void) { return printoutDC; }
- inline void SetDC(wxDC *dc) { printoutDC = dc; }
- inline void SetPageSizePixels(int w, int h) { pageWidthPixels = w; pageHeightPixels = h; }
- inline void GetPageSizePixels(int *w, int *h) { *w = pageWidthPixels; *h = pageHeightPixels; }
- inline void SetPageSizeMM(int w, int h) { pageWidthMM = w; pageHeightMM = h; }
- inline void GetPageSizeMM(int *w, int *h) { *w = pageWidthMM; *h = pageHeightMM; }
+ int m_pageWidthPixels;
+ int m_pageHeightPixels;
- inline void SetPPIScreen(int x, int y) { PPIScreenX = x; PPIScreenY = y; }
- inline void GetPPIScreen(int *x, int *y) { *x = PPIScreenX; *y = PPIScreenY; }
- inline void SetPPIPrinter(int x, int y) { PPIPrinterX = x; PPIPrinterY = y; }
- inline void GetPPIPrinter(int *x, int *y) { *x = PPIPrinterX; *y = PPIPrinterY; }
+ int m_pageWidthMM;
+ int m_pageHeightMM;
- inline virtual bool IsPreview(void) { return isPreview; }
+ int m_PPIScreenX;
+ int m_PPIScreenY;
+ int m_PPIPrinterX;
+ int m_PPIPrinterY;
- inline virtual void SetIsPreview(bool p) { isPreview = p; }
+ bool m_isPreview;
};
/*
{
DECLARE_CLASS(wxPreviewCanvas)
- private:
- wxPrintPreviewBase *printPreview;
- public:
+public:
wxPreviewCanvas(wxPrintPreviewBase *preview, wxWindow *parent,
const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = 0, const wxString& name = "canvas");
- ~wxPreviewCanvas(void);
+ ~wxPreviewCanvas();
void OnPaint(wxPaintEvent& event);
// Responds to colour changes
void OnSysColourChanged(wxSysColourChangedEvent& event);
+private:
+ wxPrintPreviewBase* m_printPreview;
+
DECLARE_EVENT_TABLE()
};
{
DECLARE_CLASS(wxPreviewFrame)
- protected:
- wxWindow *previewCanvas;
- wxPreviewControlBar *controlBar;
- wxPrintPreviewBase *printPreview;
- public:
+public:
wxPreviewFrame(wxPrintPreviewBase *preview, wxFrame *parent, const wxString& title = "Print Preview",
const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME, const wxString& name = "frame");
- ~wxPreviewFrame(void);
+ ~wxPreviewFrame();
- bool OnClose(void);
- virtual void Initialize(void);
- virtual void CreateCanvas(void);
- virtual void CreateControlBar(void);
+ bool OnClose();
+ virtual void Initialize();
+ virtual void CreateCanvas();
+ virtual void CreateControlBar();
+
+protected:
+ wxWindow* m_previewCanvas;
+ wxPreviewControlBar* m_controlBar;
+ wxPrintPreviewBase* m_printPreview;
};
/*
{
DECLARE_CLASS(wxPreviewControlBar)
- protected:
- wxPrintPreviewBase *printPreview;
- wxButton *closeButton;
- wxButton *nextPageButton;
- wxButton *previousPageButton;
- wxButton *printButton;
- wxChoice *zoomControl;
- static wxFont *buttonFont;
- long buttonFlags;
- public:
+public:
wxPreviewControlBar(wxPrintPreviewBase *preview, long buttons,
wxWindow *parent, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = 0, const wxString& name = "panel");
- ~wxPreviewControlBar(void);
+ ~wxPreviewControlBar();
- virtual void CreateButtons(void);
+ virtual void CreateButtons();
virtual void SetZoomControl(int zoom);
- virtual int GetZoomControl(void);
- inline virtual wxPrintPreviewBase *GetPrintPreview(void) { return printPreview; }
+ virtual int GetZoomControl();
+ inline virtual wxPrintPreviewBase *GetPrintPreview() const { return m_printPreview; }
void OnPrint(wxCommandEvent& event);
void OnClose(wxCommandEvent& event);
void OnZoom(wxCommandEvent& event);
void OnPaint(wxPaintEvent& event);
+protected:
+ wxPrintPreviewBase* m_printPreview;
+ wxButton* m_closeButton;
+ wxButton* m_nextPageButton;
+ wxButton* m_previousPageButton;
+ wxButton* m_printButton;
+ wxChoice* m_zoomControl;
+ long m_buttonFlags;
+
DECLARE_EVENT_TABLE()
};
{
DECLARE_CLASS(wxPrintPreviewBase)
- protected:
- wxPrintData printData;
- wxWindow *previewCanvas;
- wxFrame *previewFrame;
- wxBitmap *previewBitmap;
- wxPrintout *previewPrintout;
- wxPrintout *printPrintout;
- int currentPage;
- int currentZoom;
- float previewScale;
- int topMargin;
- int leftMargin;
- int pageWidth;
- int pageHeight;
- int minPage;
- int maxPage;
- protected:
- bool isOk;
- public:
+public:
wxPrintPreviewBase(wxPrintout *printout, wxPrintout *printoutForPrinting = (wxPrintout *) NULL, wxPrintData *data = (wxPrintData *) NULL);
- ~wxPrintPreviewBase(void);
+ ~wxPrintPreviewBase();
virtual bool SetCurrentPage(int pageNum);
- inline int GetCurrentPage(void) { return currentPage; };
+ inline int GetCurrentPage() const { return m_currentPage; };
- inline void SetPrintout(wxPrintout *printout) { previewPrintout = printout; };
- inline wxPrintout *GetPrintout(void) { return previewPrintout; };
- inline wxPrintout *GetPrintoutForPrinting(void) { return printPrintout; };
+ inline void SetPrintout(wxPrintout *printout) { m_previewPrintout = printout; };
+ inline wxPrintout *GetPrintout() const { return m_previewPrintout; };
+ inline wxPrintout *GetPrintoutForPrinting() const { return m_printPrintout; };
- inline void SetFrame(wxFrame *frame) { previewFrame = frame; };
- inline void SetCanvas(wxWindow *canvas) { previewCanvas = canvas; };
+ inline void SetFrame(wxFrame *frame) { m_previewFrame = frame; };
+ inline void SetCanvas(wxWindow *canvas) { m_previewCanvas = canvas; };
- inline virtual wxFrame *GetFrame(void) { return previewFrame; }
- inline virtual wxWindow *GetCanvas(void) { return previewCanvas; }
+ inline virtual wxFrame *GetFrame() const { return m_previewFrame; }
+ inline virtual wxWindow *GetCanvas() const { return m_previewCanvas; }
// The preview canvas should call this from OnPaint
virtual bool PaintPage(wxWindow *canvas, wxDC& dc);
// a wxMemoryDC.
virtual bool RenderPage(int pageNum);
- inline wxPrintData& GetPrintData(void) { return printData; }
+ inline wxPrintData& GetPrintData() { return m_printData; }
virtual void SetZoom(int percent);
- int GetZoom(void) { return currentZoom; };
+ inline int GetZoom() const { return m_currentZoom; };
+
+ inline int GetMaxPage() const { return m_maxPage; }
+ inline int GetMinPage() const { return m_minPage; }
- inline int GetMaxPage(void) { return maxPage; }
- inline int GetMinPage(void) { return minPage; }
-
- inline bool Ok(void) { return isOk; }
- inline void SetOk(bool ok) { isOk = ok; }
+ inline bool Ok() const { return m_isOk; }
+ inline void SetOk(bool ok) { m_isOk = ok; }
///////////////////////////////////////////////////////////////////////////
// OVERRIDES
// Calculate scaling that needs to be done to get roughly
// the right scaling for the screen pretending to be
// the currently selected printer.
- virtual void DetermineScaling(void) = 0;
+ virtual void DetermineScaling() = 0;
+
+protected:
+ wxPrintData m_printData;
+ wxWindow* m_previewCanvas;
+ wxFrame* m_previewFrame;
+ wxBitmap* m_previewBitmap;
+ wxPrintout* m_previewPrintout;
+ wxPrintout* m_printPrintout;
+ int m_currentPage;
+ int m_currentZoom;
+ float m_previewScale;
+ int m_topMargin;
+ int m_leftMargin;
+ int m_pageWidth;
+ int m_pageHeight;
+ int m_minPage;
+ int m_maxPage;
+ protected:
+ bool m_isOk;
};
/*
class WXDLLEXPORT wxPrintAbortDialog: public wxDialog
{
public:
- void OnCancel(wxCommandEvent& event);
-
wxPrintAbortDialog(wxWindow *parent,
const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = 0, const wxString& name = "dialog"):
{
}
+ void OnCancel(wxCommandEvent& event);
+
DECLARE_EVENT_TABLE()
};
// Main proc
IMPLEMENT_APP(MyApp)
-// Must initialise these in OnInit, not statically
-wxPen *red_pen;
-wxFont *labelFont;
-wxFont *itemFont;
-
-float zoom_factor = 1.0;
-
#ifdef __WXGTK__
#include "folder.xpm"
#endif
// main frame
bool MyApp::OnInit(void)
{
- // Create a red pen
- red_pen = new wxPen("RED", 3, wxSOLID);
-
- // Create a small font
- itemFont = new wxFont(11, wxROMAN, wxNORMAL, wxNORMAL);
- labelFont = new wxFont(12, wxROMAN, wxITALIC, wxBOLD);
+ m_testFont = new wxFont(10, wxSWISS, wxNORMAL, wxNORMAL);
// Create the main frame window
frame = new MyFrame((wxFrame *) NULL, (char *) "wxWindows Printing Demo", wxPoint(0, 0), wxSize(400, 400));
// Give it scrollbars: the virtual canvas is 20 * 50 = 1000 pixels in each direction
canvas->SetScrollbars(20, 20, 50, 50);
- // This ensures that the fonts get created as _screen_
- // fonts, not printer fonts.
- canvas->SetFont(itemFont);
- canvas->SetFont(labelFont);
-
frame->canvas = canvas;
frame->Centre(wxBOTH);
void MyFrame::Draw(wxDC& dc)
{
- dc.SetFont(itemFont);
+ dc.SetFont(* wxGetApp().m_testFont);
+
dc.SetBackgroundMode(wxTRANSPARENT);
- dc.SetBrush(wxCYAN_BRUSH);
- dc.SetPen(wxRED_PEN);
+ dc.SetBrush(* wxCYAN_BRUSH);
+ dc.SetPen(* wxRED_PEN);
dc.DrawRectangle(0, 30, 200, 100);
dc.DrawText("Rectangle 200 by 100", 40, 40);
dc.DrawEllipse(50, 140, 100, 50);
- dc.DrawText("Test message: this is in 11 point text", 10, 180);
+ dc.DrawText("Test message: this is in 10 point text", 10, 180);
- dc.SetPen(wxBLACK_PEN);
+ dc.SetPen(* wxBLACK_PEN);
dc.DrawLine(0, 0, 200, 200);
dc.DrawLine(200, 0, 0, 200);
{
}
-// Define the behaviour for the frame closing
-// - must delete all frames except for the main one.
bool MyFrame::OnClose(void)
{
Show(FALSE);
+ delete wxGetApp().m_testFont;
return TRUE;
}
// Draw 50 mm by 50 mm L shape
float logUnitsFactor = (float)(ppiPrinterX/(scale*25.1));
float logUnits = (float)(50*logUnitsFactor);
- dc->SetPen(wxBLACK_PEN);
+ dc->SetPen(* wxBLACK_PEN);
dc->DrawLine(50, 50, (long)(50.0 + logUnits), 50);
dc->DrawLine(50, 50, 50, (long)(50.0 + logUnits));
- dc->SetFont(itemFont);
+ dc->SetFont(* wxGetApp().m_testFont);
dc->SetBackgroundMode(wxTRANSPARENT);
dc->DrawText("Some test text", 200, 200 );
float xPos = (float)(((((pageWidthMM - leftMargin - rightMargin)/2.0)+leftMargin)*mmToLogical) - (xExtent/2.0));
dc->DrawText(text, (long)xPos, (long)topMarginLogical);
- dc->SetPen(wxBLACK_PEN);
+ dc->SetPen(* wxBLACK_PEN);
dc->DrawLine( (long)leftMarginLogical, (long)(topMarginLogical+yExtent),
(long)rightMarginLogical, (long)topMarginLogical+yExtent );
public:
MyApp(void) ;
bool OnInit(void);
+
+ wxFont* m_testFont;
};
+DECLARE_APP(MyApp)
+
class MyCanvas;
// Define a new canvas and frame
#include <print.h>
#endif
-#if !defined(APIENTRY) // NT defines APIENTRY, 3.x not
-#define APIENTRY FAR PASCAL
-#endif
-
-#ifdef __WIN32__
-#define _EXPORT /**/
-#else
-#define _EXPORT _export
-typedef signed short int SHORT ;
-#endif
-
-#if !defined(__WIN32__) // 3.x uses FARPROC for dialogs
-#define DLGPROC FARPROC
-#endif
-
-LONG APIENTRY _EXPORT wxAbortProc(HDC hPr, int Code);
#endif
// End __WXMSW__
wxPrinterBase::wxPrinterBase(wxPrintData *data)
{
- currentPrintout = (wxPrintout *) NULL;
- abortWindow = (wxWindow *) NULL;
- abortIt = FALSE;
+ m_currentPrintout = (wxPrintout *) NULL;
+ sm_abortWindow = (wxWindow *) NULL;
+ sm_abortIt = FALSE;
if (data)
- printData = (*data);
+ m_printData = (*data);
}
-wxWindow *wxPrinterBase::abortWindow = (wxWindow *) NULL;
-bool wxPrinterBase::abortIt = FALSE;
+wxWindow *wxPrinterBase::sm_abortWindow = (wxWindow *) NULL;
+bool wxPrinterBase::sm_abortIt = FALSE;
-wxPrinterBase::~wxPrinterBase(void)
+wxPrinterBase::~wxPrinterBase()
{
}
void wxPrintAbortDialog::OnCancel(wxCommandEvent& WXUNUSED(event))
{
- wxPrinterBase::abortIt = TRUE;
- wxPrinterBase::abortWindow->Show(FALSE);
- wxPrinterBase::abortWindow->Close(TRUE);
- wxPrinterBase::abortWindow = (wxWindow *) NULL;
+ wxPrinterBase::sm_abortIt = TRUE;
+ wxPrinterBase::sm_abortWindow->Show(FALSE);
+ wxPrinterBase::sm_abortWindow->Close(TRUE);
+ wxPrinterBase::sm_abortWindow = (wxWindow *) NULL;
}
wxWindow *wxPrinterBase::CreateAbortWindow(wxWindow *parent, wxPrintout *WXUNUSED(printout))
{
- wxPrintAbortDialog *dialog = new wxPrintAbortDialog(parent, _("Printing"), wxPoint(0, 0), wxSize(400, 400));
+ wxPrintAbortDialog *dialog = new wxPrintAbortDialog(parent, _("Printing"), wxPoint(0, 0), wxSize(400, 400), wxDEFAULT_DIALOG_STYLE);
(void) new wxStaticText(dialog, -1, _("Please wait..."), wxPoint(5, 5));
wxButton *button = new wxButton(dialog, wxID_CANCEL, _("Cancel"), wxPoint(5, 30));
* Printout class
*/
-wxPrintout::wxPrintout(const char *title)
+wxPrintout::wxPrintout(const wxString& title)
{
- printoutTitle = title ? copystring(title) : (char *) NULL;
- printoutDC = (wxDC *) NULL;
- pageWidthMM = 0;
- pageHeightMM = 0;
- pageWidthPixels = 0;
- pageHeightPixels = 0;
- PPIScreenX = 0;
- PPIScreenY = 0;
- PPIPrinterX = 0;
- PPIPrinterY = 0;
- isPreview = FALSE;
+ m_printoutTitle = title ;
+ m_printoutDC = (wxDC *) NULL;
+ m_pageWidthMM = 0;
+ m_pageHeightMM = 0;
+ m_pageWidthPixels = 0;
+ m_pageHeightPixels = 0;
+ m_PPIScreenX = 0;
+ m_PPIScreenY = 0;
+ m_PPIPrinterX = 0;
+ m_PPIPrinterY = 0;
+ m_isPreview = FALSE;
}
-wxPrintout::~wxPrintout(void)
+wxPrintout::~wxPrintout()
{
- if (printoutTitle)
- delete[] printoutTitle;
}
bool wxPrintout::OnBeginDocument(int WXUNUSED(startPage), int WXUNUSED(endPage))
return GetDC()->StartDoc(_("Printing"));
}
-void wxPrintout::OnEndDocument(void)
+void wxPrintout::OnEndDocument()
{
GetDC()->EndDoc();
}
-void wxPrintout::OnBeginPrinting(void)
+void wxPrintout::OnBeginPrinting()
{
}
-void wxPrintout::OnEndPrinting(void)
+void wxPrintout::OnEndPrinting()
{
}
const wxPoint& pos, const wxSize& size, long style, const wxString& name):
wxScrolledWindow(parent, -1, pos, size, style, name)
{
- printPreview = preview;
+ m_printPreview = preview;
SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
SetScrollbars(40, 40, 100, 100);
}
-wxPreviewCanvas::~wxPreviewCanvas(void)
+wxPreviewCanvas::~wxPreviewCanvas()
{
}
{
wxPaintDC dc(this);
- if (printPreview)
+ if (m_printPreview)
{
- printPreview->PaintPage(this, dc);
+ m_printPreview->PaintPage(this, dc);
}
}
long style, const wxString& name):
wxPanel(parent, -1, pos, size, style, name)
{
- printPreview = preview;
- closeButton = (wxButton *) NULL;
- nextPageButton = (wxButton *) NULL;
- previousPageButton = (wxButton *) NULL;
- printButton = (wxButton *) NULL;
- zoomControl = (wxChoice *) NULL;
- buttonFlags = buttons;
+ m_printPreview = preview;
+ m_closeButton = (wxButton *) NULL;
+ m_nextPageButton = (wxButton *) NULL;
+ m_previousPageButton = (wxButton *) NULL;
+ m_printButton = (wxButton *) NULL;
+ m_zoomControl = (wxChoice *) NULL;
+ m_buttonFlags = buttons;
}
-wxFont *wxPreviewControlBar::buttonFont = (wxFont *) NULL;
-
-wxPreviewControlBar::~wxPreviewControlBar(void)
+wxPreviewControlBar::~wxPreviewControlBar()
{
}
GetPrintPreview()->SetZoom(zoom);
}
-void wxPreviewControlBar::CreateButtons(void)
+void wxPreviewControlBar::CreateButtons()
{
#ifdef __GOOD_COMPILER__ // Robert Roebling
int fontSize = 10;
#endif
- if (!buttonFont)
- buttonFont = wxTheFontList->FindOrCreateFont(fontSize, wxSWISS, wxNORMAL, wxBOLD);
- SetButtonFont(*buttonFont);
+ wxFont buttonFont(fontSize, wxSWISS, wxNORMAL, wxBOLD);
+ SetButtonFont(buttonFont);
int buttonWidth = 65;
int buttonHeight = 24;
int y = 5;
int gap = 5;
- closeButton = new wxButton(this, wxID_PREVIEW_CLOSE, _("Close"),
+ m_closeButton = new wxButton(this, wxID_PREVIEW_CLOSE, _("Close"),
wxPoint(x, y), wxSize(buttonWidth, buttonHeight));
x += gap + buttonWidth;
- if (buttonFlags & wxPREVIEW_PRINT)
+ if (m_buttonFlags & wxPREVIEW_PRINT)
{
- printButton = new wxButton(this, wxID_PREVIEW_PRINT, _("Print..."), wxPoint(x, y),
+ m_printButton = new wxButton(this, wxID_PREVIEW_PRINT, _("Print..."), wxPoint(x, y),
wxSize(buttonWidth, buttonHeight));
x += gap + buttonWidth;
}
- if (buttonFlags & wxPREVIEW_PREVIOUS)
+ if (m_buttonFlags & wxPREVIEW_PREVIOUS)
{
- previousPageButton = new wxButton(this, wxID_PREVIEW_PREVIOUS, "<<", wxPoint(x, y),
+ m_previousPageButton = new wxButton(this, wxID_PREVIEW_PREVIOUS, "<<", wxPoint(x, y),
wxSize(buttonWidth, buttonHeight));
x += gap + buttonWidth;
}
- if (buttonFlags & wxPREVIEW_NEXT)
+ if (m_buttonFlags & wxPREVIEW_NEXT)
{
- nextPageButton = new wxButton(this, wxID_PREVIEW_NEXT, ">>",
+ m_nextPageButton = new wxButton(this, wxID_PREVIEW_NEXT, ">>",
wxPoint(x, y), wxSize(buttonWidth, buttonHeight));
x += gap + buttonWidth;
}
static wxString choices[] = { "10%", "20%", "25%", "30%", "35%", "40%", "45%", "50%", "55%", "60%",
"65%", "70%", "75%", "80%", "85%", "90%", "95%", "100%", "110%", "120%", "150%", "200%" };
int n = 22;
- if (buttonFlags & wxPREVIEW_ZOOM)
+ if (m_buttonFlags & wxPREVIEW_ZOOM)
{
- zoomControl = new wxChoice(this, wxID_PREVIEW_ZOOM, wxPoint(x, y),
+ m_zoomControl = new wxChoice(this, wxID_PREVIEW_ZOOM, wxPoint(x, y),
wxSize(100, -1), n, (wxString *)choices);
- SetZoomControl(printPreview->GetZoom());
+ SetZoomControl(m_printPreview->GetZoom());
}
- closeButton->SetDefault();
+ m_closeButton->SetDefault();
#endif
}
#ifdef __GOOD_COMPILER__ // Robert Roebling
char buf[20];
sprintf(buf, "%d%%", zoom);
- if (zoomControl)
- zoomControl->SetStringSelection(buf);
+ if (m_zoomControl)
+ m_zoomControl->SetStringSelection(buf);
#endif
}
-int wxPreviewControlBar::GetZoomControl(void)
+int wxPreviewControlBar::GetZoomControl()
{
#ifdef __GOOD_COMPILER__ // Robert Roebling
char buf[20];
- if (zoomControl && zoomControl->GetStringSelection())
+ if (m_zoomControl && m_zoomControl->GetStringSelection())
{
- strcpy(buf, zoomControl->GetStringSelection());
+ strcpy(buf, m_zoomControl->GetStringSelection());
buf[strlen(buf) - 1] = 0;
return (int)atoi(buf);
}
wxFrame(parent, -1, title, pos, size, style, name)
{
#ifdef __GOOD_COMPILER__ // Robert Roebling
-
- printPreview = preview;
- controlBar = NULL;
- previewCanvas = NULL;
+ m_printPreview = preview;
+ m_controlBar = NULL;
+ m_previewCanvas = NULL;
#endif
}
-wxPreviewFrame::~wxPreviewFrame(void)
+wxPreviewFrame::~wxPreviewFrame()
{
}
-bool wxPreviewFrame::OnClose(void)
+bool wxPreviewFrame::OnClose()
{
#ifdef __GOOD_COMPILER__ // Robert Roebling
MakeModal(FALSE);
// Need to delete the printout and the print preview
- wxPrintout *printout = printPreview->GetPrintout();
+ wxPrintout *printout = m_printPreview->GetPrintout();
if (printout)
{
delete printout;
- printPreview->SetPrintout(NULL);
- printPreview->SetCanvas(NULL);
- printPreview->SetFrame(NULL);
+ m_printPreview->SetPrintout(NULL);
+ m_printPreview->SetCanvas(NULL);
+ m_printPreview->SetFrame(NULL);
}
- delete printPreview;
+ delete m_printPreview;
return TRUE;
#else
return FALSE;
#endif
}
-void wxPreviewFrame::Initialize(void)
+void wxPreviewFrame::Initialize()
{
#ifdef __GOOD_COMPILER__ // Robert Roebling
CreateCanvas();
CreateControlBar();
- printPreview->SetCanvas(previewCanvas);
- printPreview->SetFrame(this);
+ m_printPreview->SetCanvas(m_previewCanvas);
+ m_printPreview->SetFrame(this);
// Set layout constraints here
// Control bar constraints
wxLayoutConstraints *c1 = new wxLayoutConstraints;
// int w, h;
-// controlBar->GetSize(&w, &h);
+// m_controlBar->GetSize(&w, &h);
int h;
#ifdef __WXMSW__
h = 40;
c1->right.SameAs (this, wxRight);
c1->height.Absolute (h);
- controlBar->SetConstraints(c1);
+ m_controlBar->SetConstraints(c1);
// Canvas constraints
wxLayoutConstraints *c2 = new wxLayoutConstraints;
c2->left.SameAs (this, wxLeft);
- c2->top.Below (controlBar);
+ c2->top.Below (m_controlBar);
c2->right.SameAs (this, wxRight);
c2->bottom.SameAs (this, wxBottom);
- previewCanvas->SetConstraints(c2);
+ m_previewCanvas->SetConstraints(c2);
SetAutoLayout(TRUE);
#endif
}
-void wxPreviewFrame::CreateCanvas(void)
+void wxPreviewFrame::CreateCanvas()
{
#ifdef __GOOD_COMPILER__ // Robert Roebling
- previewCanvas = new wxPreviewCanvas(printPreview, this);
+ m_previewCanvas = new wxPreviewCanvas(m_printPreview, this);
#endif
}
-void wxPreviewFrame::CreateControlBar(void)
+void wxPreviewFrame::CreateControlBar()
{
#ifdef __GOOD_COMPILER__ // Robert Roebling
long buttons = wxPREVIEW_DEFAULT;
- if (printPreview->GetPrintoutForPrinting())
+ if (m_printPreview->GetPrintoutForPrinting())
buttons |= wxPREVIEW_PRINT;
- controlBar = new wxPreviewControlBar(printPreview, buttons, this, wxPoint(0, 0), wxSize(400, 40));
- controlBar->CreateButtons();
+ m_controlBar = new wxPreviewControlBar(m_printPreview, buttons, this, wxPoint(0, 0), wxSize(400, 40));
+ m_controlBar->CreateButtons();
#endif
}
#ifdef __GOOD_COMPILER__ // Robert Roebling
- isOk = TRUE;
- previewPrintout = printout;
- if (previewPrintout)
- previewPrintout->SetIsPreview(TRUE);
+ m_isOk = TRUE;
+ m_previewPrintout = printout;
+ if (m_previewPrintout)
+ m_previewPrintout->SetIsPreview(TRUE);
- printPrintout = printoutForPrinting;
+ m_printPrintout = printoutForPrinting;
if (data)
- printData = (*data);
-
- previewCanvas = NULL;
- previewFrame = NULL;
- previewBitmap = NULL;
- currentPage = 1;
- currentZoom = 30;
- topMargin = 40;
- leftMargin = 40;
- pageWidth = 0;
- pageHeight = 0;
+ m_printData = (*data);
+
+ m_previewCanvas = NULL;
+ m_previewFrame = NULL;
+ m_previewBitmap = NULL;
+ m_currentPage = 1;
+ m_currentZoom = 30;
+ m_topMargin = 40;
+ m_leftMargin = 40;
+ m_pageWidth = 0;
+ m_pageHeight = 0;
printout->OnPreparePrinting();
// Get some parameters from the printout, if defined
int selFrom, selTo;
- printout->GetPageInfo(&minPage, &maxPage, &selFrom, &selTo);
+ printout->GetPageInfo(&m_minPage, &m_maxPage, &selFrom, &selTo);
#endif
}
-wxPrintPreviewBase::~wxPrintPreviewBase(void)
+wxPrintPreviewBase::~wxPrintPreviewBase()
{
#ifdef __GOOD_COMPILER__ // Robert Roebling
- if (previewPrintout)
- delete previewPrintout;
- if (previewBitmap)
- delete previewBitmap;
- if (printPrintout)
- delete printPrintout;
+ if (m_previewPrintout)
+ delete m_previewPrintout;
+ if (m_previewBitmap)
+ delete m_previewBitmap;
+ if (m_printPrintout)
+ delete m_printPrintout;
#endif
}
bool wxPrintPreviewBase::SetCurrentPage(int pageNum)
{
#ifdef __GOOD_COMPILER__ // Robert Roebling
- if (currentPage == pageNum)
+ if (m_currentPage == pageNum)
return TRUE;
- currentPage = pageNum;
- if (previewBitmap)
+ m_currentPage = pageNum;
+ if (m_previewBitmap)
{
- delete previewBitmap;
- previewBitmap = NULL;
+ delete m_previewBitmap;
+ m_previewBitmap = NULL;
}
- if (previewCanvas)
+ if (m_previewCanvas)
{
RenderPage(pageNum);
- previewCanvas->Refresh();
+ m_previewCanvas->Refresh();
}
#endif
DrawBlankPage(canvas, dc);
- if (!previewBitmap)
- RenderPage(currentPage);
+ if (!m_previewBitmap)
+ RenderPage(m_currentPage);
- if (!previewBitmap)
+ if (!m_previewBitmap)
return FALSE;
if (!canvas)
int canvasWidth, canvasHeight;
canvas->GetSize(&canvasWidth, &canvasHeight);
- float zoomScale = (float)((float)currentZoom/(float)100);
- float actualWidth = (float)(zoomScale*pageWidth*previewScale);
-// float actualHeight = (float)(zoomScale*pageHeight*previewScale);
+ double zoomScale = ((float)m_currentZoom/(float)100);
+ double actualWidth = (zoomScale*m_pageWidth*m_previewScale);
+// float actualHeight = (float)(zoomScale*m_pageHeight*m_previewScale);
- float x = (float)((canvasWidth - actualWidth)/2.0);
- if (x < leftMargin)
- x = (float)leftMargin;
- float y = (float)topMargin;
+ int x = ((canvasWidth - actualWidth)/2.0);
+ if (x < m_leftMargin)
+ x = m_leftMargin;
+ int y = m_topMargin;
wxMemoryDC temp_dc;
- temp_dc.SelectObject(*previewBitmap);
+ temp_dc.SelectObject(*m_previewBitmap);
- dc.Blit((float)x, (float)y, (float)previewBitmap->GetWidth(), (float)previewBitmap->GetHeight(), &temp_dc, (float)0, (float)0);
+ dc.Blit(x, y, m_previewBitmap->GetWidth(), m_previewBitmap->GetHeight(), &temp_dc, 0, 0);
temp_dc.SelectObject(wxNullBitmap);
#ifdef __GOOD_COMPILER__ // Robert Roebling
- if (!previewCanvas)
+ if (!m_previewCanvas)
{
wxMessageBox(_("wxPrintPreviewBase::RenderPage: must use wxPrintPreviewBase::SetCanvas to let me know about the canvas!"),
_("Print Preview Failure"), wxOK);
return FALSE;
}
- previewCanvas->GetSize(&canvasWidth, &canvasHeight);
+ m_previewCanvas->GetSize(&canvasWidth, &canvasHeight);
- float zoomScale = (float)((float)currentZoom/(float)100);
- float actualWidth = (float)(zoomScale*pageWidth*previewScale);
- float actualHeight = (float)(zoomScale*pageHeight*previewScale);
+ double zoomScale = (m_currentZoom/100.0);
+ int actualWidth = (int)(zoomScale*m_pageWidth*m_previewScale);
+ int actualHeight = (int)(zoomScale*m_pageHeight*m_previewScale);
- float x = (float)((canvasWidth - actualWidth)/2.0);
- if (x < leftMargin)
- x = (float)leftMargin;
-// float y = topMargin;
+ int x = (int)((canvasWidth - actualWidth)/2.0);
+ if (x < m_leftMargin)
+ x = m_leftMargin;
+// int y = m_topMargin;
- if (!previewBitmap)
+ if (!m_previewBitmap)
{
- previewBitmap = new wxBitmap((int)actualWidth, (int)actualHeight);
- if (!previewBitmap || !previewBitmap->Ok())
+ m_previewBitmap = new wxBitmap((int)actualWidth, (int)actualHeight);
+ if (!m_previewBitmap || !m_previewBitmap->Ok())
{
- if (previewBitmap)
- delete previewBitmap;
+ if (m_previewBitmap)
+ delete m_previewBitmap;
wxMessageBox(_("Sorry, not enough memory to create a preview."), _("Print Preview Failure"), wxOK);
return FALSE;
}
}
wxMemoryDC memoryDC;
- memoryDC.SelectObject(*previewBitmap);
+ memoryDC.SelectObject(*m_previewBitmap);
memoryDC.Clear();
- previewPrintout->SetDC(&memoryDC);
- previewPrintout->SetPageSizePixels(pageWidth, pageHeight);
+ m_previewPrintout->SetDC(&memoryDC);
+ m_previewPrintout->SetPageSizePixels(m_pageWidth, m_pageHeight);
- previewPrintout->OnBeginPrinting();
+ m_previewPrintout->OnBeginPrinting();
- if (!previewPrintout->OnBeginDocument(printData.GetFromPage(), printData.GetToPage()))
+ if (!m_previewPrintout->OnBeginDocument(m_printData.GetFromPage(), m_printData.GetToPage()))
{
wxMessageBox(_("Could not start document preview."), _("Print Preview Failure"), wxOK);
memoryDC.SelectObject(wxNullBitmap);
- delete previewBitmap;
+ delete m_previewBitmap;
return FALSE;
}
- previewPrintout->OnPrintPage(pageNum);
- previewPrintout->OnEndDocument();
- previewPrintout->OnEndPrinting();
+ m_previewPrintout->OnPrintPage(pageNum);
+ m_previewPrintout->OnEndDocument();
+ m_previewPrintout->OnEndPrinting();
- previewPrintout->SetDC(NULL);
+ m_previewPrintout->SetDC(NULL);
memoryDC.SelectObject(wxNullBitmap);
#endif
char buf[200];
- if (maxPage != 0)
- sprintf(buf, _("Page %d of %d"), pageNum, maxPage);
+ if (m_maxPage != 0)
+ sprintf(buf, _("Page %d of %d"), pageNum, m_maxPage);
else
sprintf(buf, _("Page %d"), pageNum);
- if (previewFrame)
- previewFrame->SetStatusText(buf);
+ if (m_previewFrame)
+ m_previewFrame->SetStatusText(buf);
return TRUE;
}
int canvasWidth, canvasHeight;
canvas->GetSize(&canvasWidth, &canvasHeight);
- float zoomScale = (float)((float)currentZoom/(float)100);
- float actualWidth = zoomScale*pageWidth*previewScale;
- float actualHeight = zoomScale*pageHeight*previewScale;
+ float zoomScale = (float)((float)m_currentZoom/(float)100);
+ float actualWidth = zoomScale*m_pageWidth*m_previewScale;
+ float actualHeight = zoomScale*m_pageHeight*m_previewScale;
float x = (float)((canvasWidth - actualWidth)/2.0);
- if (x < leftMargin)
- x = (float)leftMargin;
- float y = (float)topMargin;
+ if (x < m_leftMargin)
+ x = (float)m_leftMargin;
+ float y = (float)m_topMargin;
// Draw shadow, allowing for 1-pixel border AROUND the actual page
int shadowOffset = 4;
void wxPrintPreviewBase::SetZoom(int percent)
{
#ifdef __GOOD_COMPILER__ // Robert Roebling
- if (currentZoom == percent)
+ if (m_currentZoom == percent)
return;
- currentZoom = percent;
- if (previewBitmap)
+ m_currentZoom = percent;
+ if (m_previewBitmap)
{
- delete previewBitmap;
- previewBitmap = NULL;
+ delete m_previewBitmap;
+ m_previewBitmap = NULL;
}
- RenderPage(currentPage);
+ RenderPage(m_currentPage);
- if (previewCanvas)
+ if (m_previewCanvas)
{
- previewCanvas->Clear();
- previewCanvas->Refresh();
+ m_previewCanvas->Clear();
+ m_previewCanvas->Refresh();
}
#endif
bool wxPostScriptPrinter::Print(wxWindow *parent, wxPrintout *printout, bool prompt)
{
- abortIt = FALSE;
- abortWindow = (wxWindow *) NULL;
+ sm_abortIt = FALSE;
+ sm_abortWindow = (wxWindow *) NULL;
if (!printout)
return FALSE;
if (maxPage == 0)
return FALSE;
- printData.SetMinPage(minPage);
- printData.SetMaxPage(maxPage);
+ m_printData.SetMinPage(minPage);
+ m_printData.SetMaxPage(maxPage);
if (fromPage != 0)
- printData.SetFromPage(fromPage);
+ m_printData.SetFromPage(fromPage);
if (toPage != 0)
- printData.SetToPage(toPage);
+ m_printData.SetToPage(toPage);
if (minPage != 0)
{
- printData.EnablePageNumbers(TRUE);
- if (printData.GetFromPage() < printData.GetMinPage())
- printData.SetFromPage(printData.GetMinPage());
- else if (printData.GetFromPage() > printData.GetMaxPage())
- printData.SetFromPage(printData.GetMaxPage());
- if (printData.GetToPage() > printData.GetMaxPage())
- printData.SetToPage(printData.GetMaxPage());
- else if (printData.GetToPage() < printData.GetMinPage())
- printData.SetToPage(printData.GetMinPage());
+ m_printData.EnablePageNumbers(TRUE);
+ if (m_printData.GetFromPage() < m_printData.GetMinPage())
+ m_printData.SetFromPage(m_printData.GetMinPage());
+ else if (m_printData.GetFromPage() > m_printData.GetMaxPage())
+ m_printData.SetFromPage(m_printData.GetMaxPage());
+ if (m_printData.GetToPage() > m_printData.GetMaxPage())
+ m_printData.SetToPage(m_printData.GetMaxPage());
+ else if (m_printData.GetToPage() < m_printData.GetMinPage())
+ m_printData.SetToPage(m_printData.GetMinPage());
}
else
- printData.EnablePageNumbers(FALSE);
-
+ m_printData.EnablePageNumbers(FALSE);
+
// Create a suitable device context
wxDC *dc = (wxDC *) NULL;
if (prompt)
{
- wxGenericPrintDialog dialog(parent, & printData);
+ wxGenericPrintDialog dialog(parent, & m_printData);
if (dialog.ShowModal() == wxID_OK)
{
dc = dialog.GetPrintDC();
- printData = dialog.GetPrintData();
+ m_printData = dialog.GetPrintData();
}
}
else
bool keepGoing = TRUE;
int copyCount;
- for (copyCount = 1; copyCount <= printData.GetNoCopies(); copyCount ++)
+ for (copyCount = 1; copyCount <= m_printData.GetNoCopies(); copyCount ++)
{
- if (!printout->OnBeginDocument(printData.GetFromPage(), printData.GetToPage()))
+ if (!printout->OnBeginDocument(m_printData.GetFromPage(), m_printData.GetToPage()))
{
wxEndBusyCursor();
wxMessageBox(_("Could not start printing."), _("Print Error"), wxOK, parent);
break;
}
- if (abortIt)
+ if (sm_abortIt)
break;
int pn;
- for (pn = printData.GetFromPage(); keepGoing && (pn <= printData.GetToPage()) && printout->HasPage(pn);
+ for (pn = m_printData.GetFromPage(); keepGoing && (pn <= m_printData.GetToPage()) && printout->HasPage(pn);
pn++)
{
- if (abortIt)
+ if (sm_abortIt)
{
keepGoing = FALSE;
break;
bool wxPostScriptPrinter::PrintDialog(wxWindow *parent)
{
- wxGenericPrintDialog dialog(parent, & printData);
+ wxGenericPrintDialog dialog(parent, & m_printData);
return (dialog.ShowModal() == wxID_OK);
}
bool wxPostScriptPrinter::Setup(wxWindow *parent)
{
- wxGenericPrintDialog dialog(parent, & printData);
+ wxGenericPrintDialog dialog(parent, & m_printData);
dialog.GetPrintData().SetSetupDialog(TRUE);
return (dialog.ShowModal() == wxID_OK);
}
bool wxPostScriptPrintPreview::Print(bool interactive)
{
- if (!printPrintout)
+ if (!m_printPrintout)
return FALSE;
- wxPostScriptPrinter printer(&printData);
- return printer.Print(previewFrame, printPrintout, interactive);
+ wxPostScriptPrinter printer(&m_printData);
+ return printer.Print(m_previewFrame, m_printPrintout, interactive);
}
void wxPostScriptPrintPreview::DetermineScaling(void)
paper = wxThePrintPaperDatabase->FindPaperType(_("A4 210 x 297 mm"));
if (paper)
{
- previewPrintout->SetPPIScreen(100, 100);
- previewPrintout->SetPPIPrinter(100, 100);
+ m_previewPrintout->SetPPIScreen(100, 100);
+ m_previewPrintout->SetPPIPrinter(100, 100);
// If in landscape mode, we need to swap the width and height.
- if ( printData.GetOrientation() == wxLANDSCAPE )
+ if ( m_printData.GetOrientation() == wxLANDSCAPE )
{
- pageWidth = paper->heightPixels;
- pageHeight = paper->widthPixels;
- previewPrintout->SetPageSizeMM(paper->heightMM, paper->widthMM);
- previewPrintout->SetPageSizePixels(paper->heightPixels, paper->widthPixels);
+ m_pageWidth = paper->heightPixels;
+ m_pageHeight = paper->widthPixels;
+ m_previewPrintout->SetPageSizeMM(paper->heightMM, paper->widthMM);
+ m_previewPrintout->SetPageSizePixels(paper->heightPixels, paper->widthPixels);
}
else
{
- pageWidth = paper->widthPixels;
- pageHeight = paper->heightPixels;
- previewPrintout->SetPageSizeMM(paper->widthMM, paper->heightMM);
- previewPrintout->SetPageSizePixels(paper->widthPixels, paper->heightPixels);
+ m_pageWidth = paper->widthPixels;
+ m_pageHeight = paper->heightPixels;
+ m_previewPrintout->SetPageSizeMM(paper->widthMM, paper->heightMM);
+ m_previewPrintout->SetPageSizePixels(paper->widthPixels, paper->heightPixels);
}
// At 100%, the page should look about page-size on the screen.
- previewScale = (float)0.8;
-// previewScale = (float)((float)screenWidth/(float)printerWidth);
-// previewScale = previewScale * (float)((float)screenXRes/(float)printerYRes);
+ m_previewScale = (float)0.8;
+// m_previewScale = (float)((float)screenWidth/(float)printerWidth);
+// m_previewScale = previewScale * (float)((float)screenXRes/(float)printerYRes);
}
}
wxDebugMsg("wxDC::SetFont: Selecting HFONT %X\n", m_font.GetResourceHandle());
#endif
HFONT f = (HFONT) ::SelectObject((HDC) m_hDC, (HFONT) m_font.GetResourceHandle());
+ if (f == NULL)
+ {
+ wxDebugMsg("::SelectObject failed in wxDC::SetFont.");
+ }
if (!m_oldFont)
m_oldFont = (WXHFONT) f;
}
void wxDC::DrawText(const wxString& text, long x, long y, bool use16bit)
{
+ // Should be unnecessary: SetFont should have done this already.
+#if 0
if (m_font.Ok() && m_font.GetResourceHandle())
{
#if WXDEBUG > 1
if (!m_oldFont)
m_oldFont = (WXHFONT) f;
}
+#endif
if (m_textForegroundColour.Ok())
SetTextColor((HDC) m_hDC, m_textForegroundColour.GetPixel() ) ;
if (!this->IsKindOf(CLASSINFO(wxPrinterDC)))
return TRUE;
- bool flag = FALSE;
-
DOCINFO docinfo;
docinfo.cbSize = sizeof(DOCINFO);
docinfo.lpszDocName = (const char *)message;
- docinfo.lpszOutput = (const char *)m_filename;
+
+ if (m_filename.IsEmpty())
+ docinfo.lpszOutput = NULL;
+ else
+ docinfo.lpszOutput = (const char *)m_filename;
+
#if defined(__WIN95__)
docinfo.lpszDatatype = NULL;
docinfo.fwType = 0;
#endif
- if (m_hDC) flag = (SP_ERROR !=
+ if (!m_hDC)
+ return FALSE;
+
+ int ret =
#ifndef __WIN32__
- ::StartDoc((HDC) m_hDC, &docinfo));
+ ::StartDoc((HDC) m_hDC, &docinfo);
#else
#ifdef UNICODE
- ::StartDocW((HDC) m_hDC, &docinfo));
+ ::StartDocW((HDC) m_hDC, &docinfo);
#else
- ::StartDocA((HDC) m_hDC, &docinfo));
+ ::StartDocA((HDC) m_hDC, &docinfo);
#endif
#endif
- else flag = FALSE;
-
- return flag;
+ if (ret <= 0)
+ {
+ DWORD lastError = GetLastError();
+ wxDebugMsg("wxDC::StartDoc failed with error: %d\n", lastError);
+ }
+ return (ret > 0);
}
void wxDC::EndDoc(void)
else if (M_FONTDATA->m_weight == wxBOLD)
ff_weight = FW_BOLD;
-#if defined(__X__) || (defined(__WXMSW__) && USE_PORTABLE_FONTS_IN_MSW)
- ff_face = wxTheFontNameDirectory.GetScreenName(M_FONTDATA->m_family, M_FONTDATA->m_weight, M_FONTDATA->m_style);
-#else
- ff_face = M_FONTDATA->m_faceName;
- if ( ff_face.IsNull() )
- ff_face = "";
-#endif
+ const char* pzFace = (const char*) ff_face;
+ if (!M_FONTDATA->m_faceName.IsNull())
+ pzFace = (const char*) M_FONTDATA->m_faceName ;
/* Always calculate fonts using the screen DC (is this the best strategy?)
* There may be confusion if a font is selected into a printer
M_FONTDATA->m_hFont = (WXHFONT) CreateFont(nHeight, 0, 0, 0,ff_weight,ff_italic,(BYTE)ff_underline,
0, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
- PROOF_QUALITY, DEFAULT_PITCH | ff_family, (ff_face == "" ? NULL : (const char *)ff_face));
+ PROOF_QUALITY, DEFAULT_PITCH | ff_family, pzFace);
#ifdef WXDEBUG_CREATE
if (m_hFont==NULL) wxError("Cannot create font","Internal Error") ;
#endif
wxWindowsPrinter::wxWindowsPrinter(wxPrintData *data):
wxPrinterBase(data)
{
- lpAbortProc = (WXFARPROC) MakeProcInstance((FARPROC) wxAbortProc, wxGetInstance());
+ m_lpAbortProc = (WXFARPROC) MakeProcInstance((FARPROC) wxAbortProc, wxGetInstance());
}
wxWindowsPrinter::~wxWindowsPrinter(void)
{
- FreeProcInstance((FARPROC) lpAbortProc);
+ FreeProcInstance((FARPROC) m_lpAbortProc);
}
bool wxWindowsPrinter::Print(wxWindow *parent, wxPrintout *printout, bool prompt)
{
- abortIt = FALSE;
- abortWindow = NULL;
+ sm_abortIt = FALSE;
+ sm_abortWindow = NULL;
if (!printout)
return FALSE;
if (maxPage == 0)
return FALSE;
- printData.SetMinPage(minPage);
- printData.SetMaxPage(maxPage);
+ m_printData.SetMinPage(minPage);
+ m_printData.SetMaxPage(maxPage);
if (fromPage != 0)
- printData.SetFromPage(fromPage);
+ m_printData.SetFromPage(fromPage);
if (toPage != 0)
- printData.SetToPage(toPage);
+ m_printData.SetToPage(toPage);
if (minPage != 0)
{
- printData.EnablePageNumbers(TRUE);
- if (printData.GetFromPage() < printData.GetMinPage())
- printData.SetFromPage(printData.GetMinPage());
- else if (printData.GetFromPage() > printData.GetMaxPage())
- printData.SetFromPage(printData.GetMaxPage());
- if (printData.GetToPage() > printData.GetMaxPage())
- printData.SetToPage(printData.GetMaxPage());
- else if (printData.GetToPage() < printData.GetMinPage())
- printData.SetToPage(printData.GetMinPage());
+ m_printData.EnablePageNumbers(TRUE);
+ if (m_printData.GetFromPage() < m_printData.GetMinPage())
+ m_printData.SetFromPage(m_printData.GetMinPage());
+ else if (m_printData.GetFromPage() > m_printData.GetMaxPage())
+ m_printData.SetFromPage(m_printData.GetMaxPage());
+ if (m_printData.GetToPage() > m_printData.GetMaxPage())
+ m_printData.SetToPage(m_printData.GetMaxPage());
+ else if (m_printData.GetToPage() < m_printData.GetMinPage())
+ m_printData.SetToPage(m_printData.GetMinPage());
}
else
- printData.EnablePageNumbers(FALSE);
-
+ m_printData.EnablePageNumbers(FALSE);
+
// Create a suitable device context
wxDC *dc = NULL;
if (prompt)
{
- wxPrintDialog dialog(parent, & printData);
+ wxPrintDialog dialog(parent, & m_printData);
if (dialog.ShowModal() == wxID_OK)
{
dc = dialog.GetPrintDC();
- printData = dialog.GetPrintData();
+ m_printData = dialog.GetPrintData();
}
}
else
{
- dc = new wxPrinterDC("", "", "", FALSE, printData.GetOrientation());
+ dc = new wxPrinterDC("", "", "", FALSE, m_printData.GetOrientation());
}
// May have pressed cancel.
wxYield();
#if defined(__BORLANDC__) || defined(__GNUWIN32__) || !defined(__WIN32__)
- ::SetAbortProc((HDC) dc->GetHDC(), (FARPROC) lpAbortProc);
+ ::SetAbortProc((HDC) dc->GetHDC(), (FARPROC) m_lpAbortProc);
#else
::SetAbortProc((HDC) dc->GetHDC(), (int (_stdcall *)
// cast it to right type only if required
#else
()
#endif
- )lpAbortProc);
+ )m_lpAbortProc);
#endif
if (!win)
wxMessageBox("Sorry, could not create an abort dialog.", "Print Error", wxOK, parent);
delete dc;
}
- abortWindow = win;
- abortWindow->Show(TRUE);
+ sm_abortWindow = win;
+ sm_abortWindow->Show(TRUE);
wxYield();
printout->OnBeginPrinting();
bool keepGoing = TRUE;
int copyCount;
- for (copyCount = 1; copyCount <= printData.GetNoCopies(); copyCount ++)
+ for (copyCount = 1; copyCount <= m_printData.GetNoCopies(); copyCount ++)
{
- if (!printout->OnBeginDocument(printData.GetFromPage(), printData.GetToPage()))
+ if (!printout->OnBeginDocument(m_printData.GetFromPage(), m_printData.GetToPage()))
{
wxEndBusyCursor();
wxMessageBox("Could not start printing.", "Print Error", wxOK, parent);
break;
}
- if (abortIt)
+ if (sm_abortIt)
break;
int pn;
- for (pn = printData.GetFromPage(); keepGoing && (pn <= printData.GetToPage()) && printout->HasPage(pn);
+ for (pn = m_printData.GetFromPage(); keepGoing && (pn <= m_printData.GetToPage()) && printout->HasPage(pn);
pn++)
{
- if (abortIt)
+ if (sm_abortIt)
{
keepGoing = FALSE;
break;
printout->OnEndPrinting();
- if (abortWindow)
+ if (sm_abortWindow)
{
- abortWindow->Show(FALSE);
- delete abortWindow;
- abortWindow = NULL;
+ sm_abortWindow->Show(FALSE);
+ delete sm_abortWindow;
+ sm_abortWindow = NULL;
}
wxEndBusyCursor();
bool wxWindowsPrinter::PrintDialog(wxWindow *parent)
{
- wxPrintDialog dialog(parent, & printData);
+ wxPrintDialog dialog(parent, & m_printData);
return (dialog.ShowModal() == wxID_OK);
}
bool wxWindowsPrinter::Setup(wxWindow *parent)
{
- wxPrintDialog dialog(parent, & printData);
+ wxPrintDialog dialog(parent, & m_printData);
dialog.GetPrintData().SetSetupDialog(TRUE);
return (dialog.ShowModal() == wxID_OK);
}
bool wxWindowsPrintPreview::Print(bool interactive)
{
- if (!printPrintout)
+ if (!m_printPrintout)
return FALSE;
- wxWindowsPrinter printer(&printData);
- return printer.Print(previewFrame, printPrintout, interactive);
+ wxWindowsPrinter printer(&m_printData);
+ return printer.Print(m_previewFrame, m_printPrintout, interactive);
}
void wxWindowsPrintPreview::DetermineScaling(void)
// int screenYRes = ::GetDeviceCaps(dc, VERTRES);
int logPPIScreenX = ::GetDeviceCaps(dc, LOGPIXELSX);
int logPPIScreenY = ::GetDeviceCaps(dc, LOGPIXELSY);
- previewPrintout->SetPPIScreen(logPPIScreenX, logPPIScreenY);
+ m_previewPrintout->SetPPIScreen(logPPIScreenX, logPPIScreenY);
::ReleaseDC(NULL, dc);
// Get a device context for the currently selected printer
- wxPrinterDC printerDC("", "", "", FALSE, printData.GetOrientation());
+ wxPrinterDC printerDC("", "", "", FALSE, m_printData.GetOrientation());
int printerWidth = 150;
int printerHeight = 250;
int logPPIPrinterX = ::GetDeviceCaps((HDC) printerDC.GetHDC(), LOGPIXELSX);
int logPPIPrinterY = ::GetDeviceCaps((HDC) printerDC.GetHDC(), LOGPIXELSY);
- previewPrintout->SetPPIPrinter(logPPIPrinterX, logPPIPrinterY);
- previewPrintout->SetPageSizeMM(printerWidth, printerHeight);
+ m_previewPrintout->SetPPIPrinter(logPPIPrinterX, logPPIPrinterY);
+ m_previewPrintout->SetPageSizeMM(printerWidth, printerHeight);
if (logPPIPrinterX == 0 || logPPIPrinterY == 0 || printerWidth == 0 || printerHeight == 0)
- isOk = FALSE;
+ m_isOk = FALSE;
}
else
- isOk = FALSE;
+ m_isOk = FALSE;
- pageWidth = printerXRes;
- pageHeight = printerYRes;
+ m_pageWidth = printerXRes;
+ m_pageHeight = printerYRes;
// At 100%, the page should look about page-size on the screen.
- previewScale = (float)((float)screenWidth/(float)printerWidth);
- previewScale = previewScale * (float)((float)screenXRes/(float)printerYRes);
+ m_previewScale = (float)((float)screenWidth/(float)printerWidth);
+ m_previewScale = m_previewScale * (float)((float)screenXRes/(float)printerYRes);
}
/****************************************************************************
{
MSG msg;
- if (!wxPrinterBase::abortWindow) /* If the abort dialog isn't up yet */
+ if (!wxPrinterBase::sm_abortWindow) /* If the abort dialog isn't up yet */
return(TRUE);
/* Process messages intended for the abort dialog box */
- while (!wxPrinterBase::abortIt && PeekMessage(&msg, 0, 0, 0, TRUE))
- if (!IsDialogMessage((HWND) wxPrinterBase::abortWindow->GetHWND(), &msg)) {
+ while (!wxPrinterBase::sm_abortIt && PeekMessage(&msg, 0, 0, 0, TRUE))
+ if (!IsDialogMessage((HWND) wxPrinterBase::sm_abortWindow->GetHWND(), &msg)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
/* bAbort is TRUE (return is FALSE) if the user has aborted */
- return (!wxPrinterBase::abortIt);
+ return (!wxPrinterBase::sm_abortIt);
}
projects / wxWidgets.git / commitdiff
