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