]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/gnome/gprint.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
removed spurious if in DoGradientFillLinear()
[wxWidgets.git] / src / gtk / gnome / gprint.cpp
... / ...
CommitLineData
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
38static const double RAD2DEG = 180.0 / M_PI;
39
40#include "wx/html/forcelnk.h"
41FORCE_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
57class wxGnomePrintLibrary
58{
59public:
60 wxGnomePrintLibrary();
61 ~wxGnomePrintLibrary();
62
63 bool IsOk();
64 void InitializeMethods();
65
66private:
67 bool m_ok;
68 wxDynamicLibrary *m_gnome_print_lib;
69 wxDynamicLibrary *m_gnome_printui_lib;
70
71public:
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
171wxGnomePrintLibrary::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
189wxGnomePrintLibrary::~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
197bool wxGnomePrintLibrary::IsOk()
198{
199 return m_ok;
200}
201
202void 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
264static wxGnomePrintLibrary* gs_lgp = NULL;
265
266//----------------------------------------------------------------------------
267// wxGnomePrintNativeData
268//----------------------------------------------------------------------------
269
270IMPLEMENT_CLASS(wxGnomePrintNativeData, wxPrintNativeDataBase)
271
272wxGnomePrintNativeData::wxGnomePrintNativeData()
273{
274 m_config = gs_lgp->gnome_print_config_default();
275 m_job = gs_lgp->gnome_print_job_new( m_config );
276}
277
278wxGnomePrintNativeData::~wxGnomePrintNativeData()
279{
280 g_object_unref (G_OBJECT (m_config));
281}
282
283bool wxGnomePrintNativeData::TransferTo( wxPrintData &data )
284{
285 // TODO
286 return true;
287}
288
289bool wxGnomePrintNativeData::TransferFrom( const wxPrintData &data )
290{
291 // TODO
292 return true;
293}
294
295//----------------------------------------------------------------------------
296// wxGnomePrintFactory
297//----------------------------------------------------------------------------
298
299wxPrinterBase* wxGnomePrintFactory::CreatePrinter( wxPrintDialogData *data )
300{
301 return new wxGnomePrinter( data );
302}
303
304wxPrintPreviewBase *wxGnomePrintFactory::CreatePrintPreview( wxPrintout *preview,
305 wxPrintout *printout,
306 wxPrintDialogData *data )
307{
308 return new wxPostScriptPrintPreview( preview, printout, data );
309}
310
311wxPrintPreviewBase *wxGnomePrintFactory::CreatePrintPreview( wxPrintout *preview,
312 wxPrintout *printout,
313 wxPrintData *data )
314{
315 return new wxPostScriptPrintPreview( preview, printout, data );
316}
317
318wxPrintDialogBase *wxGnomePrintFactory::CreatePrintDialog( wxWindow *parent,
319 wxPrintDialogData *data )
320{
321 return new wxGnomePrintDialog( parent, data );
322}
323
324wxPrintDialogBase *wxGnomePrintFactory::CreatePrintDialog( wxWindow *parent,
325 wxPrintData *data )
326{
327 return new wxGnomePrintDialog( parent, data );
328}
329
330wxPageSetupDialogBase *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
343bool wxGnomePrintFactory::HasPrintSetupDialog()
344{
345 return false;
346}
347
348wxDialog *wxGnomePrintFactory::CreatePrintSetupDialog( wxWindow *parent, wxPrintData *data )
349{
350 return NULL;
351}
352
353bool wxGnomePrintFactory::HasOwnPrintToFile()
354{
355 return true;
356}
357
358bool wxGnomePrintFactory::HasPrinterLine()
359{
360 return true;
361}
362
363wxString wxGnomePrintFactory::CreatePrinterLine()
364{
365 // redundant now
366 return wxEmptyString;
367}
368
369bool wxGnomePrintFactory::HasStatusLine()
370{
371 // redundant now
372 return true;
373}
374
375wxString wxGnomePrintFactory::CreateStatusLine()
376{
377 // redundant now
378 return wxEmptyString;
379}
380
381wxPrintNativeDataBase *wxGnomePrintFactory::CreatePrintNativeData()
382{
383 return new wxGnomePrintNativeData;
384}
385
386//----------------------------------------------------------------------------
387// wxGnomePrintSetupDialog
388//----------------------------------------------------------------------------
389
390IMPLEMENT_CLASS(wxGnomePrintDialog, wxPrintDialogBase)
391
392wxGnomePrintDialog::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
404wxGnomePrintDialog::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
416void 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
441wxGnomePrintDialog::~wxGnomePrintDialog()
442{
443 m_widget = NULL;
444}
445
446int 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
494wxDC *wxGnomePrintDialog::GetPrintDC()
495{
496 // Later
497 return NULL;
498}
499
500bool wxGnomePrintDialog::Validate()
501{
502 return true;
503}
504
505bool wxGnomePrintDialog::TransferDataToWindow()
506{
507 return true;
508}
509
510bool wxGnomePrintDialog::TransferDataFromWindow()
511{
512 return true;
513}
514
515//----------------------------------------------------------------------------
516// wxGnomePageSetupDialog
517//----------------------------------------------------------------------------
518
519IMPLEMENT_CLASS(wxGnomePageSetupDialog, wxPageSetupDialogBase)
520
521wxGnomePageSetupDialog::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
558wxGnomePageSetupDialog::~wxGnomePageSetupDialog()
559{
560}
561
562wxPageSetupDialogData& wxGnomePageSetupDialog::GetPageSetupDialogData()
563{
564 return m_pageDialogData;
565}
566
567int 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
635bool wxGnomePageSetupDialog::Validate()
636{
637 return true;
638}
639
640bool wxGnomePageSetupDialog::TransferDataToWindow()
641{
642 return true;
643}
644
645bool wxGnomePageSetupDialog::TransferDataFromWindow()
646{
647 return true;
648}
649
650//----------------------------------------------------------------------------
651// wxGnomePrinter
652//----------------------------------------------------------------------------
653
654IMPLEMENT_CLASS(wxGnomePrinter, wxPrinterBase)
655
656wxGnomePrinter::wxGnomePrinter( wxPrintDialogData *data ) :
657 wxPrinterBase( data )
658{
659 m_gpc = NULL;
660 m_native_preview = false;
661}
662
663wxGnomePrinter::~wxGnomePrinter()
664{
665}
666
667bool 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 GtkWidget *preview = gs_lgp->gnome_print_job_preview_new
784 (
785 job,
786 wxGTK_CONV_SYS(_("Print preview"))
787 );
788 gtk_widget_show(preview);
789 }
790 else
791 {
792 gs_lgp->gnome_print_job_print( job );
793 }
794
795 g_object_unref (G_OBJECT (job));
796 delete dc;
797
798 return (sm_lastError == wxPRINTER_NO_ERROR);
799}
800
801wxDC* wxGnomePrinter::PrintDialog( wxWindow *parent )
802{
803 wxGnomePrintDialog dialog( parent, &m_printDialogData );
804 int ret = dialog.ShowModal();
805 if (ret == wxID_CANCEL)
806 {
807 sm_lastError = wxPRINTER_CANCELLED;
808 return NULL;
809 }
810
811 m_native_preview = ret == wxID_PREVIEW;
812
813 m_printDialogData = dialog.GetPrintDialogData();
814 return new wxGnomePrintDC( this );
815}
816
817bool wxGnomePrinter::Setup( wxWindow *parent )
818{
819 return false;
820}
821
822//-----------------------------------------------------------------------------
823// wxGnomePrintDC
824//-----------------------------------------------------------------------------
825
826IMPLEMENT_CLASS(wxGnomePrintDC, wxDC)
827
828wxGnomePrintDC::wxGnomePrintDC( wxGnomePrinter *printer )
829{
830 m_printer = printer;
831
832 m_gpc = printer->GetPrintContext();
833
834 m_layout = gs_lgp->gnome_print_pango_create_layout( m_gpc );
835 m_fontdesc = pango_font_description_from_string( "Sans 12" );
836
837 m_currentRed = 0;
838 m_currentBlue = 0;
839 m_currentGreen = 0;
840
841 m_signX = 1; // default x-axis left to right
842 m_signY = -1; // default y-axis bottom up -> top down
843}
844
845wxGnomePrintDC::~wxGnomePrintDC()
846{
847}
848
849bool wxGnomePrintDC::Ok() const
850{
851 return true;
852}
853
854bool wxGnomePrintDC::DoFloodFill(wxCoord x1, wxCoord y1, const wxColour &col, int style )
855{
856 return false;
857}
858
859bool wxGnomePrintDC::DoGetPixel(wxCoord x1, wxCoord y1, wxColour *col) const
860{
861 return false;
862}
863
864void wxGnomePrintDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
865{
866 if (m_pen.GetStyle() == wxTRANSPARENT) return;
867
868 SetPen( m_pen );
869
870 gs_lgp->gnome_print_moveto ( m_gpc, XLOG2DEV(x1), YLOG2DEV(y1) );
871 gs_lgp->gnome_print_lineto ( m_gpc, XLOG2DEV(x2), YLOG2DEV(y2) );
872 gs_lgp->gnome_print_stroke ( m_gpc);
873
874 CalcBoundingBox( x1, y1 );
875 CalcBoundingBox( x2, y2 );
876}
877
878void wxGnomePrintDC::DoCrossHair(wxCoord x, wxCoord y)
879{
880}
881
882void wxGnomePrintDC::DoDrawArc(wxCoord x1,wxCoord y1,wxCoord x2,wxCoord y2,wxCoord xc,wxCoord yc)
883{
884 double dx = x1 - xc;
885 double dy = y1 - yc;
886 double radius = sqrt((double)(dx*dx+dy*dy));
887 double alpha1, alpha2;
888 if (x1 == x2 && y1 == y2)
889 {
890 alpha1 = 0.0;
891 alpha2 = 360.0;
892 }
893 else
894 if (radius == 0.0)
895 {
896 alpha1 = alpha2 = 0.0;
897 }
898 else
899 {
900 alpha1 = (x1 - xc == 0) ?
901 (y1 - yc < 0) ? 90.0 : -90.0 :
902 -atan2(double(y1-yc), double(x1-xc)) * RAD2DEG;
903 alpha2 = (x2 - xc == 0) ?
904 (y2 - yc < 0) ? 90.0 : -90.0 :
905 -atan2(double(y2-yc), double(x2-xc)) * RAD2DEG;
906
907 while (alpha1 <= 0) alpha1 += 360;
908 while (alpha2 <= 0) alpha2 += 360; // adjust angles to be between
909 while (alpha1 > 360) alpha1 -= 360; // 0 and 360 degree
910 while (alpha2 > 360) alpha2 -= 360;
911 }
912
913 if (m_brush.GetStyle() != wxTRANSPARENT)
914 {
915 SetBrush( m_brush );
916 gs_lgp->gnome_print_moveto ( m_gpc, XLOG2DEV(xc), YLOG2DEV(yc) );
917 gs_lgp->gnome_print_arcto( m_gpc, XLOG2DEV(xc), YLOG2DEV(yc), XLOG2DEVREL((int)radius), alpha1, alpha2, 0 );
918
919 gs_lgp->gnome_print_fill( m_gpc );
920 }
921
922 if (m_pen.GetStyle() != wxTRANSPARENT)
923 {
924 SetPen (m_pen);
925 gs_lgp->gnome_print_newpath( m_gpc );
926 gs_lgp->gnome_print_moveto ( m_gpc, XLOG2DEV(xc), YLOG2DEV(yc) );
927 gs_lgp->gnome_print_arcto( m_gpc, XLOG2DEV(xc), YLOG2DEV(yc), XLOG2DEVREL((int)radius), alpha1, alpha2, 0 );
928 gs_lgp->gnome_print_closepath( m_gpc );
929
930 gs_lgp->gnome_print_stroke( m_gpc );
931 }
932
933 CalcBoundingBox (x1, y1);
934 CalcBoundingBox (x2, y2);
935 CalcBoundingBox (xc, yc);
936}
937
938void wxGnomePrintDC::DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,double ea)
939{
940 x += w/2;
941 y += h/2;
942
943 int xx = XLOG2DEV(x);
944 int yy = YLOG2DEV(y);
945
946 gs_lgp->gnome_print_gsave( m_gpc );
947
948 gs_lgp->gnome_print_translate( m_gpc, xx, yy );
949 double scale = (double)YLOG2DEVREL(h) / (double) XLOG2DEVREL(w);
950 gs_lgp->gnome_print_scale( m_gpc, 1.0, scale );
951
952 xx = 0;
953 yy = 0;
954
955 if (m_brush.GetStyle () != wxTRANSPARENT)
956 {
957 SetBrush( m_brush );
958
959 gs_lgp->gnome_print_moveto ( m_gpc, xx, yy );
960 gs_lgp->gnome_print_arcto( m_gpc, xx, yy,
961 XLOG2DEVREL(w)/2, sa, ea, 0 );
962 gs_lgp->gnome_print_moveto ( m_gpc, xx, yy );
963
964 gs_lgp->gnome_print_fill( m_gpc );
965 }
966
967 if (m_pen.GetStyle () != wxTRANSPARENT)
968 {
969 SetPen (m_pen);
970
971 gs_lgp->gnome_print_arcto( m_gpc, xx, yy,
972 XLOG2DEVREL(w)/2, sa, ea, 0 );
973
974 gs_lgp->gnome_print_stroke( m_gpc );
975 }
976
977 gs_lgp->gnome_print_grestore( m_gpc );
978
979 CalcBoundingBox( x, y );
980 CalcBoundingBox( x+w, y+h );
981}
982
983void wxGnomePrintDC::DoDrawPoint(wxCoord x, wxCoord y)
984{
985}
986
987void wxGnomePrintDC::DoDrawLines(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset)
988{
989 if (m_pen.GetStyle() == wxTRANSPARENT) return;
990
991 if (n <= 0) return;
992
993 SetPen (m_pen);
994
995 int i;
996 for ( i =0; i<n ; i++ )
997 CalcBoundingBox( points[i].x+xoffset, points[i].y+yoffset);
998
999 gs_lgp->gnome_print_moveto ( m_gpc, XLOG2DEV(points[0].x+xoffset), YLOG2DEV(points[0].y+yoffset) );
1000
1001 for (i = 1; i < n; i++)
1002 gs_lgp->gnome_print_lineto ( m_gpc, XLOG2DEV(points[i].x+xoffset), YLOG2DEV(points[i].y+yoffset) );
1003
1004 gs_lgp->gnome_print_stroke ( m_gpc);
1005}
1006
1007void wxGnomePrintDC::DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset, int fillStyle)
1008{
1009 if (n==0) return;
1010
1011 if (m_brush.GetStyle () != wxTRANSPARENT)
1012 {
1013 SetBrush( m_brush );
1014
1015 int x = points[0].x + xoffset;
1016 int y = points[0].y + yoffset;
1017 CalcBoundingBox( x, y );
1018 gs_lgp->gnome_print_newpath( m_gpc );
1019 gs_lgp->gnome_print_moveto( m_gpc, XLOG2DEV(x), YLOG2DEV(y) );
1020 int i;
1021 for (i = 1; i < n; i++)
1022 {
1023 int x = points[i].x + xoffset;
1024 int y = points[i].y + yoffset;
1025 gs_lgp->gnome_print_lineto( m_gpc, XLOG2DEV(x), YLOG2DEV(y) );
1026 CalcBoundingBox( x, y );
1027 }
1028 gs_lgp->gnome_print_closepath( m_gpc );
1029 gs_lgp->gnome_print_fill( m_gpc );
1030 }
1031
1032 if (m_pen.GetStyle () != wxTRANSPARENT)
1033 {
1034 SetPen (m_pen);
1035
1036 int x = points[0].x + xoffset;
1037 int y = points[0].y + yoffset;
1038 gs_lgp->gnome_print_newpath( m_gpc );
1039 gs_lgp->gnome_print_moveto( m_gpc, XLOG2DEV(x), YLOG2DEV(y) );
1040 int i;
1041 for (i = 1; i < n; i++)
1042 {
1043 int x = points[i].x + xoffset;
1044 int y = points[i].y + yoffset;
1045 gs_lgp->gnome_print_lineto( m_gpc, XLOG2DEV(x), YLOG2DEV(y) );
1046 CalcBoundingBox( x, y );
1047 }
1048 gs_lgp->gnome_print_closepath( m_gpc );
1049 gs_lgp->gnome_print_stroke( m_gpc );
1050 }
1051}
1052
1053void wxGnomePrintDC::DoDrawPolyPolygon(int n, int count[], wxPoint points[], wxCoord xoffset, wxCoord yoffset, int fillStyle)
1054{
1055 wxDC::DoDrawPolyPolygon( n, count, points, xoffset, yoffset, fillStyle );
1056}
1057
1058void wxGnomePrintDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1059{
1060 if (m_brush.GetStyle () != wxTRANSPARENT)
1061 {
1062 SetBrush( m_brush );
1063
1064 gs_lgp->gnome_print_newpath( m_gpc );
1065 gs_lgp->gnome_print_moveto( m_gpc, XLOG2DEV(x), YLOG2DEV(y) );
1066 gs_lgp->gnome_print_lineto( m_gpc, XLOG2DEV(x + width), YLOG2DEV(y) );
1067 gs_lgp->gnome_print_lineto( m_gpc, XLOG2DEV(x + width), YLOG2DEV(y + height) );
1068 gs_lgp->gnome_print_lineto( m_gpc, XLOG2DEV(x), YLOG2DEV(y + height) );
1069 gs_lgp->gnome_print_closepath( m_gpc );
1070 gs_lgp->gnome_print_fill( m_gpc );
1071
1072 CalcBoundingBox( x, y );
1073 CalcBoundingBox( x + width, y + height );
1074 }
1075
1076 if (m_pen.GetStyle () != wxTRANSPARENT)
1077 {
1078 SetPen (m_pen);
1079
1080 gs_lgp->gnome_print_newpath( m_gpc );
1081 gs_lgp->gnome_print_moveto( m_gpc, XLOG2DEV(x), YLOG2DEV(y) );
1082 gs_lgp->gnome_print_lineto( m_gpc, XLOG2DEV(x + width), YLOG2DEV(y) );
1083 gs_lgp->gnome_print_lineto( m_gpc, XLOG2DEV(x + width), YLOG2DEV(y + height) );
1084 gs_lgp->gnome_print_lineto( m_gpc, XLOG2DEV(x), YLOG2DEV(y + height) );
1085 gs_lgp->gnome_print_closepath( m_gpc );
1086 gs_lgp->gnome_print_stroke( m_gpc );
1087
1088 CalcBoundingBox( x, y );
1089 CalcBoundingBox( x + width, y + height );
1090 }
1091}
1092
1093void wxGnomePrintDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius)
1094{
1095 wxCoord rad = (wxCoord) radius;
1096
1097 if (m_brush.GetStyle() != wxTRANSPARENT)
1098 {
1099 SetBrush(m_brush);
1100 gs_lgp->gnome_print_newpath(m_gpc);
1101 gs_lgp->gnome_print_moveto(m_gpc,XLOG2DEV(x + rad),YLOG2DEV(y));
1102 gs_lgp->gnome_print_curveto(m_gpc,
1103 XLOG2DEV(x + rad),YLOG2DEV(y),
1104 XLOG2DEV(x),YLOG2DEV(y),
1105 XLOG2DEV(x),YLOG2DEV(y + rad));
1106 gs_lgp->gnome_print_lineto(m_gpc,XLOG2DEV(x),YLOG2DEV(y + height - rad));
1107 gs_lgp->gnome_print_curveto(m_gpc,
1108 XLOG2DEV(x),YLOG2DEV(y + height - rad),
1109 XLOG2DEV(x),YLOG2DEV(y + height),
1110 XLOG2DEV(x + rad),YLOG2DEV(y + height));
1111 gs_lgp->gnome_print_lineto(m_gpc,XLOG2DEV(x + width - rad),YLOG2DEV(y + height));
1112 gs_lgp->gnome_print_curveto(m_gpc,
1113 XLOG2DEV(x + width - rad),YLOG2DEV(y + height),
1114 XLOG2DEV(x + width),YLOG2DEV(y + height),
1115 XLOG2DEV(x + width),YLOG2DEV(y + height - rad));
1116 gs_lgp->gnome_print_lineto(m_gpc,XLOG2DEV(x + width),YLOG2DEV(y + rad));
1117 gs_lgp->gnome_print_curveto(m_gpc,
1118 XLOG2DEV(x + width),YLOG2DEV(y + rad),
1119 XLOG2DEV(x + width),YLOG2DEV(y),
1120 XLOG2DEV(x + width - rad),YLOG2DEV(y));
1121 gs_lgp->gnome_print_lineto(m_gpc,XLOG2DEV(x + rad),YLOG2DEV(y));
1122 gs_lgp->gnome_print_closepath(m_gpc);
1123 gs_lgp->gnome_print_fill(m_gpc);
1124
1125 CalcBoundingBox(x,y);
1126 CalcBoundingBox(x+width,y+height);
1127 }
1128
1129 if (m_pen.GetStyle() != wxTRANSPARENT)
1130 {
1131 SetPen(m_pen);
1132 gs_lgp->gnome_print_newpath(m_gpc);
1133 gs_lgp->gnome_print_moveto(m_gpc,XLOG2DEV(x + rad),YLOG2DEV(y));
1134 gs_lgp->gnome_print_curveto(m_gpc,
1135 XLOG2DEV(x + rad),YLOG2DEV(y),
1136 XLOG2DEV(x),YLOG2DEV(y),
1137 XLOG2DEV(x),YLOG2DEV(y + rad));
1138 gs_lgp->gnome_print_lineto(m_gpc,XLOG2DEV(x),YLOG2DEV(y + height - rad));
1139 gs_lgp->gnome_print_curveto(m_gpc,
1140 XLOG2DEV(x),YLOG2DEV(y + height - rad),
1141 XLOG2DEV(x),YLOG2DEV(y + height),
1142 XLOG2DEV(x + rad),YLOG2DEV(y + height));
1143 gs_lgp->gnome_print_lineto(m_gpc,XLOG2DEV(x + width - rad),YLOG2DEV(y + height));
1144 gs_lgp->gnome_print_curveto(m_gpc,
1145 XLOG2DEV(x + width - rad),YLOG2DEV(y + height),
1146 XLOG2DEV(x + width),YLOG2DEV(y + height),
1147 XLOG2DEV(x + width),YLOG2DEV(y + height - rad));
1148 gs_lgp->gnome_print_lineto(m_gpc,XLOG2DEV(x + width),YLOG2DEV(y + rad));
1149 gs_lgp->gnome_print_curveto(m_gpc,
1150 XLOG2DEV(x + width),YLOG2DEV(y + rad),
1151 XLOG2DEV(x + width),YLOG2DEV(y),
1152 XLOG2DEV(x + width - rad),YLOG2DEV(y));
1153 gs_lgp->gnome_print_lineto(m_gpc,XLOG2DEV(x + rad),YLOG2DEV(y));
1154 gs_lgp->gnome_print_closepath(m_gpc);
1155 gs_lgp->gnome_print_stroke(m_gpc);
1156
1157 CalcBoundingBox(x,y);
1158 CalcBoundingBox(x+width,y+height);
1159 }
1160}
1161
1162void wxGnomePrintDC::makeEllipticalPath(wxCoord x, wxCoord y,
1163 wxCoord width, wxCoord height)
1164{
1165 double r = 4 * (sqrt (2) - 1) / 3;
1166 double halfW = 0.5 * width,
1167 halfH = 0.5 * height,
1168 halfWR = r * halfW,
1169 halfHR = r * halfH;
1170 wxCoord halfWI = (wxCoord) halfW,
1171 halfHI = (wxCoord) halfH;
1172
1173 gs_lgp->gnome_print_newpath( m_gpc );
1174
1175 // Approximate an ellipse using four cubic splines, clockwise from 0 deg */
1176 gs_lgp->gnome_print_moveto( m_gpc,
1177 XLOG2DEV(x + width),
1178 YLOG2DEV(y + halfHI) );
1179 gs_lgp->gnome_print_curveto( m_gpc,
1180 XLOG2DEV(x + width),
1181 YLOG2DEV(y + (wxCoord) rint (halfH + halfHR)),
1182 XLOG2DEV(x + (wxCoord) rint(halfW + halfWR)),
1183 YLOG2DEV(y + height),
1184 XLOG2DEV(x + halfWI),
1185 YLOG2DEV(y + height) );
1186 gs_lgp->gnome_print_curveto( m_gpc,
1187 XLOG2DEV(x + (wxCoord) rint(halfW - halfWR)),
1188 YLOG2DEV(y + height),
1189 XLOG2DEV(x),
1190 YLOG2DEV(y + (wxCoord) rint (halfH + halfHR)),
1191 XLOG2DEV(x), YLOG2DEV(y+halfHI) );
1192 gs_lgp->gnome_print_curveto( m_gpc,
1193 XLOG2DEV(x),
1194 YLOG2DEV(y + (wxCoord) rint (halfH - halfHR)),
1195 XLOG2DEV(x + (wxCoord) rint (halfW - halfWR)),
1196 YLOG2DEV(y),
1197 XLOG2DEV(x+halfWI), YLOG2DEV(y) );
1198 gs_lgp->gnome_print_curveto( m_gpc,
1199 XLOG2DEV(x + (wxCoord) rint(halfW + halfWR)),
1200 YLOG2DEV(y),
1201 XLOG2DEV(x + width),
1202 YLOG2DEV(y + (wxCoord) rint(halfH - halfHR)),
1203 XLOG2DEV(x + width), YLOG2DEV(y + halfHI) );
1204
1205 gs_lgp->gnome_print_closepath(m_gpc);
1206}
1207
1208void wxGnomePrintDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1209{
1210 if (m_brush.GetStyle () != wxTRANSPARENT)
1211 {
1212 SetBrush( m_brush );
1213 makeEllipticalPath( x, y, width, height );
1214 gs_lgp->gnome_print_fill( m_gpc );
1215 CalcBoundingBox( x, y );
1216 CalcBoundingBox( x + width, y + height );
1217 }
1218
1219 if (m_pen.GetStyle () != wxTRANSPARENT)
1220 {
1221 SetPen (m_pen);
1222 makeEllipticalPath( x, y, width, height );
1223 gs_lgp->gnome_print_stroke( m_gpc );
1224 CalcBoundingBox( x, y );
1225 CalcBoundingBox( x + width, y + height );
1226 }
1227}
1228
1229#if wxUSE_SPLINES
1230void wxGnomePrintDC::DoDrawSpline(wxList *points)
1231{
1232 SetPen (m_pen);
1233
1234 double c, d, x1, y1, x2, y2, x3, y3;
1235 wxPoint *p, *q;
1236
1237 wxList::compatibility_iterator node = points->GetFirst();
1238 p = (wxPoint *)node->GetData();
1239 x1 = p->x;
1240 y1 = p->y;
1241
1242 node = node->GetNext();
1243 p = (wxPoint *)node->GetData();
1244 c = p->x;
1245 d = p->y;
1246 x3 =
1247 (double)(x1 + c) / 2;
1248 y3 =
1249 (double)(y1 + d) / 2;
1250
1251 gs_lgp->gnome_print_newpath( m_gpc );
1252 gs_lgp->gnome_print_moveto( m_gpc, XLOG2DEV((wxCoord)x1), YLOG2DEV((wxCoord)y1) );
1253 gs_lgp->gnome_print_lineto( m_gpc, XLOG2DEV((wxCoord)x3), YLOG2DEV((wxCoord)y3) );
1254
1255 CalcBoundingBox( (wxCoord)x1, (wxCoord)y1 );
1256 CalcBoundingBox( (wxCoord)x3, (wxCoord)y3 );
1257
1258 node = node->GetNext();
1259 while (node)
1260 {
1261 q = (wxPoint *)node->GetData();
1262
1263 x1 = x3;
1264 y1 = y3;
1265 x2 = c;
1266 y2 = d;
1267 c = q->x;
1268 d = q->y;
1269 x3 = (double)(x2 + c) / 2;
1270 y3 = (double)(y2 + d) / 2;
1271
1272 gs_lgp->gnome_print_curveto(m_gpc,
1273 XLOG2DEV((wxCoord)x1), YLOG2DEV((wxCoord)y1),
1274 XLOG2DEV((wxCoord)x2), YLOG2DEV((wxCoord)y2),
1275 XLOG2DEV((wxCoord)x3), YLOG2DEV((wxCoord)y3) );
1276
1277 CalcBoundingBox( (wxCoord)x1, (wxCoord)y1 );
1278 CalcBoundingBox( (wxCoord)x3, (wxCoord)y3 );
1279
1280 node = node->GetNext();
1281 }
1282
1283 gs_lgp->gnome_print_lineto ( m_gpc, XLOG2DEV((wxCoord)c), YLOG2DEV((wxCoord)d) );
1284
1285 gs_lgp->gnome_print_stroke( m_gpc );
1286}
1287#endif // wxUSE_SPLINES
1288
1289bool wxGnomePrintDC::DoBlit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
1290 wxDC *source, wxCoord xsrc, wxCoord ysrc, int rop, bool useMask,
1291 wxCoord xsrcMask, wxCoord ysrcMask)
1292{
1293 wxCHECK_MSG( source, false, wxT("invalid source dc") );
1294
1295 // blit into a bitmap
1296 wxBitmap bitmap( width, height );
1297 wxMemoryDC memDC;
1298 memDC.SelectObject(bitmap);
1299 memDC.Blit(0, 0, width, height, source, xsrc, ysrc, rop); /* TODO: Blit transparently? */
1300 memDC.SelectObject(wxNullBitmap);
1301
1302 // draw bitmap. scaling and positioning is done there
1303 DrawBitmap( bitmap, xdest, ydest );
1304
1305 return true;
1306}
1307
1308void wxGnomePrintDC::DoDrawIcon( const wxIcon& icon, wxCoord x, wxCoord y )
1309{
1310 DoDrawBitmap( icon, x, y, true );
1311}
1312
1313void wxGnomePrintDC::DoDrawBitmap( const wxBitmap& bitmap, wxCoord x, wxCoord y, bool useMask )
1314{
1315 if (!bitmap.Ok()) return;
1316
1317 if (bitmap.HasPixbuf())
1318 {
1319 GdkPixbuf *pixbuf = bitmap.GetPixbuf();
1320 guchar *raw_image = gdk_pixbuf_get_pixels( pixbuf );
1321 bool has_alpha = gdk_pixbuf_get_has_alpha( pixbuf );
1322 int rowstride = gdk_pixbuf_get_rowstride( pixbuf );
1323 int height = gdk_pixbuf_get_height( pixbuf );
1324 int width = gdk_pixbuf_get_width( pixbuf );
1325
1326 gs_lgp->gnome_print_gsave( m_gpc );
1327 double matrix[6];
1328 matrix[0] = XLOG2DEVREL(width);
1329 matrix[1] = 0;
1330 matrix[2] = 0;
1331 matrix[3] = YLOG2DEVREL(height);
1332 matrix[4] = XLOG2DEV(x);
1333 matrix[5] = YLOG2DEV(y+height);
1334 gs_lgp->gnome_print_concat( m_gpc, matrix );
1335 gs_lgp->gnome_print_moveto( m_gpc, 0, 0 );
1336 if (has_alpha)
1337 gs_lgp->gnome_print_rgbaimage( m_gpc, (guchar *)raw_image, width, height, rowstride );
1338 else
1339 gs_lgp->gnome_print_rgbimage( m_gpc, (guchar *)raw_image, width, height, rowstride );
1340 gs_lgp->gnome_print_grestore( m_gpc );
1341 }
1342 else
1343 {
1344 wxImage image = bitmap.ConvertToImage();
1345
1346 if (!image.Ok()) return;
1347
1348 gs_lgp->gnome_print_gsave( m_gpc );
1349 double matrix[6];
1350 matrix[0] = XLOG2DEVREL(image.GetWidth());
1351 matrix[1] = 0;
1352 matrix[2] = 0;
1353 matrix[3] = YLOG2DEVREL(image.GetHeight());
1354 matrix[4] = XLOG2DEV(x);
1355 matrix[5] = YLOG2DEV(y+image.GetHeight());
1356 gs_lgp->gnome_print_concat( m_gpc, matrix );
1357 gs_lgp->gnome_print_moveto( m_gpc, 0, 0 );
1358 gs_lgp->gnome_print_rgbimage( m_gpc, (guchar*) image.GetData(), image.GetWidth(), image.GetHeight(), image.GetWidth()*3 );
1359 gs_lgp->gnome_print_grestore( m_gpc );
1360 }
1361}
1362
1363void wxGnomePrintDC::DoDrawText(const wxString& text, wxCoord x, wxCoord y )
1364{
1365 DoDrawRotatedText( text, x, y, 0.0 );
1366}
1367
1368void wxGnomePrintDC::DoDrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle)
1369{
1370 x = XLOG2DEV(x);
1371 y = YLOG2DEV(y);
1372
1373 bool underlined = m_font.Ok() && m_font.GetUnderlined();
1374
1375#if wxUSE_UNICODE
1376 const wxCharBuffer data = wxConvUTF8.cWC2MB( text );
1377#else
1378 const wxWCharBuffer wdata = wxConvLocal.cMB2WC( text );
1379 if ( !wdata )
1380 return;
1381 const wxCharBuffer data = wxConvUTF8.cWC2MB( wdata );
1382#endif
1383
1384 size_t datalen = strlen((const char*)data);
1385 pango_layout_set_text( m_layout, (const char*) data, datalen);
1386
1387 if (underlined)
1388 {
1389 PangoAttrList *attrs = pango_attr_list_new();
1390 PangoAttribute *a = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
1391 a->start_index = 0;
1392 a->end_index = datalen;
1393 pango_attr_list_insert(attrs, a);
1394 pango_layout_set_attributes(m_layout, attrs);
1395 pango_attr_list_unref(attrs);
1396 }
1397
1398 if (m_textForegroundColour.Ok())
1399 {
1400 unsigned char red = m_textForegroundColour.Red();
1401 unsigned char blue = m_textForegroundColour.Blue();
1402 unsigned char green = m_textForegroundColour.Green();
1403
1404 if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
1405 {
1406 double redPS = (double)(red) / 255.0;
1407 double bluePS = (double)(blue) / 255.0;
1408 double greenPS = (double)(green) / 255.0;
1409
1410 gs_lgp->gnome_print_setrgbcolor( m_gpc, redPS, greenPS, bluePS );
1411
1412 m_currentRed = red;
1413 m_currentBlue = blue;
1414 m_currentGreen = green;
1415 }
1416 }
1417
1418 int w,h;
1419
1420 if (fabs(m_scaleY - 1.0) > 0.00001)
1421 {
1422 // If there is a user or actually any scale applied to
1423 // the device context, scale the font.
1424
1425 // scale font description
1426 gint oldSize = pango_font_description_get_size( m_fontdesc );
1427 double size = oldSize;
1428 size = size * m_scaleY;
1429 pango_font_description_set_size( m_fontdesc, (gint)size );
1430
1431 // actually apply scaled font
1432 pango_layout_set_font_description( m_layout, m_fontdesc );
1433
1434 pango_layout_get_pixel_size( m_layout, &w, &h );
1435#if 0
1436 if ( m_backgroundMode == wxSOLID )
1437 {
1438 gdk_gc_set_foreground(m_textGC, m_textBackgroundColour.GetColor());
1439 gdk_draw_rectangle(m_window, m_textGC, TRUE, x, y, w, h);
1440 gdk_gc_set_foreground(m_textGC, m_textForegroundColour.GetColor());
1441 }
1442#endif
1443 // Draw layout.
1444 gs_lgp->gnome_print_moveto (m_gpc, x, y);
1445 if (fabs(angle) > 0.00001)
1446 {
1447 gs_lgp->gnome_print_gsave( m_gpc );
1448 gs_lgp->gnome_print_rotate( m_gpc, angle );
1449 gs_lgp->gnome_print_pango_layout( m_gpc, m_layout );
1450 gs_lgp->gnome_print_grestore( m_gpc );
1451 }
1452 else
1453 {
1454 gs_lgp->gnome_print_pango_layout( m_gpc, m_layout );
1455 }
1456
1457 // reset unscaled size
1458 pango_font_description_set_size( m_fontdesc, oldSize );
1459
1460 // actually apply unscaled font
1461 pango_layout_set_font_description( m_layout, m_fontdesc );
1462 }
1463 else
1464 {
1465 pango_layout_get_pixel_size( m_layout, &w, &h );
1466#if 0
1467 if ( m_backgroundMode == wxSOLID )
1468 {
1469 gdk_gc_set_foreground(m_textGC, m_textBackgroundColour.GetColor());
1470 gdk_draw_rectangle(m_window, m_textGC, TRUE, x, y, w, h);
1471 gdk_gc_set_foreground(m_textGC, m_textForegroundColour.GetColor());
1472 }
1473#endif
1474 // Draw layout.
1475 gs_lgp->gnome_print_moveto (m_gpc, x, y);
1476 if (fabs(angle) > 0.00001)
1477 {
1478 gs_lgp->gnome_print_gsave( m_gpc );
1479 gs_lgp->gnome_print_rotate( m_gpc, angle );
1480 gs_lgp->gnome_print_pango_layout( m_gpc, m_layout );
1481 gs_lgp->gnome_print_grestore( m_gpc );
1482 }
1483 else
1484 {
1485 gs_lgp->gnome_print_pango_layout( m_gpc, m_layout );
1486 }
1487 }
1488
1489 if (underlined)
1490 {
1491 // undo underline attributes setting:
1492 pango_layout_set_attributes(m_layout, NULL);
1493 }
1494
1495 CalcBoundingBox (x + w, y + h);
1496}
1497
1498void wxGnomePrintDC::Clear()
1499{
1500}
1501
1502void wxGnomePrintDC::SetFont( const wxFont& font )
1503{
1504 m_font = font;
1505
1506 if (m_font.Ok())
1507 {
1508 if (m_fontdesc)
1509 pango_font_description_free( m_fontdesc );
1510
1511 m_fontdesc = pango_font_description_copy( m_font.GetNativeFontInfo()->description );
1512
1513 pango_layout_set_font_description( m_layout, m_fontdesc );
1514 }
1515}
1516
1517void wxGnomePrintDC::SetPen( const wxPen& pen )
1518{
1519 if (!pen.Ok()) return;
1520
1521 m_pen = pen;
1522
1523 gs_lgp->gnome_print_setlinewidth( m_gpc, XLOG2DEVREL( 1000 * m_pen.GetWidth() ) / 1000.0f );
1524
1525 static const double dotted[] = {2.0, 5.0};
1526 static const double short_dashed[] = {4.0, 4.0};
1527 static const double wxCoord_dashed[] = {4.0, 8.0};
1528 static const double dotted_dashed[] = {6.0, 6.0, 2.0, 6.0};
1529
1530 switch (m_pen.GetStyle())
1531 {
1532 case wxDOT: gs_lgp->gnome_print_setdash( m_gpc, 2, dotted, 0 ); break;
1533 case wxSHORT_DASH: gs_lgp->gnome_print_setdash( m_gpc, 2, short_dashed, 0 ); break;
1534 case wxLONG_DASH: gs_lgp->gnome_print_setdash( m_gpc, 2, wxCoord_dashed, 0 ); break;
1535 case wxDOT_DASH: gs_lgp->gnome_print_setdash( m_gpc, 4, dotted_dashed, 0 ); break;
1536 case wxUSER_DASH:
1537 {
1538 // It may be noted that libgnomeprint between at least
1539 // versions 2.8.0 and 2.12.1 makes a copy of the dashes
1540 // and then leak the memory since it doesn't set the
1541 // internal flag "privatedash" to 0.
1542 wxDash *wx_dashes;
1543 int num = m_pen.GetDashes (&wx_dashes);
1544 gdouble *g_dashes = g_new( gdouble, num );
1545 int i;
1546 for (i = 0; i < num; ++i)
1547 g_dashes[i] = (gdouble) wx_dashes[i];
1548 gs_lgp -> gnome_print_setdash( m_gpc, num, g_dashes, 0);
1549 g_free( g_dashes );
1550 }
1551 break;
1552 case wxSOLID:
1553 case wxTRANSPARENT:
1554 default: gs_lgp->gnome_print_setdash( m_gpc, 0, NULL, 0 ); break;
1555 }
1556
1557
1558 unsigned char red = m_pen.GetColour().Red();
1559 unsigned char blue = m_pen.GetColour().Blue();
1560 unsigned char green = m_pen.GetColour().Green();
1561
1562 if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
1563 {
1564 double redPS = (double)(red) / 255.0;
1565 double bluePS = (double)(blue) / 255.0;
1566 double greenPS = (double)(green) / 255.0;
1567
1568 gs_lgp->gnome_print_setrgbcolor( m_gpc, redPS, greenPS, bluePS );
1569
1570 m_currentRed = red;
1571 m_currentBlue = blue;
1572 m_currentGreen = green;
1573 }
1574}
1575
1576void wxGnomePrintDC::SetBrush( const wxBrush& brush )
1577{
1578 if (!brush.Ok()) return;
1579
1580 m_brush = brush;
1581
1582 // Brush colour
1583 unsigned char red = m_brush.GetColour().Red();
1584 unsigned char blue = m_brush.GetColour().Blue();
1585 unsigned char green = m_brush.GetColour().Green();
1586
1587 if (!m_colour)
1588 {
1589 // Anything not white is black
1590 if (! (red == (unsigned char) 255 &&
1591 blue == (unsigned char) 255 &&
1592 green == (unsigned char) 255) )
1593 {
1594 red = (unsigned char) 0;
1595 green = (unsigned char) 0;
1596 blue = (unsigned char) 0;
1597 }
1598 // setgray here ?
1599 }
1600
1601 if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
1602 {
1603 double redPS = (double)(red) / 255.0;
1604 double bluePS = (double)(blue) / 255.0;
1605 double greenPS = (double)(green) / 255.0;
1606
1607 gs_lgp->gnome_print_setrgbcolor( m_gpc, redPS, greenPS, bluePS );
1608
1609 m_currentRed = red;
1610 m_currentBlue = blue;
1611 m_currentGreen = green;
1612 }
1613}
1614
1615void wxGnomePrintDC::SetLogicalFunction( int function )
1616{
1617}
1618
1619void wxGnomePrintDC::SetBackground( const wxBrush& brush )
1620{
1621}
1622
1623void wxGnomePrintDC::DoSetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1624{
1625}
1626
1627void wxGnomePrintDC::DestroyClippingRegion()
1628{
1629}
1630
1631bool wxGnomePrintDC::StartDoc(const wxString& message)
1632{
1633 SetDeviceOrigin( 0,0 );
1634
1635 return true;
1636}
1637
1638void wxGnomePrintDC::EndDoc()
1639{
1640 gs_lgp->gnome_print_end_doc( m_gpc );
1641}
1642
1643void wxGnomePrintDC::StartPage()
1644{
1645 gs_lgp->gnome_print_beginpage( m_gpc, (const guchar*) "page" );
1646}
1647
1648void wxGnomePrintDC::EndPage()
1649{
1650 gs_lgp->gnome_print_showpage( m_gpc );
1651}
1652
1653wxCoord wxGnomePrintDC::GetCharHeight() const
1654{
1655 pango_layout_set_text( m_layout, "H", 1 );
1656
1657 int w,h;
1658 pango_layout_get_pixel_size( m_layout, &w, &h );
1659
1660 return h;
1661}
1662
1663wxCoord wxGnomePrintDC::GetCharWidth() const
1664{
1665 pango_layout_set_text( m_layout, "H", 1 );
1666
1667 int w,h;
1668 pango_layout_get_pixel_size( m_layout, &w, &h );
1669
1670 return w;
1671}
1672
1673void wxGnomePrintDC::DoGetTextExtent(const wxString& string, wxCoord *width, wxCoord *height,
1674 wxCoord *descent,
1675 wxCoord *externalLeading,
1676 wxFont *theFont ) const
1677{
1678 if ( width )
1679 *width = 0;
1680 if ( height )
1681 *height = 0;
1682 if ( descent )
1683 *descent = 0;
1684 if ( externalLeading )
1685 *externalLeading = 0;
1686
1687 if (string.empty())
1688 {
1689 return;
1690 }
1691
1692 // Set new font description
1693 if (theFont)
1694 pango_layout_set_font_description( m_layout, theFont->GetNativeFontInfo()->description );
1695
1696 // Set layout's text
1697#if wxUSE_UNICODE
1698 const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
1699 const char *dataUTF8 = (const char *)data;
1700#else
1701 const wxWCharBuffer wdata = wxConvLocal.cMB2WC( string );
1702 if ( !wdata )
1703 {
1704 if (width) (*width) = 0;
1705 if (height) (*height) = 0;
1706 return;
1707 }
1708 const wxCharBuffer data = wxConvUTF8.cWC2MB( wdata );
1709 const char *dataUTF8 = (const char *)data;
1710#endif
1711
1712 if ( !dataUTF8 )
1713 {
1714 // hardly ideal, but what else can we do if conversion failed?
1715 return;
1716 }
1717
1718 pango_layout_set_text( m_layout, dataUTF8, strlen(dataUTF8) );
1719
1720 int w,h;
1721 pango_layout_get_pixel_size( m_layout, &w, &h );
1722
1723 if (width)
1724 *width = (wxCoord)(w / m_scaleX);
1725 if (height)
1726 *height = (wxCoord)(h / m_scaleY);
1727 if (descent)
1728 {
1729 PangoLayoutIter *iter = pango_layout_get_iter(m_layout);
1730 int baseline = pango_layout_iter_get_baseline(iter);
1731 pango_layout_iter_free(iter);
1732 *descent = h - PANGO_PIXELS(baseline);
1733 }
1734
1735 // Reset old font description
1736 if (theFont)
1737 pango_layout_set_font_description( m_layout, m_fontdesc );
1738}
1739
1740void wxGnomePrintDC::DoGetSize(int* width, int* height) const
1741{
1742 wxGnomePrintNativeData *native =
1743 (wxGnomePrintNativeData*) m_printData.GetNativeData();
1744
1745 // Query page size. This seems to omit the margins
1746 // right now, although it shouldn't
1747 double pw,ph;
1748 gs_lgp->gnome_print_job_get_page_size( native->GetPrintJob(), &pw, &ph );
1749
1750 if (width)
1751 *width = (int) (pw + 0.5);
1752 if (height)
1753 *height = (int) (ph + 0.5);
1754}
1755
1756void wxGnomePrintDC::DoGetSizeMM(int *width, int *height) const
1757{
1758 wxGnomePrintNativeData *native =
1759 (wxGnomePrintNativeData*) m_printData.GetNativeData();
1760
1761 // This code assumes values in Pts.
1762
1763 double pw,ph;
1764 gs_lgp->gnome_print_job_get_page_size( native->GetPrintJob(), &pw, &ph );
1765
1766 // Convert to mm.
1767
1768 const GnomePrintUnit *mm_unit = gs_lgp->gnome_print_unit_get_by_abbreviation( (const guchar*) "mm" );
1769 const GnomePrintUnit *pts_unit = gs_lgp->gnome_print_unit_get_by_abbreviation( (const guchar*) "Pts" );
1770 gs_lgp->gnome_print_convert_distance( &pw, pts_unit, mm_unit );
1771 gs_lgp->gnome_print_convert_distance( &ph, pts_unit, mm_unit );
1772
1773 if (width)
1774 *width = (int) (pw + 0.5);
1775 if (height)
1776 *height = (int) (ph + 0.5);
1777}
1778
1779wxSize wxGnomePrintDC::GetPPI() const
1780{
1781 return wxSize(72,72);
1782}
1783
1784void wxGnomePrintDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
1785{
1786 m_signX = (xLeftRight ? 1 : -1);
1787 m_signY = (yBottomUp ? 1 : -1);
1788
1789 ComputeScaleAndOrigin();
1790}
1791
1792void wxGnomePrintDC::SetDeviceOrigin( wxCoord x, wxCoord y )
1793{
1794 int h = 0;
1795 int w = 0;
1796 GetSize( &w, &h );
1797
1798 wxDC::SetDeviceOrigin( x, h-y );
1799}
1800
1801void wxGnomePrintDC::SetResolution(int ppi)
1802{
1803}
1804
1805int wxGnomePrintDC::GetResolution()
1806{
1807 return 72;
1808}
1809
1810
1811class wxGnomePrintModule: public wxModule
1812{
1813public:
1814 wxGnomePrintModule() {}
1815 bool OnInit();
1816 void OnExit();
1817
1818private:
1819 DECLARE_DYNAMIC_CLASS(wxGnomePrintModule)
1820};
1821
1822bool wxGnomePrintModule::OnInit()
1823{
1824 gs_lgp = new wxGnomePrintLibrary;
1825 if (gs_lgp->IsOk())
1826 wxPrintFactory::SetPrintFactory( new wxGnomePrintFactory );
1827 return true;
1828}
1829
1830void wxGnomePrintModule::OnExit()
1831{
1832 delete gs_lgp;
1833}
1834
1835IMPLEMENT_DYNAMIC_CLASS(wxGnomePrintModule, wxModule)
1836
1837#endif
1838 // wxUSE_LIBGNOMEPRINT
wxWidgets (Impactor)