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