]> git.saurik.com Git - wxWidgets.git/blob - src/html/htmprint.cpp
Initial revision
[wxWidgets.git] / src / html / htmprint.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: 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
12 #ifdef __GNUG__
13 #pragma implementation
14 #endif
15
16 // For compilers that support precompilation, includes "wx/wx.h".
17 #include "wx/wxprec.h"
18
19 #include "wx/defs.h"
20
21 #ifdef __BORLANDC__
22 #pragma hdrstop
23 #endif
24
25 #ifndef WX_PRECOMP
26 #include "wx/wx.h"
27 #endif
28
29 #if wxUSE_HTML & wxUSE_PRINTING_ARCHITECTURE
30
31 #include "wx/print.h"
32 #include "wx/printdlg.h"
33 #include "wx/html/htmprint.h"
34 #include "wx/wxhtml.h"
35 #include "wx/wfstream.h"
36
37
38 //--------------------------------------------------------------------------------
39 // wxHtmlDCRenderer
40 //--------------------------------------------------------------------------------
41
42
43 wxHtmlDCRenderer::wxHtmlDCRenderer() : wxObject()
44 {
45 m_DC = NULL;
46 m_Width = m_Height = 0;
47 m_Cells = NULL;
48 m_Parser = new wxHtmlWinParser(NULL);
49 m_FS = new wxFileSystem();
50 m_Parser -> SetFS(m_FS);
51 }
52
53
54
55 wxHtmlDCRenderer::~wxHtmlDCRenderer()
56 {
57 if (m_Cells) delete m_Cells;
58 if (m_Parser) delete m_Parser;
59 if (m_FS) delete m_FS;
60 }
61
62
63
64 void wxHtmlDCRenderer::SetDC(wxDC *dc, double pixel_scale)
65 {
66 m_DC = dc;
67 m_Parser -> SetDC(m_DC, pixel_scale);
68 }
69
70
71
72 void wxHtmlDCRenderer::SetSize(int width, int height)
73 {
74 m_Width = width;
75 m_Height = height;
76 }
77
78
79
80 void wxHtmlDCRenderer::SetHtmlText(const wxString& html, const wxString& basepath, bool isdir)
81 {
82 if (m_DC == NULL) return;
83
84 if (m_Cells != NULL) delete m_Cells;
85
86 m_FS -> ChangePathTo(basepath, isdir);
87 m_Cells = (wxHtmlContainerCell*) m_Parser -> Parse(html);
88 m_Cells -> SetIndent(0, wxHTML_INDENT_ALL, wxHTML_UNITS_PIXELS);
89 m_Cells -> Layout(m_Width);
90 }
91
92
93
94 int wxHtmlDCRenderer::Render(int x, int y, int from, int dont_render)
95 {
96 int pbreak, hght;
97
98 if (m_Cells == NULL || m_DC == NULL) return 0;
99
100 pbreak = (int)(from + m_Height);
101 while (m_Cells -> AdjustPagebreak(&pbreak)) {}
102 hght = pbreak - from;
103
104 if (!dont_render) {
105 m_DC -> SetBrush(*wxWHITE_BRUSH);
106
107 m_DC -> SetClippingRegion(x, y, m_Width, hght);
108 m_Cells -> Draw(*m_DC,
109 x, (y - from),
110 y, pbreak + (y /*- from*/));
111 m_DC -> DestroyClippingRegion();
112 }
113
114 if (pbreak < m_Cells -> GetHeight()) return pbreak;
115 else return GetTotalHeight();
116 }
117
118
119
120 int wxHtmlDCRenderer::GetTotalHeight()
121 {
122 if (m_Cells) return m_Cells -> GetHeight();
123 else return 0;
124 }
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141 //--------------------------------------------------------------------------------
142 // wxHtmlPrintout
143 //--------------------------------------------------------------------------------
144
145
146
147 wxHtmlPrintout::wxHtmlPrintout(const wxString& title) : wxPrintout(title)
148 {
149 m_Renderer = new wxHtmlDCRenderer;
150 m_RendererHdr = new wxHtmlDCRenderer;
151 m_NumPages = wxHTML_PRINT_MAX_PAGES;
152 m_Document = m_BasePath = wxEmptyString; m_BasePathIsDir = TRUE;
153 m_Headers[0] = m_Headers[1] = wxEmptyString;
154 m_Footers[0] = m_Footers[1] = wxEmptyString;
155 m_HeaderHeight = m_FooterHeight = 0;
156 SetMargins(); // to default values
157 }
158
159
160
161 wxHtmlPrintout::~wxHtmlPrintout()
162 {
163 delete m_Renderer;
164 delete m_RendererHdr;
165 }
166
167
168
169 bool wxHtmlPrintout::OnBeginDocument(int startPage, int endPage)
170 {
171 int pageWidth, pageHeight, mm_w, mm_h, scr_w, scr_h, dc_w, dc_h;
172 float ppmm_h, ppmm_v;
173
174 if (!wxPrintout::OnBeginDocument(startPage, endPage)) return FALSE;
175
176 GetPageSizePixels(&pageWidth, &pageHeight);
177 GetPageSizeMM(&mm_w, &mm_h);
178 ppmm_h = (float)pageWidth / mm_w;
179 ppmm_v = (float)pageHeight / mm_h;
180
181 int ppiPrinterX, ppiPrinterY;
182 GetPPIPrinter(&ppiPrinterX, &ppiPrinterY);
183 int ppiScreenX, ppiScreenY;
184 GetPPIScreen(&ppiScreenX, &ppiScreenY);
185
186 wxDisplaySize(&scr_w, &scr_h);
187 GetDC() -> GetSize(&dc_w, &dc_h);
188
189 GetDC() -> SetUserScale((double)dc_w / (double)pageWidth, (double)dc_w / (double)pageWidth);
190
191 /* prepare headers/footers renderer: */
192
193 m_RendererHdr -> SetDC(GetDC(), (double)ppiPrinterY / (double)ppiScreenY);
194 m_RendererHdr -> SetSize(ppmm_h * (mm_w - m_MarginLeft - m_MarginTop),
195 ppmm_v * (mm_h - m_MarginTop - m_MarginBottom));
196 if (m_Headers[0] != wxEmptyString) {
197 m_RendererHdr -> SetHtmlText(TranslateHeader(m_Headers[0], 1));
198 m_HeaderHeight = m_RendererHdr -> GetTotalHeight();
199 }
200 else if (m_Headers[1] != wxEmptyString) {
201 m_RendererHdr -> SetHtmlText(TranslateHeader(m_Headers[1], 1));
202 m_HeaderHeight = m_RendererHdr -> GetTotalHeight();
203 }
204 if (m_Footers[0] != wxEmptyString) {
205 m_RendererHdr -> SetHtmlText(TranslateHeader(m_Footers[0], 1));
206 m_FooterHeight = m_RendererHdr -> GetTotalHeight();
207 }
208 else if (m_Footers[1] != wxEmptyString) {
209 m_RendererHdr -> SetHtmlText(TranslateHeader(m_Footers[1], 1));
210 m_FooterHeight = m_RendererHdr -> GetTotalHeight();
211 }
212
213 /* prepare main renderer: */
214 m_Renderer -> SetDC(GetDC(), (double)ppiPrinterY / (double)ppiScreenY);
215 m_Renderer -> SetSize(ppmm_h * (mm_w - m_MarginLeft - m_MarginTop),
216 ppmm_v * (mm_h - m_MarginTop - m_MarginBottom) -
217 m_FooterHeight - m_HeaderHeight -
218 ((m_HeaderHeight == 0) ? 0 : m_MarginSpace * ppmm_v) -
219 ((m_FooterHeight == 0) ? 0 : m_MarginSpace * ppmm_v)
220 );
221 m_Renderer -> SetHtmlText(m_Document, m_BasePath, m_BasePathIsDir);
222 CountPages();
223 return TRUE;
224 }
225
226
227 bool wxHtmlPrintout::OnPrintPage(int page)
228 {
229 wxDC *dc = GetDC();
230 if (dc) {
231 if (HasPage(page))
232 RenderPage(dc, page);
233 return TRUE;
234 } else
235 return FALSE;
236 }
237
238
239 void wxHtmlPrintout::GetPageInfo(int *minPage, int *maxPage, int *selPageFrom, int *selPageTo)
240 {
241 *minPage = 1;
242 *maxPage = wxHTML_PRINT_MAX_PAGES;
243 *selPageFrom = 1;
244 *selPageTo = wxHTML_PRINT_MAX_PAGES;
245 }
246
247
248
249 bool wxHtmlPrintout::HasPage(int pageNum)
250 {
251 return (pageNum >= 1 && pageNum <= m_NumPages);
252 }
253
254
255
256 void wxHtmlPrintout::SetHtmlText(const wxString& html, const wxString &basepath, bool isdir)
257 {
258 m_Document = html;
259 m_BasePath = basepath;
260 m_BasePathIsDir = isdir;
261 }
262
263
264
265 void wxHtmlPrintout::SetHtmlFile(const wxString& htmlfile)
266 {
267 wxFileSystem fs;
268 wxFSFile *ff = fs.OpenFile(htmlfile);
269 wxInputStream *st = ff -> GetStream();
270 char *t = new char[st -> GetSize() + 1];
271 st -> Read(t, st -> GetSize());
272 t[st -> GetSize()] = 0;
273
274 wxString doc = wxString(t);
275 delete t;
276 delete ff;
277
278 SetHtmlText(doc, htmlfile, FALSE);
279 }
280
281
282
283 void wxHtmlPrintout::SetHeader(const wxString& header, int pg)
284 {
285 if (pg == wxPAGE_ALL || pg == wxPAGE_EVEN)
286 m_Headers[0] = header;
287 if (pg == wxPAGE_ALL || pg == wxPAGE_ODD)
288 m_Headers[1] = header;
289 }
290
291
292
293 void wxHtmlPrintout::SetFooter(const wxString& footer, int pg)
294 {
295 if (pg == wxPAGE_ALL || pg == wxPAGE_EVEN)
296 m_Footers[0] = footer;
297 if (pg == wxPAGE_ALL || pg == wxPAGE_ODD)
298 m_Footers[1] = footer;
299 }
300
301
302
303 void wxHtmlPrintout::CountPages()
304 {
305 wxBusyCursor wait;
306 int pageWidth, pageHeight, mm_w, mm_h;
307 float ppmm_h, ppmm_v;
308
309 GetPageSizePixels(&pageWidth, &pageHeight);
310 GetPageSizeMM(&mm_w, &mm_h);
311 ppmm_h = (float)pageWidth / mm_w;
312 ppmm_v = (float)pageHeight / mm_h;
313
314 int pos = 0;
315
316 m_NumPages = 0;
317
318 m_PageBreaks[0] = 0;
319 do {
320 pos = m_Renderer -> Render(ppmm_h * m_MarginLeft,
321 ppmm_v * (m_MarginTop + (m_HeaderHeight == 0 ? 0 : m_MarginSpace)) + m_HeaderHeight,
322 pos, TRUE);
323 m_PageBreaks[++m_NumPages] = pos;
324 } while (pos < m_Renderer -> GetTotalHeight());
325 }
326
327
328
329 void wxHtmlPrintout::RenderPage(wxDC *dc, int page)
330 {
331 wxBusyCursor wait;
332
333 int pageWidth, pageHeight, mm_w, mm_h, scr_w, scr_h, dc_w, dc_h;
334 float ppmm_h, ppmm_v;
335
336 GetPageSizePixels(&pageWidth, &pageHeight);
337 GetPageSizeMM(&mm_w, &mm_h);
338 ppmm_h = (float)pageWidth / mm_w;
339 ppmm_v = (float)pageHeight / mm_h;
340 wxDisplaySize(&scr_w, &scr_h);
341 dc -> GetSize(&dc_w, &dc_h);
342
343 int ppiPrinterX, ppiPrinterY;
344 GetPPIPrinter(&ppiPrinterX, &ppiPrinterY);
345 int ppiScreenX, ppiScreenY;
346 GetPPIScreen(&ppiScreenX, &ppiScreenY);
347
348 dc -> SetUserScale((double)dc_w / (double)pageWidth, (double)dc_w / (double)pageWidth);
349
350 m_Renderer -> SetDC(dc, (double)ppiPrinterY / (double)ppiScreenY);
351
352 dc -> SetBackgroundMode(wxTRANSPARENT);
353
354 m_Renderer -> Render(ppmm_h * m_MarginLeft,
355 ppmm_v * (m_MarginTop + (m_HeaderHeight == 0 ? 0 : m_MarginSpace)) + m_HeaderHeight,
356 m_PageBreaks[page-1]);
357
358 m_RendererHdr -> SetDC(dc, (double)ppiPrinterY / (double)ppiScreenY);
359 if (m_Headers[page % 2] != wxEmptyString) {
360 m_RendererHdr -> SetHtmlText(TranslateHeader(m_Headers[page % 2], page));
361 m_RendererHdr -> Render(ppmm_h * m_MarginLeft, ppmm_v * m_MarginTop);
362 }
363 if (m_Footers[page % 2] != wxEmptyString) {
364 m_RendererHdr -> SetHtmlText(TranslateHeader(m_Footers[page % 2], page));
365 m_RendererHdr -> Render(ppmm_h * m_MarginLeft, pageHeight - ppmm_v * m_MarginBottom - m_FooterHeight);
366 }
367 }
368
369
370
371 wxString wxHtmlPrintout::TranslateHeader(const wxString& instr, int page)
372 {
373 wxString r = instr;
374 wxString num;
375
376 num.Printf(wxT("%i"), page);
377 r.Replace(wxT("@PAGENUM@"), num);
378
379 num.Printf(wxT("%i"), m_NumPages);
380 r.Replace(wxT("@PAGESCNT@"), num);
381
382 return r;
383 }
384
385
386
387 void wxHtmlPrintout::SetMargins(float top, float bottom, float left, float right, float spaces)
388 {
389 m_MarginTop = top;
390 m_MarginBottom = bottom;
391 m_MarginLeft = left;
392 m_MarginRight = right;
393 m_MarginSpace = spaces;
394 }
395
396
397
398
399
400
401 //--------------------------------------------------------------------------------
402 // wxHtmlEasyPrinting
403 //--------------------------------------------------------------------------------
404
405
406 wxHtmlEasyPrinting::wxHtmlEasyPrinting(const wxString& name, wxFrame *parent_frame)
407 {
408 m_Frame = parent_frame;
409 m_Name = name;
410 m_PrintData = new wxPrintData;
411 #if (defined __WXGTK__) || (defined __WXMOTIF__)
412 (*m_PrintData) = (*wxThePrintSetupData);
413 #endif
414 m_PageSetupData = new wxPageSetupDialogData;
415 m_Headers[0] = m_Headers[1] = m_Footers[0] = m_Footers[1] = wxEmptyString;
416
417 m_PageSetupData -> EnableMargins(TRUE);
418 m_PageSetupData -> SetMarginTopLeft(wxPoint(25, 25));
419 m_PageSetupData -> SetMarginBottomRight(wxPoint(25, 25));
420 }
421
422
423
424 wxHtmlEasyPrinting::~wxHtmlEasyPrinting()
425 {
426 delete m_PrintData;
427 delete m_PageSetupData;
428 }
429
430
431
432 void wxHtmlEasyPrinting::PreviewFile(const wxString &htmlfile)
433 {
434 wxHtmlPrintout *p1 = CreatePrintout();
435 p1 -> SetHtmlFile(htmlfile);
436 wxHtmlPrintout *p2 = CreatePrintout();
437 p2 -> SetHtmlFile(htmlfile);
438 DoPreview(p1, p2);
439 }
440
441
442
443 void wxHtmlEasyPrinting::PreviewText(const wxString &htmltext, const wxString &basepath)
444 {
445 wxHtmlPrintout *p1 = CreatePrintout();
446 p1 -> SetHtmlText(htmltext, basepath, TRUE);
447 wxHtmlPrintout *p2 = CreatePrintout();
448 p2 -> SetHtmlText(htmltext, basepath, TRUE);
449 DoPreview(p1, p2);
450 }
451
452
453
454 void wxHtmlEasyPrinting::PrintFile(const wxString &htmlfile)
455 {
456 wxHtmlPrintout *p = CreatePrintout();
457 p -> SetHtmlFile(htmlfile);
458 DoPrint(p);
459 }
460
461
462
463 void wxHtmlEasyPrinting::PrintText(const wxString &htmltext, const wxString &basepath)
464 {
465 wxHtmlPrintout *p = CreatePrintout();
466 p -> SetHtmlText(htmltext, basepath, TRUE);
467 DoPrint(p);
468 }
469
470
471
472 void wxHtmlEasyPrinting::DoPreview(wxHtmlPrintout *printout1, wxHtmlPrintout *printout2)
473 {
474 // Pass two printout objects: for preview, and possible printing.
475 wxPrintDialogData printDialogData(*m_PrintData);
476 wxPrintPreview *preview = new wxPrintPreview(printout1, printout2, &printDialogData);
477 if (!preview -> Ok()) {
478 delete preview;
479 wxMessageBox(_("There was a problem previewing.\nPerhaps your current printer is not set correctly?"), _("Previewing"), wxOK);
480 }
481
482 else {
483 wxPreviewFrame *frame = new wxPreviewFrame(preview, m_Frame,
484 m_Name + _(" Preview"),
485 wxPoint(100, 100), wxSize(650, 500));
486 frame -> Centre(wxBOTH);
487 frame -> Initialize();
488 frame -> Show(TRUE);
489 }
490 }
491
492
493
494 void wxHtmlEasyPrinting::DoPrint(wxHtmlPrintout *printout)
495 {
496 wxPrintDialogData printDialogData(*m_PrintData);
497 wxPrinter printer(&printDialogData);
498
499 if (!printer.Print(m_Frame, printout, TRUE))
500 wxMessageBox(_("There was a problem printing.\nPerhaps your current printer is not set correctly?"), _("Printing"), wxOK);
501 else
502 (*m_PrintData) = printer.GetPrintDialogData().GetPrintData();
503 }
504
505
506
507 void wxHtmlEasyPrinting::PrinterSetup()
508 {
509 wxPrintDialogData printDialogData(*m_PrintData);
510 wxPrintDialog printerDialog(m_Frame, &printDialogData);
511
512 printerDialog.GetPrintDialogData().SetSetupDialog(TRUE);
513
514 if (printerDialog.ShowModal() == wxID_OK)
515 (*m_PrintData) = printerDialog.GetPrintDialogData().GetPrintData();
516 }
517
518
519
520 void wxHtmlEasyPrinting::PageSetup()
521 {
522 m_PageSetupData -> SetPrintData(*m_PrintData);
523 wxPageSetupDialog pageSetupDialog(m_Frame, m_PageSetupData);
524
525 if (pageSetupDialog.ShowModal() == wxID_OK) {
526 (*m_PrintData) = pageSetupDialog.GetPageSetupData().GetPrintData();
527 (*m_PageSetupData) = pageSetupDialog.GetPageSetupData();
528 }
529 }
530
531
532
533 void wxHtmlEasyPrinting::SetHeader(const wxString& header, int pg)
534 {
535 if (pg == wxPAGE_ALL || pg == wxPAGE_EVEN)
536 m_Headers[0] = header;
537 if (pg == wxPAGE_ALL || pg == wxPAGE_ODD)
538 m_Headers[1] = header;
539 }
540
541
542
543 void wxHtmlEasyPrinting::SetFooter(const wxString& footer, int pg)
544 {
545 if (pg == wxPAGE_ALL || pg == wxPAGE_EVEN)
546 m_Footers[0] = footer;
547 if (pg == wxPAGE_ALL || pg == wxPAGE_ODD)
548 m_Footers[1] = footer;
549 }
550
551
552
553 wxHtmlPrintout *wxHtmlEasyPrinting::CreatePrintout()
554 {
555 wxHtmlPrintout *p = new wxHtmlPrintout(m_Name);
556
557 p -> SetHeader(m_Headers[0], wxPAGE_EVEN);
558 p -> SetHeader(m_Headers[1], wxPAGE_ODD);
559 p -> SetFooter(m_Footers[0], wxPAGE_EVEN);
560 p -> SetFooter(m_Footers[1], wxPAGE_ODD);
561
562 p -> SetMargins(m_PageSetupData -> GetMarginTopLeft().y,
563 m_PageSetupData -> GetMarginBottomRight().y,
564 m_PageSetupData -> GetMarginTopLeft().x,
565 m_PageSetupData -> GetMarginBottomRight().x);
566
567 return p;
568 }
569
570
571
572 #endif // wxUSE_HTML & wxUSE_PRINTING_ARCHITECTURE