]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/gnome/gprint.cpp
Tweaks for demos on MacOSX
[wxWidgets.git] / src / gtk / gnome / gprint.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/gnome/gprint.cpp
3 // Author: Robert Roebling
4 // Purpose: Implement GNOME printing support
5 // Created: 09/20/04
6 // RCS-ID: $Id$
7 // Copyright: Robert Roebling
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 #include "wx/gtk/gnome/gprint.h"
19
20 #if wxUSE_LIBGNOMEPRINT
21
22 #include "wx/math.h"
23 #include "wx/fontutil.h"
24 #include "wx/gtk/private.h"
25 #include "wx/module.h"
26 #include "wx/dynlib.h"
27 #include "wx/dcmemory.h"
28 #include "wx/log.h"
29 #include "wx/icon.h"
30
31 #include <libgnomeprint/gnome-print.h>
32 #include <libgnomeprint/gnome-print-pango.h>
33 #include <libgnomeprint/gnome-print-config.h>
34 #include <libgnomeprintui/gnome-print-dialog.h>
35 #include <libgnomeprintui/gnome-print-job-preview.h>
36 #include <libgnomeprintui/gnome-print-paper-selector.h>
37
38 static const double RAD2DEG = 180.0 / M_PI;
39
40 #include "wx/html/forcelnk.h"
41 FORCE_LINK_ME(gnome_print)
42
43 //----------------------------------------------------------------------------
44 // wxGnomePrintLibrary
45 //----------------------------------------------------------------------------
46
47 #define wxDL_METHOD_DEFINE( rettype, name, args, shortargs, defret ) \
48 typedef rettype (* name ## Type) args ; \
49 name ## Type pfn_ ## name; \
50 rettype name args \
51 { if (m_ok) return pfn_ ## name shortargs ; return defret; }
52
53 #define wxDL_METHOD_LOAD( lib, name, success ) \
54 pfn_ ## name = (name ## Type) lib->GetSymbol( wxT(#name), &success ); \
55 if (!success) return;
56
57 class wxGnomePrintLibrary
58 {
59 public:
60 wxGnomePrintLibrary();
61 ~wxGnomePrintLibrary();
62
63 bool IsOk();
64 void InitializeMethods();
65
66 private:
67 bool m_ok;
68 wxDynamicLibrary *m_gnome_print_lib;
69 wxDynamicLibrary *m_gnome_printui_lib;
70
71 public:
72 wxDL_METHOD_DEFINE( gint, gnome_print_newpath,
73 (GnomePrintContext *pc), (pc), 0 )
74 wxDL_METHOD_DEFINE( gint, gnome_print_moveto,
75 (GnomePrintContext *pc, gdouble x, gdouble y), (pc, x, y), 0 )
76 wxDL_METHOD_DEFINE( gint, gnome_print_lineto,
77 (GnomePrintContext *pc, gdouble x, gdouble y), (pc, x, y), 0 )
78 wxDL_METHOD_DEFINE( gint, gnome_print_arcto,
79 (GnomePrintContext *pc, gdouble x, gdouble y, gdouble radius, gdouble angle1, gdouble angle2, gint direction ), (pc, x, y, radius, angle1, angle2, direction), 0 )
80 wxDL_METHOD_DEFINE( gint, gnome_print_curveto,
81 (GnomePrintContext *pc, gdouble x1, gdouble y1, gdouble x2, gdouble y2, gdouble x3, gdouble y3), (pc, x1, y1, x2, y2, x3, y3), 0 )
82 wxDL_METHOD_DEFINE( gint, gnome_print_closepath,
83 (GnomePrintContext *pc), (pc), 0 )
84 wxDL_METHOD_DEFINE( gint, gnome_print_stroke,
85 (GnomePrintContext *pc), (pc), 0 )
86 wxDL_METHOD_DEFINE( gint, gnome_print_fill,
87 (GnomePrintContext *pc), (pc), 0 )
88 wxDL_METHOD_DEFINE( gint, gnome_print_setrgbcolor,
89 (GnomePrintContext *pc, gdouble r, gdouble g, gdouble b), (pc, r, g, b), 0 )
90 wxDL_METHOD_DEFINE( gint, gnome_print_setlinewidth,
91 (GnomePrintContext *pc, gdouble width), (pc, width), 0 )
92 wxDL_METHOD_DEFINE( gint, gnome_print_setdash,
93 (GnomePrintContext *pc, gint n_values, const gdouble *values, gdouble offset), (pc, n_values, values, offset), 0 )
94
95 wxDL_METHOD_DEFINE( gint, gnome_print_rgbimage,
96 (GnomePrintContext *pc, const guchar *data, gint width, gint height, gint rowstride), (pc, data, width, height, rowstride ), 0 )
97 wxDL_METHOD_DEFINE( gint, gnome_print_rgbaimage,
98 (GnomePrintContext *pc, const guchar *data, gint width, gint height, gint rowstride), (pc, data, width, height, rowstride ), 0 )
99
100 wxDL_METHOD_DEFINE( gint, gnome_print_concat,
101 (GnomePrintContext *pc, const gdouble *matrix), (pc, matrix), 0 )
102 wxDL_METHOD_DEFINE( gint, gnome_print_scale,
103 (GnomePrintContext *pc, gdouble sx, gdouble sy), (pc, sx, sy), 0 )
104 wxDL_METHOD_DEFINE( gint, gnome_print_rotate,
105 (GnomePrintContext *pc, gdouble theta), (pc, theta), 0 )
106 wxDL_METHOD_DEFINE( gint, gnome_print_translate,
107 (GnomePrintContext *pc, gdouble x, gdouble y), (pc, x, y), 0 )
108
109 wxDL_METHOD_DEFINE( gint, gnome_print_gsave,
110 (GnomePrintContext *pc), (pc), 0 )
111 wxDL_METHOD_DEFINE( gint, gnome_print_grestore,
112 (GnomePrintContext *pc), (pc), 0 )
113
114 wxDL_METHOD_DEFINE( gint, gnome_print_beginpage,
115 (GnomePrintContext *pc, const guchar* name), (pc, name), 0 )
116 wxDL_METHOD_DEFINE( gint, gnome_print_showpage,
117 (GnomePrintContext *pc), (pc), 0 )
118 wxDL_METHOD_DEFINE( gint, gnome_print_end_doc,
119 (GnomePrintContext *pc), (pc), 0 )
120
121 wxDL_METHOD_DEFINE( PangoLayout*, gnome_print_pango_create_layout,
122 (GnomePrintContext *gpc), (gpc), NULL )
123 wxDL_METHOD_DEFINE( void, gnome_print_pango_layout,
124 (GnomePrintContext *gpc, PangoLayout *layout), (gpc, layout), /**/ )
125
126 wxDL_METHOD_DEFINE( GnomePrintJob*, gnome_print_job_new,
127 (GnomePrintConfig *config), (config), NULL )
128 wxDL_METHOD_DEFINE( GnomePrintContext*, gnome_print_job_get_context,
129 (GnomePrintJob *job), (job), NULL )
130 wxDL_METHOD_DEFINE( gint, gnome_print_job_close,
131 (GnomePrintJob *job), (job), 0 )
132 wxDL_METHOD_DEFINE( gint, gnome_print_job_print,
133 (GnomePrintJob *job), (job), 0 )
134 wxDL_METHOD_DEFINE( gboolean, gnome_print_job_get_page_size,
135 (GnomePrintJob *job, gdouble *width, gdouble *height), (job, width, height), 0 )
136
137 wxDL_METHOD_DEFINE( GnomePrintUnit*, gnome_print_unit_get_by_abbreviation,
138 (const guchar *abbreviation), (abbreviation), NULL )
139 wxDL_METHOD_DEFINE( gboolean, gnome_print_convert_distance,
140 (gdouble *distance, const GnomePrintUnit *from, const GnomePrintUnit *to), (distance, from, to), false )
141
142 wxDL_METHOD_DEFINE( GnomePrintConfig*, gnome_print_config_default,
143 (void), (), NULL )
144 wxDL_METHOD_DEFINE( gboolean, gnome_print_config_set,
145 (GnomePrintConfig *config, const guchar *key, const guchar *value), (config, key, value), false )
146 wxDL_METHOD_DEFINE( gboolean, gnome_print_config_get_length,
147 (GnomePrintConfig *config, const guchar *key, gdouble *val, const GnomePrintUnit **unit), (config, key, val, unit), false )
148
149 wxDL_METHOD_DEFINE( GtkWidget*, gnome_print_dialog_new,
150 (GnomePrintJob *gpj, const guchar *title, gint flags), (gpj, title, flags), NULL )
151 wxDL_METHOD_DEFINE( void, gnome_print_dialog_construct_range_page,
152 (GnomePrintDialog *gpd, gint flags, gint start, gint end,
153 const guchar *currentlabel, const guchar *rangelabel),
154 (gpd, flags, start, end, currentlabel, rangelabel), /**/ )
155 wxDL_METHOD_DEFINE( void, gnome_print_dialog_get_copies,
156 (GnomePrintDialog *gpd, gint *copies, gboolean *collate), (gpd, copies, collate), /**/ )
157 wxDL_METHOD_DEFINE( void, gnome_print_dialog_set_copies,
158 (GnomePrintDialog *gpd, gint copies, gint collate), (gpd, copies, collate), /**/ )
159 wxDL_METHOD_DEFINE( GnomePrintRangeType, gnome_print_dialog_get_range,
160 (GnomePrintDialog *gpd), (gpd), GNOME_PRINT_RANGETYPE_NONE )
161 wxDL_METHOD_DEFINE( int, gnome_print_dialog_get_range_page,
162 (GnomePrintDialog *gpd, gint *start, gint *end), (gpd, start, end), 0 )
163
164 wxDL_METHOD_DEFINE( GtkWidget*, gnome_paper_selector_new_with_flags,
165 (GnomePrintConfig *config, gint flags), (config, flags), NULL )
166
167 wxDL_METHOD_DEFINE( GtkWidget*, gnome_print_job_preview_new,
168 (GnomePrintJob *gpm, const guchar *title), (gpm, title), NULL )
169 };
170
171 wxGnomePrintLibrary::wxGnomePrintLibrary()
172 {
173 m_gnome_print_lib = NULL;
174 m_gnome_printui_lib = NULL;
175
176 wxLogNull log;
177
178 m_gnome_print_lib = new wxDynamicLibrary( wxT("libgnomeprint-2-2.so.0") );
179 m_ok = m_gnome_print_lib->IsLoaded();
180 if (!m_ok) return;
181
182 m_gnome_printui_lib = new wxDynamicLibrary( wxT("libgnomeprintui-2-2.so.0") );
183 m_ok = m_gnome_printui_lib->IsLoaded();
184 if (!m_ok) return;
185
186 InitializeMethods();
187 }
188
189 wxGnomePrintLibrary::~wxGnomePrintLibrary()
190 {
191 if (m_gnome_print_lib)
192 delete m_gnome_print_lib;
193 if (m_gnome_printui_lib)
194 delete m_gnome_printui_lib;
195 }
196
197 bool wxGnomePrintLibrary::IsOk()
198 {
199 return m_ok;
200 }
201
202 void wxGnomePrintLibrary::InitializeMethods()
203 {
204 m_ok = false;
205 bool success;
206
207 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_newpath, success )
208 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_moveto, success )
209 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_lineto, success )
210 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_curveto, success )
211 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_arcto, success )
212 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_closepath, success )
213 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_stroke, success )
214 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_fill, success )
215 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_setrgbcolor, success )
216 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_setlinewidth, success )
217 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_setdash, success )
218
219 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_rgbimage, success )
220 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_rgbaimage, success )
221
222 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_concat, success )
223 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_scale, success )
224 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_rotate, success )
225 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_translate, success )
226
227 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_gsave, success )
228 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_grestore, success )
229
230 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_beginpage, success )
231 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_showpage, success )
232 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_end_doc, success )
233
234 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_pango_create_layout, success )
235 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_pango_layout, success )
236
237 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_job_new, success )
238 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_job_get_context, success )
239 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_job_close, success )
240 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_job_print, success )
241 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_job_get_page_size, success )
242
243 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_unit_get_by_abbreviation, success )
244 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_convert_distance, success )
245
246 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_config_default, success )
247 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_config_set, success )
248 wxDL_METHOD_LOAD( m_gnome_print_lib, gnome_print_config_get_length, success )
249
250 wxDL_METHOD_LOAD( m_gnome_printui_lib, gnome_print_dialog_new, success )
251 wxDL_METHOD_LOAD( m_gnome_printui_lib, gnome_print_dialog_construct_range_page, success )
252 wxDL_METHOD_LOAD( m_gnome_printui_lib, gnome_print_dialog_get_copies, success )
253 wxDL_METHOD_LOAD( m_gnome_printui_lib, gnome_print_dialog_set_copies, success )
254 wxDL_METHOD_LOAD( m_gnome_printui_lib, gnome_print_dialog_get_range, success )
255 wxDL_METHOD_LOAD( m_gnome_printui_lib, gnome_print_dialog_get_range_page, success )
256
257 wxDL_METHOD_LOAD( m_gnome_printui_lib, gnome_paper_selector_new_with_flags, success )
258
259 wxDL_METHOD_LOAD( m_gnome_printui_lib, gnome_print_job_preview_new, success )
260
261 m_ok = true;
262 }
263
264 static wxGnomePrintLibrary* gs_lgp = NULL;
265
266 //----------------------------------------------------------------------------
267 // wxGnomePrintNativeData
268 //----------------------------------------------------------------------------
269
270 IMPLEMENT_CLASS(wxGnomePrintNativeData, wxPrintNativeDataBase)
271
272 wxGnomePrintNativeData::wxGnomePrintNativeData()
273 {
274 m_config = gs_lgp->gnome_print_config_default();
275 m_job = gs_lgp->gnome_print_job_new( m_config );
276 }
277
278 wxGnomePrintNativeData::~wxGnomePrintNativeData()
279 {
280 g_object_unref (G_OBJECT (m_config));
281 }
282
283 bool wxGnomePrintNativeData::TransferTo( wxPrintData &data )
284 {
285 // TODO
286 return true;
287 }
288
289 bool wxGnomePrintNativeData::TransferFrom( const wxPrintData &data )
290 {
291 // TODO
292 return true;
293 }
294
295 //----------------------------------------------------------------------------
296 // wxGnomePrintFactory
297 //----------------------------------------------------------------------------
298
299 wxPrinterBase* wxGnomePrintFactory::CreatePrinter( wxPrintDialogData *data )
300 {
301 return new wxGnomePrinter( data );
302 }
303
304 wxPrintPreviewBase *wxGnomePrintFactory::CreatePrintPreview( wxPrintout *preview,
305 wxPrintout *printout,
306 wxPrintDialogData *data )
307 {
308 return new wxPostScriptPrintPreview( preview, printout, data );
309 }
310
311 wxPrintPreviewBase *wxGnomePrintFactory::CreatePrintPreview( wxPrintout *preview,
312 wxPrintout *printout,
313 wxPrintData *data )
314 {
315 return new wxPostScriptPrintPreview( preview, printout, data );
316 }
317
318 wxPrintDialogBase *wxGnomePrintFactory::CreatePrintDialog( wxWindow *parent,
319 wxPrintDialogData *data )
320 {
321 return new wxGnomePrintDialog( parent, data );
322 }
323
324 wxPrintDialogBase *wxGnomePrintFactory::CreatePrintDialog( wxWindow *parent,
325 wxPrintData *data )
326 {
327 return new wxGnomePrintDialog( parent, data );
328 }
329
330 wxPageSetupDialogBase *wxGnomePrintFactory::CreatePageSetupDialog( wxWindow *parent,
331 wxPageSetupDialogData * data )
332 {
333 // The native page setup dialog is broken. It
334 // miscalculates newly entered values for the
335 // margins if you have not chose "points" but
336 // e.g. centimerters.
337 // This has been fixed in GNOME CVS (maybe
338 // fixed in libgnomeprintui 2.8.1)
339
340 return new wxGnomePageSetupDialog( parent, data );
341 }
342
343 bool wxGnomePrintFactory::HasPrintSetupDialog()
344 {
345 return false;
346 }
347
348 wxDialog *wxGnomePrintFactory::CreatePrintSetupDialog( wxWindow *parent, wxPrintData *data )
349 {
350 return NULL;
351 }
352
353 bool wxGnomePrintFactory::HasOwnPrintToFile()
354 {
355 return true;
356 }
357
358 bool wxGnomePrintFactory::HasPrinterLine()
359 {
360 return true;
361 }
362
363 wxString wxGnomePrintFactory::CreatePrinterLine()
364 {
365 // redundant now
366 return wxEmptyString;
367 }
368
369 bool wxGnomePrintFactory::HasStatusLine()
370 {
371 // redundant now
372 return true;
373 }
374
375 wxString wxGnomePrintFactory::CreateStatusLine()
376 {
377 // redundant now
378 return wxEmptyString;
379 }
380
381 wxPrintNativeDataBase *wxGnomePrintFactory::CreatePrintNativeData()
382 {
383 return new wxGnomePrintNativeData;
384 }
385
386 //----------------------------------------------------------------------------
387 // wxGnomePrintSetupDialog
388 //----------------------------------------------------------------------------
389
390 IMPLEMENT_CLASS(wxGnomePrintDialog, wxPrintDialogBase)
391
392 wxGnomePrintDialog::wxGnomePrintDialog( wxWindow *parent, wxPrintDialogData *data )
393 : wxPrintDialogBase(parent, wxID_ANY, _("Print"),
394 wxPoint(0, 0), wxSize(600, 600),
395 wxDEFAULT_DIALOG_STYLE |
396 wxTAB_TRAVERSAL)
397 {
398 if (data)
399 m_printDialogData = *data;
400
401 Init();
402 }
403
404 wxGnomePrintDialog::wxGnomePrintDialog( wxWindow *parent, wxPrintData *data )
405 : wxPrintDialogBase(parent, wxID_ANY, _("Print"),
406 wxPoint(0, 0), wxSize(600, 600),
407 wxDEFAULT_DIALOG_STYLE |
408 wxTAB_TRAVERSAL)
409 {
410 if (data)
411 m_printDialogData = *data;
412
413 Init();
414 }
415
416 void wxGnomePrintDialog::Init()
417 {
418 wxPrintData data = m_printDialogData.GetPrintData();
419
420 wxGnomePrintNativeData *native =
421 (wxGnomePrintNativeData*) data.GetNativeData();
422
423 m_widget = gs_lgp->gnome_print_dialog_new( native->GetPrintJob(),
424 (guchar*)"Print",
425 GNOME_PRINT_DIALOG_RANGE|GNOME_PRINT_DIALOG_COPIES );
426
427 int flag = 0;
428 if (m_printDialogData.GetEnableSelection())
429 flag |= GNOME_PRINT_RANGE_SELECTION;
430 if (m_printDialogData.GetEnablePageNumbers())
431 flag |= GNOME_PRINT_RANGE_ALL|GNOME_PRINT_RANGE_RANGE;
432
433 gs_lgp->gnome_print_dialog_construct_range_page( (GnomePrintDialog*) m_widget,
434 flag,
435 m_printDialogData.GetMinPage(),
436 m_printDialogData.GetMaxPage(),
437 NULL,
438 NULL );
439 }
440
441 wxGnomePrintDialog::~wxGnomePrintDialog()
442 {
443 m_widget = NULL;
444 }
445
446 int wxGnomePrintDialog::ShowModal()
447 {
448 // Transfer data from m_printDalogData to dialog here
449
450 int response = gtk_dialog_run (GTK_DIALOG (m_widget));
451
452 if (response == GNOME_PRINT_DIALOG_RESPONSE_CANCEL)
453 {
454 gtk_widget_destroy(m_widget);
455 m_widget = NULL;
456
457 return wxID_CANCEL;
458 }
459
460 gint copies = 1;
461 gboolean collate = false;
462 gs_lgp->gnome_print_dialog_get_copies( (GnomePrintDialog*) m_widget, &copies, &collate );
463 m_printDialogData.SetNoCopies( copies );
464 m_printDialogData.SetCollate( collate );
465
466 switch (gs_lgp->gnome_print_dialog_get_range( (GnomePrintDialog*) m_widget ))
467 {
468 case GNOME_PRINT_RANGE_SELECTION:
469 m_printDialogData.SetSelection( true );
470 break;
471 case GNOME_PRINT_RANGE_ALL:
472 m_printDialogData.SetAllPages( true );
473 m_printDialogData.SetFromPage( 0 );
474 m_printDialogData.SetToPage( 9999 );
475 break;
476 case GNOME_PRINT_RANGE_RANGE:
477 default:
478 gint start,end;
479 gs_lgp->gnome_print_dialog_get_range_page( (GnomePrintDialog*) m_widget, &start, &end );
480 m_printDialogData.SetFromPage( start );
481 m_printDialogData.SetToPage( end );
482 break;
483 }
484
485 gtk_widget_destroy(m_widget);
486 m_widget = NULL;
487
488 if (response == GNOME_PRINT_DIALOG_RESPONSE_PREVIEW)
489 return wxID_PREVIEW;
490
491 return wxID_OK;
492 }
493
494 wxDC *wxGnomePrintDialog::GetPrintDC()
495 {
496 // Later
497 return NULL;
498 }
499
500 bool wxGnomePrintDialog::Validate()
501 {
502 return true;
503 }
504
505 bool wxGnomePrintDialog::TransferDataToWindow()
506 {
507 return true;
508 }
509
510 bool wxGnomePrintDialog::TransferDataFromWindow()
511 {
512 return true;
513 }
514
515 //----------------------------------------------------------------------------
516 // wxGnomePageSetupDialog
517 //----------------------------------------------------------------------------
518
519 IMPLEMENT_CLASS(wxGnomePageSetupDialog, wxPageSetupDialogBase)
520
521 wxGnomePageSetupDialog::wxGnomePageSetupDialog( wxWindow *parent,
522 wxPageSetupDialogData* data )
523 {
524 if (data)
525 m_pageDialogData = *data;
526
527 wxGnomePrintNativeData *native =
528 (wxGnomePrintNativeData*) m_pageDialogData.GetPrintData().GetNativeData();
529
530 // This is required as the page setup dialog
531 // calculates wrong values otherwise.
532 gs_lgp->gnome_print_config_set( native->GetPrintConfig(),
533 (const guchar*) GNOME_PRINT_KEY_PREFERED_UNIT,
534 (const guchar*) "Pts" );
535
536 m_widget = gtk_dialog_new();
537
538 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( _("Page setup") ) );
539
540 GtkWidget *main = gs_lgp->gnome_paper_selector_new_with_flags( native->GetPrintConfig(),
541 GNOME_PAPER_SELECTOR_MARGINS|GNOME_PAPER_SELECTOR_FEED_ORIENTATION );
542 gtk_container_set_border_width (GTK_CONTAINER (main), 8);
543 gtk_widget_show (main);
544
545 gtk_container_add( GTK_CONTAINER (GTK_DIALOG (m_widget)->vbox), main );
546
547 gtk_dialog_set_has_separator (GTK_DIALOG (m_widget), TRUE);
548
549 gtk_dialog_add_buttons (GTK_DIALOG (m_widget),
550 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
551 GTK_STOCK_OK, GTK_RESPONSE_OK,
552 NULL);
553
554 gtk_dialog_set_default_response (GTK_DIALOG (m_widget),
555 GTK_RESPONSE_OK);
556 }
557
558 wxGnomePageSetupDialog::~wxGnomePageSetupDialog()
559 {
560 }
561
562 wxPageSetupDialogData& wxGnomePageSetupDialog::GetPageSetupDialogData()
563 {
564 return m_pageDialogData;
565 }
566
567 int wxGnomePageSetupDialog::ShowModal()
568 {
569 wxGnomePrintNativeData *native =
570 (wxGnomePrintNativeData*) m_pageDialogData.GetPrintData().GetNativeData();
571 GnomePrintConfig *config = native->GetPrintConfig();
572
573 // Transfer data from m_pageDialogData to native dialog
574
575 int ret = gtk_dialog_run( GTK_DIALOG(m_widget) );
576
577 if (ret == GTK_RESPONSE_OK)
578 {
579 // Transfer data back to m_pageDialogData
580
581 // I don't know how querying the last parameter works
582 // I cannot test it as the dialog is currently broken
583 // anyways (it only works for points).
584 double ml,mr,mt,mb,pw,ph;
585 gs_lgp->gnome_print_config_get_length (config,
586 (const guchar*) GNOME_PRINT_KEY_PAGE_MARGIN_LEFT, &ml, NULL);
587 gs_lgp->gnome_print_config_get_length (config,
588 (const guchar*) GNOME_PRINT_KEY_PAGE_MARGIN_RIGHT, &mr, NULL);
589 gs_lgp->gnome_print_config_get_length (config,
590 (const guchar*) GNOME_PRINT_KEY_PAGE_MARGIN_TOP, &mt, NULL);
591 gs_lgp->gnome_print_config_get_length (config,
592 (const guchar*) GNOME_PRINT_KEY_PAGE_MARGIN_BOTTOM, &mb, NULL);
593 gs_lgp->gnome_print_config_get_length (config,
594 (const guchar*) GNOME_PRINT_KEY_PAPER_WIDTH, &pw, NULL);
595 gs_lgp->gnome_print_config_get_length (config,
596 (const guchar*) GNOME_PRINT_KEY_PAPER_HEIGHT, &ph, NULL);
597
598 // This probably assumes that the user entered the
599 // values in Pts. Since that is the only the dialog
600 // works right now, we need to fix this later.
601 const GnomePrintUnit *mm_unit = gs_lgp->gnome_print_unit_get_by_abbreviation( (const guchar*) "mm" );
602 const GnomePrintUnit *pts_unit = gs_lgp->gnome_print_unit_get_by_abbreviation( (const guchar*) "Pts" );
603 gs_lgp->gnome_print_convert_distance( &ml, pts_unit, mm_unit );
604 gs_lgp->gnome_print_convert_distance( &mr, pts_unit, mm_unit );
605 gs_lgp->gnome_print_convert_distance( &mt, pts_unit, mm_unit );
606 gs_lgp->gnome_print_convert_distance( &mb, pts_unit, mm_unit );
607 gs_lgp->gnome_print_convert_distance( &pw, pts_unit, mm_unit );
608 gs_lgp->gnome_print_convert_distance( &ph, pts_unit, mm_unit );
609
610 m_pageDialogData.SetMarginTopLeft( wxPoint( (int)(ml+0.5), (int)(mt+0.5)) );
611 m_pageDialogData.SetMarginBottomRight( wxPoint( (int)(mr+0.5), (int)(mb+0.5)) );
612
613 m_pageDialogData.SetPaperSize( wxSize( (int)(pw+0.5), (int)(ph+0.5) ) );
614
615 #if 0
616 wxPrintf( wxT("paper %d %d, top margin %d\n"),
617 m_pageDialogData.GetPaperSize().x,
618 m_pageDialogData.GetPaperSize().y,
619 m_pageDialogData.GetMarginTopLeft().x );
620 #endif
621
622 ret = wxID_OK;
623 }
624 else
625 {
626 ret = wxID_CANCEL;
627 }
628
629 gtk_widget_destroy( m_widget );
630 m_widget = NULL;
631
632 return ret;
633 }
634
635 bool wxGnomePageSetupDialog::Validate()
636 {
637 return true;
638 }
639
640 bool wxGnomePageSetupDialog::TransferDataToWindow()
641 {
642 return true;
643 }
644
645 bool wxGnomePageSetupDialog::TransferDataFromWindow()
646 {
647 return true;
648 }
649
650 //----------------------------------------------------------------------------
651 // wxGnomePrinter
652 //----------------------------------------------------------------------------
653
654 IMPLEMENT_CLASS(wxGnomePrinter, wxPrinterBase)
655
656 wxGnomePrinter::wxGnomePrinter( wxPrintDialogData *data ) :
657 wxPrinterBase( data )
658 {
659 m_gpc = NULL;
660 m_native_preview = false;
661 }
662
663 wxGnomePrinter::~wxGnomePrinter()
664 {
665 }
666
667 bool wxGnomePrinter::Print(wxWindow *parent, wxPrintout *printout, bool prompt )
668 {
669 if (!printout)
670 {
671 sm_lastError = wxPRINTER_ERROR;
672 return false;
673 }
674
675 wxPrintData printdata = GetPrintDialogData().GetPrintData();
676 wxGnomePrintNativeData *native =
677 (wxGnomePrintNativeData*) printdata.GetNativeData();
678
679 GnomePrintJob *job = gs_lgp->gnome_print_job_new( native->GetPrintConfig() );
680 m_gpc = gs_lgp->gnome_print_job_get_context (job);
681
682 // The GnomePrintJob is temporarily stored in the
683 // native print data as the native print dialog
684 // needs to access it.
685 native->SetPrintJob( job );
686
687
688 printout->SetIsPreview(false);
689
690 if (m_printDialogData.GetMinPage() < 1)
691 m_printDialogData.SetMinPage(1);
692 if (m_printDialogData.GetMaxPage() < 1)
693 m_printDialogData.SetMaxPage(9999);
694
695 wxDC *dc;
696 if (prompt)
697 dc = PrintDialog( parent );
698 else
699 dc = new wxGnomePrintDC( this );
700
701 if (m_native_preview)
702 printout->SetIsPreview(true);
703
704 if (!dc)
705 {
706 gs_lgp->gnome_print_job_close( job );
707 g_object_unref (G_OBJECT (job));
708 sm_lastError = wxPRINTER_ERROR;
709 return false;
710 }
711
712 wxSize ScreenPixels = wxGetDisplaySize();
713 wxSize ScreenMM = wxGetDisplaySizeMM();
714
715 printout->SetPPIScreen( (int) ((ScreenPixels.GetWidth() * 25.4) / ScreenMM.GetWidth()),
716 (int) ((ScreenPixels.GetHeight() * 25.4) / ScreenMM.GetHeight()) );
717 printout->SetPPIPrinter( wxGnomePrintDC::GetResolution(),
718 wxGnomePrintDC::GetResolution() );
719
720 printout->SetDC(dc);
721
722 int w, h;
723 dc->GetSize(&w, &h);
724 printout->SetPageSizePixels((int)w, (int)h);
725 dc->GetSizeMM(&w, &h);
726 printout->SetPageSizeMM((int)w, (int)h);
727
728 printout->OnPreparePrinting();
729
730 // Get some parameters from the printout, if defined
731 int fromPage, toPage;
732 int minPage, maxPage;
733 printout->GetPageInfo(&minPage, &maxPage, &fromPage, &toPage);
734
735 if (maxPage == 0)
736 {
737 gs_lgp->gnome_print_job_close( job );
738 g_object_unref (G_OBJECT (job));
739 sm_lastError = wxPRINTER_ERROR;
740 return false;
741 }
742
743 printout->OnBeginPrinting();
744
745 int minPageNum = minPage, maxPageNum = maxPage;
746
747 if ( !m_printDialogData.GetAllPages() )
748 {
749 minPageNum = m_printDialogData.GetFromPage();
750 maxPageNum = m_printDialogData.GetToPage();
751 }
752
753
754 int copyCount;
755 for ( copyCount = 1;
756 copyCount <= m_printDialogData.GetNoCopies();
757 copyCount++ )
758 {
759 if (!printout->OnBeginDocument(minPageNum, maxPageNum))
760 {
761 wxLogError(_("Could not start printing."));
762 sm_lastError = wxPRINTER_ERROR;
763 break;
764 }
765
766 int pn;
767 for ( pn = minPageNum;
768 pn <= maxPageNum && printout->HasPage(pn);
769 pn++ )
770 {
771 dc->StartPage();
772 printout->OnPrintPage(pn);
773 dc->EndPage();
774 }
775
776 printout->OnEndDocument();
777 printout->OnEndPrinting();
778 }
779
780 gs_lgp->gnome_print_job_close( job );
781 if (m_native_preview)
782 {
783 wxString title( _("Print preview") );
784 gtk_widget_show( gs_lgp->gnome_print_job_preview_new( job, (const guchar*)(const char*)wxGTK_CONV(title) ));
785 }
786 else
787 {
788 gs_lgp->gnome_print_job_print( job );
789 }
790
791 g_object_unref (G_OBJECT (job));
792 delete dc;
793
794 return (sm_lastError == wxPRINTER_NO_ERROR);
795 }
796
797 wxDC* wxGnomePrinter::PrintDialog( wxWindow *parent )
798 {
799 wxGnomePrintDialog dialog( parent, &m_printDialogData );
800 int ret = dialog.ShowModal();
801 if (ret == wxID_CANCEL)
802 {
803 sm_lastError = wxPRINTER_CANCELLED;
804 return NULL;
805 }
806
807 m_native_preview = ret == wxID_PREVIEW;
808
809 m_printDialogData = dialog.GetPrintDialogData();
810 return new wxGnomePrintDC( this );
811 }
812
813 bool wxGnomePrinter::Setup( wxWindow *parent )
814 {
815 return false;
816 }
817
818 //-----------------------------------------------------------------------------
819 // wxGnomePrintDC
820 //-----------------------------------------------------------------------------
821
822 IMPLEMENT_CLASS(wxGnomePrintDC, wxDC)
823
824 wxGnomePrintDC::wxGnomePrintDC( wxGnomePrinter *printer )
825 {
826 m_printer = printer;
827
828 m_gpc = printer->GetPrintContext();
829
830 m_layout = gs_lgp->gnome_print_pango_create_layout( m_gpc );
831 m_fontdesc = pango_font_description_from_string( "Sans 12" );
832
833 m_currentRed = 0;
834 m_currentBlue = 0;
835 m_currentGreen = 0;
836
837 m_signX = 1; // default x-axis left to right
838 m_signY = -1; // default y-axis bottom up -> top down
839 }
840
841 wxGnomePrintDC::~wxGnomePrintDC()
842 {
843 }
844
845 bool wxGnomePrintDC::Ok() const
846 {
847 return true;
848 }
849
850 bool wxGnomePrintDC::DoFloodFill(wxCoord x1, wxCoord y1, const wxColour &col, int style )
851 {
852 return false;
853 }
854
855 bool wxGnomePrintDC::DoGetPixel(wxCoord x1, wxCoord y1, wxColour *col) const
856 {
857 return false;
858 }
859
860 void wxGnomePrintDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
861 {
862 if (m_pen.GetStyle() == wxTRANSPARENT) return;
863
864 SetPen( m_pen );
865
866 gs_lgp->gnome_print_moveto ( m_gpc, XLOG2DEV(x1), YLOG2DEV(y1) );
867 gs_lgp->gnome_print_lineto ( m_gpc, XLOG2DEV(x2), YLOG2DEV(y2) );
868 gs_lgp->gnome_print_stroke ( m_gpc);
869
870 CalcBoundingBox( x1, y1 );
871 CalcBoundingBox( x2, y2 );
872 }
873
874 void wxGnomePrintDC::DoCrossHair(wxCoord x, wxCoord y)
875 {
876 }
877
878 void wxGnomePrintDC::DoDrawArc(wxCoord x1,wxCoord y1,wxCoord x2,wxCoord y2,wxCoord xc,wxCoord yc)
879 {
880 double dx = x1 - xc;
881 double dy = y1 - yc;
882 double radius = sqrt((double)(dx*dx+dy*dy));
883 double alpha1, alpha2;
884 if (x1 == x2 && y1 == y2)
885 {
886 alpha1 = 0.0;
887 alpha2 = 360.0;
888 }
889 else
890 if (radius == 0.0)
891 {
892 alpha1 = alpha2 = 0.0;
893 }
894 else
895 {
896 alpha1 = (x1 - xc == 0) ?
897 (y1 - yc < 0) ? 90.0 : -90.0 :
898 -atan2(double(y1-yc), double(x1-xc)) * RAD2DEG;
899 alpha2 = (x2 - xc == 0) ?
900 (y2 - yc < 0) ? 90.0 : -90.0 :
901 -atan2(double(y2-yc), double(x2-xc)) * RAD2DEG;
902
903 while (alpha1 <= 0) alpha1 += 360;
904 while (alpha2 <= 0) alpha2 += 360; // adjust angles to be between
905 while (alpha1 > 360) alpha1 -= 360; // 0 and 360 degree
906 while (alpha2 > 360) alpha2 -= 360;
907 }
908
909 if (m_brush.GetStyle() != wxTRANSPARENT)
910 {
911 SetBrush( m_brush );
912 gs_lgp->gnome_print_moveto ( m_gpc, XLOG2DEV(xc), YLOG2DEV(yc) );
913 gs_lgp->gnome_print_arcto( m_gpc, XLOG2DEV(xc), YLOG2DEV(yc), XLOG2DEVREL((int)radius), alpha1, alpha2, 0 );
914
915 gs_lgp->gnome_print_fill( m_gpc );
916 }
917
918 if (m_pen.GetStyle() != wxTRANSPARENT)
919 {
920 SetPen (m_pen);
921 gs_lgp->gnome_print_newpath( m_gpc );
922 gs_lgp->gnome_print_moveto ( m_gpc, XLOG2DEV(xc), YLOG2DEV(yc) );
923 gs_lgp->gnome_print_arcto( m_gpc, XLOG2DEV(xc), YLOG2DEV(yc), XLOG2DEVREL((int)radius), alpha1, alpha2, 0 );
924 gs_lgp->gnome_print_closepath( m_gpc );
925
926 gs_lgp->gnome_print_stroke( m_gpc );
927 }
928
929 CalcBoundingBox (x1, y1);
930 CalcBoundingBox (x2, y2);
931 CalcBoundingBox (xc, yc);
932 }
933
934 void wxGnomePrintDC::DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,double ea)
935 {
936 x += w/2;
937 y += h/2;
938
939 int xx = XLOG2DEV(x);
940 int yy = YLOG2DEV(y);
941
942 gs_lgp->gnome_print_gsave( m_gpc );
943
944 gs_lgp->gnome_print_translate( m_gpc, xx, yy );
945 double scale = (double)YLOG2DEVREL(h) / (double) XLOG2DEVREL(w);
946 gs_lgp->gnome_print_scale( m_gpc, 1.0, scale );
947
948 xx = 0;
949 yy = 0;
950
951 if (m_brush.GetStyle () != wxTRANSPARENT)
952 {
953 SetBrush( m_brush );
954
955 gs_lgp->gnome_print_moveto ( m_gpc, xx, yy );
956 gs_lgp->gnome_print_arcto( m_gpc, xx, yy,
957 XLOG2DEVREL(w)/2, sa, ea, 0 );
958 gs_lgp->gnome_print_moveto ( m_gpc, xx, yy );
959
960 gs_lgp->gnome_print_fill( m_gpc );
961 }
962
963 if (m_pen.GetStyle () != wxTRANSPARENT)
964 {
965 SetPen (m_pen);
966
967 gs_lgp->gnome_print_arcto( m_gpc, xx, yy,
968 XLOG2DEVREL(w)/2, sa, ea, 0 );
969
970 gs_lgp->gnome_print_stroke( m_gpc );
971 }
972
973 gs_lgp->gnome_print_grestore( m_gpc );
974
975 CalcBoundingBox( x, y );
976 CalcBoundingBox( x+w, y+h );
977 }
978
979 void wxGnomePrintDC::DoDrawPoint(wxCoord x, wxCoord y)
980 {
981 }
982
983 void wxGnomePrintDC::DoDrawLines(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset)
984 {
985 if (m_pen.GetStyle() == wxTRANSPARENT) return;
986
987 if (n <= 0) return;
988
989 SetPen (m_pen);
990
991 int i;
992 for ( i =0; i<n ; i++ )
993 CalcBoundingBox( points[i].x+xoffset, points[i].y+yoffset);
994
995 gs_lgp->gnome_print_moveto ( m_gpc, XLOG2DEV(points[0].x+xoffset), YLOG2DEV(points[0].y+yoffset) );
996
997 for (i = 1; i < n; i++)
998 gs_lgp->gnome_print_lineto ( m_gpc, XLOG2DEV(points[i].x+xoffset), YLOG2DEV(points[i].y+yoffset) );
999
1000 gs_lgp->gnome_print_stroke ( m_gpc);
1001 }
1002
1003 void wxGnomePrintDC::DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset, int fillStyle)
1004 {
1005 if (n==0) return;
1006
1007 if (m_brush.GetStyle () != wxTRANSPARENT)
1008 {
1009 SetBrush( m_brush );
1010
1011 int x = points[0].x + xoffset;
1012 int y = points[0].y + yoffset;
1013 CalcBoundingBox( x, y );
1014 gs_lgp->gnome_print_newpath( m_gpc );
1015 gs_lgp->gnome_print_moveto( m_gpc, XLOG2DEV(x), YLOG2DEV(y) );
1016 int i;
1017 for (i = 1; i < n; i++)
1018 {
1019 int x = points[i].x + xoffset;
1020 int y = points[i].y + yoffset;
1021 gs_lgp->gnome_print_lineto( m_gpc, XLOG2DEV(x), YLOG2DEV(y) );
1022 CalcBoundingBox( x, y );
1023 }
1024 gs_lgp->gnome_print_closepath( m_gpc );
1025 gs_lgp->gnome_print_fill( m_gpc );
1026 }
1027
1028 if (m_pen.GetStyle () != wxTRANSPARENT)
1029 {
1030 SetPen (m_pen);
1031
1032 int x = points[0].x + xoffset;
1033 int y = points[0].y + yoffset;
1034 gs_lgp->gnome_print_newpath( m_gpc );
1035 gs_lgp->gnome_print_moveto( m_gpc, XLOG2DEV(x), YLOG2DEV(y) );
1036 int i;
1037 for (i = 1; i < n; i++)
1038 {
1039 int x = points[i].x + xoffset;
1040 int y = points[i].y + yoffset;
1041 gs_lgp->gnome_print_lineto( m_gpc, XLOG2DEV(x), YLOG2DEV(y) );
1042 CalcBoundingBox( x, y );
1043 }
1044 gs_lgp->gnome_print_closepath( m_gpc );
1045 gs_lgp->gnome_print_stroke( m_gpc );
1046 }
1047 }
1048
1049 void wxGnomePrintDC::DoDrawPolyPolygon(int n, int count[], wxPoint points[], wxCoord xoffset, wxCoord yoffset, int fillStyle)
1050 {
1051 wxDC::DoDrawPolyPolygon( n, count, points, xoffset, yoffset, fillStyle );
1052 }
1053
1054 void wxGnomePrintDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1055 {
1056 if (m_brush.GetStyle () != wxTRANSPARENT)
1057 {
1058 SetBrush( m_brush );
1059
1060 gs_lgp->gnome_print_newpath( m_gpc );
1061 gs_lgp->gnome_print_moveto( m_gpc, XLOG2DEV(x), YLOG2DEV(y) );
1062 gs_lgp->gnome_print_lineto( m_gpc, XLOG2DEV(x + width), YLOG2DEV(y) );
1063 gs_lgp->gnome_print_lineto( m_gpc, XLOG2DEV(x + width), YLOG2DEV(y + height) );
1064 gs_lgp->gnome_print_lineto( m_gpc, XLOG2DEV(x), YLOG2DEV(y + height) );
1065 gs_lgp->gnome_print_closepath( m_gpc );
1066 gs_lgp->gnome_print_fill( m_gpc );
1067
1068 CalcBoundingBox( x, y );
1069 CalcBoundingBox( x + width, y + height );
1070 }
1071
1072 if (m_pen.GetStyle () != wxTRANSPARENT)
1073 {
1074 SetPen (m_pen);
1075
1076 gs_lgp->gnome_print_newpath( m_gpc );
1077 gs_lgp->gnome_print_moveto( m_gpc, XLOG2DEV(x), YLOG2DEV(y) );
1078 gs_lgp->gnome_print_lineto( m_gpc, XLOG2DEV(x + width), YLOG2DEV(y) );
1079 gs_lgp->gnome_print_lineto( m_gpc, XLOG2DEV(x + width), YLOG2DEV(y + height) );
1080 gs_lgp->gnome_print_lineto( m_gpc, XLOG2DEV(x), YLOG2DEV(y + height) );
1081 gs_lgp->gnome_print_closepath( m_gpc );
1082 gs_lgp->gnome_print_stroke( m_gpc );
1083
1084 CalcBoundingBox( x, y );
1085 CalcBoundingBox( x + width, y + height );
1086 }
1087 }
1088
1089 void wxGnomePrintDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius)
1090 {
1091 wxCoord rad = (wxCoord) radius;
1092
1093 if (m_brush.GetStyle() != wxTRANSPARENT)
1094 {
1095 SetBrush(m_brush);
1096 gs_lgp->gnome_print_newpath(m_gpc);
1097 gs_lgp->gnome_print_moveto(m_gpc,XLOG2DEV(x + rad),YLOG2DEV(y));
1098 gs_lgp->gnome_print_curveto(m_gpc,
1099 XLOG2DEV(x + rad),YLOG2DEV(y),
1100 XLOG2DEV(x),YLOG2DEV(y),
1101 XLOG2DEV(x),YLOG2DEV(y + rad));
1102 gs_lgp->gnome_print_lineto(m_gpc,XLOG2DEV(x),YLOG2DEV(y + height - rad));
1103 gs_lgp->gnome_print_curveto(m_gpc,
1104 XLOG2DEV(x),YLOG2DEV(y + height - rad),
1105 XLOG2DEV(x),YLOG2DEV(y + height),
1106 XLOG2DEV(x + rad),YLOG2DEV(y + height));
1107 gs_lgp->gnome_print_lineto(m_gpc,XLOG2DEV(x + width - rad),YLOG2DEV(y + height));
1108 gs_lgp->gnome_print_curveto(m_gpc,
1109 XLOG2DEV(x + width - rad),YLOG2DEV(y + height),
1110 XLOG2DEV(x + width),YLOG2DEV(y + height),
1111 XLOG2DEV(x + width),YLOG2DEV(y + height - rad));
1112 gs_lgp->gnome_print_lineto(m_gpc,XLOG2DEV(x + width),YLOG2DEV(y + rad));
1113 gs_lgp->gnome_print_curveto(m_gpc,
1114 XLOG2DEV(x + width),YLOG2DEV(y + rad),
1115 XLOG2DEV(x + width),YLOG2DEV(y),
1116 XLOG2DEV(x + width - rad),YLOG2DEV(y));
1117 gs_lgp->gnome_print_lineto(m_gpc,XLOG2DEV(x + rad),YLOG2DEV(y));
1118 gs_lgp->gnome_print_closepath(m_gpc);
1119 gs_lgp->gnome_print_fill(m_gpc);
1120
1121 CalcBoundingBox(x,y);
1122 CalcBoundingBox(x+width,y+height);
1123 }
1124
1125 if (m_pen.GetStyle() != wxTRANSPARENT)
1126 {
1127 SetPen(m_pen);
1128 gs_lgp->gnome_print_newpath(m_gpc);
1129 gs_lgp->gnome_print_moveto(m_gpc,XLOG2DEV(x + rad),YLOG2DEV(y));
1130 gs_lgp->gnome_print_curveto(m_gpc,
1131 XLOG2DEV(x + rad),YLOG2DEV(y),
1132 XLOG2DEV(x),YLOG2DEV(y),
1133 XLOG2DEV(x),YLOG2DEV(y + rad));
1134 gs_lgp->gnome_print_lineto(m_gpc,XLOG2DEV(x),YLOG2DEV(y + height - rad));
1135 gs_lgp->gnome_print_curveto(m_gpc,
1136 XLOG2DEV(x),YLOG2DEV(y + height - rad),
1137 XLOG2DEV(x),YLOG2DEV(y + height),
1138 XLOG2DEV(x + rad),YLOG2DEV(y + height));
1139 gs_lgp->gnome_print_lineto(m_gpc,XLOG2DEV(x + width - rad),YLOG2DEV(y + height));
1140 gs_lgp->gnome_print_curveto(m_gpc,
1141 XLOG2DEV(x + width - rad),YLOG2DEV(y + height),
1142 XLOG2DEV(x + width),YLOG2DEV(y + height),
1143 XLOG2DEV(x + width),YLOG2DEV(y + height - rad));
1144 gs_lgp->gnome_print_lineto(m_gpc,XLOG2DEV(x + width),YLOG2DEV(y + rad));
1145 gs_lgp->gnome_print_curveto(m_gpc,
1146 XLOG2DEV(x + width),YLOG2DEV(y + rad),
1147 XLOG2DEV(x + width),YLOG2DEV(y),
1148 XLOG2DEV(x + width - rad),YLOG2DEV(y));
1149 gs_lgp->gnome_print_lineto(m_gpc,XLOG2DEV(x + rad),YLOG2DEV(y));
1150 gs_lgp->gnome_print_closepath(m_gpc);
1151 gs_lgp->gnome_print_stroke(m_gpc);
1152
1153 CalcBoundingBox(x,y);
1154 CalcBoundingBox(x+width,y+height);
1155 }
1156 }
1157
1158 void wxGnomePrintDC::makeEllipticalPath(wxCoord x, wxCoord y,
1159 wxCoord width, wxCoord height)
1160 {
1161 double r = 4 * (sqrt (2) - 1) / 3;
1162 double halfW = 0.5 * width,
1163 halfH = 0.5 * height,
1164 halfWR = r * halfW,
1165 halfHR = r * halfH;
1166 wxCoord halfWI = (wxCoord) halfW,
1167 halfHI = (wxCoord) halfH;
1168
1169 gs_lgp->gnome_print_newpath( m_gpc );
1170
1171 // Approximate an ellipse using four cubic splines, clockwise from 0 deg */
1172 gs_lgp->gnome_print_moveto( m_gpc,
1173 XLOG2DEV(x + width),
1174 YLOG2DEV(y + halfHI) );
1175 gs_lgp->gnome_print_curveto( m_gpc,
1176 XLOG2DEV(x + width),
1177 YLOG2DEV(y + (wxCoord) rint (halfH + halfHR)),
1178 XLOG2DEV(x + (wxCoord) rint(halfW + halfWR)),
1179 YLOG2DEV(y + height),
1180 XLOG2DEV(x + halfWI),
1181 YLOG2DEV(y + height) );
1182 gs_lgp->gnome_print_curveto( m_gpc,
1183 XLOG2DEV(x + (wxCoord) rint(halfW - halfWR)),
1184 YLOG2DEV(y + height),
1185 XLOG2DEV(x),
1186 YLOG2DEV(y + (wxCoord) rint (halfH + halfHR)),
1187 XLOG2DEV(x), YLOG2DEV(y+halfHI) );
1188 gs_lgp->gnome_print_curveto( m_gpc,
1189 XLOG2DEV(x),
1190 YLOG2DEV(y + (wxCoord) rint (halfH - halfHR)),
1191 XLOG2DEV(x + (wxCoord) rint (halfW - halfWR)),
1192 YLOG2DEV(y),
1193 XLOG2DEV(x+halfWI), YLOG2DEV(y) );
1194 gs_lgp->gnome_print_curveto( m_gpc,
1195 XLOG2DEV(x + (wxCoord) rint(halfW + halfWR)),
1196 YLOG2DEV(y),
1197 XLOG2DEV(x + width),
1198 YLOG2DEV(y + (wxCoord) rint(halfH - halfHR)),
1199 XLOG2DEV(x + width), YLOG2DEV(y + halfHI) );
1200
1201 gs_lgp->gnome_print_closepath(m_gpc);
1202 }
1203
1204 void wxGnomePrintDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1205 {
1206 if (m_brush.GetStyle () != wxTRANSPARENT)
1207 {
1208 SetBrush( m_brush );
1209 makeEllipticalPath( x, y, width, height );
1210 gs_lgp->gnome_print_fill( m_gpc );
1211 CalcBoundingBox( x, y );
1212 CalcBoundingBox( x + width, y + height );
1213 }
1214
1215 if (m_pen.GetStyle () != wxTRANSPARENT)
1216 {
1217 SetPen (m_pen);
1218 makeEllipticalPath( x, y, width, height );
1219 gs_lgp->gnome_print_stroke( m_gpc );
1220 CalcBoundingBox( x, y );
1221 CalcBoundingBox( x + width, y + height );
1222 }
1223 }
1224
1225 #if wxUSE_SPLINES
1226 void wxGnomePrintDC::DoDrawSpline(wxList *points)
1227 {
1228 SetPen (m_pen);
1229
1230 double c, d, x1, y1, x2, y2, x3, y3;
1231 wxPoint *p, *q;
1232
1233 wxList::compatibility_iterator node = points->GetFirst();
1234 p = (wxPoint *)node->GetData();
1235 x1 = p->x;
1236 y1 = p->y;
1237
1238 node = node->GetNext();
1239 p = (wxPoint *)node->GetData();
1240 c = p->x;
1241 d = p->y;
1242 x3 =
1243 (double)(x1 + c) / 2;
1244 y3 =
1245 (double)(y1 + d) / 2;
1246
1247 gs_lgp->gnome_print_newpath( m_gpc );
1248 gs_lgp->gnome_print_moveto( m_gpc, XLOG2DEV((wxCoord)x1), YLOG2DEV((wxCoord)y1) );
1249 gs_lgp->gnome_print_lineto( m_gpc, XLOG2DEV((wxCoord)x3), YLOG2DEV((wxCoord)y3) );
1250
1251 CalcBoundingBox( (wxCoord)x1, (wxCoord)y1 );
1252 CalcBoundingBox( (wxCoord)x3, (wxCoord)y3 );
1253
1254 node = node->GetNext();
1255 while (node)
1256 {
1257 q = (wxPoint *)node->GetData();
1258
1259 x1 = x3;
1260 y1 = y3;
1261 x2 = c;
1262 y2 = d;
1263 c = q->x;
1264 d = q->y;
1265 x3 = (double)(x2 + c) / 2;
1266 y3 = (double)(y2 + d) / 2;
1267
1268 gs_lgp->gnome_print_curveto(m_gpc,
1269 XLOG2DEV((wxCoord)x1), YLOG2DEV((wxCoord)y1),
1270 XLOG2DEV((wxCoord)x2), YLOG2DEV((wxCoord)y2),
1271 XLOG2DEV((wxCoord)x3), YLOG2DEV((wxCoord)y3) );
1272
1273 CalcBoundingBox( (wxCoord)x1, (wxCoord)y1 );
1274 CalcBoundingBox( (wxCoord)x3, (wxCoord)y3 );
1275
1276 node = node->GetNext();
1277 }
1278
1279 gs_lgp->gnome_print_lineto ( m_gpc, XLOG2DEV((wxCoord)c), YLOG2DEV((wxCoord)d) );
1280
1281 gs_lgp->gnome_print_stroke( m_gpc );
1282 }
1283 #endif // wxUSE_SPLINES
1284
1285 bool wxGnomePrintDC::DoBlit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
1286 wxDC *source, wxCoord xsrc, wxCoord ysrc, int rop, bool useMask,
1287 wxCoord xsrcMask, wxCoord ysrcMask)
1288 {
1289 wxCHECK_MSG( source, false, wxT("invalid source dc") );
1290
1291 // blit into a bitmap
1292 wxBitmap bitmap( width, height );
1293 wxMemoryDC memDC;
1294 memDC.SelectObject(bitmap);
1295 memDC.Blit(0, 0, width, height, source, xsrc, ysrc, rop); /* TODO: Blit transparently? */
1296 memDC.SelectObject(wxNullBitmap);
1297
1298 // draw bitmap. scaling and positioning is done there
1299 DrawBitmap( bitmap, xdest, ydest );
1300
1301 return true;
1302 }
1303
1304 void wxGnomePrintDC::DoDrawIcon( const wxIcon& icon, wxCoord x, wxCoord y )
1305 {
1306 DoDrawBitmap( icon, x, y, true );
1307 }
1308
1309 void wxGnomePrintDC::DoDrawBitmap( const wxBitmap& bitmap, wxCoord x, wxCoord y, bool useMask )
1310 {
1311 if (!bitmap.Ok()) return;
1312
1313 if (bitmap.HasPixbuf())
1314 {
1315 GdkPixbuf *pixbuf = bitmap.GetPixbuf();
1316 guchar *raw_image = gdk_pixbuf_get_pixels( pixbuf );
1317 bool has_alpha = gdk_pixbuf_get_has_alpha( pixbuf );
1318 int rowstride = gdk_pixbuf_get_rowstride( pixbuf );
1319 int height = gdk_pixbuf_get_height( pixbuf );
1320 int width = gdk_pixbuf_get_width( pixbuf );
1321
1322 gs_lgp->gnome_print_gsave( m_gpc );
1323 double matrix[6];
1324 matrix[0] = XLOG2DEVREL(width);
1325 matrix[1] = 0;
1326 matrix[2] = 0;
1327 matrix[3] = YLOG2DEVREL(height);
1328 matrix[4] = XLOG2DEV(x);
1329 matrix[5] = YLOG2DEV(y+height);
1330 gs_lgp->gnome_print_concat( m_gpc, matrix );
1331 gs_lgp->gnome_print_moveto( m_gpc, 0, 0 );
1332 if (has_alpha)
1333 gs_lgp->gnome_print_rgbaimage( m_gpc, (guchar *)raw_image, width, height, rowstride );
1334 else
1335 gs_lgp->gnome_print_rgbimage( m_gpc, (guchar *)raw_image, width, height, rowstride );
1336 gs_lgp->gnome_print_grestore( m_gpc );
1337 }
1338 else
1339 {
1340 wxImage image = bitmap.ConvertToImage();
1341
1342 if (!image.Ok()) return;
1343
1344 gs_lgp->gnome_print_gsave( m_gpc );
1345 double matrix[6];
1346 matrix[0] = XLOG2DEVREL(image.GetWidth());
1347 matrix[1] = 0;
1348 matrix[2] = 0;
1349 matrix[3] = YLOG2DEVREL(image.GetHeight());
1350 matrix[4] = XLOG2DEV(x);
1351 matrix[5] = YLOG2DEV(y+image.GetHeight());
1352 gs_lgp->gnome_print_concat( m_gpc, matrix );
1353 gs_lgp->gnome_print_moveto( m_gpc, 0, 0 );
1354 gs_lgp->gnome_print_rgbimage( m_gpc, (guchar*) image.GetData(), image.GetWidth(), image.GetHeight(), image.GetWidth()*3 );
1355 gs_lgp->gnome_print_grestore( m_gpc );
1356 }
1357 }
1358
1359 void wxGnomePrintDC::DoDrawText(const wxString& text, wxCoord x, wxCoord y )
1360 {
1361 DoDrawRotatedText( text, x, y, 0.0 );
1362 }
1363
1364 void wxGnomePrintDC::DoDrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle)
1365 {
1366 x = XLOG2DEV(x);
1367 y = YLOG2DEV(y);
1368
1369 bool underlined = m_font.Ok() && m_font.GetUnderlined();
1370
1371 #if wxUSE_UNICODE
1372 const wxCharBuffer data = wxConvUTF8.cWC2MB( text );
1373 #else
1374 const wxWCharBuffer wdata = wxConvLocal.cMB2WC( text );
1375 if ( !wdata )
1376 return;
1377 const wxCharBuffer data = wxConvUTF8.cWC2MB( wdata );
1378 #endif
1379
1380 size_t datalen = strlen((const char*)data);
1381 pango_layout_set_text( m_layout, (const char*) data, datalen);
1382
1383 if (underlined)
1384 {
1385 PangoAttrList *attrs = pango_attr_list_new();
1386 PangoAttribute *a = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
1387 a->start_index = 0;
1388 a->end_index = datalen;
1389 pango_attr_list_insert(attrs, a);
1390 pango_layout_set_attributes(m_layout, attrs);
1391 pango_attr_list_unref(attrs);
1392 }
1393
1394 if (m_textForegroundColour.Ok())
1395 {
1396 unsigned char red = m_textForegroundColour.Red();
1397 unsigned char blue = m_textForegroundColour.Blue();
1398 unsigned char green = m_textForegroundColour.Green();
1399
1400 if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
1401 {
1402 double redPS = (double)(red) / 255.0;
1403 double bluePS = (double)(blue) / 255.0;
1404 double greenPS = (double)(green) / 255.0;
1405
1406 gs_lgp->gnome_print_setrgbcolor( m_gpc, redPS, greenPS, bluePS );
1407
1408 m_currentRed = red;
1409 m_currentBlue = blue;
1410 m_currentGreen = green;
1411 }
1412 }
1413
1414 int w,h;
1415
1416 if (fabs(m_scaleY - 1.0) > 0.00001)
1417 {
1418 // If there is a user or actually any scale applied to
1419 // the device context, scale the font.
1420
1421 // scale font description
1422 gint oldSize = pango_font_description_get_size( m_fontdesc );
1423 double size = oldSize;
1424 size = size * m_scaleY;
1425 pango_font_description_set_size( m_fontdesc, (gint)size );
1426
1427 // actually apply scaled font
1428 pango_layout_set_font_description( m_layout, m_fontdesc );
1429
1430 pango_layout_get_pixel_size( m_layout, &w, &h );
1431 #if 0
1432 if ( m_backgroundMode == wxSOLID )
1433 {
1434 gdk_gc_set_foreground(m_textGC, m_textBackgroundColour.GetColor());
1435 gdk_draw_rectangle(m_window, m_textGC, TRUE, x, y, w, h);
1436 gdk_gc_set_foreground(m_textGC, m_textForegroundColour.GetColor());
1437 }
1438 #endif
1439 // Draw layout.
1440 gs_lgp->gnome_print_moveto (m_gpc, x, y);
1441 if (fabs(angle) > 0.00001)
1442 {
1443 gs_lgp->gnome_print_gsave( m_gpc );
1444 gs_lgp->gnome_print_rotate( m_gpc, angle );
1445 gs_lgp->gnome_print_pango_layout( m_gpc, m_layout );
1446 gs_lgp->gnome_print_grestore( m_gpc );
1447 }
1448 else
1449 {
1450 gs_lgp->gnome_print_pango_layout( m_gpc, m_layout );
1451 }
1452
1453 // reset unscaled size
1454 pango_font_description_set_size( m_fontdesc, oldSize );
1455
1456 // actually apply unscaled font
1457 pango_layout_set_font_description( m_layout, m_fontdesc );
1458 }
1459 else
1460 {
1461 pango_layout_get_pixel_size( m_layout, &w, &h );
1462 #if 0
1463 if ( m_backgroundMode == wxSOLID )
1464 {
1465 gdk_gc_set_foreground(m_textGC, m_textBackgroundColour.GetColor());
1466 gdk_draw_rectangle(m_window, m_textGC, TRUE, x, y, w, h);
1467 gdk_gc_set_foreground(m_textGC, m_textForegroundColour.GetColor());
1468 }
1469 #endif
1470 // Draw layout.
1471 gs_lgp->gnome_print_moveto (m_gpc, x, y);
1472 if (fabs(angle) > 0.00001)
1473 {
1474 gs_lgp->gnome_print_gsave( m_gpc );
1475 gs_lgp->gnome_print_rotate( m_gpc, angle );
1476 gs_lgp->gnome_print_pango_layout( m_gpc, m_layout );
1477 gs_lgp->gnome_print_grestore( m_gpc );
1478 }
1479 else
1480 {
1481 gs_lgp->gnome_print_pango_layout( m_gpc, m_layout );
1482 }
1483 }
1484
1485 if (underlined)
1486 {
1487 // undo underline attributes setting:
1488 pango_layout_set_attributes(m_layout, NULL);
1489 }
1490
1491 CalcBoundingBox (x + w, y + h);
1492 }
1493
1494 void wxGnomePrintDC::Clear()
1495 {
1496 }
1497
1498 void wxGnomePrintDC::SetFont( const wxFont& font )
1499 {
1500 m_font = font;
1501
1502 if (m_font.Ok())
1503 {
1504 if (m_fontdesc)
1505 pango_font_description_free( m_fontdesc );
1506
1507 m_fontdesc = pango_font_description_copy( m_font.GetNativeFontInfo()->description );
1508
1509 pango_layout_set_font_description( m_layout, m_fontdesc );
1510 }
1511 }
1512
1513 void wxGnomePrintDC::SetPen( const wxPen& pen )
1514 {
1515 if (!pen.Ok()) return;
1516
1517 m_pen = pen;
1518
1519 gs_lgp->gnome_print_setlinewidth( m_gpc, XLOG2DEVREL( 1000 * m_pen.GetWidth() ) / 1000.0f );
1520
1521 static const double dotted[] = {2.0, 5.0};
1522 static const double short_dashed[] = {4.0, 4.0};
1523 static const double wxCoord_dashed[] = {4.0, 8.0};
1524 static const double dotted_dashed[] = {6.0, 6.0, 2.0, 6.0};
1525
1526 switch (m_pen.GetStyle())
1527 {
1528 case wxDOT: gs_lgp->gnome_print_setdash( m_gpc, 2, dotted, 0 ); break;
1529 case wxSHORT_DASH: gs_lgp->gnome_print_setdash( m_gpc, 2, short_dashed, 0 ); break;
1530 case wxLONG_DASH: gs_lgp->gnome_print_setdash( m_gpc, 2, wxCoord_dashed, 0 ); break;
1531 case wxDOT_DASH: gs_lgp->gnome_print_setdash( m_gpc, 4, dotted_dashed, 0 ); break;
1532 case wxUSER_DASH:
1533 {
1534 // It may be noted that libgnomeprint between at least
1535 // versions 2.8.0 and 2.12.1 makes a copy of the dashes
1536 // and then leak the memory since it doesn't set the
1537 // internal flag "privatedash" to 0.
1538 wxDash *wx_dashes;
1539 int num = m_pen.GetDashes (&wx_dashes);
1540 gdouble *g_dashes = g_new( gdouble, num );
1541 int i;
1542 for (i = 0; i < num; ++i)
1543 g_dashes[i] = (gdouble) wx_dashes[i];
1544 gs_lgp -> gnome_print_setdash( m_gpc, num, g_dashes, 0);
1545 g_free( g_dashes );
1546 }
1547 break;
1548 case wxSOLID:
1549 case wxTRANSPARENT:
1550 default: gs_lgp->gnome_print_setdash( m_gpc, 0, NULL, 0 ); break;
1551 }
1552
1553
1554 unsigned char red = m_pen.GetColour().Red();
1555 unsigned char blue = m_pen.GetColour().Blue();
1556 unsigned char green = m_pen.GetColour().Green();
1557
1558 if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
1559 {
1560 double redPS = (double)(red) / 255.0;
1561 double bluePS = (double)(blue) / 255.0;
1562 double greenPS = (double)(green) / 255.0;
1563
1564 gs_lgp->gnome_print_setrgbcolor( m_gpc, redPS, greenPS, bluePS );
1565
1566 m_currentRed = red;
1567 m_currentBlue = blue;
1568 m_currentGreen = green;
1569 }
1570 }
1571
1572 void wxGnomePrintDC::SetBrush( const wxBrush& brush )
1573 {
1574 if (!brush.Ok()) return;
1575
1576 m_brush = brush;
1577
1578 // Brush colour
1579 unsigned char red = m_brush.GetColour().Red();
1580 unsigned char blue = m_brush.GetColour().Blue();
1581 unsigned char green = m_brush.GetColour().Green();
1582
1583 if (!m_colour)
1584 {
1585 // Anything not white is black
1586 if (! (red == (unsigned char) 255 &&
1587 blue == (unsigned char) 255 &&
1588 green == (unsigned char) 255) )
1589 {
1590 red = (unsigned char) 0;
1591 green = (unsigned char) 0;
1592 blue = (unsigned char) 0;
1593 }
1594 // setgray here ?
1595 }
1596
1597 if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
1598 {
1599 double redPS = (double)(red) / 255.0;
1600 double bluePS = (double)(blue) / 255.0;
1601 double greenPS = (double)(green) / 255.0;
1602
1603 gs_lgp->gnome_print_setrgbcolor( m_gpc, redPS, greenPS, bluePS );
1604
1605 m_currentRed = red;
1606 m_currentBlue = blue;
1607 m_currentGreen = green;
1608 }
1609 }
1610
1611 void wxGnomePrintDC::SetLogicalFunction( int function )
1612 {
1613 }
1614
1615 void wxGnomePrintDC::SetBackground( const wxBrush& brush )
1616 {
1617 }
1618
1619 void wxGnomePrintDC::DoSetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1620 {
1621 }
1622
1623 void wxGnomePrintDC::DestroyClippingRegion()
1624 {
1625 }
1626
1627 bool wxGnomePrintDC::StartDoc(const wxString& message)
1628 {
1629 SetDeviceOrigin( 0,0 );
1630
1631 return true;
1632 }
1633
1634 void wxGnomePrintDC::EndDoc()
1635 {
1636 gs_lgp->gnome_print_end_doc( m_gpc );
1637 }
1638
1639 void wxGnomePrintDC::StartPage()
1640 {
1641 gs_lgp->gnome_print_beginpage( m_gpc, (const guchar*) "page" );
1642 }
1643
1644 void wxGnomePrintDC::EndPage()
1645 {
1646 gs_lgp->gnome_print_showpage( m_gpc );
1647 }
1648
1649 wxCoord wxGnomePrintDC::GetCharHeight() const
1650 {
1651 pango_layout_set_text( m_layout, "H", 1 );
1652
1653 int w,h;
1654 pango_layout_get_pixel_size( m_layout, &w, &h );
1655
1656 return h;
1657 }
1658
1659 wxCoord wxGnomePrintDC::GetCharWidth() const
1660 {
1661 pango_layout_set_text( m_layout, "H", 1 );
1662
1663 int w,h;
1664 pango_layout_get_pixel_size( m_layout, &w, &h );
1665
1666 return w;
1667 }
1668
1669 void wxGnomePrintDC::DoGetTextExtent(const wxString& string, wxCoord *width, wxCoord *height,
1670 wxCoord *descent,
1671 wxCoord *externalLeading,
1672 wxFont *theFont ) const
1673 {
1674 if ( width )
1675 *width = 0;
1676 if ( height )
1677 *height = 0;
1678 if ( descent )
1679 *descent = 0;
1680 if ( externalLeading )
1681 *externalLeading = 0;
1682
1683 if (string.empty())
1684 {
1685 return;
1686 }
1687
1688 // Set new font description
1689 if (theFont)
1690 pango_layout_set_font_description( m_layout, theFont->GetNativeFontInfo()->description );
1691
1692 // Set layout's text
1693 #if wxUSE_UNICODE
1694 const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
1695 const char *dataUTF8 = (const char *)data;
1696 #else
1697 const wxWCharBuffer wdata = wxConvLocal.cMB2WC( string );
1698 if ( !wdata )
1699 {
1700 if (width) (*width) = 0;
1701 if (height) (*height) = 0;
1702 return;
1703 }
1704 const wxCharBuffer data = wxConvUTF8.cWC2MB( wdata );
1705 const char *dataUTF8 = (const char *)data;
1706 #endif
1707
1708 if ( !dataUTF8 )
1709 {
1710 // hardly ideal, but what else can we do if conversion failed?
1711 return;
1712 }
1713
1714 pango_layout_set_text( m_layout, dataUTF8, strlen(dataUTF8) );
1715
1716 int w,h;
1717 pango_layout_get_pixel_size( m_layout, &w, &h );
1718
1719 if (width)
1720 *width = (wxCoord)(w / m_scaleX);
1721 if (height)
1722 *height = (wxCoord)(h / m_scaleY);
1723 if (descent)
1724 {
1725 PangoLayoutIter *iter = pango_layout_get_iter(m_layout);
1726 int baseline = pango_layout_iter_get_baseline(iter);
1727 pango_layout_iter_free(iter);
1728 *descent = h - PANGO_PIXELS(baseline);
1729 }
1730
1731 // Reset old font description
1732 if (theFont)
1733 pango_layout_set_font_description( m_layout, m_fontdesc );
1734 }
1735
1736 void wxGnomePrintDC::DoGetSize(int* width, int* height) const
1737 {
1738 wxGnomePrintNativeData *native =
1739 (wxGnomePrintNativeData*) m_printData.GetNativeData();
1740
1741 // Query page size. This seems to omit the margins
1742 // right now, although it shouldn't
1743 double pw,ph;
1744 gs_lgp->gnome_print_job_get_page_size( native->GetPrintJob(), &pw, &ph );
1745
1746 if (width)
1747 *width = (int) (pw + 0.5);
1748 if (height)
1749 *height = (int) (ph + 0.5);
1750 }
1751
1752 void wxGnomePrintDC::DoGetSizeMM(int *width, int *height) const
1753 {
1754 wxGnomePrintNativeData *native =
1755 (wxGnomePrintNativeData*) m_printData.GetNativeData();
1756
1757 // This code assumes values in Pts.
1758
1759 double pw,ph;
1760 gs_lgp->gnome_print_job_get_page_size( native->GetPrintJob(), &pw, &ph );
1761
1762 // Convert to mm.
1763
1764 const GnomePrintUnit *mm_unit = gs_lgp->gnome_print_unit_get_by_abbreviation( (const guchar*) "mm" );
1765 const GnomePrintUnit *pts_unit = gs_lgp->gnome_print_unit_get_by_abbreviation( (const guchar*) "Pts" );
1766 gs_lgp->gnome_print_convert_distance( &pw, pts_unit, mm_unit );
1767 gs_lgp->gnome_print_convert_distance( &ph, pts_unit, mm_unit );
1768
1769 if (width)
1770 *width = (int) (pw + 0.5);
1771 if (height)
1772 *height = (int) (ph + 0.5);
1773 }
1774
1775 wxSize wxGnomePrintDC::GetPPI() const
1776 {
1777 return wxSize(72,72);
1778 }
1779
1780 void wxGnomePrintDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
1781 {
1782 m_signX = (xLeftRight ? 1 : -1);
1783 m_signY = (yBottomUp ? 1 : -1);
1784
1785 ComputeScaleAndOrigin();
1786 }
1787
1788 void wxGnomePrintDC::SetDeviceOrigin( wxCoord x, wxCoord y )
1789 {
1790 int h = 0;
1791 int w = 0;
1792 GetSize( &w, &h );
1793
1794 wxDC::SetDeviceOrigin( x, h-y );
1795 }
1796
1797 void wxGnomePrintDC::SetResolution(int ppi)
1798 {
1799 }
1800
1801 int wxGnomePrintDC::GetResolution()
1802 {
1803 return 72;
1804 }
1805
1806
1807 class wxGnomePrintModule: public wxModule
1808 {
1809 public:
1810 wxGnomePrintModule() {}
1811 bool OnInit();
1812 void OnExit();
1813
1814 private:
1815 DECLARE_DYNAMIC_CLASS(wxGnomePrintModule)
1816 };
1817
1818 bool wxGnomePrintModule::OnInit()
1819 {
1820 gs_lgp = new wxGnomePrintLibrary;
1821 if (gs_lgp->IsOk())
1822 wxPrintFactory::SetPrintFactory( new wxGnomePrintFactory );
1823 return true;
1824 }
1825
1826 void wxGnomePrintModule::OnExit()
1827 {
1828 delete gs_lgp;
1829 }
1830
1831 IMPLEMENT_DYNAMIC_CLASS(wxGnomePrintModule, wxModule)
1832
1833 #endif
1834 // wxUSE_LIBGNOMEPRINT