]> git.saurik.com Git - wxWidgets.git/blob - samples/printing/printing.cpp
Don't enter an infinite loop if a spacer with min size of -1 is used.
[wxWidgets.git] / samples / printing / printing.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: samples/printing.cpp
3 // Purpose: Printing demo for wxWidgets
4 // Author: Julian Smart
5 // Modified by: Francesco Montorsi
6 // Created: 1995
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // For compilers that support precompilation, includes "wx/wx.h".
13 #include "wx/wxprec.h"
14
15 #ifdef __BORLANDC__
16 #pragma hdrstop
17 #endif
18
19 #ifndef WX_PRECOMP
20 #include "wx/wx.h"
21 #include "wx/log.h"
22 #endif
23
24 #if !wxUSE_PRINTING_ARCHITECTURE
25 #error "You must set wxUSE_PRINTING_ARCHITECTURE to 1 in setup.h, and recompile the library."
26 #endif
27
28 // Set this to 1 if you want to test PostScript printing under MSW.
29 // However, you'll also need to edit src/msw/makefile.nt.
30 #define wxTEST_POSTSCRIPT_IN_MSW 0
31
32 #include <ctype.h>
33 #include "wx/metafile.h"
34 #include "wx/print.h"
35 #include "wx/printdlg.h"
36 #include "wx/image.h"
37 #include "wx/accel.h"
38
39 #if wxTEST_POSTSCRIPT_IN_MSW
40 #include "wx/generic/printps.h"
41 #include "wx/generic/prntdlgg.h"
42 #endif
43
44 #if wxUSE_GRAPHICS_CONTEXT
45 #include "wx/graphics.h"
46 #endif
47
48 #ifdef __WXMAC__
49 #include "wx/osx/printdlg.h"
50 #endif
51
52 #include "printing.h"
53
54 #ifndef __WXMSW__
55 #include "mondrian.xpm"
56 #endif
57
58 // Global print data, to remember settings during the session
59 wxPrintData *g_printData = NULL;
60
61 // Global page setup data
62 wxPageSetupDialogData* g_pageSetupData = NULL;
63
64
65
66 // ----------------------------------------------------------------------------
67 // MyApp
68 // ----------------------------------------------------------------------------
69
70 IMPLEMENT_APP(MyApp)
71
72 bool MyApp::OnInit(void)
73 {
74 if ( !wxApp::OnInit() )
75 return false;
76
77 wxInitAllImageHandlers();
78
79
80 // init global objects
81 // -------------------
82
83 g_printData = new wxPrintData;
84
85 // You could set an initial paper size here
86 #if 0
87 g_printData->SetPaperId(wxPAPER_LETTER); // for Americans
88 g_printData->SetPaperId(wxPAPER_A4); // for everyone else
89 #endif
90
91 g_pageSetupData = new wxPageSetupDialogData;
92
93 // copy over initial paper size from print record
94 (*g_pageSetupData) = *g_printData;
95
96 // Set some initial page margins in mm.
97 g_pageSetupData->SetMarginTopLeft(wxPoint(15, 15));
98 g_pageSetupData->SetMarginBottomRight(wxPoint(15, 15));
99
100
101 // init local GUI objects
102 // ----------------------
103
104 #if 0
105 wxImage image( wxT("test.jpg") );
106 image.SetAlpha();
107 int i,j;
108 for (i = 0; i < image.GetWidth(); i++)
109 for (j = 0; j < image.GetHeight(); j++)
110 image.SetAlpha( i, j, 50 );
111 m_bitmap = image;
112 #endif
113 m_angle = 30;
114 m_testFont.Create(10, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
115
116
117 // Create the main frame window
118 // ----------------------------
119
120 MyFrame* frame = new MyFrame((wxFrame *) NULL, wxT("wxWidgets Printing Demo"),
121 wxPoint(0, 0), wxSize(400, 400));
122
123 frame->Centre(wxBOTH);
124 frame->Show();
125
126 SetTopWindow(frame);
127
128 return true;
129 }
130
131 int MyApp::OnExit()
132 {
133 delete g_printData;
134 delete g_pageSetupData;
135
136 return wxApp::OnExit();
137 }
138
139 void MyApp::Draw(wxDC&dc)
140 {
141 // This routine just draws a bunch of random stuff on the screen so that we
142 // can check that different types of object are being drawn consistently
143 // between the screen image, the print preview image (at various zoom
144 // levels), and the printed page.
145 dc.SetBackground(*wxWHITE_BRUSH);
146 // dc.Clear();
147 dc.SetFont(m_testFont);
148
149 // dc.SetBackgroundMode(wxTRANSPARENT);
150
151 dc.SetPen(*wxBLACK_PEN);
152 dc.SetBrush(*wxLIGHT_GREY_BRUSH);
153
154 dc.DrawRectangle(0, 0, 230, 350);
155 dc.DrawLine(0, 0, 229, 349);
156 dc.DrawLine(229, 0, 0, 349);
157 dc.SetBrush(*wxTRANSPARENT_BRUSH);
158
159 dc.SetBrush(*wxCYAN_BRUSH);
160 dc.SetPen(*wxRED_PEN);
161
162 dc.DrawRoundedRectangle(0, 20, 200, 80, 20);
163
164 dc.DrawText( wxT("Rectangle 200 by 80"), 40, 40);
165
166 dc.SetPen( wxPen(*wxBLACK,0,wxDOT_DASH) );
167 dc.DrawEllipse(50, 140, 100, 50);
168 dc.SetPen(*wxRED_PEN);
169
170 dc.DrawText( wxT("Test message: this is in 10 point text"), 10, 180);
171
172 #if wxUSE_UNICODE
173 const char *test = "Hebrew שלום -- Japanese (日本語)";
174 wxString tmp = wxConvUTF8.cMB2WC( test );
175 dc.DrawText( tmp, 10, 200 );
176 #endif
177
178 wxPoint points[5];
179 points[0].x = 0;
180 points[0].y = 0;
181 points[1].x = 20;
182 points[1].y = 0;
183 points[2].x = 20;
184 points[2].y = 20;
185 points[3].x = 10;
186 points[3].y = 20;
187 points[4].x = 10;
188 points[4].y = -20;
189 dc.DrawPolygon( 5, points, 20, 250, wxODDEVEN_RULE );
190 dc.DrawPolygon( 5, points, 50, 250, wxWINDING_RULE );
191
192 dc.DrawEllipticArc( 80, 250, 60, 30, 0.0, 270.0 );
193
194 points[0].x = 150;
195 points[0].y = 250;
196 points[1].x = 180;
197 points[1].y = 250;
198 points[2].x = 180;
199 points[2].y = 220;
200 points[3].x = 200;
201 points[3].y = 220;
202 dc.DrawSpline( 4, points );
203
204 dc.DrawArc( 20,10, 10,10, 25,40 );
205
206 wxString str;
207 int i = 0;
208 str.Printf( wxT("---- Text at angle %d ----"), i );
209 dc.DrawRotatedText( str, 100, 300, i );
210
211 i = m_angle;
212 str.Printf( wxT("---- Text at angle %d ----"), i );
213 dc.DrawRotatedText( str, 100, 300, i );
214
215 wxIcon my_icon = wxICON(mondrian);
216
217 dc.DrawIcon( my_icon, 100, 100);
218
219 if (m_bitmap.IsOk())
220 dc.DrawBitmap( m_bitmap, 10, 10 );
221
222 #if wxUSE_GRAPHICS_CONTEXT
223 wxGraphicsContext *gc = NULL;
224
225 wxPrinterDC *printer_dc = wxDynamicCast( &dc, wxPrinterDC );
226 if (printer_dc)
227 gc = wxGraphicsContext::Create( *printer_dc );
228
229 wxWindowDC *window_dc = wxDynamicCast( &dc, wxWindowDC );
230 if (window_dc)
231 gc = wxGraphicsContext::Create( *window_dc );
232
233 if (gc)
234 {
235 // make a path that contains a circle and some lines, centered at 100,100
236 gc->SetPen( *wxRED_PEN );
237 gc->SetFont( m_testFont, *wxGREEN );
238 wxGraphicsPath path = gc->CreatePath();
239 path.AddCircle( 50.0, 50.0, 50.0 );
240 path.MoveToPoint(0.0, 50.0);
241 path.AddLineToPoint(100.0, 50.0);
242 path.MoveToPoint(50.0, 0.0);
243 path.AddLineToPoint(50.0, 100.0 );
244 path.CloseSubpath();
245 path.AddRectangle(25.0, 25.0, 50.0, 50.0);
246
247 gc->StrokePath(path);
248
249 delete gc;
250 }
251 #endif
252 }
253
254
255 // ----------------------------------------------------------------------------
256 // MyFrame
257 // ----------------------------------------------------------------------------
258
259 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
260 EVT_MENU(wxID_EXIT, MyFrame::OnExit)
261 EVT_MENU(wxID_PRINT, MyFrame::OnPrint)
262 EVT_MENU(wxID_PREVIEW, MyFrame::OnPrintPreview)
263 EVT_MENU(WXPRINT_PAGE_SETUP, MyFrame::OnPageSetup)
264 EVT_MENU(wxID_ABOUT, MyFrame::OnPrintAbout)
265 #if defined(__WXMSW__) &&wxTEST_POSTSCRIPT_IN_MSW
266 EVT_MENU(WXPRINT_PRINT_PS, MyFrame::OnPrintPS)
267 EVT_MENU(WXPRINT_PREVIEW_PS, MyFrame::OnPrintPreviewPS)
268 EVT_MENU(WXPRINT_PAGE_SETUP_PS, MyFrame::OnPageSetupPS)
269 #endif
270 #ifdef __WXMAC__
271 EVT_MENU(WXPRINT_PAGE_MARGINS, MyFrame::OnPageMargins)
272 #endif
273 EVT_MENU(WXPRINT_ANGLEUP, MyFrame::OnAngleUp)
274 EVT_MENU(WXPRINT_ANGLEDOWN, MyFrame::OnAngleDown)
275 END_EVENT_TABLE()
276
277 MyFrame::MyFrame(wxFrame *frame, const wxString&title, const wxPoint&pos, const wxSize&size)
278 : wxFrame(frame, wxID_ANY, title, pos, size)
279 {
280 m_canvas = NULL;
281
282 #if wxUSE_STATUSBAR
283 // Give us a status line
284 CreateStatusBar(2);
285 SetStatusText(wxT("Printing demo"));
286 #endif // wxUSE_STATUSBAR
287
288 // Load icon and bitmap
289 SetIcon( wxICON( mondrian) );
290
291 // Make a menubar
292 wxMenu *file_menu = new wxMenu;
293
294 file_menu->Append(wxID_PRINT, wxT("&Print..."), wxT("Print"));
295 file_menu->Append(WXPRINT_PAGE_SETUP, wxT("Page Set&up..."), wxT("Page setup"));
296 #ifdef __WXMAC__
297 file_menu->Append(WXPRINT_PAGE_MARGINS, wxT("Page Margins..."), wxT("Page margins"));
298 #endif
299 file_menu->Append(wxID_PREVIEW, wxT("Print Pre&view"), wxT("Preview"));
300
301 #if wxUSE_ACCEL
302 // Accelerators
303 wxAcceleratorEntry entries[1];
304 entries[0].Set(wxACCEL_CTRL, (int) 'V', wxID_PREVIEW);
305 wxAcceleratorTable accel(1, entries);
306 SetAcceleratorTable(accel);
307 #endif
308
309 #if defined(__WXMSW__) &&wxTEST_POSTSCRIPT_IN_MSW
310 file_menu->AppendSeparator();
311 file_menu->Append(WXPRINT_PRINT_PS, wxT("Print PostScript..."), wxT("Print (PostScript)"));
312 file_menu->Append(WXPRINT_PAGE_SETUP_PS, wxT("Page Setup PostScript..."), wxT("Page setup (PostScript)"));
313 file_menu->Append(WXPRINT_PREVIEW_PS, wxT("Print Preview PostScript"), wxT("Preview (PostScript)"));
314 #endif
315
316 file_menu->AppendSeparator();
317 file_menu->Append(WXPRINT_ANGLEUP, wxT("Angle up\tAlt-U"), wxT("Raise rotated text angle"));
318 file_menu->Append(WXPRINT_ANGLEDOWN, wxT("Angle down\tAlt-D"), wxT("Lower rotated text angle"));
319 file_menu->AppendSeparator();
320 file_menu->Append(wxID_EXIT, wxT("E&xit"), wxT("Exit program"));
321
322 wxMenu *help_menu = new wxMenu;
323 help_menu->Append(wxID_ABOUT, wxT("&About"), wxT("About this demo"));
324
325 wxMenuBar *menu_bar = new wxMenuBar;
326
327 menu_bar->Append(file_menu, wxT("&File"));
328 menu_bar->Append(help_menu, wxT("&Help"));
329
330 // Associate the menu bar with the frame
331 SetMenuBar(menu_bar);
332
333
334 // create the canvas
335 // -----------------
336
337 m_canvas = new MyCanvas(this, wxPoint(0, 0), wxSize(100, 100),
338 wxRETAINED|wxHSCROLL|wxVSCROLL);
339
340 // Give it scrollbars: the virtual canvas is 20 * 50 = 1000 pixels in each direction
341 m_canvas->SetScrollbars(20, 20, 50, 50);
342 }
343
344 void MyFrame::OnExit(wxCommandEvent& WXUNUSED(event))
345 {
346 Close(true /*force closing*/);
347 }
348
349 void MyFrame::OnPrint(wxCommandEvent& WXUNUSED(event))
350 {
351 wxPrintDialogData printDialogData(* g_printData);
352
353 wxPrinter printer(&printDialogData);
354 MyPrintout printout(this, wxT("My printout"));
355 if (!printer.Print(this, &printout, true /*prompt*/))
356 {
357 if (wxPrinter::GetLastError() == wxPRINTER_ERROR)
358 {
359 wxLogError(wxT("There was a problem printing. Perhaps your current printer is not set correctly?"));
360 }
361 else
362 {
363 wxLogMessage(wxT("You canceled printing"));
364 }
365 }
366 else
367 {
368 (*g_printData) = printer.GetPrintDialogData().GetPrintData();
369 }
370 }
371
372 void MyFrame::OnPrintPreview(wxCommandEvent& WXUNUSED(event))
373 {
374 // Pass two printout objects: for preview, and possible printing.
375 wxPrintDialogData printDialogData(* g_printData);
376 wxPrintPreview *preview =
377 new wxPrintPreview(new MyPrintout(this), new MyPrintout(this), &printDialogData);
378 if (!preview->IsOk())
379 {
380 delete preview;
381 wxLogError(wxT("There was a problem previewing.\nPerhaps your current printer is not set correctly?"));
382 return;
383 }
384
385 wxPreviewFrame *frame =
386 new wxPreviewFrame(preview, this, wxT("Demo Print Preview"), wxPoint(100, 100), wxSize(600, 650));
387 frame->Centre(wxBOTH);
388 frame->Initialize();
389 frame->Show();
390 }
391
392 void MyFrame::OnPageSetup(wxCommandEvent& WXUNUSED(event))
393 {
394 (*g_pageSetupData) = *g_printData;
395
396 wxPageSetupDialog pageSetupDialog(this, g_pageSetupData);
397 pageSetupDialog.ShowModal();
398
399 (*g_printData) = pageSetupDialog.GetPageSetupDialogData().GetPrintData();
400 (*g_pageSetupData) = pageSetupDialog.GetPageSetupDialogData();
401 }
402
403 #if defined(__WXMSW__) && wxTEST_POSTSCRIPT_IN_MSW
404 void MyFrame::OnPrintPS(wxCommandEvent& WXUNUSED(event))
405 {
406 wxPostScriptPrinter printer(g_printData);
407 MyPrintout printout(wxT("My printout"));
408 printer.Print(this, &printout, true/*prompt*/);
409
410 (*g_printData) = printer.GetPrintData();
411 }
412
413 void MyFrame::OnPrintPreviewPS(wxCommandEvent& WXUNUSED(event))
414 {
415 // Pass two printout objects: for preview, and possible printing.
416 wxPrintDialogData printDialogData(* g_printData);
417 wxPrintPreview *preview = new wxPrintPreview(new MyPrintout, new MyPrintout, &printDialogData);
418 wxPreviewFrame *frame =
419 new wxPreviewFrame(preview, this, wxT("Demo Print Preview"), wxPoint(100, 100), wxSize(600, 650));
420 frame->Centre(wxBOTH);
421 frame->Initialize();
422 frame->Show();
423 }
424
425 void MyFrame::OnPageSetupPS(wxCommandEvent& WXUNUSED(event))
426 {
427 (*g_pageSetupData) = * g_printData;
428
429 wxGenericPageSetupDialog pageSetupDialog(this, g_pageSetupData);
430 pageSetupDialog.ShowModal();
431
432 (*g_printData) = pageSetupDialog.GetPageSetupDialogData().GetPrintData();
433 (*g_pageSetupData) = pageSetupDialog.GetPageSetupDialogData();
434 }
435 #endif
436
437 #ifdef __WXMAC__
438 void MyFrame::OnPageMargins(wxCommandEvent& WXUNUSED(event))
439 {
440 (*g_pageSetupData) = *g_printData;
441
442 wxMacPageMarginsDialog pageMarginsDialog(this, g_pageSetupData);
443 pageMarginsDialog.ShowModal();
444
445 (*g_printData) = pageMarginsDialog.GetPageSetupDialogData().GetPrintData();
446 (*g_pageSetupData) = pageMarginsDialog.GetPageSetupDialogData();
447 }
448 #endif
449
450 void MyFrame::OnPrintAbout(wxCommandEvent& WXUNUSED(event))
451 {
452 (void)wxMessageBox(wxT("wxWidgets printing demo\nAuthor: Julian Smart"),
453 wxT("About wxWidgets printing demo"), wxOK|wxCENTRE);
454 }
455
456 void MyFrame::OnAngleUp(wxCommandEvent& WXUNUSED(event))
457 {
458 wxGetApp().IncrementAngle();
459 m_canvas->Refresh();
460 }
461
462 void MyFrame::OnAngleDown(wxCommandEvent& WXUNUSED(event))
463 {
464 wxGetApp().DecrementAngle();
465 m_canvas->Refresh();
466 }
467
468
469 // ----------------------------------------------------------------------------
470 // MyCanvas
471 // ----------------------------------------------------------------------------
472
473 BEGIN_EVENT_TABLE(MyCanvas, wxScrolledWindow)
474 // EVT_PAINT(MyCanvas::OnPaint)
475 END_EVENT_TABLE()
476
477 MyCanvas::MyCanvas(wxFrame *frame, const wxPoint&pos, const wxSize&size, long style)
478 : wxScrolledWindow(frame, wxID_ANY, pos, size, style)
479 {
480 SetBackgroundColour(*wxWHITE);
481 }
482
483 //void MyCanvas::OnPaint(wxPaintEvent& WXUNUSED(evt))
484 void MyCanvas::OnDraw(wxDC& dc)
485 {
486 //wxPaintDC dc(this);
487 wxGetApp().Draw(dc);
488 }
489
490
491 // ----------------------------------------------------------------------------
492 // MyPrintout
493 // ----------------------------------------------------------------------------
494
495 bool MyPrintout::OnPrintPage(int page)
496 {
497 wxDC *dc = GetDC();
498 if (dc)
499 {
500 if (page == 1)
501 DrawPageOne();
502 else if (page == 2)
503 DrawPageTwo();
504
505 // Draw page numbers at top left corner of printable area, sized so that
506 // screen size of text matches paper size.
507 MapScreenSizeToPage();
508
509 dc->DrawText(wxString::Format(wxT("PAGE %d"), page), 0, 0);
510
511 return true;
512 }
513 else
514 return false;
515 }
516
517 bool MyPrintout::OnBeginDocument(int startPage, int endPage)
518 {
519 if (!wxPrintout::OnBeginDocument(startPage, endPage))
520 return false;
521
522 return true;
523 }
524
525 void MyPrintout::GetPageInfo(int *minPage, int *maxPage, int *selPageFrom, int *selPageTo)
526 {
527 *minPage = 1;
528 *maxPage = 2;
529 *selPageFrom = 1;
530 *selPageTo = 2;
531 }
532
533 bool MyPrintout::HasPage(int pageNum)
534 {
535 return (pageNum == 1 || pageNum == 2);
536 }
537
538 void MyPrintout::DrawPageOne()
539 {
540 // You might use THIS code if you were scaling graphics of known size to fit
541 // on the page. The commented-out code illustrates different ways of scaling
542 // the graphics.
543
544 // We know the graphic is 230x350. If we didn't know this, we'd need to
545 // calculate it.
546 wxCoord maxX = 230;
547 wxCoord maxY = 350;
548
549 // This sets the user scale and origin of the DC so that the image fits
550 // within the paper rectangle (but the edges could be cut off by printers
551 // that can't print to the edges of the paper -- which is most of them. Use
552 // this if your image already has its own margins.
553 // FitThisSizeToPaper(wxSize(maxX, maxY));
554 // wxRect fitRect = GetLogicalPaperRect();
555
556 // This sets the user scale and origin of the DC so that the image fits
557 // within the page rectangle, which is the printable area on Mac and MSW
558 // and is the entire page on other platforms.
559 // FitThisSizeToPage(wxSize(maxX, maxY));
560 // wxRect fitRect = GetLogicalPageRect();
561
562 // This sets the user scale and origin of the DC so that the image fits
563 // within the page margins as specified by g_PageSetupData, which you can
564 // change (on some platforms, at least) in the Page Setup dialog. Note that
565 // on Mac, the native Page Setup dialog doesn't let you change the margins
566 // of a wxPageSetupDialogData object, so you'll have to write your own dialog or
567 // use the Mac-only wxMacPageMarginsDialog, as we do in this program.
568 FitThisSizeToPageMargins(wxSize(maxX, maxY), *g_pageSetupData);
569 wxRect fitRect = GetLogicalPageMarginsRect(*g_pageSetupData);
570
571 // This sets the user scale and origin of the DC so that the image appears
572 // on the paper at the same size that it appears on screen (i.e., 10-point
573 // type on screen is 10-point on the printed page) and is positioned in the
574 // top left corner of the page rectangle (just as the screen image appears
575 // in the top left corner of the window).
576 // MapScreenSizeToPage();
577 // wxRect fitRect = GetLogicalPageRect();
578
579 // You could also map the screen image to the entire paper at the same size
580 // as it appears on screen.
581 // MapScreenSizeToPaper();
582 // wxRect fitRect = GetLogicalPaperRect();
583
584 // You might also wish to do you own scaling in order to draw objects at
585 // full native device resolution. In this case, you should do the following.
586 // Note that you can use the GetLogicalXXXRect() commands to obtain the
587 // appropriate rect to scale to.
588 // MapScreenSizeToDevice();
589 // wxRect fitRect = GetLogicalPageRect();
590
591 // Each of the preceding Fit or Map routines positions the origin so that
592 // the drawn image is positioned at the top left corner of the reference
593 // rectangle. You can easily center or right- or bottom-justify the image as
594 // follows.
595
596 // This offsets the image so that it is centered within the reference
597 // rectangle defined above.
598 wxCoord xoff = (fitRect.width - maxX) / 2;
599 wxCoord yoff = (fitRect.height - maxY) / 2;
600 OffsetLogicalOrigin(xoff, yoff);
601
602 // This offsets the image so that it is positioned at the bottom right of
603 // the reference rectangle defined above.
604 // wxCoord xoff = (fitRect.width - maxX);
605 // wxCoord yoff = (fitRect.height - maxY);
606 // OffsetLogicalOrigin(xoff, yoff);
607
608 wxGetApp().Draw(*GetDC());
609 }
610
611 void MyPrintout::DrawPageTwo()
612 {
613 // You might use THIS code to set the printer DC to ROUGHLY reflect
614 // the screen text size. This page also draws lines of actual length
615 // 5cm on the page.
616
617 // Compare this to DrawPageOne(), which uses the really convenient routines
618 // from wxPrintout to fit the screen image onto the printed page. This page
619 // illustrates how to do all the scaling calculations yourself, if you're so
620 // inclined.
621
622 wxDC *dc = GetDC();
623
624 // Get the logical pixels per inch of screen and printer
625 int ppiScreenX, ppiScreenY;
626 GetPPIScreen(&ppiScreenX, &ppiScreenY);
627 int ppiPrinterX, ppiPrinterY;
628 GetPPIPrinter(&ppiPrinterX, &ppiPrinterY);
629
630 // This scales the DC so that the printout roughly represents the the screen
631 // scaling. The text point size _should_ be the right size but in fact is
632 // too small for some reason. This is a detail that will need to be
633 // addressed at some point but can be fudged for the moment.
634 float scale = (float)((float)ppiPrinterX/(float)ppiScreenX);
635
636 // Now we have to check in case our real page size is reduced (e.g. because
637 // we're drawing to a print preview memory DC)
638 int pageWidth, pageHeight;
639 int w, h;
640 dc->GetSize(&w, &h);
641 GetPageSizePixels(&pageWidth, &pageHeight);
642
643 // If printer pageWidth == current DC width, then this doesn't change. But w
644 // might be the preview bitmap width, so scale down.
645 float overallScale = scale * (float)(w/(float)pageWidth);
646 dc->SetUserScale(overallScale, overallScale);
647
648 // Calculate conversion factor for converting millimetres into logical
649 // units. There are approx. 25.4 mm to the inch. There are ppi device units
650 // to the inch. Therefore 1 mm corresponds to ppi/25.4 device units. We also
651 // divide by the screen-to-printer scaling factor, because we need to
652 // unscale to pass logical units to DrawLine.
653
654 // Draw 50 mm by 50 mm L shape
655 float logUnitsFactor = (float)(ppiPrinterX/(scale*25.4));
656 float logUnits = (float)(50*logUnitsFactor);
657 dc->SetPen(* wxBLACK_PEN);
658 dc->DrawLine(50, 250, (long)(50.0 + logUnits), 250);
659 dc->DrawLine(50, 250, 50, (long)(250.0 + logUnits));
660
661 dc->SetBackgroundMode(wxTRANSPARENT);
662 dc->SetBrush(*wxTRANSPARENT_BRUSH);
663
664 { // GetTextExtent demo:
665 wxString words[7] = { wxT("This "), wxT("is "), wxT("GetTextExtent "),
666 wxT("testing "), wxT("string. "), wxT("Enjoy "), wxT("it!") };
667 wxCoord w, h;
668 long x = 200, y= 250;
669 wxFont fnt(15, wxSWISS, wxNORMAL, wxNORMAL);
670
671 dc->SetFont(fnt);
672
673 for (int i = 0; i < 7; i++)
674 {
675 wxString word = words[i];
676 word.Remove( word.Len()-1, 1 );
677 dc->GetTextExtent(word, &w, &h);
678 dc->DrawRectangle(x, y, w, h);
679 dc->GetTextExtent(words[i], &w, &h);
680 dc->DrawText(words[i], x, y);
681 x += w;
682 }
683
684 }
685
686 dc->SetFont(wxGetApp().GetTestFont());
687
688 dc->DrawText(wxT("Some test text"), 200, 300 );
689
690 // TESTING
691
692 int leftMargin = 20;
693 int rightMargin = 20;
694 int topMargin = 20;
695 int bottomMargin = 20;
696
697 int pageWidthMM, pageHeightMM;
698 GetPageSizeMM(&pageWidthMM, &pageHeightMM);
699
700 float leftMarginLogical = (float)(logUnitsFactor*leftMargin);
701 float topMarginLogical = (float)(logUnitsFactor*topMargin);
702 float bottomMarginLogical = (float)(logUnitsFactor*(pageHeightMM - bottomMargin));
703 float rightMarginLogical = (float)(logUnitsFactor*(pageWidthMM - rightMargin));
704
705 dc->SetPen(* wxRED_PEN);
706 dc->DrawLine( (long)leftMarginLogical, (long)topMarginLogical,
707 (long)rightMarginLogical, (long)topMarginLogical);
708 dc->DrawLine( (long)leftMarginLogical, (long)bottomMarginLogical,
709 (long)rightMarginLogical, (long)bottomMarginLogical);
710
711 WritePageHeader(this, dc, wxT("A header"), logUnitsFactor);
712 }
713
714 // Writes a header on a page. Margin units are in millimetres.
715 bool MyPrintout::WritePageHeader(wxPrintout *printout, wxDC *dc, const wxString&text, float mmToLogical)
716 {
717 #if 0
718 static wxFont *headerFont = (wxFont *) NULL;
719 if (!headerFont)
720 {
721 headerFont = wxTheFontList->FindOrCreateFont(16, wxSWISS, wxNORMAL, wxBOLD);
722 }
723 dc->SetFont(headerFont);
724 #endif
725
726 int pageWidthMM, pageHeightMM;
727
728 printout->GetPageSizeMM(&pageWidthMM, &pageHeightMM);
729 wxUnusedVar(pageHeightMM);
730
731 int leftMargin = 10;
732 int topMargin = 10;
733 int rightMargin = 10;
734
735 float leftMarginLogical = (float)(mmToLogical*leftMargin);
736 float topMarginLogical = (float)(mmToLogical*topMargin);
737 float rightMarginLogical = (float)(mmToLogical*(pageWidthMM - rightMargin));
738
739 wxCoord xExtent, yExtent;
740 dc->GetTextExtent(text, &xExtent, &yExtent);
741
742 float xPos = (float)(((((pageWidthMM - leftMargin - rightMargin)/2.0)+leftMargin)*mmToLogical) - (xExtent/2.0));
743 dc->DrawText(text, (long)xPos, (long)topMarginLogical);
744
745 dc->SetPen(* wxBLACK_PEN);
746 dc->DrawLine( (long)leftMarginLogical, (long)(topMarginLogical+yExtent),
747 (long)rightMarginLogical, (long)topMarginLogical+yExtent );
748
749 return true;
750 }