]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/html/htmprint.cpp
Applied [ 1708971 ] Make a virtual function to enable/disable docking
[wxWidgets.git] / src / html / htmprint.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/html/htmprint.cpp
3// Purpose: html printing classes
4// Author: Vaclav Slavik
5// Created: 25/09/99
6// RCS-ID: $Id$
7// Copyright: (c) Vaclav Slavik, 1999
8// Licence: wxWindows licence
9/////////////////////////////////////////////////////////////////////////////
10
11// For compilers that support precompilation, includes "wx/wx.h".
12#include "wx/wxprec.h"
13
14#ifdef __BORLANDC__
15 #pragma hdrstop
16#endif
17
18#if wxUSE_HTML && wxUSE_PRINTING_ARCHITECTURE && wxUSE_STREAMS
19
20#ifndef WX_PRECOMP
21 #include "wx/log.h"
22 #include "wx/intl.h"
23 #include "wx/dc.h"
24 #include "wx/settings.h"
25 #include "wx/msgdlg.h"
26 #include "wx/module.h"
27#endif
28
29#include "wx/print.h"
30#include "wx/printdlg.h"
31#include "wx/html/htmprint.h"
32#include "wx/wxhtml.h"
33#include "wx/wfstream.h"
34
35
36//--------------------------------------------------------------------------------
37// wxHtmlDCRenderer
38//--------------------------------------------------------------------------------
39
40
41wxHtmlDCRenderer::wxHtmlDCRenderer() : wxObject()
42{
43 m_DC = NULL;
44 m_Width = m_Height = 0;
45 m_Cells = NULL;
46 m_Parser = new wxHtmlWinParser();
47 m_FS = new wxFileSystem();
48 m_Parser->SetFS(m_FS);
49}
50
51
52
53wxHtmlDCRenderer::~wxHtmlDCRenderer()
54{
55 if (m_Cells) delete m_Cells;
56 if (m_Parser) delete m_Parser;
57 if (m_FS) delete m_FS;
58}
59
60
61
62void wxHtmlDCRenderer::SetDC(wxDC *dc, double pixel_scale)
63{
64 m_DC = dc;
65 m_Parser->SetDC(m_DC, pixel_scale);
66}
67
68
69
70void wxHtmlDCRenderer::SetSize(int width, int height)
71{
72 m_Width = width;
73 m_Height = height;
74}
75
76
77void wxHtmlDCRenderer::SetHtmlText(const wxString& html, const wxString& basepath, bool isdir)
78{
79 if (m_DC == NULL) return;
80
81 if (m_Cells != NULL) delete m_Cells;
82
83 m_FS->ChangePathTo(basepath, isdir);
84 m_Cells = (wxHtmlContainerCell*) m_Parser->Parse(html);
85 m_Cells->SetIndent(0, wxHTML_INDENT_ALL, wxHTML_UNITS_PIXELS);
86 m_Cells->Layout(m_Width);
87}
88
89
90void wxHtmlDCRenderer::SetFonts(const wxString& normal_face, const wxString& fixed_face,
91 const int *sizes)
92{
93 m_Parser->SetFonts(normal_face, fixed_face, sizes);
94 if (m_DC == NULL && m_Cells != NULL)
95 m_Cells->Layout(m_Width);
96}
97
98void wxHtmlDCRenderer::SetStandardFonts(int size,
99 const wxString& normal_face,
100 const wxString& fixed_face)
101{
102 m_Parser->SetStandardFonts(size, normal_face, fixed_face);
103 if (m_DC == NULL && m_Cells != NULL)
104 m_Cells->Layout(m_Width);
105}
106
107int wxHtmlDCRenderer::Render(int x, int y,
108 wxArrayInt& known_pagebreaks,
109 int from, int dont_render, int to)
110{
111 int pbreak, hght;
112
113 if (m_Cells == NULL || m_DC == NULL) return 0;
114
115 pbreak = (int)(from + m_Height);
116 while (m_Cells->AdjustPagebreak(&pbreak, known_pagebreaks)) {}
117 hght = pbreak - from;
118 if(to < hght)
119 hght = to;
120
121 if (!dont_render)
122 {
123 wxHtmlRenderingInfo rinfo;
124 wxDefaultHtmlRenderingStyle rstyle;
125 rinfo.SetStyle(&rstyle);
126 m_DC->SetBrush(*wxWHITE_BRUSH);
127 m_DC->SetClippingRegion(x, y, m_Width, hght);
128 m_Cells->Draw(*m_DC,
129 x, (y - from),
130 y, pbreak + (y /*- from*/),
131 rinfo);
132 m_DC->DestroyClippingRegion();
133 }
134
135 if (pbreak < m_Cells->GetHeight()) return pbreak;
136 else return GetTotalHeight();
137}
138
139
140int wxHtmlDCRenderer::GetTotalHeight()
141{
142 if (m_Cells) return m_Cells->GetHeight();
143 else return 0;
144}
145
146
147//--------------------------------------------------------------------------------
148// wxHtmlPrintout
149//--------------------------------------------------------------------------------
150
151
152wxList wxHtmlPrintout::m_Filters;
153
154wxHtmlPrintout::wxHtmlPrintout(const wxString& title) : wxPrintout(title)
155{
156 m_Renderer = new wxHtmlDCRenderer;
157 m_RendererHdr = new wxHtmlDCRenderer;
158 m_NumPages = wxHTML_PRINT_MAX_PAGES;
159 m_Document = m_BasePath = wxEmptyString; m_BasePathIsDir = true;
160 m_Headers[0] = m_Headers[1] = wxEmptyString;
161 m_Footers[0] = m_Footers[1] = wxEmptyString;
162 m_HeaderHeight = m_FooterHeight = 0;
163 SetMargins(); // to default values
164}
165
166
167
168wxHtmlPrintout::~wxHtmlPrintout()
169{
170 delete m_Renderer;
171 delete m_RendererHdr;
172}
173
174void wxHtmlPrintout::CleanUpStatics()
175{
176 WX_CLEAR_LIST(wxList, m_Filters);
177}
178
179// Adds input filter
180void wxHtmlPrintout::AddFilter(wxHtmlFilter *filter)
181{
182 m_Filters.Append(filter);
183}
184
185void wxHtmlPrintout::OnPreparePrinting()
186{
187 int pageWidth, pageHeight, mm_w, mm_h, scr_w, scr_h, dc_w, dc_h;
188 float ppmm_h, ppmm_v;
189
190 GetPageSizePixels(&pageWidth, &pageHeight);
191 GetPageSizeMM(&mm_w, &mm_h);
192 ppmm_h = (float)pageWidth / mm_w;
193 ppmm_v = (float)pageHeight / mm_h;
194
195 int ppiPrinterX, ppiPrinterY;
196 GetPPIPrinter(&ppiPrinterX, &ppiPrinterY);
197 int ppiScreenX, ppiScreenY;
198 GetPPIScreen(&ppiScreenX, &ppiScreenY);
199
200 wxDisplaySize(&scr_w, &scr_h);
201 GetDC()->GetSize(&dc_w, &dc_h);
202
203 GetDC()->SetUserScale((double)dc_w / (double)pageWidth, (double)dc_w / (double)pageWidth);
204
205 /* prepare headers/footers renderer: */
206
207 m_RendererHdr->SetDC(GetDC(), (double)ppiPrinterY / (double)ppiScreenY);
208 m_RendererHdr->SetSize((int) (ppmm_h * (mm_w - m_MarginLeft - m_MarginRight)),
209 (int) (ppmm_v * (mm_h - m_MarginTop - m_MarginBottom)));
210 if (m_Headers[0] != wxEmptyString)
211 {
212 m_RendererHdr->SetHtmlText(TranslateHeader(m_Headers[0], 1));
213 m_HeaderHeight = m_RendererHdr->GetTotalHeight();
214 }
215 else if (m_Headers[1] != wxEmptyString)
216 {
217 m_RendererHdr->SetHtmlText(TranslateHeader(m_Headers[1], 1));
218 m_HeaderHeight = m_RendererHdr->GetTotalHeight();
219 }
220 if (m_Footers[0] != wxEmptyString)
221 {
222 m_RendererHdr->SetHtmlText(TranslateHeader(m_Footers[0], 1));
223 m_FooterHeight = m_RendererHdr->GetTotalHeight();
224 }
225 else if (m_Footers[1] != wxEmptyString)
226 {
227 m_RendererHdr->SetHtmlText(TranslateHeader(m_Footers[1], 1));
228 m_FooterHeight = m_RendererHdr->GetTotalHeight();
229 }
230
231 /* prepare main renderer: */
232 m_Renderer->SetDC(GetDC(), (double)ppiPrinterY / (double)ppiScreenY);
233 m_Renderer->SetSize((int) (ppmm_h * (mm_w - m_MarginLeft - m_MarginRight)),
234 (int) (ppmm_v * (mm_h - m_MarginTop - m_MarginBottom) -
235 m_FooterHeight - m_HeaderHeight -
236 ((m_HeaderHeight == 0) ? 0 : m_MarginSpace * ppmm_v) -
237 ((m_FooterHeight == 0) ? 0 : m_MarginSpace * ppmm_v)
238 ));
239 m_Renderer->SetHtmlText(m_Document, m_BasePath, m_BasePathIsDir);
240 CountPages();
241}
242
243bool wxHtmlPrintout::OnBeginDocument(int startPage, int endPage)
244{
245 if (!wxPrintout::OnBeginDocument(startPage, endPage)) return false;
246
247 return true;
248}
249
250
251bool wxHtmlPrintout::OnPrintPage(int page)
252{
253 wxDC *dc = GetDC();
254 if (dc)
255 {
256 if (HasPage(page))
257 RenderPage(dc, page);
258 return true;
259 }
260 else return false;
261}
262
263
264void wxHtmlPrintout::GetPageInfo(int *minPage, int *maxPage, int *selPageFrom, int *selPageTo)
265{
266 *minPage = 1;
267 if ( m_NumPages >= (signed)m_PageBreaks.GetCount()-1)
268 *maxPage = m_NumPages;
269 else
270 *maxPage = (signed)m_PageBreaks.GetCount()-1;
271 *selPageFrom = 1;
272 *selPageTo = (signed)m_PageBreaks.GetCount()-1;
273}
274
275
276
277bool wxHtmlPrintout::HasPage(int pageNum)
278{
279 return pageNum > 0 && (unsigned)pageNum < m_PageBreaks.GetCount();
280}
281
282
283
284void wxHtmlPrintout::SetHtmlText(const wxString& html, const wxString &basepath, bool isdir)
285{
286 m_Document = html;
287 m_BasePath = basepath;
288 m_BasePathIsDir = isdir;
289}
290
291void wxHtmlPrintout::SetHtmlFile(const wxString& htmlfile)
292{
293 wxFileSystem fs;
294 wxFSFile *ff;
295
296 if (wxFileExists(htmlfile))
297 ff = fs.OpenFile(wxFileSystem::FileNameToURL(htmlfile));
298 else
299 ff = fs.OpenFile(htmlfile);
300
301 if (ff == NULL)
302 {
303 wxLogError(htmlfile + _(": file does not exist!"));
304 return;
305 }
306
307 bool done = false;
308 wxHtmlFilterHTML defaultFilter;
309 wxString doc;
310
311 wxList::compatibility_iterator node = m_Filters.GetFirst();
312 while (node)
313 {
314 wxHtmlFilter *h = (wxHtmlFilter*) node->GetData();
315 if (h->CanRead(*ff))
316 {
317 doc = h->ReadFile(*ff);
318 done = true;
319 break;
320 }
321 node = node->GetNext();
322 }
323
324 if (!done)
325 doc = defaultFilter.ReadFile(*ff);
326
327 SetHtmlText(doc, htmlfile, false);
328 delete ff;
329}
330
331
332
333void wxHtmlPrintout::SetHeader(const wxString& header, int pg)
334{
335 if (pg == wxPAGE_ALL || pg == wxPAGE_EVEN)
336 m_Headers[0] = header;
337 if (pg == wxPAGE_ALL || pg == wxPAGE_ODD)
338 m_Headers[1] = header;
339}
340
341
342
343void wxHtmlPrintout::SetFooter(const wxString& footer, int pg)
344{
345 if (pg == wxPAGE_ALL || pg == wxPAGE_EVEN)
346 m_Footers[0] = footer;
347 if (pg == wxPAGE_ALL || pg == wxPAGE_ODD)
348 m_Footers[1] = footer;
349}
350
351
352
353void wxHtmlPrintout::CountPages()
354{
355 wxBusyCursor wait;
356 int pageWidth, pageHeight, mm_w, mm_h;
357 float ppmm_h, ppmm_v;
358
359 GetPageSizePixels(&pageWidth, &pageHeight);
360 GetPageSizeMM(&mm_w, &mm_h);
361 ppmm_h = (float)pageWidth / mm_w;
362 ppmm_v = (float)pageHeight / mm_h;
363
364 int pos = 0;
365 m_NumPages = 0;
366 // m_PageBreaks[0] = 0;
367
368 m_PageBreaks.Clear();
369 m_PageBreaks.Add( 0);
370 do
371 {
372 pos = m_Renderer->Render((int)( ppmm_h * m_MarginLeft),
373 (int) (ppmm_v * (m_MarginTop + (m_HeaderHeight == 0 ? 0 : m_MarginSpace)) + m_HeaderHeight),
374 m_PageBreaks,
375 pos, true, INT_MAX);
376 m_PageBreaks.Add( pos);
377 if( m_PageBreaks.GetCount() > wxHTML_PRINT_MAX_PAGES)
378 {
379 wxMessageBox( _("HTML pagination algorithm generated more than the allowed maximum number of pages and it can't continue any longer!"),
380 _("Warning"), wxCANCEL | wxICON_ERROR );
381 break;
382 }
383 } while (pos < m_Renderer->GetTotalHeight());
384}
385
386
387
388void wxHtmlPrintout::RenderPage(wxDC *dc, int page)
389{
390 wxBusyCursor wait;
391
392 int pageWidth, pageHeight, mm_w, mm_h, scr_w, scr_h, dc_w, dc_h;
393 float ppmm_h, ppmm_v;
394
395 GetPageSizePixels(&pageWidth, &pageHeight);
396 GetPageSizeMM(&mm_w, &mm_h);
397 ppmm_h = (float)pageWidth / mm_w;
398 ppmm_v = (float)pageHeight / mm_h;
399 wxDisplaySize(&scr_w, &scr_h);
400 dc->GetSize(&dc_w, &dc_h);
401
402 int ppiPrinterX, ppiPrinterY;
403 GetPPIPrinter(&ppiPrinterX, &ppiPrinterY);
404 wxUnusedVar(ppiPrinterX);
405 int ppiScreenX, ppiScreenY;
406 GetPPIScreen(&ppiScreenX, &ppiScreenY);
407 wxUnusedVar(ppiScreenX);
408
409 dc->SetUserScale((double)dc_w / (double)pageWidth, (double)dc_w / (double)pageWidth);
410
411 m_Renderer->SetDC(dc, (double)ppiPrinterY / (double)ppiScreenY);
412
413 dc->SetBackgroundMode(wxTRANSPARENT);
414
415 m_Renderer->Render((int) (ppmm_h * m_MarginLeft),
416 (int) (ppmm_v * (m_MarginTop + (m_HeaderHeight == 0 ? 0 : m_MarginSpace)) + m_HeaderHeight), m_PageBreaks,
417 m_PageBreaks[page-1], false, m_PageBreaks[page]-m_PageBreaks[page-1]);
418
419
420 m_RendererHdr->SetDC(dc, (double)ppiPrinterY / (double)ppiScreenY);
421 if (m_Headers[page % 2] != wxEmptyString)
422 {
423 m_RendererHdr->SetHtmlText(TranslateHeader(m_Headers[page % 2], page));
424 m_RendererHdr->Render((int) (ppmm_h * m_MarginLeft), (int) (ppmm_v * m_MarginTop), m_PageBreaks);
425 }
426 if (m_Footers[page % 2] != wxEmptyString)
427 {
428 m_RendererHdr->SetHtmlText(TranslateHeader(m_Footers[page % 2], page));
429 m_RendererHdr->Render((int) (ppmm_h * m_MarginLeft), (int) (pageHeight - ppmm_v * m_MarginBottom - m_FooterHeight), m_PageBreaks);
430 }
431}
432
433
434
435wxString wxHtmlPrintout::TranslateHeader(const wxString& instr, int page)
436{
437 wxString r = instr;
438 wxString num;
439
440 num.Printf(wxT("%i"), page);
441 r.Replace(wxT("@PAGENUM@"), num);
442
443 num.Printf(wxT("%lu"), (unsigned long)(m_PageBreaks.GetCount() - 1));
444 r.Replace(wxT("@PAGESCNT@"), num);
445
446 const wxDateTime now = wxDateTime::Now();
447 r.Replace(wxT("@DATE@"), now.FormatDate());
448 r.Replace(wxT("@TIME@"), now.FormatTime());
449
450 r.Replace(wxT("@TITLE@"), GetTitle());
451
452 return r;
453}
454
455
456
457void wxHtmlPrintout::SetMargins(float top, float bottom, float left, float right, float spaces)
458{
459 m_MarginTop = top;
460 m_MarginBottom = bottom;
461 m_MarginLeft = left;
462 m_MarginRight = right;
463 m_MarginSpace = spaces;
464}
465
466
467
468
469void wxHtmlPrintout::SetFonts(const wxString& normal_face, const wxString& fixed_face,
470 const int *sizes)
471{
472 m_Renderer->SetFonts(normal_face, fixed_face, sizes);
473 m_RendererHdr->SetFonts(normal_face, fixed_face, sizes);
474}
475
476void wxHtmlPrintout::SetStandardFonts(int size,
477 const wxString& normal_face,
478 const wxString& fixed_face)
479{
480 m_Renderer->SetStandardFonts(size, normal_face, fixed_face);
481 m_RendererHdr->SetStandardFonts(size, normal_face, fixed_face);
482}
483
484
485
486//----------------------------------------------------------------------------
487// wxHtmlEasyPrinting
488//----------------------------------------------------------------------------
489
490
491wxHtmlEasyPrinting::wxHtmlEasyPrinting(const wxString& name, wxWindow *parentWindow)
492{
493 m_ParentWindow = parentWindow;
494 m_Name = name;
495 m_PrintData = NULL;
496 m_PageSetupData = new wxPageSetupDialogData;
497 m_Headers[0] = m_Headers[1] = m_Footers[0] = m_Footers[1] = wxEmptyString;
498
499 m_PageSetupData->EnableMargins(true);
500 m_PageSetupData->SetMarginTopLeft(wxPoint(25, 25));
501 m_PageSetupData->SetMarginBottomRight(wxPoint(25, 25));
502
503 SetFonts(wxEmptyString, wxEmptyString, NULL);
504}
505
506
507
508wxHtmlEasyPrinting::~wxHtmlEasyPrinting()
509{
510 delete m_PrintData;
511 delete m_PageSetupData;
512}
513
514
515wxPrintData *wxHtmlEasyPrinting::GetPrintData()
516{
517 if (m_PrintData == NULL)
518 m_PrintData = new wxPrintData();
519 return m_PrintData;
520}
521
522
523bool wxHtmlEasyPrinting::PreviewFile(const wxString &htmlfile)
524{
525 wxHtmlPrintout *p1 = CreatePrintout();
526 p1->SetHtmlFile(htmlfile);
527 wxHtmlPrintout *p2 = CreatePrintout();
528 p2->SetHtmlFile(htmlfile);
529 return DoPreview(p1, p2);
530}
531
532
533
534bool wxHtmlEasyPrinting::PreviewText(const wxString &htmltext, const wxString &basepath)
535{
536 wxHtmlPrintout *p1 = CreatePrintout();
537 p1->SetHtmlText(htmltext, basepath, true);
538 wxHtmlPrintout *p2 = CreatePrintout();
539 p2->SetHtmlText(htmltext, basepath, true);
540 return DoPreview(p1, p2);
541}
542
543
544
545bool wxHtmlEasyPrinting::PrintFile(const wxString &htmlfile)
546{
547 wxHtmlPrintout *p = CreatePrintout();
548 p->SetHtmlFile(htmlfile);
549 bool ret = DoPrint(p);
550 delete p;
551 return ret;
552}
553
554
555
556bool wxHtmlEasyPrinting::PrintText(const wxString &htmltext, const wxString &basepath)
557{
558 wxHtmlPrintout *p = CreatePrintout();
559 p->SetHtmlText(htmltext, basepath, true);
560 bool ret = DoPrint(p);
561 delete p;
562 return ret;
563}
564
565
566
567bool wxHtmlEasyPrinting::DoPreview(wxHtmlPrintout *printout1, wxHtmlPrintout *printout2)
568{
569 // Pass two printout objects: for preview, and possible printing.
570 wxPrintDialogData printDialogData(*GetPrintData());
571 wxPrintPreview *preview = new wxPrintPreview(printout1, printout2, &printDialogData);
572 if (!preview->Ok())
573 {
574 delete preview;
575 return false;
576 }
577
578 wxPreviewFrame *frame = new wxPreviewFrame(preview, m_ParentWindow,
579 m_Name + _(" Preview"),
580 wxPoint(100, 100), wxSize(650, 500));
581 frame->Centre(wxBOTH);
582 frame->Initialize();
583 frame->Show(true);
584 return true;
585}
586
587
588
589bool wxHtmlEasyPrinting::DoPrint(wxHtmlPrintout *printout)
590{
591 wxPrintDialogData printDialogData(*GetPrintData());
592 wxPrinter printer(&printDialogData);
593
594 if (!printer.Print(m_ParentWindow, printout, true))
595 {
596 return false;
597 }
598
599 (*GetPrintData()) = printer.GetPrintDialogData().GetPrintData();
600 return true;
601}
602
603
604
605
606void wxHtmlEasyPrinting::PageSetup()
607{
608 if (!GetPrintData()->Ok())
609 {
610 wxLogError(_("There was a problem during page setup: you may need to set a default printer."));
611 return;
612 }
613
614 m_PageSetupData->SetPrintData(*GetPrintData());
615 wxPageSetupDialog pageSetupDialog(m_ParentWindow, m_PageSetupData);
616
617 if (pageSetupDialog.ShowModal() == wxID_OK)
618 {
619 (*GetPrintData()) = pageSetupDialog.GetPageSetupData().GetPrintData();
620 (*m_PageSetupData) = pageSetupDialog.GetPageSetupData();
621 }
622}
623
624
625
626void wxHtmlEasyPrinting::SetHeader(const wxString& header, int pg)
627{
628 if (pg == wxPAGE_ALL || pg == wxPAGE_EVEN)
629 m_Headers[0] = header;
630 if (pg == wxPAGE_ALL || pg == wxPAGE_ODD)
631 m_Headers[1] = header;
632}
633
634
635
636void wxHtmlEasyPrinting::SetFooter(const wxString& footer, int pg)
637{
638 if (pg == wxPAGE_ALL || pg == wxPAGE_EVEN)
639 m_Footers[0] = footer;
640 if (pg == wxPAGE_ALL || pg == wxPAGE_ODD)
641 m_Footers[1] = footer;
642}
643
644
645void wxHtmlEasyPrinting::SetFonts(const wxString& normal_face, const wxString& fixed_face,
646 const int *sizes)
647{
648 m_fontMode = FontMode_Explicit;
649 m_FontFaceNormal = normal_face;
650 m_FontFaceFixed = fixed_face;
651
652 if (sizes)
653 {
654 m_FontsSizes = m_FontsSizesArr;
655 for (int i = 0; i < 7; i++) m_FontsSizes[i] = sizes[i];
656 }
657 else
658 m_FontsSizes = NULL;
659}
660
661void wxHtmlEasyPrinting::SetStandardFonts(int size,
662 const wxString& normal_face,
663 const wxString& fixed_face)
664{
665 m_fontMode = FontMode_Standard;
666 m_FontFaceNormal = normal_face;
667 m_FontFaceFixed = fixed_face;
668 m_FontsSizesArr[0] = size;
669}
670
671
672wxHtmlPrintout *wxHtmlEasyPrinting::CreatePrintout()
673{
674 wxHtmlPrintout *p = new wxHtmlPrintout(m_Name);
675
676 if (m_fontMode == FontMode_Explicit)
677 {
678 p->SetFonts(m_FontFaceNormal, m_FontFaceFixed, m_FontsSizes);
679 }
680 else // FontMode_Standard
681 {
682 p->SetStandardFonts(m_FontsSizesArr[0],
683 m_FontFaceNormal, m_FontFaceFixed);
684 }
685
686 p->SetHeader(m_Headers[0], wxPAGE_EVEN);
687 p->SetHeader(m_Headers[1], wxPAGE_ODD);
688 p->SetFooter(m_Footers[0], wxPAGE_EVEN);
689 p->SetFooter(m_Footers[1], wxPAGE_ODD);
690
691 p->SetMargins(m_PageSetupData->GetMarginTopLeft().y,
692 m_PageSetupData->GetMarginBottomRight().y,
693 m_PageSetupData->GetMarginTopLeft().x,
694 m_PageSetupData->GetMarginBottomRight().x);
695
696 return p;
697}
698
699// A module to allow initialization/cleanup
700// without calling these functions from app.cpp or from
701// the user's application.
702
703class wxHtmlPrintingModule: public wxModule
704{
705DECLARE_DYNAMIC_CLASS(wxHtmlPrintingModule)
706public:
707 wxHtmlPrintingModule() : wxModule() {}
708 bool OnInit() { return true; }
709 void OnExit() { wxHtmlPrintout::CleanUpStatics(); }
710};
711
712IMPLEMENT_DYNAMIC_CLASS(wxHtmlPrintingModule, wxModule)
713
714
715// This hack forces the linker to always link in m_* files
716// (wxHTML doesn't work without handlers from these files)
717#include "wx/html/forcelnk.h"
718FORCE_WXHTML_MODULES()
719
720#endif // wxUSE_HTML & wxUSE_PRINTING_ARCHITECTURE