src/gtk1/gnome/gprint.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        gprint.cpp
   3 // Author:      Robert Roebling
   4 // Purpose:     Implement GNOME printing support
   5 // Created:     09/20/04
   6 // Copyright:   Robert Roebling
   7 // Licence:     wxWindows Licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  11 #pragma implementation "gprint.h"
  12 #endif
  13
  14 // For compilers that support precompilation, includes "wx/wx.h".
  15 #include "wx/wxprec.h"
  16
  17 #ifdef __BORLANDC__
  18     #pragma hdrstop
  19 #endif
  20
  21 #include "wx/gtk/gnome/gprint.h"
  22
  23 #if wxUSE_LIBGNOMEPRINT
  24
  25 #include "math.h"
  26
  27 #include "wx/fontutil.h"
  28 #include "wx/printdlg.h"
  29 #include "wx/gtk/private.h"
  30
  31 #include <libgnomeprint/gnome-print.h>
  32 #include <libgnomeprint/gnome-print-pango.h>
  33 #include <libgnomeprintui/gnome-print-dialog.h>
  34
  35 //----------------------------------------------------------------------------
  36 // wxGnomePrintNativeData
  37 //----------------------------------------------------------------------------
  38
  39 IMPLEMENT_CLASS(wxGnomePrintNativeData, wxPrintNativeDataBase)
  40
  41 wxGnomePrintNativeData::wxGnomePrintNativeData()
  42 {
  43     m_config = gnome_print_config_default();
  44     m_job = gnome_print_job_new( m_config );
  45 }
  46
  47 wxGnomePrintNativeData::~wxGnomePrintNativeData()
  48 {
  49     g_object_unref (G_OBJECT (m_config));
  50     g_object_unref (G_OBJECT (m_job));
  51 }
  52
  53 bool wxGnomePrintNativeData::TransferTo( wxPrintData &data )
  54 {
  55     // TODO
  56     return true;
  57 }
  58
  59 bool wxGnomePrintNativeData::TransferFrom( const wxPrintData &data )
  60 {
  61     // TODO
  62     return true;
  63 }
  64
  65 //----------------------------------------------------------------------------
  66 // wxGnomePrintFactory
  67 //----------------------------------------------------------------------------
  68
  69 wxPrinterBase* wxGnomePrintFactory::CreatePrinter( wxPrintDialogData *data )
  70 {
  71     return new wxGnomePrinter( data );
  72 }
  73
  74 wxPrintPreviewBase *wxGnomePrintFactory::CreatePrintPreview( wxPrintout *preview,
  75                                                     wxPrintout *printout,
  76                                                     wxPrintDialogData *data )
  77 {
  78     return new wxPostScriptPrintPreview( preview, printout, data );
  79 }
  80
  81 wxPrintPreviewBase *wxGnomePrintFactory::CreatePrintPreview( wxPrintout *preview,
  82                                                     wxPrintout *printout,
  83                                                     wxPrintData *data )
  84 {
  85     return new wxPostScriptPrintPreview( preview, printout, data );
  86 }
  87
  88 wxPrintDialogBase *wxGnomePrintFactory::CreatePrintDialog( wxWindow *parent,
  89                                                   wxPrintDialogData *data )
  90 {
  91     return new wxGenericPrintDialog( parent, data );
  92 }
  93
  94 wxPrintDialogBase *wxGnomePrintFactory::CreatePrintDialog( wxWindow *parent,
  95                                                   wxPrintData *data )
  96 {
  97     return new wxGenericPrintDialog( parent, data );
  98 }
  99
 100 bool wxGnomePrintFactory::HasPrintSetupDialog()
 101 {
 102     return true;
 103 }
 104
 105 wxDialog *wxGnomePrintFactory::CreatePrintSetupDialog( wxWindow *parent, wxPrintData *data )
 106 {
 107     return new wxGnomePrintSetupDialog( parent, data );
 108 }
 109
 110 bool wxGnomePrintFactory::HasOwnPrintToFile()
 111 {
 112     return true;
 113 }
 114
 115 bool wxGnomePrintFactory::HasPrinterLine()
 116 {
 117     return true;
 118 }
 119
 120 wxString wxGnomePrintFactory::CreatePrinterLine()
 121 {
 122     // We should query "gnome_config_default" here
 123     return _("GNOME print");
 124 }
 125
 126 bool wxGnomePrintFactory::HasStatusLine()
 127 {
 128     return true;
 129 }
 130
 131 wxString wxGnomePrintFactory::CreateStatusLine()
 132 {
 133     // We should query "gnome_config_default" here
 134     return _("Ready");
 135 }
 136
 137 wxPrintNativeDataBase *wxGnomePrintFactory::CreatePrintNativeData()
 138 {
 139     return new wxGnomePrintNativeData;
 140 }
 141
 142 //----------------------------------------------------------------------------
 143 // wxGnomePrintSetupDialog
 144 //----------------------------------------------------------------------------
 145
 146 IMPLEMENT_CLASS(wxGnomePrintSetupDialog, wxDialog)
 147
 148 wxGnomePrintSetupDialog::wxGnomePrintSetupDialog( wxWindow *parent, wxPrintData *data )
 149 {
 150     wxGnomePrintNativeData *native =
 151       (wxGnomePrintNativeData*) data->GetNativeData();
 152
 153     m_widget = gnome_print_dialog_new (native->GetPrintJob(), (guchar*)"Print setup", 0);
 154 }
 155
 156 wxGnomePrintSetupDialog::~wxGnomePrintSetupDialog()
 157 {
 158     m_widget = NULL;
 159 }
 160
 161 int wxGnomePrintSetupDialog::ShowModal()
 162 {
 163     int response = gtk_dialog_run (GTK_DIALOG (m_widget));
 164     gtk_widget_destroy(m_widget);
 165     m_widget = NULL;
 166
 167         if (response == GNOME_PRINT_DIALOG_RESPONSE_CANCEL)
 168         return wxID_CANCEL;
 169
 170     return wxID_OK;
 171 }
 172
 173 bool wxGnomePrintSetupDialog::Validate()
 174 {
 175     return true;
 176 }
 177
 178 bool wxGnomePrintSetupDialog::TransferDataToWindow()
 179 {
 180     return true;
 181 }
 182
 183 bool wxGnomePrintSetupDialog::TransferDataFromWindow()
 184 {
 185     return true;
 186 }
 187
 188
 189 //----------------------------------------------------------------------------
 190 // wxGnomePrinter
 191 //----------------------------------------------------------------------------
 192
 193 IMPLEMENT_CLASS(wxGnomePrinter, wxPrinterBase)
 194
 195 wxGnomePrinter::wxGnomePrinter( wxPrintDialogData *data ) :
 196     wxPrinterBase( data )
 197 {
 198     m_gpc = NULL;
 199 }
 200
 201 wxGnomePrinter::~wxGnomePrinter()
 202 {
 203 }
 204
 205 bool wxGnomePrinter::Print(wxWindow *parent, wxPrintout *printout, bool prompt )
 206 {
 207     if (!printout)
 208     {
 209         sm_lastError = wxPRINTER_ERROR;
 210         return false;
 211     }
 212
 213     wxPrintData printdata = GetPrintDialogData().GetPrintData();
 214     wxGnomePrintNativeData *data =
 215         (wxGnomePrintNativeData*) printdata.GetNativeData();
 216
 217     // The GnomePrintJob is temporarily stored in the
 218     // native print data as the native print setup dialog
 219     // needs to access it.
 220     GnomePrintJob *job = data->GetPrintJob();
 221     m_gpc = gnome_print_job_get_context (job);
 222
 223     printout->SetIsPreview(false);
 224
 225     if (m_printDialogData.GetMinPage() < 1)
 226         m_printDialogData.SetMinPage(1);
 227     if (m_printDialogData.GetMaxPage() < 1)
 228         m_printDialogData.SetMaxPage(9999);
 229
 230     wxDC *dc;
 231     if (prompt)
 232         dc = PrintDialog( parent );
 233     else
 234         dc = new wxGnomePrintDC( this );
 235
 236     if (!dc)
 237     {
 238         gnome_print_job_close( job );
 239         sm_lastError = wxPRINTER_ERROR;
 240         return false;
 241     }
 242
 243     wxSize ScreenPixels = wxGetDisplaySize();
 244     wxSize ScreenMM = wxGetDisplaySizeMM();
 245
 246     printout->SetPPIScreen( (int) ((ScreenPixels.GetWidth() * 25.4) / ScreenMM.GetWidth()),
 247                             (int) ((ScreenPixels.GetHeight() * 25.4) / ScreenMM.GetHeight()) );
 248     printout->SetPPIPrinter( wxPostScriptDC::GetResolution(),
 249                              wxPostScriptDC::GetResolution() );
 250
 251     printout->SetDC(dc);
 252
 253     int w, h;
 254     dc->GetSize(&w, &h);
 255     printout->SetPageSizePixels((int)w, (int)h);
 256     dc->GetSizeMM(&w, &h);
 257     printout->SetPageSizeMM((int)w, (int)h);
 258
 259     printout->OnPreparePrinting();
 260     printout->OnBeginPrinting();
 261
 262     if (!printout->OnBeginDocument(0, 0))
 263     {
 264         sm_lastError = wxPRINTER_ERROR;
 265     }
 266     else
 267     {
 268         int pn;
 269         for (pn = 1; pn <= 2; pn++)
 270         {
 271             dc->StartPage();
 272             printout->OnPrintPage(pn);
 273             dc->EndPage();
 274         }
 275
 276         printout->OnEndDocument();
 277         printout->OnEndPrinting();
 278     }
 279
 280     gnome_print_job_close( job );
 281     gnome_print_job_print( job );
 282
 283     delete dc;
 284
 285     return (sm_lastError == wxPRINTER_NO_ERROR);
 286 }
 287
 288 wxDC* wxGnomePrinter::PrintDialog( wxWindow *parent )
 289 {
 290     wxPrintDialog dialog( parent, &m_printDialogData );
 291     if (dialog.ShowModal() == wxID_CANCEL)
 292     {
 293         sm_lastError = wxPRINTER_ERROR;
 294         return NULL;
 295     }
 296
 297     return new wxGnomePrintDC( this );
 298 }
 299
 300 bool wxGnomePrinter::Setup( wxWindow *parent )
 301 {
 302     return false;
 303 }
 304
 305 //-----------------------------------------------------------------------------
 306 // wxGnomePrintDC
 307 //-----------------------------------------------------------------------------
 308
 309 IMPLEMENT_CLASS(wxGnomePrintDC, wxDCBase)
 310
 311 wxGnomePrintDC::wxGnomePrintDC( wxGnomePrinter *printer )
 312 {
 313     m_printer = printer;
 314
 315     m_gpc = printer->GetPrintContext();
 316
 317     m_layout = gnome_print_pango_create_layout( m_gpc );
 318     m_fontdesc = pango_font_description_from_string( "Sans 12" );
 319
 320     m_currentRed = 0;
 321     m_currentBlue = 0;
 322     m_currentGreen = 0;
 323
 324     m_signX =  1;  // default x-axis left to right
 325     m_signY = -1;  // default y-axis bottom up -> top down
 326 }
 327
 328 wxGnomePrintDC::~wxGnomePrintDC()
 329 {
 330 }
 331
 332 bool wxGnomePrintDC::Ok() const
 333 {
 334     return true;
 335 }
 336
 337 bool wxGnomePrintDC::DoFloodFill(wxCoord x1, wxCoord y1, const wxColour &col, int style )
 338 {
 339     return false;
 340 }
 341
 342 bool wxGnomePrintDC::DoGetPixel(wxCoord x1, wxCoord y1, wxColour *col) const
 343 {
 344     return false;
 345 }
 346
 347 void wxGnomePrintDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
 348 {
 349     if  (m_pen.GetStyle() == wxTRANSPARENT) return;
 350
 351     SetPen( m_pen );
 352
 353         gnome_print_moveto ( m_gpc, XLOG2DEV(x1), YLOG2DEV(y1) );
 354         gnome_print_lineto ( m_gpc, XLOG2DEV(x2), YLOG2DEV(y2) );
 355         gnome_print_stroke ( m_gpc);
 356
 357     CalcBoundingBox( x1, y1 );
 358     CalcBoundingBox( x2, y2 );
 359 }
 360
 361 void wxGnomePrintDC::DoCrossHair(wxCoord x, wxCoord y)
 362 {
 363 }
 364
 365 void wxGnomePrintDC::DoDrawArc(wxCoord x1,wxCoord y1,wxCoord x2,wxCoord y2,wxCoord xc,wxCoord yc)
 366 {
 367 }
 368
 369 void wxGnomePrintDC::DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,double ea)
 370 {
 371 }
 372
 373 void wxGnomePrintDC::DoDrawPoint(wxCoord x, wxCoord y)
 374 {
 375 }
 376
 377 void wxGnomePrintDC::DoDrawLines(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset)
 378 {
 379 }
 380
 381 void wxGnomePrintDC::DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset, int fillStyle)
 382 {
 383 }
 384
 385 void wxGnomePrintDC::DoDrawPolyPolygon(int n, int count[], wxPoint points[], wxCoord xoffset, wxCoord yoffset, int fillStyle)
 386 {
 387 }
 388
 389 void wxGnomePrintDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 390 {
 391     if (m_brush.GetStyle () != wxTRANSPARENT)
 392     {
 393         SetBrush( m_brush );
 394
 395         gnome_print_newpath( m_gpc );
 396         gnome_print_moveto( m_gpc, XLOG2DEV(x), YLOG2DEV(y) );
 397         gnome_print_lineto( m_gpc, XLOG2DEV(x + width), YLOG2DEV(y) );
 398         gnome_print_lineto( m_gpc, XLOG2DEV(x + width), YLOG2DEV(y + height) );
 399         gnome_print_lineto( m_gpc, XLOG2DEV(x), YLOG2DEV(y + height) );
 400         gnome_print_closepath( m_gpc );
 401         gnome_print_fill( m_gpc );
 402
 403         CalcBoundingBox( x, y );
 404         CalcBoundingBox( x + width, y + height );
 405     }
 406
 407     if (m_pen.GetStyle () != wxTRANSPARENT)
 408     {
 409         SetPen (m_pen);
 410
 411         gnome_print_newpath( m_gpc );
 412         gnome_print_moveto( m_gpc, XLOG2DEV(x), YLOG2DEV(y) );
 413         gnome_print_lineto( m_gpc, XLOG2DEV(x + width), YLOG2DEV(y) );
 414         gnome_print_lineto( m_gpc, XLOG2DEV(x + width), YLOG2DEV(y + height) );
 415         gnome_print_lineto( m_gpc, XLOG2DEV(x), YLOG2DEV(y + height) );
 416         gnome_print_closepath( m_gpc );
 417         gnome_print_stroke( m_gpc );
 418
 419         CalcBoundingBox( x, y );
 420         CalcBoundingBox( x + width, y + height );
 421     }
 422 }
 423
 424 void wxGnomePrintDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius)
 425 {
 426 }
 427
 428 void wxGnomePrintDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 429 {
 430 }
 431
 432 void wxGnomePrintDC::DoDrawSpline(wxList *points)
 433 {
 434 }
 435
 436 bool wxGnomePrintDC::DoBlit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
 437             wxDC *source, wxCoord xsrc, wxCoord ysrc, int rop, bool useMask,
 438             wxCoord xsrcMask, wxCoord ysrcMask)
 439 {
 440     return false;
 441 }
 442
 443 void wxGnomePrintDC::DoDrawIcon( const wxIcon& icon, wxCoord x, wxCoord y )
 444 {
 445 }
 446
 447 void wxGnomePrintDC::DoDrawBitmap( const wxBitmap& bitmap, wxCoord x, wxCoord y, bool useMask )
 448 {
 449 }
 450
 451 void wxGnomePrintDC::DoDrawText(const wxString& text, wxCoord x, wxCoord y )
 452 {
 453     if (m_textForegroundColour.Ok())
 454     {
 455         unsigned char red = m_textForegroundColour.Red();
 456         unsigned char blue = m_textForegroundColour.Blue();
 457         unsigned char green = m_textForegroundColour.Green();
 458
 459         if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
 460         {
 461             double redPS = (double)(red) / 255.0;
 462             double bluePS = (double)(blue) / 255.0;
 463             double greenPS = (double)(green) / 255.0;
 464
 465             gnome_print_setrgbcolor( m_gpc, redPS, bluePS, greenPS );
 466
 467             m_currentRed = red;
 468             m_currentBlue = blue;
 469             m_currentGreen = green;
 470         }
 471     }
 472
 473     x = XLOG2DEV(x);
 474     y = YLOG2DEV(y);
 475
 476     bool underlined = m_font.Ok() && m_font.GetUnderlined();
 477
 478 #if wxUSE_UNICODE
 479     const wxCharBuffer data = wxConvUTF8.cWC2MB( text );
 480 #else
 481     const wxWCharBuffer wdata = wxConvLocal.cMB2WC( text );
 482     if ( !wdata )
 483         return;
 484     const wxCharBuffer data = wxConvUTF8.cWC2MB( wdata );
 485 #endif
 486
 487     size_t datalen = strlen((const char*)data);
 488     pango_layout_set_text( m_layout, (const char*) data, datalen);
 489
 490     if (underlined)
 491     {
 492         PangoAttrList *attrs = pango_attr_list_new();
 493         PangoAttribute *a = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
 494         a->start_index = 0;
 495         a->end_index = datalen;
 496         pango_attr_list_insert(attrs, a);
 497         pango_layout_set_attributes(m_layout, attrs);
 498         pango_attr_list_unref(attrs);
 499     }
 500
 501     int w,h;
 502
 503     if (fabs(m_scaleY - 1.0) > 0.00001)
 504     {
 505         // If there is a user or actually any scale applied to
 506         // the device context, scale the font.
 507
 508         // scale font description
 509         gint oldSize = pango_font_description_get_size( m_fontdesc );
 510         double size = oldSize;
 511         size = size * m_scaleY;
 512         pango_font_description_set_size( m_fontdesc, (gint)size );
 513
 514         // actually apply scaled font
 515         pango_layout_set_font_description( m_layout, m_fontdesc );
 516
 517         pango_layout_get_pixel_size( m_layout, &w, &h );
 518 #if 0
 519         if ( m_backgroundMode == wxSOLID )
 520         {
 521             gdk_gc_set_foreground(m_textGC, m_textBackgroundColour.GetColor());
 522             gdk_draw_rectangle(m_window, m_textGC, TRUE, x, y, w, h);
 523             gdk_gc_set_foreground(m_textGC, m_textForegroundColour.GetColor());
 524         }
 525 #endif
 526         // Draw layout.
 527         gnome_print_moveto (m_gpc, x, y);
 528             gnome_print_pango_layout( m_gpc, m_layout );
 529
 530         // reset unscaled size
 531         pango_font_description_set_size( m_fontdesc, oldSize );
 532
 533         // actually apply unscaled font
 534         pango_layout_set_font_description( m_layout, m_fontdesc );
 535     }
 536     else
 537     {
 538         pango_layout_get_pixel_size( m_layout, &w, &h );
 539 #if 0
 540         if ( m_backgroundMode == wxSOLID )
 541         {
 542             gdk_gc_set_foreground(m_textGC, m_textBackgroundColour.GetColor());
 543             gdk_draw_rectangle(m_window, m_textGC, TRUE, x, y, w, h);
 544             gdk_gc_set_foreground(m_textGC, m_textForegroundColour.GetColor());
 545         }
 546 #endif
 547         // Draw layout.
 548         gnome_print_moveto (m_gpc, x, y);
 549             gnome_print_pango_layout( m_gpc, m_layout );
 550     }
 551
 552
 553
 554     if (underlined)
 555     {
 556         // undo underline attributes setting:
 557         pango_layout_set_attributes(m_layout, NULL);
 558     }
 559
 560 //    CalcBoundingBox (x + width, y + height);
 561     CalcBoundingBox (x, y);
 562 }
 563
 564 void wxGnomePrintDC::DoDrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle)
 565 {
 566 }
 567
 568 void wxGnomePrintDC::Clear()
 569 {
 570 }
 571
 572 void wxGnomePrintDC::SetFont( const wxFont& font )
 573 {
 574     m_font = font;
 575
 576     if (m_font.Ok())
 577     {
 578         if (m_fontdesc)
 579             pango_font_description_free( m_fontdesc );
 580
 581         m_fontdesc = pango_font_description_copy( m_font.GetNativeFontInfo()->description );
 582
 583         pango_layout_set_font_description( m_layout, m_fontdesc );
 584     }
 585 }
 586
 587 void wxGnomePrintDC::SetPen( const wxPen& pen )
 588 {
 589     if (!pen.Ok()) return;
 590
 591     int oldStyle = m_pen.GetStyle();
 592
 593     m_pen = pen;
 594
 595     gnome_print_setlinewidth( m_gpc, XLOG2DEVREL( 1000 * m_pen.GetWidth() ) / 1000.0f );
 596
 597     unsigned char red = m_pen.GetColour().Red();
 598     unsigned char blue = m_pen.GetColour().Blue();
 599     unsigned char green = m_pen.GetColour().Green();
 600
 601     if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
 602     {
 603         double redPS = (double)(red) / 255.0;
 604         double bluePS = (double)(blue) / 255.0;
 605         double greenPS = (double)(green) / 255.0;
 606
 607         gnome_print_setrgbcolor( m_gpc, redPS, bluePS, greenPS );
 608
 609         m_currentRed = red;
 610         m_currentBlue = blue;
 611         m_currentGreen = green;
 612     }
 613 }
 614
 615 void wxGnomePrintDC::SetBrush( const wxBrush& brush )
 616 {
 617     if (!brush.Ok()) return;
 618
 619     m_brush = brush;
 620
 621     // Brush colour
 622     unsigned char red = m_brush.GetColour().Red();
 623     unsigned char blue = m_brush.GetColour().Blue();
 624     unsigned char green = m_brush.GetColour().Green();
 625
 626     if (!m_colour)
 627     {
 628         // Anything not white is black
 629         if (! (red == (unsigned char) 255 &&
 630                blue == (unsigned char) 255 &&
 631                green == (unsigned char) 255) )
 632         {
 633             red = (unsigned char) 0;
 634             green = (unsigned char) 0;
 635             blue = (unsigned char) 0;
 636         }
 637         // setgray here ?
 638     }
 639
 640     if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
 641     {
 642         double redPS = (double)(red) / 255.0;
 643         double bluePS = (double)(blue) / 255.0;
 644         double greenPS = (double)(green) / 255.0;
 645
 646         gnome_print_setrgbcolor( m_gpc, redPS, bluePS, greenPS );
 647
 648         m_currentRed = red;
 649         m_currentBlue = blue;
 650         m_currentGreen = green;
 651     }
 652 }
 653
 654 void wxGnomePrintDC::SetLogicalFunction( int function )
 655 {
 656 }
 657
 658 void wxGnomePrintDC::SetBackground( const wxBrush& brush )
 659 {
 660 }
 661
 662 void wxGnomePrintDC::DoSetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 663 {
 664 }
 665
 666 void wxGnomePrintDC::DestroyClippingRegion()
 667 {
 668 }
 669
 670 bool wxGnomePrintDC::StartDoc(const wxString& message)
 671 {
 672     SetDeviceOrigin( 0,0 );
 673
 674     return true;
 675 }
 676
 677 void wxGnomePrintDC::EndDoc()
 678 {
 679 }
 680
 681 void wxGnomePrintDC::StartPage()
 682 {
 683         gnome_print_beginpage( m_gpc, (const guchar*) "1" );
 684 }
 685
 686 void wxGnomePrintDC::EndPage()
 687 {
 688         gnome_print_showpage( m_gpc );
 689 }
 690
 691 wxCoord wxGnomePrintDC::GetCharHeight() const
 692 {
 693     return 0;
 694 }
 695
 696 wxCoord wxGnomePrintDC::GetCharWidth() const
 697 {
 698     return 0;
 699 }
 700
 701 void wxGnomePrintDC::DoGetTextExtent(const wxString& string, wxCoord *width, wxCoord *height,
 702                      wxCoord *descent,
 703                      wxCoord *externalLeading,
 704                      wxFont *theFont ) const
 705 {
 706     if ( width )
 707         *width = 0;
 708     if ( height )
 709         *height = 0;
 710     if ( descent )
 711         *descent = 0;
 712     if ( externalLeading )
 713         *externalLeading = 0;
 714
 715     if (string.IsEmpty())
 716     {
 717         return;
 718     }
 719
 720     // Set new font description
 721     if (theFont)
 722         pango_layout_set_font_description( m_layout, theFont->GetNativeFontInfo()->description );
 723
 724     // Set layout's text
 725 #if wxUSE_UNICODE
 726     const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
 727     const char *dataUTF8 = (const char *)data;
 728 #else
 729     const wxWCharBuffer wdata = wxConvLocal.cMB2WC( string );
 730     if ( !wdata )
 731     {
 732         if (width) (*width) = 0;
 733         if (height) (*height) = 0;
 734         return;
 735     }
 736     const wxCharBuffer data = wxConvUTF8.cWC2MB( wdata );
 737     const char *dataUTF8 = (const char *)data;
 738 #endif
 739
 740     if ( !dataUTF8 )
 741     {
 742         // hardly ideal, but what else can we do if conversion failed?
 743         return;
 744     }
 745
 746     pango_layout_set_text( m_layout, dataUTF8, strlen(dataUTF8) );
 747
 748     int w,h;
 749     pango_layout_get_pixel_size( m_layout, &w, &h );
 750
 751     if (width)
 752         *width = (wxCoord) w;
 753     if (height)
 754         *height = (wxCoord) h;
 755     if (descent)
 756     {
 757         PangoLayoutIter *iter = pango_layout_get_iter(m_layout);
 758         int baseline = pango_layout_iter_get_baseline(iter);
 759         pango_layout_iter_free(iter);
 760         *descent = h - PANGO_PIXELS(baseline);
 761     }
 762
 763     // Reset old font description
 764     if (theFont)
 765         pango_layout_set_font_description( m_layout, m_fontdesc );
 766 }
 767
 768 void wxGnomePrintDC::DoGetSize(int* width, int* height) const
 769 {
 770     // No idea if that is efficient
 771     GnomePrintConfig *config = gnome_print_config_default();
 772
 773     double w,h;
 774     bool result = gnome_print_config_get_page_size( config, &w, &h );
 775
 776     if (!result)
 777     {
 778         // Standard PS resolution DIN A4 size.
 779         w = 595.0;
 780         h = 842.0;
 781     }
 782
 783     if (width)
 784         *width = (int) w;
 785     if (height)
 786         *height = (int) h;
 787 }
 788
 789 void wxGnomePrintDC::DoGetSizeMM(int *width, int *height) const
 790 {
 791     double w,h;
 792
 793     /// Later, for now DIN A4
 794     w = 210.0;
 795     h = 297.0;
 796
 797     if (width)
 798         *width = (int) w;
 799     if (height)
 800         *height = (int) h;
 801 }
 802
 803 wxSize wxGnomePrintDC::GetPPI() const
 804 {
 805     return wxSize(72,72);
 806 }
 807
 808 void wxGnomePrintDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
 809 {
 810     m_signX = (xLeftRight ? 1 : -1);
 811     m_signY = (yBottomUp  ? 1 : -1);
 812
 813     ComputeScaleAndOrigin();
 814 }
 815
 816 void wxGnomePrintDC::SetDeviceOrigin( wxCoord x, wxCoord y )
 817 {
 818     int h = 0;
 819     int w = 0;
 820     GetSize( &w, &h );
 821
 822     wxDC::SetDeviceOrigin( x, h-y );
 823 }
 824
 825 void wxGnomePrintDC::SetResolution(int ppi)
 826 {
 827 }
 828
 829 int wxGnomePrintDC::GetResolution()
 830 {
 831     return 72;
 832 }
 833
 834
 835 class wxGnomePrintModule: public wxModule
 836 {
 837 public:
 838     wxGnomePrintModule() {}
 839     bool OnInit() { wxPrintFactory::SetPrintFactory( new wxGnomePrintFactory ); return true; }
 840     void OnExit() { }
 841
 842 private:
 843     DECLARE_DYNAMIC_CLASS(wxGnomePrintModule)
 844 };
 845
 846 IMPLEMENT_DYNAMIC_CLASS(wxGnomePrintModule, wxModule)
 847
 848 #endif
 849     // wxUSE_LIBGNOMEPRINT