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