src/gtk/print.cpp

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