src/gtk/print.cpp

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