]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/print.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Fix deprecating warning introduced in r72446.
[wxWidgets.git] / src / gtk / print.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/gtk/print.cpp
3// Author: Anthony Bretaudeau
4// Purpose: GTK printing support
5// Created: 2007-08-25
6// RCS-ID: $Id$
7// Copyright: (c) 2007 wxWidgets development team
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_GTKPRINT
19
20#include "wx/gtk/print.h"
21
22#ifndef WX_PRECOMP
23#include "wx/log.h"
24#include "wx/dcmemory.h"
25#include "wx/dcprint.h"
26#include "wx/icon.h"
27#include "wx/math.h"
28#include "wx/image.h"
29#include "wx/module.h"
30#include "wx/crt.h"
31#endif
32
33#include "wx/fontutil.h"
34#include "wx/dynlib.h"
35#include "wx/paper.h"
36
37#include <gtk/gtk.h>
38
39#if GTK_CHECK_VERSION(2,14,0)
40#include <gtk/gtkunixprint.h>
41#else
42#include <gtk/gtkpagesetupunixdialog.h>
43#endif
44
45
46#if wxUSE_GRAPHICS_CONTEXT
47#include "wx/graphics.h"
48#endif
49
50#include "wx/link.h"
51wxFORCE_LINK_THIS_MODULE(gtk_print)
52
53#if wxUSE_LIBGNOMEPRINT
54#include "wx/gtk/gnome/gprint.h"
55#endif
56
57#include "wx/gtk/private/object.h"
58
59// Useful to convert angles from/to Rad to/from Deg.
60static const double RAD2DEG = 180.0 / M_PI;
61static const double DEG2RAD = M_PI / 180.0;
62
63//----------------------------------------------------------------------------
64// wxGtkPrintModule
65// Initialized when starting the app : if it successfully load the gtk-print framework,
66// it uses it. If not, it falls back to gnome print (see /gtk/gnome/gprint.cpp) then
67// to postscript if gnomeprint is not available.
68//----------------------------------------------------------------------------
69
70class wxGtkPrintModule: public wxModule
71{
72public:
73 wxGtkPrintModule()
74 {
75#if wxUSE_LIBGNOMEPRINT
76 // This module must be initialized AFTER gnomeprint's one
77 AddDependency(wxCLASSINFO(wxGnomePrintModule));
78#endif
79 }
80 bool OnInit();
81 void OnExit() {}
82
83private:
84 DECLARE_DYNAMIC_CLASS(wxGtkPrintModule)
85};
86
87bool wxGtkPrintModule::OnInit()
88{
89#ifndef __WXGTK3__
90 if (gtk_check_version(2,10,0) == NULL)
91#endif
92 {
93 wxPrintFactory::SetPrintFactory( new wxGtkPrintFactory );
94 }
95 return true;
96}
97
98IMPLEMENT_DYNAMIC_CLASS(wxGtkPrintModule, wxModule)
99
100//----------------------------------------------------------------------------
101// wxGtkPrintFactory
102//----------------------------------------------------------------------------
103
104wxPrinterBase* wxGtkPrintFactory::CreatePrinter( wxPrintDialogData *data )
105{
106 return new wxGtkPrinter( data );
107}
108
109wxPrintPreviewBase *wxGtkPrintFactory::CreatePrintPreview( wxPrintout *preview,
110 wxPrintout *printout,
111 wxPrintDialogData *data )
112{
113 return new wxGtkPrintPreview( preview, printout, data );
114}
115
116wxPrintPreviewBase *wxGtkPrintFactory::CreatePrintPreview( wxPrintout *preview,
117 wxPrintout *printout,
118 wxPrintData *data )
119{
120 return new wxGtkPrintPreview( preview, printout, data );
121}
122
123wxPrintDialogBase *wxGtkPrintFactory::CreatePrintDialog( wxWindow *parent,
124 wxPrintDialogData *data )
125{
126 return new wxGtkPrintDialog( parent, data );
127}
128
129wxPrintDialogBase *wxGtkPrintFactory::CreatePrintDialog( wxWindow *parent,
130 wxPrintData *data )
131{
132 return new wxGtkPrintDialog( parent, data );
133}
134
135wxPageSetupDialogBase *wxGtkPrintFactory::CreatePageSetupDialog( wxWindow *parent,
136 wxPageSetupDialogData * data )
137{
138 return new wxGtkPageSetupDialog( parent, data );
139}
140
141bool wxGtkPrintFactory::HasPrintSetupDialog()
142{
143 return false;
144}
145
146wxDialog *
147wxGtkPrintFactory::CreatePrintSetupDialog(wxWindow * WXUNUSED(parent),
148 wxPrintData * WXUNUSED(data))
149{
150 return NULL;
151}
152
153wxDCImpl* wxGtkPrintFactory::CreatePrinterDCImpl( wxPrinterDC *owner, const wxPrintData& data )
154{
155 return new wxGtkPrinterDCImpl( owner, data );
156}
157
158bool wxGtkPrintFactory::HasOwnPrintToFile()
159{
160 return true;
161}
162
163bool wxGtkPrintFactory::HasPrinterLine()
164{
165 return true;
166}
167
168wxString wxGtkPrintFactory::CreatePrinterLine()
169{
170 // redundant now
171 return wxEmptyString;
172}
173
174bool wxGtkPrintFactory::HasStatusLine()
175{
176 // redundant now
177 return true;
178}
179
180wxString wxGtkPrintFactory::CreateStatusLine()
181{
182 // redundant now
183 return wxEmptyString;
184}
185
186wxPrintNativeDataBase *wxGtkPrintFactory::CreatePrintNativeData()
187{
188 return new wxGtkPrintNativeData;
189}
190
191//----------------------------------------------------------------------------
192// Callback functions for Gtk Printings.
193//----------------------------------------------------------------------------
194
195// We use it to pass useful objects to GTK printing callback functions.
196struct wxPrinterToGtkData
197{
198 wxGtkPrinter * printer;
199 wxPrintout * printout;
200};
201
202extern "C"
203{
204 static void gtk_begin_print_callback (GtkPrintOperation *operation, GtkPrintContext *context, gpointer user_data)
205 {
206 wxPrinterToGtkData *data = (wxPrinterToGtkData *) user_data;
207
208 data->printer->BeginPrint(data->printout, operation, context);
209 }
210
211 static void gtk_draw_page_print_callback (GtkPrintOperation *operation, GtkPrintContext *context, gint page_nr, gpointer user_data)
212 {
213 wxPrinterToGtkData *data = (wxPrinterToGtkData *) user_data;
214
215 data->printer->DrawPage(data->printout, operation, context, page_nr);
216 }
217
218 static void gtk_end_print_callback(GtkPrintOperation * WXUNUSED(operation),
219 GtkPrintContext * WXUNUSED(context),
220 gpointer user_data)
221 {
222 wxPrintout *printout = (wxPrintout *) user_data;
223
224 printout->OnEndPrinting();
225 }
226}
227
228//----------------------------------------------------------------------------
229// wxGtkPrintNativeData
230//----------------------------------------------------------------------------
231
232IMPLEMENT_CLASS(wxGtkPrintNativeData, wxPrintNativeDataBase)
233
234wxGtkPrintNativeData::wxGtkPrintNativeData()
235{
236 m_config = gtk_print_settings_new();
237 m_job = gtk_print_operation_new();
238 m_context = NULL;
239}
240
241wxGtkPrintNativeData::~wxGtkPrintNativeData()
242{
243 g_object_unref(m_job);
244 g_object_unref(m_config);
245}
246
247// Convert datas stored in m_config to a wxPrintData.
248// Called by wxPrintData::ConvertFromNative().
249bool wxGtkPrintNativeData::TransferTo( wxPrintData &data )
250{
251 if(!m_config)
252 return false;
253
254 int resolution = gtk_print_settings_get_resolution(m_config);
255 if ( resolution > 0 )
256 {
257 // if resolution is explicitly set, use it
258 data.SetQuality(resolution);
259 }
260 else // use more vague "quality"
261 {
262 GtkPrintQuality quality = gtk_print_settings_get_quality(m_config);
263 if (quality == GTK_PRINT_QUALITY_HIGH)
264 data.SetQuality(wxPRINT_QUALITY_HIGH);
265 else if (quality == GTK_PRINT_QUALITY_LOW)
266 data.SetQuality(wxPRINT_QUALITY_LOW);
267 else if (quality == GTK_PRINT_QUALITY_DRAFT)
268 data.SetQuality(wxPRINT_QUALITY_DRAFT);
269 else
270 data.SetQuality(wxPRINT_QUALITY_MEDIUM);
271 }
272
273 data.SetNoCopies(gtk_print_settings_get_n_copies(m_config));
274
275 data.SetColour(gtk_print_settings_get_use_color(m_config));
276
277 switch (gtk_print_settings_get_duplex(m_config))
278 {
279 case GTK_PRINT_DUPLEX_SIMPLEX: data.SetDuplex (wxDUPLEX_SIMPLEX);
280 break;
281
282 case GTK_PRINT_DUPLEX_HORIZONTAL: data.SetDuplex (wxDUPLEX_HORIZONTAL);
283 break;
284
285 default:
286 case GTK_PRINT_DUPLEX_VERTICAL: data.SetDuplex (wxDUPLEX_VERTICAL);
287 break;
288 }
289
290 GtkPageOrientation orientation = gtk_print_settings_get_orientation (m_config);
291 if (orientation == GTK_PAGE_ORIENTATION_PORTRAIT)
292 {
293 data.SetOrientation(wxPORTRAIT);
294 data.SetOrientationReversed(false);
295 }
296 else if (orientation == GTK_PAGE_ORIENTATION_LANDSCAPE)
297 {
298 data.SetOrientation(wxLANDSCAPE);
299 data.SetOrientationReversed(false);
300 }
301 else if (orientation == GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT)
302 {
303 data.SetOrientation(wxPORTRAIT);
304 data.SetOrientationReversed(true);
305 }
306 else if (orientation == GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE)
307 {
308 data.SetOrientation(wxLANDSCAPE);
309 data.SetOrientationReversed(true);
310 }
311
312 data.SetCollate(gtk_print_settings_get_collate (m_config));
313
314 // Paper formats : these are the most common paper formats.
315 GtkPaperSize *paper_size = gtk_print_settings_get_paper_size (m_config);
316 if (!paper_size)
317 data.SetPaperId(wxPAPER_NONE);
318 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new (GTK_PAPER_NAME_A3)))
319 data.SetPaperId(wxPAPER_A3);
320 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new (GTK_PAPER_NAME_A4)))
321 data.SetPaperId(wxPAPER_A4);
322 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new (GTK_PAPER_NAME_A5)))
323 data.SetPaperId(wxPAPER_A5);
324 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new (GTK_PAPER_NAME_B5)))
325 data.SetPaperId(wxPAPER_B5);
326 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new (GTK_PAPER_NAME_LETTER)))
327 data.SetPaperId(wxPAPER_LETTER);
328 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new (GTK_PAPER_NAME_LEGAL)))
329 data.SetPaperId(wxPAPER_LEGAL);
330 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new (GTK_PAPER_NAME_EXECUTIVE)))
331 data.SetPaperId(wxPAPER_EXECUTIVE);
332 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"na_number-10")))
333 data.SetPaperId(wxPAPER_ENV_10);
334 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"iso-c5")))
335 data.SetPaperId(wxPAPER_ENV_C5);
336 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"iso-c6")))
337 data.SetPaperId(wxPAPER_ENV_C6);
338 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"jis-b5")))
339 data.SetPaperId(wxPAPER_B5_TRANSVERSE);
340 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"iso-b5")))
341 data.SetPaperId(wxPAPER_ENV_B5);
342 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"na_monarch")))
343 data.SetPaperId(wxPAPER_ENV_MONARCH);
344 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"engineering-c")))
345 data.SetPaperId( wxPAPER_CSHEET);
346 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"engineering-d")))
347 data.SetPaperId( wxPAPER_DSHEET);
348 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"engineering-e")))
349 data.SetPaperId( wxPAPER_ESHEET);
350 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"letter")))
351 data.SetPaperId( wxPAPER_LETTERSMALL);
352 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"engineering-b")))
353 data.SetPaperId( wxPAPER_TABLOID);
354 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"ledger")))
355 data.SetPaperId( wxPAPER_LEDGER);
356 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"statement")))
357 data.SetPaperId( wxPAPER_STATEMENT);
358 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( GTK_PAPER_NAME_A4 )))
359 data.SetPaperId( wxPAPER_A4SMALL);
360 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"iso-b4")))
361 data.SetPaperId( wxPAPER_B4);
362 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"folio")))
363 data.SetPaperId( wxPAPER_FOLIO);
364 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"quarto")))
365 data.SetPaperId( wxPAPER_QUARTO);
366 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"10x14")))
367 data.SetPaperId( wxPAPER_10X14);
368 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"ledger")))
369 data.SetPaperId( wxPAPER_11X17);
370 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"letter")))
371 data.SetPaperId( wxPAPER_NOTE);
372 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"na-number-9-envelope")))
373 data.SetPaperId( wxPAPER_ENV_9);
374 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"number-11")))
375 data.SetPaperId( wxPAPER_ENV_11);
376 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"number-12")))
377 data.SetPaperId( wxPAPER_ENV_12);
378 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"number-14")))
379 data.SetPaperId( wxPAPER_ENV_14);
380 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"iso-designated")))
381 data.SetPaperId( wxPAPER_ENV_DL);
382 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"iso-c3")))
383 data.SetPaperId( wxPAPER_ENV_C3);
384 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"iso-c4")))
385 data.SetPaperId( wxPAPER_ENV_C4);
386 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"c6/c5")))
387 data.SetPaperId( wxPAPER_ENV_C65);
388 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"iso-b4")))
389 data.SetPaperId( wxPAPER_ENV_B4);
390 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"iso-b6")))
391 data.SetPaperId( wxPAPER_ENV_B6);
392 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"Italian")))
393 data.SetPaperId( wxPAPER_ENV_ITALY);
394 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"personal")))
395 data.SetPaperId( wxPAPER_ENV_PERSONAL);
396 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"fanfold-us")))
397 data.SetPaperId( wxPAPER_FANFOLD_US);
398 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"fanfold-European")))
399 data.SetPaperId( wxPAPER_FANFOLD_STD_GERMAN);
400 else if (gtk_paper_size_is_equal(paper_size,gtk_paper_size_new ( (const gchar*)"foolscap")))
401 data.SetPaperId( wxPAPER_FANFOLD_LGL_GERMAN);
402 else
403 data.SetPaperId(wxPAPER_NONE);
404
405 data.SetPrinterName(gtk_print_settings_get_printer(m_config));
406
407 return true;
408}
409
410// Put datas given by the wxPrintData into m_config.
411// Called by wxPrintData::ConvertToNative().
412bool wxGtkPrintNativeData::TransferFrom( const wxPrintData &data )
413{
414 if(!m_config)
415 return false;
416
417 wxPrintQuality quality = data.GetQuality();
418 if (quality == wxPRINT_QUALITY_HIGH)
419 gtk_print_settings_set_quality (m_config, GTK_PRINT_QUALITY_HIGH);
420 else if (quality == wxPRINT_QUALITY_MEDIUM)
421 gtk_print_settings_set_quality (m_config, GTK_PRINT_QUALITY_NORMAL);
422 else if (quality == wxPRINT_QUALITY_LOW)
423 gtk_print_settings_set_quality (m_config, GTK_PRINT_QUALITY_LOW);
424 else if (quality == wxPRINT_QUALITY_DRAFT)
425 gtk_print_settings_set_quality (m_config, GTK_PRINT_QUALITY_DRAFT);
426 else if (quality > 1)
427 gtk_print_settings_set_resolution (m_config, quality);
428 else
429 gtk_print_settings_set_quality (m_config, GTK_PRINT_QUALITY_NORMAL);
430
431 gtk_print_settings_set_n_copies(m_config, data.GetNoCopies());
432
433 gtk_print_settings_set_use_color(m_config, data.GetColour());
434
435 switch (data.GetDuplex())
436 {
437 case wxDUPLEX_SIMPLEX: gtk_print_settings_set_duplex (m_config, GTK_PRINT_DUPLEX_SIMPLEX);
438 break;
439
440 case wxDUPLEX_HORIZONTAL: gtk_print_settings_set_duplex (m_config, GTK_PRINT_DUPLEX_HORIZONTAL);
441 break;
442
443 default:
444 case wxDUPLEX_VERTICAL: gtk_print_settings_set_duplex (m_config, GTK_PRINT_DUPLEX_VERTICAL);
445 break;
446 }
447
448 if (!data.IsOrientationReversed())
449 {
450 if (data.GetOrientation() == wxLANDSCAPE)
451 gtk_print_settings_set_orientation (m_config, GTK_PAGE_ORIENTATION_LANDSCAPE);
452 else
453 gtk_print_settings_set_orientation (m_config, GTK_PAGE_ORIENTATION_PORTRAIT);
454 }
455 else {
456 if (data.GetOrientation() == wxLANDSCAPE)
457 gtk_print_settings_set_orientation (m_config, GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE);
458 else
459 gtk_print_settings_set_orientation (m_config, GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT);
460 }
461
462 gtk_print_settings_set_collate (m_config, data.GetCollate());
463
464 // Paper formats: these are the most common paper formats.
465 switch (data.GetPaperId())
466 {
467 case wxPAPER_A3: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new (GTK_PAPER_NAME_A3));
468 break;
469 case wxPAPER_A4: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new (GTK_PAPER_NAME_A4));
470 break;
471 case wxPAPER_A5: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new (GTK_PAPER_NAME_A5));
472 break;
473 case wxPAPER_B5_TRANSVERSE: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "jis-b5"));
474 break;
475 case wxPAPER_B5: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new (GTK_PAPER_NAME_B5));
476 break;
477 case wxPAPER_LETTER: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new (GTK_PAPER_NAME_LETTER));
478 break;
479 case wxPAPER_LEGAL: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new (GTK_PAPER_NAME_LEGAL));
480 break;
481 case wxPAPER_EXECUTIVE: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new (GTK_PAPER_NAME_EXECUTIVE));
482 break;
483 case wxPAPER_ENV_10: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "na_number-10"));
484 break;
485 case wxPAPER_ENV_C5: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "iso-c5"));
486 break;
487 case wxPAPER_ENV_C6: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "iso-c6"));
488 break;
489 case wxPAPER_ENV_B5: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "iso-c5b5"));
490 break;
491 case wxPAPER_ENV_MONARCH: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "na_monarch"));
492 break;
493 case wxPAPER_CSHEET: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "engineering-c"));
494 break;
495 case wxPAPER_DSHEET: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "engineering-d"));
496 break;
497 case wxPAPER_ESHEET: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "engineering-e"));
498 break;
499 case wxPAPER_LETTERSMALL: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "letter"));
500 break;
501 case wxPAPER_TABLOID: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "engineering-b"));
502 break;
503 case wxPAPER_LEDGER: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "ledger"));
504 break;
505 case wxPAPER_STATEMENT: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "statement"));
506 break;
507 case wxPAPER_A4SMALL: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new (GTK_PAPER_NAME_A4));
508 break;
509 case wxPAPER_B4: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "iso-b4"));
510 break;
511 case wxPAPER_FOLIO: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "folio"));
512 break;
513 case wxPAPER_QUARTO: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "quarto"));
514 break;
515 case wxPAPER_10X14: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "10x14"));
516 break;
517 case wxPAPER_11X17: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "ledger"));
518 break;
519 case wxPAPER_NOTE: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "letter"));
520 break;
521 case wxPAPER_ENV_9: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "na-number-9-envelope"));
522 break;
523 case wxPAPER_ENV_11: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "number-11"));
524 break;
525 case wxPAPER_ENV_12: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "number-12"));
526 break;
527 case wxPAPER_ENV_14: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "number-14"));
528 break;
529 case wxPAPER_ENV_DL: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "iso-designated"));
530 break;
531 case wxPAPER_ENV_C3: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "iso-c3"));
532 break;
533 case wxPAPER_ENV_C4: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "iso-c4"));
534 break;
535 case wxPAPER_ENV_C65: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "c6/c5"));
536 break;
537 case wxPAPER_ENV_B4: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "iso-b4"));
538 break;
539 case wxPAPER_ENV_B6: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "iso-b6"));
540 break;
541 case wxPAPER_ENV_ITALY: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "Italian"));
542 break;
543 case wxPAPER_ENV_PERSONAL: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "personal"));
544 break;
545 case wxPAPER_FANFOLD_US: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "fanfold-us"));
546 break;
547 case wxPAPER_FANFOLD_STD_GERMAN: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "fanfold-European"));
548 break;
549 case wxPAPER_FANFOLD_LGL_GERMAN: gtk_print_settings_set_paper_size(m_config, gtk_paper_size_new ((const gchar*) "foolscap"));
550 break;
551 case wxPAPER_NONE:
552 default: break;
553 }
554
555 gtk_print_settings_set_printer(m_config, data.GetPrinterName().utf8_str());
556
557 return true;
558}
559
560void wxGtkPrintNativeData::SetPrintConfig( GtkPrintSettings * config )
561{
562 if (config)
563 m_config = gtk_print_settings_copy(config);
564}
565
566// Extract page setup from settings.
567GtkPageSetup* wxGtkPrintNativeData::GetPageSetupFromSettings(GtkPrintSettings* settings)
568{
569 GtkPageSetup* page_setup = gtk_page_setup_new();
570 gtk_page_setup_set_orientation (page_setup, gtk_print_settings_get_orientation (settings));
571
572 GtkPaperSize *paper_size = gtk_print_settings_get_paper_size (settings);
573 if (paper_size != NULL)
574 gtk_page_setup_set_paper_size_and_default_margins (page_setup, paper_size);
575
576 return page_setup;
577}
578
579// Insert page setup into a given GtkPrintSettings.
580void wxGtkPrintNativeData::SetPageSetupToSettings(GtkPrintSettings* settings, GtkPageSetup* page_setup)
581{
582 gtk_print_settings_set_orientation ( settings, gtk_page_setup_get_orientation (page_setup));
583 gtk_print_settings_set_paper_size ( settings, gtk_page_setup_get_paper_size (page_setup));
584}
585
586//----------------------------------------------------------------------------
587// wxGtkPrintDialog
588//----------------------------------------------------------------------------
589
590IMPLEMENT_CLASS(wxGtkPrintDialog, wxPrintDialogBase)
591
592wxGtkPrintDialog::wxGtkPrintDialog( wxWindow *parent, wxPrintDialogData *data )
593 : wxPrintDialogBase(parent, wxID_ANY, _("Print"),
594 wxPoint(0, 0), wxSize(600, 600),
595 wxDEFAULT_DIALOG_STYLE |
596 wxTAB_TRAVERSAL)
597{
598 if (data)
599 m_printDialogData = *data;
600
601 m_parent = parent;
602 SetShowDialog(true);
603}
604
605wxGtkPrintDialog::wxGtkPrintDialog( wxWindow *parent, wxPrintData *data )
606 : wxPrintDialogBase(parent, wxID_ANY, _("Print"),
607 wxPoint(0, 0), wxSize(600, 600),
608 wxDEFAULT_DIALOG_STYLE |
609 wxTAB_TRAVERSAL)
610{
611 if (data)
612 m_printDialogData = *data;
613
614 m_parent = parent;
615 SetShowDialog(true);
616}
617
618
619wxGtkPrintDialog::~wxGtkPrintDialog()
620{
621}
622
623// This is called even if we actually don't want the dialog to appear.
624int wxGtkPrintDialog::ShowModal()
625{
626 // We need to restore the settings given in the constructor.
627 wxPrintData data = m_printDialogData.GetPrintData();
628 wxGtkPrintNativeData *native =
629 (wxGtkPrintNativeData*) data.GetNativeData();
630 data.ConvertToNative();
631
632 GtkPrintSettings * settings = native->GetPrintConfig();
633
634 // We have to restore pages to print here because they're stored in a wxPrintDialogData and ConvertToNative only works for wxPrintData.
635 int fromPage = m_printDialogData.GetFromPage();
636 int toPage = m_printDialogData.GetToPage();
637 if (m_printDialogData.GetSelection())
638 gtk_print_settings_set_print_pages(settings, GTK_PRINT_PAGES_CURRENT);
639 else if (m_printDialogData.GetAllPages())
640 gtk_print_settings_set_print_pages(settings, GTK_PRINT_PAGES_ALL);
641 else {
642 gtk_print_settings_set_print_pages(settings, GTK_PRINT_PAGES_RANGES);
643 GtkPageRange *range;
644 range = g_new (GtkPageRange, 1);
645 range[0].start = fromPage-1;
646 range[0].end = (toPage >= fromPage) ? toPage-1 : fromPage-1;
647 gtk_print_settings_set_page_ranges (settings, range, 1);
648 }
649
650 GtkPrintOperation * const printOp = native->GetPrintJob();
651
652 // If the settings are OK, we restore it.
653 if (settings != NULL)
654 gtk_print_operation_set_print_settings (printOp, settings);
655 gtk_print_operation_set_default_page_setup (printOp, native->GetPageSetupFromSettings(settings));
656
657 // Show the dialog if needed.
658 GError* gError = NULL;
659 GtkPrintOperationResult response = gtk_print_operation_run
660 (
661 printOp,
662 GetShowDialog()
663 ? GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG
664 : GTK_PRINT_OPERATION_ACTION_PRINT,
665 m_parent
666 ? GTK_WINDOW(gtk_widget_get_toplevel(m_parent->m_widget))
667 : NULL,
668 &gError
669 );
670
671 // Does everything went well?
672 if (response == GTK_PRINT_OPERATION_RESULT_CANCEL)
673 {
674 return wxID_CANCEL;
675 }
676 else if (response == GTK_PRINT_OPERATION_RESULT_ERROR)
677 {
678 wxLogError(_("Error while printing: ") + wxString(gError ? gError->message : "???"));
679 g_error_free (gError);
680 return wxID_NO; // We use wxID_NO because there is no wxID_ERROR available
681 }
682
683 // Now get the settings and save it.
684 GtkPrintSettings* newSettings = gtk_print_operation_get_print_settings(printOp);
685 native->SetPrintConfig(newSettings);
686 data.ConvertFromNative();
687
688 // Set PrintDialogData variables
689 m_printDialogData.SetPrintData(data);
690 m_printDialogData.SetCollate(data.GetCollate());
691 m_printDialogData.SetNoCopies(data.GetNoCopies());
692 m_printDialogData.SetPrintToFile(data.GetPrinterName() == "Print to File");
693
694 // Same problem as a few lines before.
695 switch (gtk_print_settings_get_print_pages(newSettings))
696 {
697 case GTK_PRINT_PAGES_CURRENT:
698 m_printDialogData.SetSelection( true );
699 break;
700 case GTK_PRINT_PAGES_RANGES:
701 {// wxWidgets doesn't support multiple ranges, so we can only save the first one even if the user wants to print others.
702 // For example, the user enters "1-3;5-7" in the dialog: pages 1-3 and 5-7 will be correctly printed when the user
703 // will hit "OK" button. However we can only save 1-3 in the print data.
704 gint num_ranges = 0;
705 GtkPageRange* range;
706 range = gtk_print_settings_get_page_ranges (newSettings, &num_ranges);
707 if (num_ranges >= 1)
708 {
709 m_printDialogData.SetFromPage( range[0].start );
710 m_printDialogData.SetToPage( range[0].end );
711 }
712 else {
713 m_printDialogData.SetAllPages( true );
714 m_printDialogData.SetFromPage( 0 );
715 m_printDialogData.SetToPage( 9999 );
716 }
717 break;}
718 case GTK_PRINT_PAGES_ALL:
719 default:
720 m_printDialogData.SetAllPages( true );
721 m_printDialogData.SetFromPage( 0 );
722 m_printDialogData.SetToPage( 9999 );
723 break;
724 }
725
726 return wxID_OK;
727}
728
729//----------------------------------------------------------------------------
730// wxGtkPageSetupDialog
731//----------------------------------------------------------------------------
732
733IMPLEMENT_CLASS(wxGtkPageSetupDialog, wxPageSetupDialogBase)
734
735wxGtkPageSetupDialog::wxGtkPageSetupDialog( wxWindow *parent,
736 wxPageSetupDialogData* data )
737{
738 if (data)
739 m_pageDialogData = *data;
740
741 m_parent = parent;
742}
743
744wxGtkPageSetupDialog::~wxGtkPageSetupDialog()
745{
746}
747
748int wxGtkPageSetupDialog::ShowModal()
749{
750 // Get the config.
751 m_pageDialogData.GetPrintData().ConvertToNative();
752 wxGtkPrintNativeData *native = (wxGtkPrintNativeData*) m_pageDialogData.GetPrintData().GetNativeData();
753 GtkPrintSettings* nativeData = native->GetPrintConfig();
754
755 // We only need the pagesetup data which are part of the settings.
756 GtkPageSetup* oldPageSetup = native->GetPageSetupFromSettings(nativeData);
757
758 // If the user used a custom paper format the last time he printed, we have to restore it too.
759 if (m_pageDialogData.GetPrintData().GetPaperId() == wxPAPER_NONE)
760 {
761 wxSize customPaperSize = m_pageDialogData.GetPaperSize();
762 if (customPaperSize.GetWidth() > 0 && customPaperSize.GetHeight() > 0)
763 {
764 wxString title = _("Custom size");
765 GtkPaperSize* customSize = gtk_paper_size_new_custom ("custom", title.mb_str(), (gdouble) customPaperSize.GetWidth(), (gdouble) customPaperSize.GetHeight(), GTK_UNIT_MM);
766 gtk_page_setup_set_paper_size_and_default_margins (oldPageSetup, customSize);
767 g_object_unref(customSize);
768 }
769 }
770
771
772 // Set selected printer
773 gtk_print_settings_set(nativeData, "format-for-printer",
774 gtk_print_settings_get_printer(nativeData));
775
776 // Create custom dialog
777 wxString title(GetTitle());
778 if ( title.empty() )
779 title = _("Page Setup");
780 GtkWidget *
781 dlg = gtk_page_setup_unix_dialog_new(title.utf8_str(),
782 m_parent
783 ? GTK_WINDOW(m_parent->m_widget)
784 : NULL);
785
786 gtk_page_setup_unix_dialog_set_print_settings(
787 GTK_PAGE_SETUP_UNIX_DIALOG(dlg), nativeData);
788 gtk_page_setup_unix_dialog_set_page_setup(
789 GTK_PAGE_SETUP_UNIX_DIALOG(dlg), oldPageSetup);
790
791 int result = gtk_dialog_run(GTK_DIALOG(dlg));
792 gtk_widget_hide(dlg);
793
794 switch ( result )
795 {
796 case GTK_RESPONSE_OK:
797 case GTK_RESPONSE_APPLY:
798 {
799 // Store Selected Printer Name
800 gtk_print_settings_set_printer
801 (
802 nativeData,
803 gtk_print_settings_get(nativeData, "format-for-printer")
804 );
805
806 wxGtkObject<GtkPageSetup>
807 newPageSetup(gtk_page_setup_unix_dialog_get_page_setup(
808 GTK_PAGE_SETUP_UNIX_DIALOG(dlg)));
809 native->SetPageSetupToSettings(nativeData, newPageSetup);
810
811 m_pageDialogData.GetPrintData().ConvertFromNative();
812
813 // Store custom paper format if any.
814 if ( m_pageDialogData.GetPrintData().GetPaperId() == wxPAPER_NONE )
815 {
816 gdouble ml,mr,mt,mb,pw,ph;
817 ml = gtk_page_setup_get_left_margin (newPageSetup, GTK_UNIT_MM);
818 mr = gtk_page_setup_get_right_margin (newPageSetup, GTK_UNIT_MM);
819 mt = gtk_page_setup_get_top_margin (newPageSetup, GTK_UNIT_MM);
820 mb = gtk_page_setup_get_bottom_margin (newPageSetup, GTK_UNIT_MM);
821
822 pw = gtk_page_setup_get_paper_width (newPageSetup, GTK_UNIT_MM);
823 ph = gtk_page_setup_get_paper_height (newPageSetup, GTK_UNIT_MM);
824
825 m_pageDialogData.SetMarginTopLeft(wxPoint((int)(ml+0.5),
826 (int)(mt+0.5)));
827 m_pageDialogData.SetMarginBottomRight(wxPoint((int)(mr+0.5),
828 (int)(mb+0.5)));
829
830 m_pageDialogData.SetPaperSize(wxSize((int)(pw+0.5),
831 (int)(ph+0.5)));
832 }
833
834 result = wxID_OK;
835 }
836 break;
837
838 default:
839 case GTK_RESPONSE_CANCEL:
840 result = wxID_CANCEL;
841 break;
842 }
843
844 gtk_widget_destroy(dlg);
845
846 return result;
847}
848
849//----------------------------------------------------------------------------
850// wxGtkPrinter
851//----------------------------------------------------------------------------
852
853IMPLEMENT_CLASS(wxGtkPrinter, wxPrinterBase)
854
855wxGtkPrinter::wxGtkPrinter( wxPrintDialogData *data ) :
856 wxPrinterBase( data )
857{
858 m_gpc = NULL;
859
860 if (data)
861 m_printDialogData = *data;
862}
863
864wxGtkPrinter::~wxGtkPrinter()
865{
866}
867
868bool wxGtkPrinter::Print(wxWindow *parent, wxPrintout *printout, bool prompt )
869{
870 if (!printout)
871 {
872 sm_lastError = wxPRINTER_ERROR;
873 return false;
874 }
875
876 // Let's correct the PageInfo just in case the app gives wrong values.
877 int fromPage, toPage;
878 int minPage, maxPage;
879 printout->GetPageInfo(&minPage, &maxPage, &fromPage, &toPage);
880 m_printDialogData.SetAllPages(true);
881
882 if (minPage < 1) minPage = 1;
883 if (maxPage < 1) maxPage = 9999;
884 if (maxPage < minPage) maxPage = minPage;
885
886 m_printDialogData.SetMinPage(minPage);
887 m_printDialogData.SetMaxPage(maxPage);
888 if (fromPage != 0)
889 {
890 if (fromPage < minPage) fromPage = minPage;
891 else if (fromPage > maxPage) fromPage = maxPage;
892 m_printDialogData.SetFromPage(fromPage);
893 }
894 if (toPage != 0)
895 {
896 m_printDialogData.SetToPage(toPage);
897 if (toPage > maxPage) toPage = maxPage;
898 else if (toPage < minPage) toPage = minPage;
899 }
900
901 if (((minPage != fromPage) && fromPage != 0) || ((maxPage != toPage) && toPage != 0)) m_printDialogData.SetAllPages(false);
902
903
904 wxPrintData printdata = GetPrintDialogData().GetPrintData();
905 wxGtkPrintNativeData *native = (wxGtkPrintNativeData*) printdata.GetNativeData();
906
907 GtkPrintOperation * const printOp = native->GetPrintJob();
908
909 wxPrinterToGtkData dataToSend;
910 dataToSend.printer = this;
911 dataToSend.printout = printout;
912
913 // These Gtk signals are caught here.
914 g_signal_connect (printOp, "begin-print", G_CALLBACK (gtk_begin_print_callback), &dataToSend);
915 g_signal_connect (printOp, "draw-page", G_CALLBACK (gtk_draw_page_print_callback), &dataToSend);
916 g_signal_connect (printOp, "end-print", G_CALLBACK (gtk_end_print_callback), printout);
917
918 // This is used to setup the DC and
919 // show the dialog if desired
920 wxGtkPrintDialog dialog( parent, &m_printDialogData );
921 dialog.SetPrintDC(m_dc);
922 dialog.SetShowDialog(prompt);
923
924 // doesn't necessarily show
925 int ret = dialog.ShowModal();
926 if (ret == wxID_CANCEL)
927 {
928 sm_lastError = wxPRINTER_CANCELLED;
929 }
930 if (ret == wxID_NO)
931 {
932 sm_lastError = wxPRINTER_ERROR;
933 wxFAIL_MSG(_("The print dialog returned an error."));
934 }
935
936 return (sm_lastError == wxPRINTER_NO_ERROR);
937}
938
939void wxGtkPrinter::BeginPrint(wxPrintout *printout, GtkPrintOperation *operation, GtkPrintContext *context)
940{
941 wxPrintData printdata = GetPrintDialogData().GetPrintData();
942 wxGtkPrintNativeData *native = (wxGtkPrintNativeData*) printdata.GetNativeData();
943
944 // We need to update printdata with the new data from the dialog and we
945 // have to do this here because this method needs this new data and we
946 // cannot update it earlier
947 native->SetPrintConfig(gtk_print_operation_get_print_settings(operation));
948 printdata.ConvertFromNative();
949
950 SetPrintContext(context);
951 native->SetPrintContext( context );
952
953 wxPrinterDC *printDC = new wxPrinterDC( printdata );
954 m_dc = printDC;
955
956 if (!m_dc->IsOk())
957 {
958 if (sm_lastError != wxPRINTER_CANCELLED)
959 {
960 sm_lastError = wxPRINTER_ERROR;
961 wxFAIL_MSG(_("The wxGtkPrinterDC cannot be used."));
962 }
963 return;
964 }
965
966 printout->SetPPIScreen(wxGetDisplayPPI());
967 printout->SetPPIPrinter( printDC->GetResolution(),
968 printDC->GetResolution() );
969
970 printout->SetDC(m_dc);
971
972 int w, h;
973 m_dc->GetSize(&w, &h);
974 printout->SetPageSizePixels((int)w, (int)h);
975 printout->SetPaperRectPixels(wxRect(0, 0, w, h));
976 int mw, mh;
977 m_dc->GetSizeMM(&mw, &mh);
978 printout->SetPageSizeMM((int)mw, (int)mh);
979 printout->OnPreparePrinting();
980
981 // Get some parameters from the printout, if defined.
982 int fromPage, toPage;
983 int minPage, maxPage;
984 printout->GetPageInfo(&minPage, &maxPage, &fromPage, &toPage);
985
986 if (maxPage == 0)
987 {
988 sm_lastError = wxPRINTER_ERROR;
989 wxFAIL_MSG(_("wxPrintout::GetPageInfo gives a null maxPage."));
990 return;
991 }
992
993 printout->OnBeginPrinting();
994
995 int numPages = 0;
996
997 // If we're not previewing we need to calculate the number of pages to print.
998 // If we're previewing, Gtk Print will render every pages without wondering about the page ranges the user may
999 // have defined in the dialog. So the number of pages is the maximum available.
1000 if (!printout->IsPreview())
1001 {
1002 GtkPrintSettings * settings = gtk_print_operation_get_print_settings (operation);
1003 switch (gtk_print_settings_get_print_pages(settings))
1004 {
1005 case GTK_PRINT_PAGES_CURRENT:
1006 numPages = 1;
1007 break;
1008 case GTK_PRINT_PAGES_RANGES:
1009 {gint num_ranges = 0;
1010 GtkPageRange* range;
1011 int i;
1012 range = gtk_print_settings_get_page_ranges (settings, &num_ranges);
1013 for (i=0; i<num_ranges; i++)
1014 {
1015 if (range[i].end < range[i].start) range[i].end = range[i].start;
1016 if (range[i].start < minPage-1) range[i].start = minPage-1;
1017 if (range[i].end > maxPage-1) range[i].end = maxPage-1;
1018 if (range[i].start > maxPage-1) range[i].start = maxPage-1;
1019 numPages += range[i].end - range[i].start + 1;
1020 }
1021 gtk_print_settings_set_page_ranges (settings, range, 1);
1022 break;}
1023 case GTK_PRINT_PAGES_ALL:
1024 default:
1025 numPages = maxPage - minPage + 1;
1026 break;
1027 }
1028 }
1029 else numPages = maxPage - minPage + 1;
1030
1031 gtk_print_operation_set_n_pages(operation, numPages);
1032}
1033
1034void wxGtkPrinter::DrawPage(wxPrintout *printout,
1035 GtkPrintOperation *operation,
1036 GtkPrintContext * WXUNUSED(context),
1037 int page_nr)
1038{
1039 int fromPage, toPage, minPage, maxPage, startPage, endPage;
1040 printout->GetPageInfo(&minPage, &maxPage, &fromPage, &toPage);
1041
1042 int numPageToDraw = page_nr + minPage;
1043 if (numPageToDraw < minPage) numPageToDraw = minPage;
1044 if (numPageToDraw > maxPage) numPageToDraw = maxPage;
1045
1046 GtkPrintSettings * settings = gtk_print_operation_get_print_settings (operation);
1047 switch (gtk_print_settings_get_print_pages(settings))
1048 {
1049 case GTK_PRINT_PAGES_CURRENT:
1050 g_object_get_property((GObject*) operation, (const gchar *) "current-page", (GValue*) &startPage);
1051 g_object_get_property((GObject*) operation, (const gchar *) "current-page", (GValue*) &endPage);
1052 break;
1053 case GTK_PRINT_PAGES_RANGES:
1054 {gint num_ranges = 0;
1055 GtkPageRange* range;
1056 range = gtk_print_settings_get_page_ranges (settings, &num_ranges);
1057 // We don't need to verify these values as it has already been done in wxGtkPrinter::BeginPrint.
1058 if (num_ranges >= 1)
1059 {
1060 startPage = range[0].start + 1;
1061 endPage = range[0].end + 1;
1062 }
1063 else {
1064 startPage = minPage;
1065 endPage = maxPage;
1066 }
1067 break;}
1068 case GTK_PRINT_PAGES_ALL:
1069 default:
1070 startPage = minPage;
1071 endPage = maxPage;
1072 break;
1073 }
1074
1075 if(numPageToDraw == startPage)
1076 {
1077 if (!printout->OnBeginDocument(startPage, endPage))
1078 {
1079 wxLogError(_("Could not start printing."));
1080 sm_lastError = wxPRINTER_ERROR;
1081 }
1082 }
1083
1084 // The app can render the page numPageToDraw.
1085 if (printout->HasPage(numPageToDraw))
1086 {
1087 m_dc->StartPage();
1088 printout->OnPrintPage(numPageToDraw);
1089 m_dc->EndPage();
1090 }
1091
1092
1093 if(numPageToDraw == endPage)
1094 {
1095 printout->OnEndDocument();
1096 }
1097}
1098
1099wxDC* wxGtkPrinter::PrintDialog( wxWindow *parent )
1100{
1101 wxGtkPrintDialog dialog( parent, &m_printDialogData );
1102
1103 dialog.SetPrintDC(m_dc);
1104 dialog.SetShowDialog(true);
1105
1106 int ret = dialog.ShowModal();
1107
1108 if (ret == wxID_CANCEL)
1109 {
1110 sm_lastError = wxPRINTER_CANCELLED;
1111 return NULL;
1112 }
1113 if (ret == wxID_NO)
1114 {
1115 sm_lastError = wxPRINTER_ERROR;
1116 wxFAIL_MSG(_("The print dialog returned an error."));
1117 return NULL;
1118 }
1119
1120 m_printDialogData = dialog.GetPrintDialogData();
1121
1122 return new wxPrinterDC( m_printDialogData.GetPrintData() );
1123}
1124
1125bool wxGtkPrinter::Setup( wxWindow * WXUNUSED(parent) )
1126{
1127 // Obsolete, for backward compatibility.
1128 return false;
1129}
1130
1131//-----------------------------------------------------------------------------
1132// wxGtkPrinterDC
1133//-----------------------------------------------------------------------------
1134
1135#define wxCAIRO_SCALE 1
1136
1137#if wxCAIRO_SCALE
1138
1139#define XLOG2DEV(x) LogicalToDeviceX(x)
1140#define XLOG2DEVREL(x) LogicalToDeviceXRel(x)
1141#define YLOG2DEV(x) LogicalToDeviceY(x)
1142#define YLOG2DEVREL(x) LogicalToDeviceYRel(x)
1143
1144#else
1145
1146#define XLOG2DEV(x) ((double)(LogicalToDeviceX(x)) * m_DEV2PS)
1147#define XLOG2DEVREL(x) ((double)(LogicalToDeviceXRel(x)) * m_DEV2PS)
1148#define YLOG2DEV(x) ((double)(LogicalToDeviceY(x)) * m_DEV2PS)
1149#define YLOG2DEVREL(x) ((double)(LogicalToDeviceYRel(x)) * m_DEV2PS)
1150
1151#endif
1152
1153IMPLEMENT_ABSTRACT_CLASS(wxGtkPrinterDCImpl, wxDCImpl)
1154
1155wxGtkPrinterDCImpl::wxGtkPrinterDCImpl(wxPrinterDC *owner, const wxPrintData& data)
1156 : wxDCImpl( owner )
1157{
1158 m_printData = data;
1159
1160 wxGtkPrintNativeData *native =
1161 (wxGtkPrintNativeData*) m_printData.GetNativeData();
1162
1163 m_gpc = native->GetPrintContext();
1164
1165 // Match print quality to resolution (high = 1200dpi)
1166 m_resolution = m_printData.GetQuality(); // (int) gtk_print_context_get_dpi_x( m_gpc );
1167 if (m_resolution < 0)
1168 m_resolution = (1 << (m_resolution+4)) *150;
1169
1170 m_context = gtk_print_context_create_pango_context( m_gpc );
1171 m_layout = gtk_print_context_create_pango_layout ( m_gpc );
1172 m_fontdesc = pango_font_description_from_string( "Sans 12" );
1173
1174 m_cairo = gtk_print_context_get_cairo_context ( m_gpc );
1175
1176#if wxCAIRO_SCALE
1177 m_PS2DEV = 1.0;
1178 m_DEV2PS = 1.0;
1179
1180 cairo_scale( m_cairo, 72.0 / (double)m_resolution, 72.0 / (double)m_resolution );
1181#else
1182 m_PS2DEV = (double)m_resolution / 72.0;
1183 m_DEV2PS = 72.0 / (double)m_resolution;
1184#endif
1185
1186 m_currentRed = 0;
1187 m_currentBlue = 0;
1188 m_currentGreen = 0;
1189
1190 m_signX = 1; // default x-axis left to right.
1191 m_signY = 1; // default y-axis bottom up -> top down.
1192
1193 // By default the origin of the Cairo context is in the upper left
1194 // corner of the printable area. We need to translate it so that it
1195 // is in the upper left corner of the paper (without margins)
1196 GtkPageSetup *setup = gtk_print_context_get_page_setup( m_gpc );
1197 gdouble ml, mt;
1198 ml = gtk_page_setup_get_left_margin (setup, GTK_UNIT_POINTS);
1199 mt = gtk_page_setup_get_top_margin (setup, GTK_UNIT_POINTS);
1200 cairo_translate(m_cairo, -ml, -mt);
1201}
1202
1203wxGtkPrinterDCImpl::~wxGtkPrinterDCImpl()
1204{
1205 g_object_unref(m_context);
1206 g_object_unref(m_layout);
1207}
1208
1209bool wxGtkPrinterDCImpl::IsOk() const
1210{
1211 return m_gpc != NULL;
1212}
1213
1214void* wxGtkPrinterDCImpl::GetCairoContext() const
1215{
1216 return (void*) cairo_reference( m_cairo );
1217}
1218
1219void* wxGtkPrinterDCImpl::GetHandle() const
1220{
1221 return GetCairoContext();
1222}
1223
1224bool wxGtkPrinterDCImpl::DoFloodFill(wxCoord WXUNUSED(x1),
1225 wxCoord WXUNUSED(y1),
1226 const wxColour& WXUNUSED(col),
1227 wxFloodFillStyle WXUNUSED(style))
1228{
1229 // We can't access the given coord as a Cairo context is scalable, ie a
1230 // coord doesn't mean anything in this context.
1231 wxFAIL_MSG(_("not implemented"));
1232 return false;
1233}
1234
1235void wxGtkPrinterDCImpl::DoGradientFillConcentric(const wxRect& rect, const wxColour& initialColour, const wxColour& destColour, const wxPoint& circleCenter)
1236{
1237 wxCoord xC = circleCenter.x;
1238 wxCoord yC = circleCenter.y;
1239 wxCoord xR = rect.x;
1240 wxCoord yR = rect.y;
1241 wxCoord w = rect.width;
1242 wxCoord h = rect.height;
1243
1244 const double r2 = (w/2)*(w/2)+(h/2)*(h/2);
1245 double radius = sqrt(r2);
1246
1247 unsigned char redI = initialColour.Red();
1248 unsigned char blueI = initialColour.Blue();
1249 unsigned char greenI = initialColour.Green();
1250 unsigned char alphaI = initialColour.Alpha();
1251 unsigned char redD = destColour.Red();
1252 unsigned char blueD = destColour.Blue();
1253 unsigned char greenD = destColour.Green();
1254 unsigned char alphaD = destColour.Alpha();
1255
1256 double redIPS = (double)(redI) / 255.0;
1257 double blueIPS = (double)(blueI) / 255.0;
1258 double greenIPS = (double)(greenI) / 255.0;
1259 double alphaIPS = (double)(alphaI) / 255.0;
1260 double redDPS = (double)(redD) / 255.0;
1261 double blueDPS = (double)(blueD) / 255.0;
1262 double greenDPS = (double)(greenD) / 255.0;
1263 double alphaDPS = (double)(alphaD) / 255.0;
1264
1265 // Create a pattern with the gradient.
1266 cairo_pattern_t* gradient;
1267 gradient = cairo_pattern_create_radial (XLOG2DEV(xC+xR), YLOG2DEV(yC+yR), 0, XLOG2DEV(xC+xR), YLOG2DEV(yC+yR), radius * m_DEV2PS );
1268 cairo_pattern_add_color_stop_rgba (gradient, 0.0, redIPS, greenIPS, blueIPS, alphaIPS);
1269 cairo_pattern_add_color_stop_rgba (gradient, 1.0, redDPS, greenDPS, blueDPS, alphaDPS);
1270
1271 // Fill the rectangle with this pattern.
1272 cairo_set_source(m_cairo, gradient);
1273 cairo_rectangle (m_cairo, XLOG2DEV(xR), YLOG2DEV(yR), XLOG2DEVREL(w), YLOG2DEVREL(h) );
1274 cairo_fill(m_cairo);
1275
1276 cairo_pattern_destroy(gradient);
1277
1278 CalcBoundingBox(xR, yR);
1279 CalcBoundingBox(xR+w, yR+h);
1280}
1281
1282void wxGtkPrinterDCImpl::DoGradientFillLinear(const wxRect& rect, const wxColour& initialColour, const wxColour& destColour, wxDirection nDirection)
1283{
1284 wxCoord x = rect.x;
1285 wxCoord y = rect.y;
1286 wxCoord w = rect.width;
1287 wxCoord h = rect.height;
1288
1289 unsigned char redI = initialColour.Red();
1290 unsigned char blueI = initialColour.Blue();
1291 unsigned char greenI = initialColour.Green();
1292 unsigned char alphaI = initialColour.Alpha();
1293 unsigned char redD = destColour.Red();
1294 unsigned char blueD = destColour.Blue();
1295 unsigned char greenD = destColour.Green();
1296 unsigned char alphaD = destColour.Alpha();
1297
1298 double redIPS = (double)(redI) / 255.0;
1299 double blueIPS = (double)(blueI) / 255.0;
1300 double greenIPS = (double)(greenI) / 255.0;
1301 double alphaIPS = (double)(alphaI) / 255.0;
1302 double redDPS = (double)(redD) / 255.0;
1303 double blueDPS = (double)(blueD) / 255.0;
1304 double greenDPS = (double)(greenD) / 255.0;
1305 double alphaDPS = (double)(alphaD) / 255.0;
1306
1307 // Create a pattern with the gradient.
1308 cairo_pattern_t* gradient;
1309 gradient = cairo_pattern_create_linear (XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x+w), YLOG2DEV(y));
1310
1311 if (nDirection == wxWEST)
1312 {
1313 cairo_pattern_add_color_stop_rgba (gradient, 0.0, redDPS, greenDPS, blueDPS, alphaDPS);
1314 cairo_pattern_add_color_stop_rgba (gradient, 1.0, redIPS, greenIPS, blueIPS, alphaIPS);
1315 }
1316 else {
1317 cairo_pattern_add_color_stop_rgba (gradient, 0.0, redIPS, greenIPS, blueIPS, alphaIPS);
1318 cairo_pattern_add_color_stop_rgba (gradient, 1.0, redDPS, greenDPS, blueDPS, alphaDPS);
1319 }
1320
1321 // Fill the rectangle with this pattern.
1322 cairo_set_source(m_cairo, gradient);
1323 cairo_rectangle (m_cairo, XLOG2DEV(x), YLOG2DEV(y), XLOG2DEVREL(w), YLOG2DEVREL(h) );
1324 cairo_fill(m_cairo);
1325
1326 cairo_pattern_destroy(gradient);
1327
1328 CalcBoundingBox(x, y);
1329 CalcBoundingBox(x+w, y+h);
1330}
1331
1332bool wxGtkPrinterDCImpl::DoGetPixel(wxCoord WXUNUSED(x1),
1333 wxCoord WXUNUSED(y1),
1334 wxColour * WXUNUSED(col)) const
1335{
1336 wxFAIL_MSG(_("not implemented"));
1337 return false;
1338}
1339
1340void wxGtkPrinterDCImpl::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
1341{
1342 if ( m_pen.IsTransparent() )
1343 return;
1344
1345 SetPen( m_pen );
1346 cairo_move_to ( m_cairo, XLOG2DEV(x1), YLOG2DEV(y1) );
1347 cairo_line_to ( m_cairo, XLOG2DEV(x2), YLOG2DEV(y2) );
1348 cairo_stroke ( m_cairo );
1349
1350 CalcBoundingBox( x1, y1 );
1351 CalcBoundingBox( x2, y2 );
1352}
1353
1354void wxGtkPrinterDCImpl::DoCrossHair(wxCoord x, wxCoord y)
1355{
1356 int w, h;
1357 DoGetSize(&w, &h);
1358
1359 SetPen(m_pen);
1360
1361 cairo_move_to (m_cairo, XLOG2DEV(x), 0);
1362 cairo_line_to (m_cairo, XLOG2DEV(x), YLOG2DEVREL(h));
1363 cairo_move_to (m_cairo, 0, YLOG2DEV(y));
1364 cairo_line_to (m_cairo, XLOG2DEVREL(w), YLOG2DEV(y));
1365
1366 cairo_stroke (m_cairo);
1367 CalcBoundingBox( 0, 0 );
1368 CalcBoundingBox( w, h );
1369}
1370
1371void wxGtkPrinterDCImpl::DoDrawArc(wxCoord x1,wxCoord y1,wxCoord x2,wxCoord y2,wxCoord xc,wxCoord yc)
1372{
1373 double dx = x1 - xc;
1374 double dy = y1 - yc;
1375 double radius = sqrt((double)(dx*dx+dy*dy));
1376
1377 double alpha1, alpha2;
1378 if (x1 == x2 && y1 == y2)
1379 {
1380 alpha1 = 0.0;
1381 alpha2 = 360.0;
1382 }
1383 else
1384 if (radius == 0.0)
1385 {
1386 alpha1 = alpha2 = 0.0;
1387 }
1388 else
1389 {
1390 alpha1 = (x1 - xc == 0) ?
1391 (y1 - yc < 0) ? 90.0 : -90.0 :
1392 atan2(double(y1-yc), double(x1-xc)) * RAD2DEG;
1393 alpha2 = (x2 - xc == 0) ?
1394 (y2 - yc < 0) ? 90.0 : -90.0 :
1395 atan2(double(y2-yc), double(x2-xc)) * RAD2DEG;
1396
1397 while (alpha1 <= 0) alpha1 += 360;
1398 while (alpha2 <= 0) alpha2 += 360; // adjust angles to be between.
1399 while (alpha1 > 360) alpha1 -= 360; // 0 and 360 degree.
1400 while (alpha2 > 360) alpha2 -= 360;
1401 }
1402
1403 alpha1 *= DEG2RAD;
1404 alpha2 *= DEG2RAD;
1405
1406 cairo_new_path(m_cairo);
1407
1408 cairo_arc_negative ( m_cairo, XLOG2DEV(xc), YLOG2DEV(yc), XLOG2DEVREL((int)radius), alpha1, alpha2);
1409 cairo_line_to(m_cairo, XLOG2DEV(xc), YLOG2DEV(yc));
1410 cairo_close_path (m_cairo);
1411
1412 SetBrush( m_brush );
1413 cairo_fill_preserve( m_cairo );
1414
1415 SetPen (m_pen);
1416 cairo_stroke( m_cairo );
1417
1418 CalcBoundingBox (x1, y1);
1419 CalcBoundingBox (xc, yc);
1420 CalcBoundingBox (x2, y2);
1421}
1422
1423void wxGtkPrinterDCImpl::DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,double ea)
1424{
1425 cairo_save( m_cairo );
1426
1427 cairo_new_path(m_cairo);
1428
1429 cairo_translate( m_cairo, XLOG2DEV((wxCoord) (x + w / 2.)), XLOG2DEV((wxCoord) (y + h / 2.)) );
1430 double scale = (double)YLOG2DEVREL(h) / (double) XLOG2DEVREL(w);
1431 cairo_scale( m_cairo, 1.0, scale );
1432
1433 cairo_arc_negative ( m_cairo, 0, 0, XLOG2DEVREL(w/2), -sa*DEG2RAD, -ea*DEG2RAD);
1434
1435 SetPen (m_pen);
1436 cairo_stroke_preserve( m_cairo );
1437
1438 cairo_line_to(m_cairo, 0,0);
1439
1440 SetBrush( m_brush );
1441 cairo_fill( m_cairo );
1442
1443 cairo_restore( m_cairo );
1444
1445 CalcBoundingBox( x, y);
1446 CalcBoundingBox( x+w, y+h );
1447}
1448
1449void wxGtkPrinterDCImpl::DoDrawPoint(wxCoord x, wxCoord y)
1450{
1451 if ( m_pen.IsTransparent() )
1452 return;
1453
1454 SetPen( m_pen );
1455
1456 cairo_move_to ( m_cairo, XLOG2DEV(x), YLOG2DEV(y) );
1457 cairo_line_to ( m_cairo, XLOG2DEV(x), YLOG2DEV(y) );
1458 cairo_stroke ( m_cairo );
1459
1460 CalcBoundingBox( x, y );
1461}
1462
1463void wxGtkPrinterDCImpl::DoDrawLines(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset)
1464{
1465 if ( m_pen.IsTransparent() )
1466 return;
1467
1468
1469 if (n <= 0) return;
1470
1471 SetPen (m_pen);
1472
1473 int i;
1474 for ( i =0; i<n ; i++ )
1475 CalcBoundingBox( points[i].x+xoffset, points[i].y+yoffset);
1476
1477 cairo_move_to ( m_cairo, XLOG2DEV(points[0].x+xoffset), YLOG2DEV(points[0].y+yoffset) );
1478
1479 for (i = 1; i < n; i++)
1480 cairo_line_to ( m_cairo, XLOG2DEV(points[i].x+xoffset), YLOG2DEV(points[i].y+yoffset) );
1481
1482 cairo_stroke ( m_cairo);
1483}
1484
1485void wxGtkPrinterDCImpl::DoDrawPolygon(int n, wxPoint points[],
1486 wxCoord xoffset, wxCoord yoffset,
1487 wxPolygonFillMode fillStyle)
1488{
1489 if (n==0) return;
1490
1491 cairo_save(m_cairo);
1492 if (fillStyle == wxWINDING_RULE)
1493 cairo_set_fill_rule( m_cairo, CAIRO_FILL_RULE_WINDING);
1494 else
1495 cairo_set_fill_rule( m_cairo, CAIRO_FILL_RULE_EVEN_ODD);
1496
1497 int x = points[0].x + xoffset;
1498 int y = points[0].y + yoffset;
1499 cairo_new_path(m_cairo);
1500 cairo_move_to( m_cairo, XLOG2DEV(x), YLOG2DEV(y) );
1501 int i;
1502 for (i = 1; i < n; i++)
1503 {
1504 int x = points[i].x + xoffset;
1505 int y = points[i].y + yoffset;
1506 cairo_line_to( m_cairo, XLOG2DEV(x), YLOG2DEV(y) );
1507 }
1508 cairo_close_path(m_cairo);
1509
1510 SetBrush( m_brush );
1511 cairo_fill_preserve( m_cairo );
1512
1513 SetPen (m_pen);
1514 cairo_stroke( m_cairo );
1515
1516 CalcBoundingBox( x, y );
1517
1518 cairo_restore(m_cairo);
1519}
1520
1521void wxGtkPrinterDCImpl::DoDrawPolyPolygon(int n, int count[], wxPoint points[],
1522 wxCoord xoffset, wxCoord yoffset,
1523 wxPolygonFillMode fillStyle)
1524{
1525 wxDCImpl::DoDrawPolyPolygon( n, count, points, xoffset, yoffset, fillStyle );
1526}
1527
1528void wxGtkPrinterDCImpl::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1529{
1530 width--;
1531 height--;
1532
1533 cairo_new_path(m_cairo);
1534 cairo_rectangle ( m_cairo, XLOG2DEV(x), YLOG2DEV(y), XLOG2DEVREL(width), YLOG2DEVREL(height));
1535
1536 SetBrush( m_brush );
1537 cairo_fill_preserve( m_cairo );
1538
1539 SetPen (m_pen);
1540 cairo_stroke( m_cairo );
1541
1542 CalcBoundingBox( x, y );
1543 CalcBoundingBox( x + width, y + height );
1544}
1545
1546void wxGtkPrinterDCImpl::DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius)
1547{
1548 width--;
1549 height--;
1550
1551 if (radius < 0.0) radius = - radius * ((width < height) ? width : height);
1552
1553 wxCoord dd = 2 * (wxCoord) radius;
1554 if (dd > width) dd = width;
1555 if (dd > height) dd = height;
1556 radius = dd / 2;
1557
1558 wxCoord rad = (wxCoord) radius;
1559
1560 cairo_new_path(m_cairo);
1561 cairo_move_to(m_cairo,XLOG2DEV(x + rad),YLOG2DEV(y));
1562 cairo_curve_to(m_cairo,
1563 XLOG2DEV(x + rad),YLOG2DEV(y),
1564 XLOG2DEV(x),YLOG2DEV(y),
1565 XLOG2DEV(x),YLOG2DEV(y + rad));
1566 cairo_line_to(m_cairo,XLOG2DEV(x),YLOG2DEV(y + height - rad));
1567 cairo_curve_to(m_cairo,
1568 XLOG2DEV(x),YLOG2DEV(y + height - rad),
1569 XLOG2DEV(x),YLOG2DEV(y + height),
1570 XLOG2DEV(x + rad),YLOG2DEV(y + height));
1571 cairo_line_to(m_cairo,XLOG2DEV(x + width - rad),YLOG2DEV(y + height));
1572 cairo_curve_to(m_cairo,
1573 XLOG2DEV(x + width - rad),YLOG2DEV(y + height),
1574 XLOG2DEV(x + width),YLOG2DEV(y + height),
1575 XLOG2DEV(x + width),YLOG2DEV(y + height - rad));
1576 cairo_line_to(m_cairo,XLOG2DEV(x + width),YLOG2DEV(y + rad));
1577 cairo_curve_to(m_cairo,
1578 XLOG2DEV(x + width),YLOG2DEV(y + rad),
1579 XLOG2DEV(x + width),YLOG2DEV(y),
1580 XLOG2DEV(x + width - rad),YLOG2DEV(y));
1581 cairo_line_to(m_cairo,XLOG2DEV(x + rad),YLOG2DEV(y));
1582 cairo_close_path(m_cairo);
1583
1584 SetBrush(m_brush);
1585 cairo_fill_preserve(m_cairo);
1586
1587 SetPen(m_pen);
1588 cairo_stroke(m_cairo);
1589
1590 CalcBoundingBox(x,y);
1591 CalcBoundingBox(x+width,y+height);
1592}
1593
1594void wxGtkPrinterDCImpl::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1595{
1596 width--;
1597 height--;
1598
1599 cairo_save (m_cairo);
1600
1601 cairo_new_path(m_cairo);
1602
1603 cairo_translate (m_cairo, XLOG2DEV((wxCoord) (x + width / 2.)), YLOG2DEV((wxCoord) (y + height / 2.)));
1604 cairo_scale(m_cairo, 1, (double)YLOG2DEVREL(height)/(double)XLOG2DEVREL(width));
1605 cairo_arc ( m_cairo, 0, 0, XLOG2DEVREL(width/2), 0, 2 * M_PI);
1606
1607 SetBrush( m_brush );
1608 cairo_fill_preserve( m_cairo );
1609
1610 SetPen (m_pen);
1611 cairo_stroke( m_cairo );
1612
1613 CalcBoundingBox( x, y );
1614 CalcBoundingBox( x + width, y + height );
1615
1616 cairo_restore (m_cairo);
1617}
1618
1619#if wxUSE_SPLINES
1620void wxGtkPrinterDCImpl::DoDrawSpline(const wxPointList *points)
1621{
1622 SetPen (m_pen);
1623
1624 double c, d, x1, y1, x2, y2, x3, y3;
1625 wxPoint *p, *q;
1626
1627 wxPointList::compatibility_iterator node = points->GetFirst();
1628 p = node->GetData();
1629 x1 = p->x;
1630 y1 = p->y;
1631
1632 node = node->GetNext();
1633 p = node->GetData();
1634 c = p->x;
1635 d = p->y;
1636 x3 =
1637 (double)(x1 + c) / 2;
1638 y3 =
1639 (double)(y1 + d) / 2;
1640
1641 cairo_new_path( m_cairo );
1642 cairo_move_to( m_cairo, XLOG2DEV((wxCoord)x1), YLOG2DEV((wxCoord)y1) );
1643 cairo_line_to( m_cairo, XLOG2DEV((wxCoord)x3), YLOG2DEV((wxCoord)y3) );
1644
1645 CalcBoundingBox( (wxCoord)x1, (wxCoord)y1 );
1646 CalcBoundingBox( (wxCoord)x3, (wxCoord)y3 );
1647
1648 node = node->GetNext();
1649 while (node)
1650 {
1651 q = node->GetData();
1652
1653 x1 = x3;
1654 y1 = y3;
1655 x2 = c;
1656 y2 = d;
1657 c = q->x;
1658 d = q->y;
1659 x3 = (double)(x2 + c) / 2;
1660 y3 = (double)(y2 + d) / 2;
1661
1662 cairo_curve_to(m_cairo,
1663 XLOG2DEV((wxCoord)x1), YLOG2DEV((wxCoord)y1),
1664 XLOG2DEV((wxCoord)x2), YLOG2DEV((wxCoord)y2),
1665 XLOG2DEV((wxCoord)x3), YLOG2DEV((wxCoord)y3) );
1666
1667 CalcBoundingBox( (wxCoord)x1, (wxCoord)y1 );
1668 CalcBoundingBox( (wxCoord)x3, (wxCoord)y3 );
1669
1670 node = node->GetNext();
1671 }
1672
1673 cairo_line_to ( m_cairo, XLOG2DEV((wxCoord)c), YLOG2DEV((wxCoord)d) );
1674
1675 cairo_stroke( m_cairo );
1676}
1677#endif // wxUSE_SPLINES
1678
1679bool wxGtkPrinterDCImpl::DoBlit(wxCoord xdest, wxCoord ydest,
1680 wxCoord width, wxCoord height,
1681 wxDC *source, wxCoord xsrc, wxCoord ysrc,
1682 wxRasterOperationMode rop, bool useMask,
1683 wxCoord WXUNUSED_UNLESS_DEBUG(xsrcMask),
1684 wxCoord WXUNUSED_UNLESS_DEBUG(ysrcMask))
1685{
1686 wxASSERT_MSG( xsrcMask == wxDefaultCoord && ysrcMask == wxDefaultCoord,
1687 wxT("mask coordinates are not supported") );
1688
1689 wxCHECK_MSG( source, false, wxT("invalid source dc") );
1690
1691 // Blit into a bitmap.
1692 wxBitmap bitmap( width, height );
1693 wxMemoryDC memDC;
1694 memDC.SelectObject(bitmap);
1695 memDC.Blit(0, 0, width, height, source, xsrc, ysrc, rop);
1696 memDC.SelectObject(wxNullBitmap);
1697
1698 // Draw bitmap. scaling and positioning is done there.
1699 GetOwner()->DrawBitmap( bitmap, xdest, ydest, useMask );
1700
1701 return true;
1702}
1703
1704void wxGtkPrinterDCImpl::DoDrawIcon( const wxIcon& icon, wxCoord x, wxCoord y )
1705{
1706 DoDrawBitmap( icon, x, y, true );
1707}
1708
1709void wxGtkPrinterDCImpl::DoDrawBitmap( const wxBitmap& bitmap, wxCoord x, wxCoord y, bool useMask )
1710{
1711 wxCHECK_RET( bitmap.IsOk(), wxT("Invalid bitmap in wxGtkPrinterDCImpl::DoDrawBitmap"));
1712
1713 x = wxCoord(XLOG2DEV(x));
1714 y = wxCoord(YLOG2DEV(y));
1715 int bw = bitmap.GetWidth();
1716 int bh = bitmap.GetHeight();
1717#ifndef __WXGTK3__
1718 wxBitmap bmpSource = bitmap; // we need a non-const instance.
1719 if (!useMask && !bitmap.HasPixbuf() && bitmap.GetMask())
1720 bmpSource.SetMask(NULL);
1721#endif
1722
1723 cairo_save(m_cairo);
1724
1725 // Prepare to draw the image.
1726 cairo_translate(m_cairo, x, y);
1727
1728 // Scale the image
1729 wxDouble scaleX = (wxDouble) XLOG2DEVREL(bw) / (wxDouble) bw;
1730 wxDouble scaleY = (wxDouble) YLOG2DEVREL(bh) / (wxDouble) bh;
1731 cairo_scale(m_cairo, scaleX, scaleY);
1732
1733#ifdef __WXGTK3__
1734 bitmap.Draw(m_cairo, 0, 0, useMask, &m_textForegroundColour, &m_textBackgroundColour);
1735#else
1736 gdk_cairo_set_source_pixbuf(m_cairo, bmpSource.GetPixbuf(), 0, 0);
1737 cairo_pattern_set_filter(cairo_get_source(m_cairo), CAIRO_FILTER_NEAREST);
1738 // Use the original size here since the context is scaled already.
1739 cairo_rectangle(m_cairo, 0, 0, bw, bh);
1740 // Fill the rectangle using the pattern.
1741 cairo_fill(m_cairo);
1742#endif
1743
1744 CalcBoundingBox(0,0);
1745 CalcBoundingBox(bw,bh);
1746
1747 cairo_restore(m_cairo);
1748}
1749
1750void wxGtkPrinterDCImpl::DoDrawText(const wxString& text, wxCoord x, wxCoord y )
1751{
1752 DoDrawRotatedText( text, x, y, 0.0 );
1753}
1754
1755void wxGtkPrinterDCImpl::DoDrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle)
1756{
1757 double xx = XLOG2DEV(x);
1758 double yy = YLOG2DEV(y);
1759
1760 angle = -angle;
1761
1762 const wxScopedCharBuffer data = text.utf8_str();
1763
1764 pango_layout_set_text(m_layout, data, data.length());
1765
1766 const bool setAttrs = m_font.GTKSetPangoAttrs(m_layout);
1767 if (m_textForegroundColour.IsOk())
1768 {
1769 unsigned char red = m_textForegroundColour.Red();
1770 unsigned char blue = m_textForegroundColour.Blue();
1771 unsigned char green = m_textForegroundColour.Green();
1772 unsigned char alpha = m_textForegroundColour.Alpha();
1773
1774 if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue && alpha == m_currentAlpha))
1775 {
1776 double redPS = (double)(red) / 255.0;
1777 double bluePS = (double)(blue) / 255.0;
1778 double greenPS = (double)(green) / 255.0;
1779 double alphaPS = (double)(alpha) / 255.0;
1780
1781 cairo_set_source_rgba( m_cairo, redPS, greenPS, bluePS, alphaPS );
1782
1783 m_currentRed = red;
1784 m_currentBlue = blue;
1785 m_currentGreen = green;
1786 m_currentAlpha = alpha;
1787 }
1788 }
1789
1790 // Draw layout.
1791 cairo_move_to (m_cairo, xx, yy);
1792
1793 cairo_save( m_cairo );
1794
1795 if (fabs(angle) > 0.00001)
1796 cairo_rotate( m_cairo, angle*DEG2RAD );
1797
1798 cairo_scale(m_cairo, m_scaleX, m_scaleY);
1799
1800 int w,h;
1801 pango_layout_get_pixel_size( m_layout, &w, &h );
1802
1803 if ( m_backgroundMode == wxBRUSHSTYLE_SOLID )
1804 {
1805 unsigned char red = m_textBackgroundColour.Red();
1806 unsigned char blue = m_textBackgroundColour.Blue();
1807 unsigned char green = m_textBackgroundColour.Green();
1808 unsigned char alpha = m_textBackgroundColour.Alpha();
1809
1810 double redPS = (double)(red) / 255.0;
1811 double bluePS = (double)(blue) / 255.0;
1812 double greenPS = (double)(green) / 255.0;
1813 double alphaPS = (double)(alpha) / 255.0;
1814
1815 cairo_save(m_cairo);
1816 cairo_set_source_rgba( m_cairo, redPS, greenPS, bluePS, alphaPS );
1817 cairo_rectangle(m_cairo, 0, 0, w, h); // still in cairo units
1818 cairo_fill(m_cairo);
1819 cairo_restore(m_cairo);
1820 }
1821
1822 pango_cairo_update_layout (m_cairo, m_layout);
1823 pango_cairo_show_layout (m_cairo, m_layout);
1824
1825 cairo_restore( m_cairo );
1826
1827 if (setAttrs)
1828 {
1829 // Undo underline attributes setting
1830 pango_layout_set_attributes(m_layout, NULL);
1831 }
1832
1833 // Back to device units:
1834 CalcBoundingBox (x, y);
1835 CalcBoundingBox (x + w, y + h);
1836}
1837
1838void wxGtkPrinterDCImpl::Clear()
1839{
1840// Clear does nothing for printing, but keep the code
1841// for later reuse
1842/*
1843 cairo_save(m_cairo);
1844 cairo_set_operator (m_cairo, CAIRO_OPERATOR_SOURCE);
1845 SetBrush(m_backgroundBrush);
1846 cairo_paint(m_cairo);
1847 cairo_restore(m_cairo);
1848*/
1849}
1850
1851void wxGtkPrinterDCImpl::SetFont( const wxFont& font )
1852{
1853 m_font = font;
1854
1855 if (m_font.IsOk())
1856 {
1857 if (m_fontdesc)
1858 pango_font_description_free( m_fontdesc );
1859
1860 m_fontdesc = pango_font_description_copy( m_font.GetNativeFontInfo()->description );
1861
1862 float size = pango_font_description_get_size( m_fontdesc );
1863 size = size * GetFontPointSizeAdjustment(72.0);
1864 pango_font_description_set_size( m_fontdesc, (gint)size );
1865
1866 pango_layout_set_font_description( m_layout, m_fontdesc );
1867 }
1868}
1869
1870void wxGtkPrinterDCImpl::SetPen( const wxPen& pen )
1871{
1872 if (!pen.IsOk()) return;
1873
1874 m_pen = pen;
1875
1876 double width;
1877
1878 if (m_pen.GetWidth() <= 0)
1879 width = 0.1;
1880 else
1881 width = (double) m_pen.GetWidth();
1882
1883 cairo_set_line_width( m_cairo, width * m_DEV2PS * m_scaleX );
1884 static const double dotted[] = {2.0, 5.0};
1885 static const double short_dashed[] = {4.0, 4.0};
1886 static const double long_dashed[] = {4.0, 8.0};
1887 static const double dotted_dashed[] = {6.0, 6.0, 2.0, 6.0};
1888
1889 switch (m_pen.GetStyle())
1890 {
1891 case wxPENSTYLE_DOT: cairo_set_dash( m_cairo, dotted, 2, 0 ); break;
1892 case wxPENSTYLE_SHORT_DASH: cairo_set_dash( m_cairo, short_dashed, 2, 0 ); break;
1893 case wxPENSTYLE_LONG_DASH: cairo_set_dash( m_cairo, long_dashed, 2, 0 ); break;
1894 case wxPENSTYLE_DOT_DASH: cairo_set_dash( m_cairo, dotted_dashed, 4, 0 ); break;
1895 case wxPENSTYLE_USER_DASH:
1896 {
1897 wxDash *wx_dashes;
1898 int num = m_pen.GetDashes (&wx_dashes);
1899 gdouble *g_dashes = g_new( gdouble, num );
1900 int i;
1901 for (i = 0; i < num; ++i)
1902 g_dashes[i] = (gdouble) wx_dashes[i];
1903 cairo_set_dash( m_cairo, g_dashes, num, 0);
1904 g_free( g_dashes );
1905 }
1906 break;
1907 case wxPENSTYLE_SOLID:
1908 case wxPENSTYLE_TRANSPARENT:
1909 default: cairo_set_dash( m_cairo, NULL, 0, 0 ); break;
1910 }
1911
1912 switch (m_pen.GetCap())
1913 {
1914 case wxCAP_PROJECTING: cairo_set_line_cap (m_cairo, CAIRO_LINE_CAP_SQUARE); break;
1915 case wxCAP_BUTT: cairo_set_line_cap (m_cairo, CAIRO_LINE_CAP_BUTT); break;
1916 case wxCAP_ROUND:
1917 default: cairo_set_line_cap (m_cairo, CAIRO_LINE_CAP_ROUND); break;
1918 }
1919
1920 switch (m_pen.GetJoin())
1921 {
1922 case wxJOIN_BEVEL: cairo_set_line_join (m_cairo, CAIRO_LINE_JOIN_BEVEL); break;
1923 case wxJOIN_MITER: cairo_set_line_join (m_cairo, CAIRO_LINE_JOIN_MITER); break;
1924 case wxJOIN_ROUND:
1925 default: cairo_set_line_join (m_cairo, CAIRO_LINE_JOIN_ROUND); break;
1926 }
1927
1928 unsigned char red = m_pen.GetColour().Red();
1929 unsigned char blue = m_pen.GetColour().Blue();
1930 unsigned char green = m_pen.GetColour().Green();
1931 unsigned char alpha = m_pen.GetColour().Alpha();
1932
1933 if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue && alpha == m_currentAlpha))
1934 {
1935 double redPS = (double)(red) / 255.0;
1936 double bluePS = (double)(blue) / 255.0;
1937 double greenPS = (double)(green) / 255.0;
1938 double alphaPS = (double)(alpha) / 255.0;
1939
1940 cairo_set_source_rgba( m_cairo, redPS, greenPS, bluePS, alphaPS );
1941
1942 m_currentRed = red;
1943 m_currentBlue = blue;
1944 m_currentGreen = green;
1945 m_currentAlpha = alpha;
1946 }
1947}
1948
1949void wxGtkPrinterDCImpl::SetBrush( const wxBrush& brush )
1950{
1951 if (!brush.IsOk()) return;
1952
1953 m_brush = brush;
1954
1955 if (m_brush.GetStyle() == wxBRUSHSTYLE_TRANSPARENT)
1956 {
1957 cairo_set_source_rgba( m_cairo, 0, 0, 0, 0 );
1958 m_currentRed = 0;
1959 m_currentBlue = 0;
1960 m_currentGreen = 0;
1961 m_currentAlpha = 0;
1962 return;
1963 }
1964
1965 // Brush colour.
1966 unsigned char red = m_brush.GetColour().Red();
1967 unsigned char blue = m_brush.GetColour().Blue();
1968 unsigned char green = m_brush.GetColour().Green();
1969 unsigned char alpha = m_brush.GetColour().Alpha();
1970
1971 double redPS = (double)(red) / 255.0;
1972 double bluePS = (double)(blue) / 255.0;
1973 double greenPS = (double)(green) / 255.0;
1974 double alphaPS = (double)(alpha) / 255.0;
1975
1976 if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue && alpha == m_currentAlpha))
1977 {
1978 cairo_set_source_rgba( m_cairo, redPS, greenPS, bluePS, alphaPS );
1979
1980 m_currentRed = red;
1981 m_currentBlue = blue;
1982 m_currentGreen = green;
1983 m_currentAlpha = alpha;
1984 }
1985
1986 if (m_brush.IsHatch())
1987 {
1988 cairo_t * cr;
1989 cairo_surface_t *surface;
1990 surface = cairo_surface_create_similar(cairo_get_target(m_cairo),CAIRO_CONTENT_COLOR_ALPHA,10,10);
1991 cr = cairo_create(surface);
1992 cairo_set_line_cap(cr, CAIRO_LINE_CAP_SQUARE);
1993 cairo_set_line_width(cr, 1);
1994 cairo_set_line_join(cr,CAIRO_LINE_JOIN_MITER);
1995
1996 switch (m_brush.GetStyle())
1997 {
1998 case wxBRUSHSTYLE_CROSS_HATCH:
1999 cairo_move_to(cr, 5, 0);
2000 cairo_line_to(cr, 5, 10);
2001 cairo_move_to(cr, 0, 5);
2002 cairo_line_to(cr, 10, 5);
2003 break;
2004 case wxBRUSHSTYLE_BDIAGONAL_HATCH:
2005 cairo_move_to(cr, 0, 10);
2006 cairo_line_to(cr, 10, 0);
2007 break;
2008 case wxBRUSHSTYLE_FDIAGONAL_HATCH:
2009 cairo_move_to(cr, 0, 0);
2010 cairo_line_to(cr, 10, 10);
2011 break;
2012 case wxBRUSHSTYLE_CROSSDIAG_HATCH:
2013 cairo_move_to(cr, 0, 0);
2014 cairo_line_to(cr, 10, 10);
2015 cairo_move_to(cr, 10, 0);
2016 cairo_line_to(cr, 0, 10);
2017 break;
2018 case wxBRUSHSTYLE_HORIZONTAL_HATCH:
2019 cairo_move_to(cr, 0, 5);
2020 cairo_line_to(cr, 10, 5);
2021 break;
2022 case wxBRUSHSTYLE_VERTICAL_HATCH:
2023 cairo_move_to(cr, 5, 0);
2024 cairo_line_to(cr, 5, 10);
2025 break;
2026 default:
2027 wxFAIL_MSG(_("Couldn't get hatch style from wxBrush."));
2028 }
2029
2030 cairo_set_source_rgba(cr, redPS, greenPS, bluePS, alphaPS);
2031 cairo_stroke (cr);
2032
2033 cairo_destroy(cr);
2034 cairo_pattern_t * pattern = cairo_pattern_create_for_surface (surface);
2035 cairo_surface_destroy(surface);
2036 cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
2037 cairo_set_source(m_cairo, pattern);
2038 cairo_pattern_destroy(pattern);
2039 }
2040}
2041
2042void wxGtkPrinterDCImpl::SetLogicalFunction( wxRasterOperationMode function )
2043{
2044 if (function == wxCLEAR)
2045 cairo_set_operator (m_cairo, CAIRO_OPERATOR_CLEAR);
2046 else if (function == wxOR)
2047 cairo_set_operator (m_cairo, CAIRO_OPERATOR_OUT);
2048 else if (function == wxNO_OP)
2049 cairo_set_operator (m_cairo, CAIRO_OPERATOR_DEST);
2050 else if (function == wxAND)
2051 cairo_set_operator (m_cairo, CAIRO_OPERATOR_ADD);
2052 else if (function == wxSET)
2053 cairo_set_operator (m_cairo, CAIRO_OPERATOR_SATURATE);
2054 else if (function == wxXOR)
2055 cairo_set_operator (m_cairo, CAIRO_OPERATOR_XOR);
2056 else // wxCOPY or anything else.
2057 cairo_set_operator (m_cairo, CAIRO_OPERATOR_SOURCE);
2058}
2059
2060void wxGtkPrinterDCImpl::SetBackground( const wxBrush& brush )
2061{
2062 m_backgroundBrush = brush;
2063 cairo_save(m_cairo);
2064 cairo_set_operator (m_cairo, CAIRO_OPERATOR_DEST_OVER);
2065
2066 SetBrush(m_backgroundBrush);
2067 cairo_paint(m_cairo);
2068 cairo_restore(m_cairo);
2069}
2070
2071void wxGtkPrinterDCImpl::SetBackgroundMode(int mode)
2072{
2073 if (mode == wxBRUSHSTYLE_SOLID)
2074 m_backgroundMode = wxBRUSHSTYLE_SOLID;
2075 else
2076 m_backgroundMode = wxBRUSHSTYLE_TRANSPARENT;
2077}
2078
2079void wxGtkPrinterDCImpl::DoSetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
2080{
2081 cairo_rectangle ( m_cairo, XLOG2DEV(x), YLOG2DEV(y), XLOG2DEVREL(width), YLOG2DEVREL(height));
2082 cairo_clip(m_cairo);
2083}
2084
2085void wxGtkPrinterDCImpl::DestroyClippingRegion()
2086{
2087 cairo_reset_clip(m_cairo);
2088}
2089
2090bool wxGtkPrinterDCImpl::StartDoc(const wxString& WXUNUSED(message))
2091{
2092 return true;
2093}
2094
2095void wxGtkPrinterDCImpl::EndDoc()
2096{
2097 return;
2098}
2099
2100void wxGtkPrinterDCImpl::StartPage()
2101{
2102 return;
2103}
2104
2105void wxGtkPrinterDCImpl::EndPage()
2106{
2107 return;
2108}
2109
2110wxCoord wxGtkPrinterDCImpl::GetCharHeight() const
2111{
2112 pango_layout_set_text( m_layout, "H", 1 );
2113
2114 int w,h;
2115 pango_layout_get_pixel_size( m_layout, &w, &h );
2116
2117 return wxRound( h * m_PS2DEV );
2118}
2119
2120wxCoord wxGtkPrinterDCImpl::GetCharWidth() const
2121{
2122 pango_layout_set_text( m_layout, "H", 1 );
2123
2124 int w,h;
2125 pango_layout_get_pixel_size( m_layout, &w, &h );
2126
2127 return wxRound( w * m_PS2DEV );
2128}
2129
2130void wxGtkPrinterDCImpl::DoGetTextExtent(const wxString& string, wxCoord *width, wxCoord *height,
2131 wxCoord *descent,
2132 wxCoord *externalLeading,
2133 const wxFont *theFont ) const
2134{
2135 if ( width )
2136 *width = 0;
2137 if ( height )
2138 *height = 0;
2139 if ( descent )
2140 *descent = 0;
2141 if ( externalLeading )
2142 *externalLeading = 0;
2143
2144 if (string.empty())
2145 {
2146 return;
2147 }
2148
2149 cairo_save( m_cairo );
2150 cairo_scale(m_cairo, m_scaleX, m_scaleY);
2151
2152 // Set layout's text
2153 const wxScopedCharBuffer dataUTF8 = string.utf8_str();
2154
2155 gint oldSize=0;
2156 if ( theFont )
2157 {
2158 // scale the font and apply it
2159 PangoFontDescription *desc = theFont->GetNativeFontInfo()->description;
2160 oldSize = pango_font_description_get_size(desc);
2161 const float size = oldSize * GetFontPointSizeAdjustment(72.0);
2162 pango_font_description_set_size(desc, (gint)size);
2163
2164 pango_layout_set_font_description(m_layout, desc);
2165 }
2166
2167 pango_layout_set_text( m_layout, dataUTF8, strlen(dataUTF8) );
2168
2169 int h;
2170 pango_layout_get_pixel_size( m_layout, width, &h );
2171 if ( height )
2172 *height = h;
2173
2174 if (descent)
2175 {
2176 PangoLayoutIter *iter = pango_layout_get_iter(m_layout);
2177 int baseline = pango_layout_iter_get_baseline(iter);
2178 pango_layout_iter_free(iter);
2179 *descent = h - PANGO_PIXELS(baseline);
2180 }
2181
2182 if ( theFont )
2183 {
2184 // restore font and reset font's size back
2185 pango_layout_set_font_description(m_layout, m_fontdesc);
2186
2187 PangoFontDescription *desc = theFont->GetNativeFontInfo()->description;
2188 pango_font_description_set_size(desc, oldSize);
2189 }
2190
2191 cairo_restore( m_cairo );
2192}
2193
2194void wxGtkPrinterDCImpl::DoGetSize(int* width, int* height) const
2195{
2196 GtkPageSetup *setup = gtk_print_context_get_page_setup( m_gpc );
2197
2198 if (width)
2199 *width = wxRound( (double)gtk_page_setup_get_paper_width( setup, GTK_UNIT_POINTS ) * (double)m_resolution / 72.0 );
2200 if (height)
2201 *height = wxRound( (double)gtk_page_setup_get_paper_height( setup, GTK_UNIT_POINTS ) * (double)m_resolution / 72.0 );
2202}
2203
2204void wxGtkPrinterDCImpl::DoGetSizeMM(int *width, int *height) const
2205{
2206 GtkPageSetup *setup = gtk_print_context_get_page_setup( m_gpc );
2207
2208 if (width)
2209 *width = wxRound( gtk_page_setup_get_paper_width( setup, GTK_UNIT_MM ) );
2210 if (height)
2211 *height = wxRound( gtk_page_setup_get_paper_height( setup, GTK_UNIT_MM ) );
2212}
2213
2214wxSize wxGtkPrinterDCImpl::GetPPI() const
2215{
2216 return wxSize( (int)m_resolution, (int)m_resolution );
2217}
2218
2219void wxGtkPrinterDCImpl::SetPrintData(const wxPrintData& data)
2220{
2221 m_printData = data;
2222}
2223
2224// overridden for wxPrinterDC Impl
2225
2226wxRect wxGtkPrinterDCImpl::GetPaperRect() const
2227{
2228 // Does GtkPrint support printer margins?
2229 int w = 0;
2230 int h = 0;
2231 DoGetSize( &w, &h );
2232 return wxRect( 0,0,w,h );
2233}
2234
2235int wxGtkPrinterDCImpl::GetResolution() const
2236{
2237 return m_resolution;
2238}
2239
2240// ----------------------------------------------------------------------------
2241// Print preview
2242// ----------------------------------------------------------------------------
2243
2244IMPLEMENT_CLASS(wxGtkPrintPreview, wxPrintPreviewBase)
2245
2246void wxGtkPrintPreview::Init(wxPrintout * WXUNUSED(printout),
2247 wxPrintout * WXUNUSED(printoutForPrinting),
2248 wxPrintData *data)
2249{
2250 // convert wxPrintQuality to resolution (input pointer can be NULL)
2251 wxPrintQuality quality = data ? data->GetQuality() : wxPRINT_QUALITY_MEDIUM;
2252 switch ( quality )
2253 {
2254 case wxPRINT_QUALITY_HIGH:
2255 m_resolution = 1200;
2256 break;
2257
2258 case wxPRINT_QUALITY_LOW:
2259 m_resolution = 300;
2260 break;
2261
2262 case wxPRINT_QUALITY_DRAFT:
2263 m_resolution = 150;
2264 break;
2265
2266 default:
2267 if ( quality > 0 )
2268 {
2269 // positive values directly indicate print resolution
2270 m_resolution = quality;
2271 break;
2272 }
2273
2274 wxFAIL_MSG( "unknown print quality" );
2275 // fall through
2276
2277 case wxPRINT_QUALITY_MEDIUM:
2278 m_resolution = 600;
2279 break;
2280
2281 }
2282
2283 DetermineScaling();
2284}
2285
2286wxGtkPrintPreview::wxGtkPrintPreview(wxPrintout *printout,
2287 wxPrintout *printoutForPrinting,
2288 wxPrintDialogData *data)
2289 : wxPrintPreviewBase(printout, printoutForPrinting, data)
2290{
2291 Init(printout, printoutForPrinting, data ? &data->GetPrintData() : NULL);
2292}
2293
2294wxGtkPrintPreview::wxGtkPrintPreview(wxPrintout *printout,
2295 wxPrintout *printoutForPrinting,
2296 wxPrintData *data)
2297 : wxPrintPreviewBase(printout, printoutForPrinting, data)
2298{
2299 Init(printout, printoutForPrinting, data);
2300}
2301
2302wxGtkPrintPreview::~wxGtkPrintPreview()
2303{
2304}
2305
2306bool wxGtkPrintPreview::Print(bool interactive)
2307{
2308 if (!m_printPrintout)
2309 return false;
2310
2311 wxPrinter printer(& m_printDialogData);
2312 return printer.Print(m_previewFrame, m_printPrintout, interactive);
2313}
2314
2315void wxGtkPrintPreview::DetermineScaling()
2316{
2317 wxPaperSize paperType = m_printDialogData.GetPrintData().GetPaperId();
2318
2319 wxPrintPaperType *paper = wxThePrintPaperDatabase->FindPaperType(paperType);
2320 if (!paper)
2321 paper = wxThePrintPaperDatabase->FindPaperType(wxPAPER_A4);
2322
2323 if (paper)
2324 {
2325 const wxSize screenPPI = wxGetDisplayPPI();
2326 int logPPIScreenX = screenPPI.GetWidth();
2327 int logPPIScreenY = screenPPI.GetHeight();
2328 int logPPIPrinterX = m_resolution;
2329 int logPPIPrinterY = m_resolution;
2330
2331 m_previewPrintout->SetPPIScreen( logPPIScreenX, logPPIScreenY );
2332 m_previewPrintout->SetPPIPrinter( logPPIPrinterX, logPPIPrinterY );
2333
2334 // Get width and height in points (1/72th of an inch)
2335 wxSize sizeDevUnits(paper->GetSizeDeviceUnits());
2336 sizeDevUnits.x = wxRound((double)sizeDevUnits.x * (double)m_resolution / 72.0);
2337 sizeDevUnits.y = wxRound((double)sizeDevUnits.y * (double)m_resolution / 72.0);
2338
2339 wxSize sizeTenthsMM(paper->GetSize());
2340 wxSize sizeMM(sizeTenthsMM.x / 10, sizeTenthsMM.y / 10);
2341
2342 // If in landscape mode, we need to swap the width and height.
2343 if ( m_printDialogData.GetPrintData().GetOrientation() == wxLANDSCAPE )
2344 {
2345 m_pageWidth = sizeDevUnits.y;
2346 m_pageHeight = sizeDevUnits.x;
2347 m_previewPrintout->SetPageSizeMM(sizeMM.y, sizeMM.x);
2348 }
2349 else
2350 {
2351 m_pageWidth = sizeDevUnits.x;
2352 m_pageHeight = sizeDevUnits.y;
2353 m_previewPrintout->SetPageSizeMM(sizeMM.x, sizeMM.y);
2354 }
2355 m_previewPrintout->SetPageSizePixels(m_pageWidth, m_pageHeight);
2356 m_previewPrintout->SetPaperRectPixels(wxRect(0, 0, m_pageWidth, m_pageHeight));
2357
2358 // At 100%, the page should look about page-size on the screen.
2359 m_previewScaleX = float(logPPIScreenX) / logPPIPrinterX;
2360 m_previewScaleY = float(logPPIScreenY) / logPPIPrinterY;
2361 }
2362}
2363
2364#endif
2365 // wxUSE_GTKPRINT
wxWidgets (Impactor)