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