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