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