]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/gnome/gprint.cpp
projects / wxWidgets.git / blob
? search:


338ecd3a17cf477dcbd76ff14ee3451b9c007864
[wxWidgets.git] / src / gtk / gnome / gprint.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: gprint.cpp
3 // Author: Robert Roebling
4 // Purpose: Implement GNOME printing support
5 // Created: 09/20/04
6 // Copyright: Robert Roebling
7 // Licence: wxWindows Licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
11 #pragma implementation "gprint.h"
12 #endif
13
14 // For compilers that support precompilation, includes "wx/wx.h".
15 #include "wx/wxprec.h"
16
17 #ifdef __BORLANDC__
18 #pragma hdrstop
19 #endif
20
21 #include "wx/gtk/gnome/gprint.h"
22
23 #if wxUSE_LIBGNOMEPRINT
24
25 #include "math.h"
26
27 #include "wx/fontutil.h"
28 #include "wx/printdlg.h"
29 #include "wx/gtk/private.h"
30 #include "wx/module.h"
31 #include "wx/generic/prntdlgg.h"
32
33 #include <libgnomeprint/gnome-print.h>
34 #include <libgnomeprint/gnome-print-pango.h>
35 #include <libgnomeprint/gnome-print-config.h>
36 #include <libgnomeprintui/gnome-print-dialog.h>
37 #include <libgnomeprintui/gnome-print-job-preview.h>
38 #include <libgnomeprintui/gnome-print-paper-selector.h>
39
40 //----------------------------------------------------------------------------
41 // wxGnomePrintNativeData
42 //----------------------------------------------------------------------------
43
44 IMPLEMENT_CLASS(wxGnomePrintNativeData, wxPrintNativeDataBase)
45
46 wxGnomePrintNativeData::wxGnomePrintNativeData()
47 {
48 m_config = gnome_print_config_default();
49 m_job = gnome_print_job_new( m_config );
50 }
51
52 wxGnomePrintNativeData::~wxGnomePrintNativeData()
53 {
54 g_object_unref (G_OBJECT (m_config));
55 g_object_unref (G_OBJECT (m_job));
56 }
57
58 bool wxGnomePrintNativeData::TransferTo( wxPrintData &data )
59 {
60 // TODO
61 return true;
62 }
63
64 bool wxGnomePrintNativeData::TransferFrom( const wxPrintData &data )
65 {
66 // TODO
67 return true;
68 }
69
70 //----------------------------------------------------------------------------
71 // wxGnomePrintFactory
72 //----------------------------------------------------------------------------
73
74 wxPrinterBase* wxGnomePrintFactory::CreatePrinter( wxPrintDialogData *data )
75 {
76 return new wxGnomePrinter( data );
77 }
78
79 wxPrintPreviewBase *wxGnomePrintFactory::CreatePrintPreview( wxPrintout *preview,
80 wxPrintout *printout,
81 wxPrintDialogData *data )
82 {
83 return new wxPostScriptPrintPreview( preview, printout, data );
84 }
85
86 wxPrintPreviewBase *wxGnomePrintFactory::CreatePrintPreview( wxPrintout *preview,
87 wxPrintout *printout,
88 wxPrintData *data )
89 {
90 return new wxPostScriptPrintPreview( preview, printout, data );
91 }
92
93 wxPrintDialogBase *wxGnomePrintFactory::CreatePrintDialog( wxWindow *parent,
94 wxPrintDialogData *data )
95 {
96 return new wxGnomePrintDialog( parent, data );
97 }
98
99 wxPrintDialogBase *wxGnomePrintFactory::CreatePrintDialog( wxWindow *parent,
100 wxPrintData *data )
101 {
102 return new wxGnomePrintDialog( parent, data );
103 }
104
105 wxPageSetupDialogBase *wxGnomePrintFactory::CreatePageSetupDialog( wxWindow *parent,
106 wxPageSetupDialogData * data )
107 {
108 // The native page setup dialog is broken. It
109 // miscalculates newly entered values for the
110 // margins if you have not chose "points" but
111 // e.g. centimerters
112 //
113 // return new wxGnomePageSetupDialog( parent, data );
114
115 return new wxGenericPageSetupDialog( parent, data );
116 }
117
118 bool wxGnomePrintFactory::HasPrintSetupDialog()
119 {
120 return false;
121 }
122
123 wxDialog *wxGnomePrintFactory::CreatePrintSetupDialog( wxWindow *parent, wxPrintData *data )
124 {
125 return NULL;
126 }
127
128 bool wxGnomePrintFactory::HasOwnPrintToFile()
129 {
130 return true;
131 }
132
133 bool wxGnomePrintFactory::HasPrinterLine()
134 {
135 return true;
136 }
137
138 wxString wxGnomePrintFactory::CreatePrinterLine()
139 {
140 // redundant now
141 return wxEmptyString;
142 }
143
144 bool wxGnomePrintFactory::HasStatusLine()
145 {
146 // redundant now
147 return true;
148 }
149
150 wxString wxGnomePrintFactory::CreateStatusLine()
151 {
152 // redundant now
153 return wxEmptyString;
154 }
155
156 wxPrintNativeDataBase *wxGnomePrintFactory::CreatePrintNativeData()
157 {
158 return new wxGnomePrintNativeData;
159 }
160
161 //----------------------------------------------------------------------------
162 // wxGnomePrintSetupDialog
163 //----------------------------------------------------------------------------
164
165 IMPLEMENT_CLASS(wxGnomePrintDialog, wxPrintDialogBase)
166
167 wxGnomePrintDialog::wxGnomePrintDialog( wxWindow *parent, wxPrintDialogData *data )
168 : wxPrintDialogBase(parent, wxID_ANY, _("Print"),
169 wxPoint(0, 0), wxSize(600, 600),
170 wxDEFAULT_DIALOG_STYLE |
171 wxTAB_TRAVERSAL)
172 {
173 if (data)
174 m_printDialogData = *data;
175
176 Init();
177 }
178
179 wxGnomePrintDialog::wxGnomePrintDialog( wxWindow *parent, wxPrintData *data )
180 : wxPrintDialogBase(parent, wxID_ANY, _("Print"),
181 wxPoint(0, 0), wxSize(600, 600),
182 wxDEFAULT_DIALOG_STYLE |
183 wxTAB_TRAVERSAL)
184 {
185 if (data)
186 m_printDialogData = *data;
187
188 Init();
189 }
190
191 void wxGnomePrintDialog::Init()
192 {
193 wxPrintData data = m_printDialogData.GetPrintData();
194
195 wxGnomePrintNativeData *native =
196 (wxGnomePrintNativeData*) data.GetNativeData();
197
198 m_widget = gnome_print_dialog_new( native->GetPrintJob(),
199 (guchar*)"Print",
200 GNOME_PRINT_DIALOG_RANGE|GNOME_PRINT_DIALOG_COPIES );
201
202 int flag = 0;
203 if (m_printDialogData.GetEnableSelection())
204 flag |= GNOME_PRINT_RANGE_SELECTION;
205 if (m_printDialogData.GetEnablePageNumbers())
206 flag |= GNOME_PRINT_RANGE_ALL|GNOME_PRINT_RANGE_RANGE;
207
208 gnome_print_dialog_construct_range_page( GNOME_PRINT_DIALOG( m_widget ),
209 flag,
210 m_printDialogData.GetMinPage(),
211 m_printDialogData.GetMaxPage(),
212 NULL,
213 NULL );
214 }
215
216 wxGnomePrintDialog::~wxGnomePrintDialog()
217 {
218 m_widget = NULL;
219 }
220
221 int wxGnomePrintDialog::ShowModal()
222 {
223 // Transfer data from m_printDalogData to dialog here
224
225 int response = gtk_dialog_run (GTK_DIALOG (m_widget));
226
227 if (response == GNOME_PRINT_DIALOG_RESPONSE_CANCEL)
228 {
229 gtk_widget_destroy(m_widget);
230 m_widget = NULL;
231
232 return wxID_CANCEL;
233 }
234
235 gint copies = 1;
236 gboolean collate = false;
237 gnome_print_dialog_get_copies( GNOME_PRINT_DIALOG(m_widget), &copies, &collate );
238 m_printDialogData.SetNoCopies( copies );
239 m_printDialogData.SetCollate( collate );
240
241 switch (gnome_print_dialog_get_range( GNOME_PRINT_DIALOG(m_widget) ))
242 {
243 case GNOME_PRINT_RANGE_SELECTION:
244 m_printDialogData.SetSelection( true );
245 break;
246 case GNOME_PRINT_RANGE_ALL:
247 m_printDialogData.SetAllPages( true );
248 m_printDialogData.SetFromPage( 0 );
249 m_printDialogData.SetToPage( 9999 );
250 break;
251 case GNOME_PRINT_RANGE_RANGE:
252 default:
253 gint start,end;
254 gnome_print_dialog_get_range_page( GNOME_PRINT_DIALOG(m_widget), &start, &end );
255 m_printDialogData.SetFromPage( start );
256 m_printDialogData.SetToPage( end );
257 break;
258 }
259
260 gtk_widget_destroy(m_widget);
261 m_widget = NULL;
262
263 if (response == GNOME_PRINT_DIALOG_RESPONSE_PREVIEW)
264 return wxID_PREVIEW;
265
266 return wxID_OK;
267 }
268
269 wxDC *wxGnomePrintDialog::GetPrintDC()
270 {
271 // Later
272 return NULL;
273 }
274
275 bool wxGnomePrintDialog::Validate()
276 {
277 return true;
278 }
279
280 bool wxGnomePrintDialog::TransferDataToWindow()
281 {
282 return true;
283 }
284
285 bool wxGnomePrintDialog::TransferDataFromWindow()
286 {
287 return true;
288 }
289
290 //----------------------------------------------------------------------------
291 // wxGnomePageSetupDialog
292 //----------------------------------------------------------------------------
293
294 IMPLEMENT_CLASS(wxGnomePageSetupDialog, wxPageSetupDialogBase)
295
296 wxGnomePageSetupDialog::wxGnomePageSetupDialog( wxWindow *parent,
297 wxPageSetupDialogData* data )
298 {
299 if (data)
300 m_pageDialogData = *data;
301
302 wxGnomePrintNativeData *native =
303 (wxGnomePrintNativeData*) m_pageDialogData.GetPrintData().GetNativeData();
304
305 m_widget = gtk_dialog_new();
306
307 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( _("Page setup") ) );
308
309 GtkWidget *main = gnome_paper_selector_new_with_flags( native->GetPrintConfig(),
310 GNOME_PAPER_SELECTOR_MARGINS|GNOME_PAPER_SELECTOR_FEED_ORIENTATION );
311 gtk_container_set_border_width (GTK_CONTAINER (main), 8);
312 gtk_widget_show (main);
313
314 gtk_container_add( GTK_CONTAINER (GTK_DIALOG (m_widget)->vbox), main );
315
316 gtk_dialog_set_has_separator (GTK_DIALOG (m_widget), TRUE);
317
318 gtk_dialog_add_buttons (GTK_DIALOG (m_widget),
319 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
320 GTK_STOCK_OK, GTK_RESPONSE_OK,
321 NULL);
322
323 gtk_dialog_set_default_response (GTK_DIALOG (m_widget),
324 GTK_RESPONSE_OK);
325 }
326
327 wxGnomePageSetupDialog::~wxGnomePageSetupDialog()
328 {
329 }
330
331 wxPageSetupDialogData& wxGnomePageSetupDialog::GetPageSetupDialogData()
332 {
333 return m_pageDialogData;
334 }
335
336 int wxGnomePageSetupDialog::ShowModal()
337 {
338 wxGnomePrintNativeData *native =
339 (wxGnomePrintNativeData*) m_pageDialogData.GetPrintData().GetNativeData();
340 GnomePrintConfig *config = native->GetPrintConfig();
341
342 // Transfer data from m_pageDialogData to native dialog
343
344 int ret = gtk_dialog_run( GTK_DIALOG(m_widget) );
345
346 if (ret == GTK_RESPONSE_OK)
347 {
348 // Transfer data back to m_pageDialogData
349 #if 0
350 const GnomePrintUnit *margin_unit;
351 const GnomePrintUnit *paper_unit;
352 const GnomePrintUnit *mm_unit = gnome_print_unit_get_by_abbreviation( (const guchar*) "mm" );
353
354 double ml,mr,mt,mb,pw,ph;
355 gnome_print_config_get_length (config,
356 (const guchar*) GNOME_PRINT_KEY_PAGE_MARGIN_LEFT, &ml, NULL);
357 gnome_print_config_get_length (config,
358 (const guchar*) GNOME_PRINT_KEY_PAGE_MARGIN_RIGHT, &mr, NULL);
359 gnome_print_config_get_length (config,
360 (const guchar*) GNOME_PRINT_KEY_PAGE_MARGIN_TOP, &mt, NULL);
361 gnome_print_config_get_length (config,
362 (const guchar*) GNOME_PRINT_KEY_PAGE_MARGIN_BOTTOM, &mb, NULL);
363 gnome_print_config_get_length (config,
364 (const guchar*) GNOME_PRINT_KEY_PAPER_WIDTH, &pw, NULL);
365 gnome_print_config_get_length (config,
366 (const guchar*) GNOME_PRINT_KEY_PAPER_HEIGHT, &ph, NULL);
367
368 gnome_print_convert_distance( &ml, margin_unit, mm_unit );
369 gnome_print_convert_distance( &mr, margin_unit, mm_unit );
370 gnome_print_convert_distance( &mt, margin_unit, mm_unit );
371 gnome_print_convert_distance( &mb, margin_unit, mm_unit );
372 gnome_print_convert_distance( &pw, paper_unit, mm_unit );
373 gnome_print_convert_distance( &ph, paper_unit, mm_unit );
374
375 m_pageDialogData.SetMarginTopLeft( wxPoint( (int)(ml*72.0/25.4+0.5), (int)(mt+0.5)) );
376 m_pageDialogData.SetMarginBottomRight( wxPoint( (int)(mr+0.5), (int)(mb+0.5)) );
377
378 m_pageDialogData.SetPaperSize( wxSize( (int)(pw+0.5), (int)(ph+0.5) ) );
379
380 wxPrintf( wxT("paper %d %d, top margin %d\n"),
381 m_pageDialogData.GetPaperSize().x,
382 m_pageDialogData.GetPaperSize().y,
383 m_pageDialogData.GetMarginTopLeft().x );
384 #endif
385
386 ret = wxID_OK;
387 }
388 else
389 {
390 ret = wxID_CANCEL;
391 }
392
393 gtk_widget_destroy( m_widget );
394 m_widget = NULL;
395
396 return ret;
397 }
398
399 bool wxGnomePageSetupDialog::Validate()
400 {
401 return true;
402 }
403
404 bool wxGnomePageSetupDialog::TransferDataToWindow()
405 {
406 return true;
407 }
408
409 bool wxGnomePageSetupDialog::TransferDataFromWindow()
410 {
411 return true;
412 }
413
414 //----------------------------------------------------------------------------
415 // wxGnomePrinter
416 //----------------------------------------------------------------------------
417
418 IMPLEMENT_CLASS(wxGnomePrinter, wxPrinterBase)
419
420 wxGnomePrinter::wxGnomePrinter( wxPrintDialogData *data ) :
421 wxPrinterBase( data )
422 {
423 m_gpc = NULL;
424 m_native_preview = false;
425 }
426
427 wxGnomePrinter::~wxGnomePrinter()
428 {
429 }
430
431 bool wxGnomePrinter::Print(wxWindow *parent, wxPrintout *printout, bool prompt )
432 {
433 if (!printout)
434 {
435 sm_lastError = wxPRINTER_ERROR;
436 return false;
437 }
438
439 wxPrintData printdata = GetPrintDialogData().GetPrintData();
440 wxGnomePrintNativeData *data =
441 (wxGnomePrintNativeData*) printdata.GetNativeData();
442
443 // The GnomePrintJob is temporarily stored in the
444 // native print data as the native print dialog
445 // needs to access it.
446 GnomePrintJob *job = data->GetPrintJob();
447 m_gpc = gnome_print_job_get_context (job);
448
449 printout->SetIsPreview(false);
450
451 if (m_printDialogData.GetMinPage() < 1)
452 m_printDialogData.SetMinPage(1);
453 if (m_printDialogData.GetMaxPage() < 1)
454 m_printDialogData.SetMaxPage(9999);
455
456 wxDC *dc;
457 if (prompt)
458 dc = PrintDialog( parent );
459 else
460 dc = new wxGnomePrintDC( this );
461
462 if (m_native_preview)
463 printout->SetIsPreview(true);
464
465 if (!dc)
466 {
467 gnome_print_job_close( job );
468 sm_lastError = wxPRINTER_ERROR;
469 return false;
470 }
471
472 wxSize ScreenPixels = wxGetDisplaySize();
473 wxSize ScreenMM = wxGetDisplaySizeMM();
474
475 printout->SetPPIScreen( (int) ((ScreenPixels.GetWidth() * 25.4) / ScreenMM.GetWidth()),
476 (int) ((ScreenPixels.GetHeight() * 25.4) / ScreenMM.GetHeight()) );
477 printout->SetPPIPrinter( wxGnomePrintDC::GetResolution(),
478 wxGnomePrintDC::GetResolution() );
479
480 printout->SetDC(dc);
481
482 int w, h;
483 dc->GetSize(&w, &h);
484 printout->SetPageSizePixels((int)w, (int)h);
485 dc->GetSizeMM(&w, &h);
486 printout->SetPageSizeMM((int)w, (int)h);
487
488 printout->OnPreparePrinting();
489
490 // Get some parameters from the printout, if defined
491 int fromPage, toPage;
492 int minPage, maxPage;
493 printout->GetPageInfo(&minPage, &maxPage, &fromPage, &toPage);
494
495 if (maxPage == 0)
496 {
497 sm_lastError = wxPRINTER_ERROR;
498 return false;
499 }
500
501 printout->OnBeginPrinting();
502
503 int minPageNum = minPage, maxPageNum = maxPage;
504
505 if ( !m_printDialogData.GetAllPages() )
506 {
507 minPageNum = m_printDialogData.GetFromPage();
508 maxPageNum = m_printDialogData.GetToPage();
509 }
510
511
512 int copyCount;
513 for ( copyCount = 1;
514 copyCount <= m_printDialogData.GetNoCopies();
515 copyCount++ )
516 {
517 if (!printout->OnBeginDocument(minPageNum, maxPageNum))
518 {
519 wxLogError(_("Could not start printing."));
520 sm_lastError = wxPRINTER_ERROR;
521 break;
522 }
523
524 int pn;
525 for ( pn = minPageNum;
526 pn <= maxPageNum && printout->HasPage(pn);
527 pn++ )
528 {
529 dc->StartPage();
530 printout->OnPrintPage(pn);
531 dc->EndPage();
532 }
533
534 printout->OnEndDocument();
535 printout->OnEndPrinting();
536 }
537
538 gnome_print_job_close( job );
539 if (m_native_preview)
540 {
541 wxString title( _("Print preview") );
542 gtk_widget_show( gnome_print_job_preview_new( job, (const guchar*)(const char*)wxGTK_CONV(title) ));
543 }
544 else
545 {
546 gnome_print_job_print( job );
547 }
548
549 delete dc;
550
551 return (sm_lastError == wxPRINTER_NO_ERROR);
552 }
553
554 wxDC* wxGnomePrinter::PrintDialog( wxWindow *parent )
555 {
556 wxGnomePrintDialog dialog( parent, &m_printDialogData );
557 int ret = dialog.ShowModal();
558 if (ret == wxID_CANCEL)
559 {
560 sm_lastError = wxPRINTER_ERROR;
561 return NULL;
562 }
563
564 m_native_preview = ret == wxID_PREVIEW;
565
566 m_printDialogData = dialog.GetPrintDialogData();
567 return new wxGnomePrintDC( this );
568 }
569
570 bool wxGnomePrinter::Setup( wxWindow *parent )
571 {
572 return false;
573 }
574
575 //-----------------------------------------------------------------------------
576 // wxGnomePrintDC
577 //-----------------------------------------------------------------------------
578
579 IMPLEMENT_CLASS(wxGnomePrintDC, wxDCBase)
580
581 wxGnomePrintDC::wxGnomePrintDC( wxGnomePrinter *printer )
582 {
583 m_printer = printer;
584
585 m_gpc = printer->GetPrintContext();
586
587 m_layout = gnome_print_pango_create_layout( m_gpc );
588 m_fontdesc = pango_font_description_from_string( "Sans 12" );
589
590 m_currentRed = 0;
591 m_currentBlue = 0;
592 m_currentGreen = 0;
593
594 m_signX = 1; // default x-axis left to right
595 m_signY = -1; // default y-axis bottom up -> top down
596 }
597
598 wxGnomePrintDC::~wxGnomePrintDC()
599 {
600 }
601
602 bool wxGnomePrintDC::Ok() const
603 {
604 return true;
605 }
606
607 bool wxGnomePrintDC::DoFloodFill(wxCoord x1, wxCoord y1, const wxColour &col, int style )
608 {
609 return false;
610 }
611
612 bool wxGnomePrintDC::DoGetPixel(wxCoord x1, wxCoord y1, wxColour *col) const
613 {
614 return false;
615 }
616
617 void wxGnomePrintDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
618 {
619 if (m_pen.GetStyle() == wxTRANSPARENT) return;
620
621 SetPen( m_pen );
622
623 gnome_print_moveto ( m_gpc, XLOG2DEV(x1), YLOG2DEV(y1) );
624 gnome_print_lineto ( m_gpc, XLOG2DEV(x2), YLOG2DEV(y2) );
625 gnome_print_stroke ( m_gpc);
626
627 CalcBoundingBox( x1, y1 );
628 CalcBoundingBox( x2, y2 );
629 }
630
631 void wxGnomePrintDC::DoCrossHair(wxCoord x, wxCoord y)
632 {
633 }
634
635 void wxGnomePrintDC::DoDrawArc(wxCoord x1,wxCoord y1,wxCoord x2,wxCoord y2,wxCoord xc,wxCoord yc)
636 {
637 }
638
639 void wxGnomePrintDC::DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,double ea)
640 {
641 }
642
643 void wxGnomePrintDC::DoDrawPoint(wxCoord x, wxCoord y)
644 {
645 }
646
647 void wxGnomePrintDC::DoDrawLines(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset)
648 {
649 }
650
651 void wxGnomePrintDC::DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset, int fillStyle)
652 {
653 }
654
655 void wxGnomePrintDC::DoDrawPolyPolygon(int n, int count[], wxPoint points[], wxCoord xoffset, wxCoord yoffset, int fillStyle)
656 {
657 }
658
659 void wxGnomePrintDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
660 {
661 if (m_brush.GetStyle () != wxTRANSPARENT)
662 {
663 SetBrush( m_brush );
664
665 gnome_print_newpath( m_gpc );
666 gnome_print_moveto( m_gpc, XLOG2DEV(x), YLOG2DEV(y) );
667 gnome_print_lineto( m_gpc, XLOG2DEV(x + width), YLOG2DEV(y) );
668 gnome_print_lineto( m_gpc, XLOG2DEV(x + width), YLOG2DEV(y + height) );
669 gnome_print_lineto( m_gpc, XLOG2DEV(x), YLOG2DEV(y + height) );
670 gnome_print_closepath( m_gpc );
671 gnome_print_fill( m_gpc );
672
673 CalcBoundingBox( x, y );
674 CalcBoundingBox( x + width, y + height );
675 }
676
677 if (m_pen.GetStyle () != wxTRANSPARENT)
678 {
679 SetPen (m_pen);
680
681 gnome_print_newpath( m_gpc );
682 gnome_print_moveto( m_gpc, XLOG2DEV(x), YLOG2DEV(y) );
683 gnome_print_lineto( m_gpc, XLOG2DEV(x + width), YLOG2DEV(y) );
684 gnome_print_lineto( m_gpc, XLOG2DEV(x + width), YLOG2DEV(y + height) );
685 gnome_print_lineto( m_gpc, XLOG2DEV(x), YLOG2DEV(y + height) );
686 gnome_print_closepath( m_gpc );
687 gnome_print_stroke( m_gpc );
688
689 CalcBoundingBox( x, y );
690 CalcBoundingBox( x + width, y + height );
691 }
692 }
693
694 void wxGnomePrintDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius)
695 {
696 }
697
698 void wxGnomePrintDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
699 {
700 }
701
702 void wxGnomePrintDC::DoDrawSpline(wxList *points)
703 {
704 }
705
706 bool wxGnomePrintDC::DoBlit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
707 wxDC *source, wxCoord xsrc, wxCoord ysrc, int rop, bool useMask,
708 wxCoord xsrcMask, wxCoord ysrcMask)
709 {
710 return false;
711 }
712
713 void wxGnomePrintDC::DoDrawIcon( const wxIcon& icon, wxCoord x, wxCoord y )
714 {
715 DoDrawBitmap( icon, x, y, true );
716 }
717
718 void wxGnomePrintDC::DoDrawBitmap( const wxBitmap& bitmap, wxCoord x, wxCoord y, bool useMask )
719 {
720 if (!bitmap.Ok()) return;
721
722 if (bitmap.HasPixbuf())
723 {
724 GdkPixbuf *pixbuf = bitmap.GetPixbuf();
725 guchar *raw_image = gdk_pixbuf_get_pixels( pixbuf );
726 bool has_alpha = gdk_pixbuf_get_has_alpha( pixbuf );
727 int rowstride = gdk_pixbuf_get_rowstride( pixbuf );
728 int height = gdk_pixbuf_get_height( pixbuf );
729 int width = gdk_pixbuf_get_width( pixbuf );
730
731 gnome_print_gsave( m_gpc );
732 double matrix[6];
733 matrix[0] = XLOG2DEVREL(width);
734 matrix[1] = 0;
735 matrix[2] = 0;
736 matrix[3] = YLOG2DEVREL(height);
737 matrix[4] = XLOG2DEV(x);
738 matrix[5] = YLOG2DEV(y+height);
739 gnome_print_concat( m_gpc, matrix );
740 gnome_print_moveto( m_gpc, 0, 0 );
741 if (has_alpha)
742 gnome_print_rgbaimage( m_gpc, (guchar *)raw_image, width, height, rowstride );
743 else
744 gnome_print_rgbimage( m_gpc, (guchar *)raw_image, width, height, rowstride );
745 gnome_print_grestore( m_gpc );
746 }
747 else
748 {
749 wxImage image = bitmap.ConvertToImage();
750
751 if (!image.Ok()) return;
752
753 gnome_print_gsave( m_gpc );
754 double matrix[6];
755 matrix[0] = XLOG2DEVREL(image.GetWidth());
756 matrix[1] = 0;
757 matrix[2] = 0;
758 matrix[3] = YLOG2DEVREL(image.GetHeight());
759 matrix[4] = XLOG2DEV(x);
760 matrix[5] = YLOG2DEV(y+image.GetHeight());
761 gnome_print_concat( m_gpc, matrix );
762 gnome_print_moveto( m_gpc, 0, 0 );
763 gnome_print_rgbimage( m_gpc, (guchar*) image.GetData(), image.GetWidth(), image.GetHeight(), image.GetWidth()*3 );
764 gnome_print_grestore( m_gpc );
765 }
766 }
767
768 void wxGnomePrintDC::DoDrawText(const wxString& text, wxCoord x, wxCoord y )
769 {
770 DoDrawRotatedText( text, x, y, 0.0 );
771 }
772
773 void wxGnomePrintDC::DoDrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle)
774 {
775 x = XLOG2DEV(x);
776 y = YLOG2DEV(y);
777
778 bool underlined = m_font.Ok() && m_font.GetUnderlined();
779
780 #if wxUSE_UNICODE
781 const wxCharBuffer data = wxConvUTF8.cWC2MB( text );
782 #else
783 const wxWCharBuffer wdata = wxConvLocal.cMB2WC( text );
784 if ( !wdata )
785 return;
786 const wxCharBuffer data = wxConvUTF8.cWC2MB( wdata );
787 #endif
788
789 size_t datalen = strlen((const char*)data);
790 pango_layout_set_text( m_layout, (const char*) data, datalen);
791
792 if (underlined)
793 {
794 PangoAttrList *attrs = pango_attr_list_new();
795 PangoAttribute *a = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
796 a->start_index = 0;
797 a->end_index = datalen;
798 pango_attr_list_insert(attrs, a);
799 pango_layout_set_attributes(m_layout, attrs);
800 pango_attr_list_unref(attrs);
801 }
802
803 if (m_textForegroundColour.Ok())
804 {
805 unsigned char red = m_textForegroundColour.Red();
806 unsigned char blue = m_textForegroundColour.Blue();
807 unsigned char green = m_textForegroundColour.Green();
808
809 if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
810 {
811 double redPS = (double)(red) / 255.0;
812 double bluePS = (double)(blue) / 255.0;
813 double greenPS = (double)(green) / 255.0;
814
815 gnome_print_setrgbcolor( m_gpc, redPS, bluePS, greenPS );
816
817 m_currentRed = red;
818 m_currentBlue = blue;
819 m_currentGreen = green;
820 }
821 }
822
823 int w,h;
824
825 if (fabs(m_scaleY - 1.0) > 0.00001)
826 {
827 // If there is a user or actually any scale applied to
828 // the device context, scale the font.
829
830 // scale font description
831 gint oldSize = pango_font_description_get_size( m_fontdesc );
832 double size = oldSize;
833 size = size * m_scaleY;
834 pango_font_description_set_size( m_fontdesc, (gint)size );
835
836 // actually apply scaled font
837 pango_layout_set_font_description( m_layout, m_fontdesc );
838
839 pango_layout_get_pixel_size( m_layout, &w, &h );
840 #if 0
841 if ( m_backgroundMode == wxSOLID )
842 {
843 gdk_gc_set_foreground(m_textGC, m_textBackgroundColour.GetColor());
844 gdk_draw_rectangle(m_window, m_textGC, TRUE, x, y, w, h);
845 gdk_gc_set_foreground(m_textGC, m_textForegroundColour.GetColor());
846 }
847 #endif
848 // Draw layout.
849 gnome_print_moveto (m_gpc, x, y);
850 if (fabs(angle) > 0.00001)
851 {
852 gnome_print_gsave( m_gpc );
853 gnome_print_rotate( m_gpc, angle );
854 gnome_print_pango_layout( m_gpc, m_layout );
855 gnome_print_grestore( m_gpc );
856 }
857 else
858 {
859 gnome_print_pango_layout( m_gpc, m_layout );
860 }
861
862 // reset unscaled size
863 pango_font_description_set_size( m_fontdesc, oldSize );
864
865 // actually apply unscaled font
866 pango_layout_set_font_description( m_layout, m_fontdesc );
867 }
868 else
869 {
870 pango_layout_get_pixel_size( m_layout, &w, &h );
871 #if 0
872 if ( m_backgroundMode == wxSOLID )
873 {
874 gdk_gc_set_foreground(m_textGC, m_textBackgroundColour.GetColor());
875 gdk_draw_rectangle(m_window, m_textGC, TRUE, x, y, w, h);
876 gdk_gc_set_foreground(m_textGC, m_textForegroundColour.GetColor());
877 }
878 #endif
879 // Draw layout.
880 gnome_print_moveto (m_gpc, x, y);
881 if (fabs(angle) > 0.00001)
882 {
883 gnome_print_gsave( m_gpc );
884 gnome_print_rotate( m_gpc, angle );
885 gnome_print_pango_layout( m_gpc, m_layout );
886 gnome_print_grestore( m_gpc );
887 }
888 else
889 {
890 gnome_print_pango_layout( m_gpc, m_layout );
891 }
892 }
893
894 if (underlined)
895 {
896 // undo underline attributes setting:
897 pango_layout_set_attributes(m_layout, NULL);
898 }
899
900 CalcBoundingBox (x + w, y + h);
901 }
902
903 void wxGnomePrintDC::Clear()
904 {
905 }
906
907 void wxGnomePrintDC::SetFont( const wxFont& font )
908 {
909 m_font = font;
910
911 if (m_font.Ok())
912 {
913 if (m_fontdesc)
914 pango_font_description_free( m_fontdesc );
915
916 m_fontdesc = pango_font_description_copy( m_font.GetNativeFontInfo()->description );
917
918 pango_layout_set_font_description( m_layout, m_fontdesc );
919 }
920 }
921
922 void wxGnomePrintDC::SetPen( const wxPen& pen )
923 {
924 if (!pen.Ok()) return;
925
926 // TODO: support for pen styles other than solid (use gnome_print_setdash)
927
928 m_pen = pen;
929
930 gnome_print_setlinewidth( m_gpc, XLOG2DEVREL( 1000 * m_pen.GetWidth() ) / 1000.0f );
931
932 unsigned char red = m_pen.GetColour().Red();
933 unsigned char blue = m_pen.GetColour().Blue();
934 unsigned char green = m_pen.GetColour().Green();
935
936 if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
937 {
938 double redPS = (double)(red) / 255.0;
939 double bluePS = (double)(blue) / 255.0;
940 double greenPS = (double)(green) / 255.0;
941
942 gnome_print_setrgbcolor( m_gpc, redPS, bluePS, greenPS );
943
944 m_currentRed = red;
945 m_currentBlue = blue;
946 m_currentGreen = green;
947 }
948 }
949
950 void wxGnomePrintDC::SetBrush( const wxBrush& brush )
951 {
952 if (!brush.Ok()) return;
953
954 m_brush = brush;
955
956 // Brush colour
957 unsigned char red = m_brush.GetColour().Red();
958 unsigned char blue = m_brush.GetColour().Blue();
959 unsigned char green = m_brush.GetColour().Green();
960
961 if (!m_colour)
962 {
963 // Anything not white is black
964 if (! (red == (unsigned char) 255 &&
965 blue == (unsigned char) 255 &&
966 green == (unsigned char) 255) )
967 {
968 red = (unsigned char) 0;
969 green = (unsigned char) 0;
970 blue = (unsigned char) 0;
971 }
972 // setgray here ?
973 }
974
975 if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
976 {
977 double redPS = (double)(red) / 255.0;
978 double bluePS = (double)(blue) / 255.0;
979 double greenPS = (double)(green) / 255.0;
980
981 gnome_print_setrgbcolor( m_gpc, redPS, bluePS, greenPS );
982
983 m_currentRed = red;
984 m_currentBlue = blue;
985 m_currentGreen = green;
986 }
987 }
988
989 void wxGnomePrintDC::SetLogicalFunction( int function )
990 {
991 }
992
993 void wxGnomePrintDC::SetBackground( const wxBrush& brush )
994 {
995 }
996
997 void wxGnomePrintDC::DoSetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
998 {
999 }
1000
1001 void wxGnomePrintDC::DestroyClippingRegion()
1002 {
1003 }
1004
1005 bool wxGnomePrintDC::StartDoc(const wxString& message)
1006 {
1007 SetDeviceOrigin( 0,0 );
1008
1009 return true;
1010 }
1011
1012 void wxGnomePrintDC::EndDoc()
1013 {
1014 }
1015
1016 void wxGnomePrintDC::StartPage()
1017 {
1018 gnome_print_beginpage( m_gpc, (const guchar*) "1" );
1019 }
1020
1021 void wxGnomePrintDC::EndPage()
1022 {
1023 gnome_print_showpage( m_gpc );
1024 }
1025
1026 wxCoord wxGnomePrintDC::GetCharHeight() const
1027 {
1028 pango_layout_set_text( m_layout, "H", 1 );
1029
1030 int w,h;
1031 pango_layout_get_pixel_size( m_layout, &w, &h );
1032
1033 return h;
1034 }
1035
1036 wxCoord wxGnomePrintDC::GetCharWidth() const
1037 {
1038 pango_layout_set_text( m_layout, "H", 1 );
1039
1040 int w,h;
1041 pango_layout_get_pixel_size( m_layout, &w, &h );
1042
1043 return w;
1044 }
1045
1046 void wxGnomePrintDC::DoGetTextExtent(const wxString& string, wxCoord *width, wxCoord *height,
1047 wxCoord *descent,
1048 wxCoord *externalLeading,
1049 wxFont *theFont ) const
1050 {
1051 if ( width )
1052 *width = 0;
1053 if ( height )
1054 *height = 0;
1055 if ( descent )
1056 *descent = 0;
1057 if ( externalLeading )
1058 *externalLeading = 0;
1059
1060 if (string.IsEmpty())
1061 {
1062 return;
1063 }
1064
1065 // Set new font description
1066 if (theFont)
1067 pango_layout_set_font_description( m_layout, theFont->GetNativeFontInfo()->description );
1068
1069 // Set layout's text
1070 #if wxUSE_UNICODE
1071 const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
1072 const char *dataUTF8 = (const char *)data;
1073 #else
1074 const wxWCharBuffer wdata = wxConvLocal.cMB2WC( string );
1075 if ( !wdata )
1076 {
1077 if (width) (*width) = 0;
1078 if (height) (*height) = 0;
1079 return;
1080 }
1081 const wxCharBuffer data = wxConvUTF8.cWC2MB( wdata );
1082 const char *dataUTF8 = (const char *)data;
1083 #endif
1084
1085 if ( !dataUTF8 )
1086 {
1087 // hardly ideal, but what else can we do if conversion failed?
1088 return;
1089 }
1090
1091 pango_layout_set_text( m_layout, dataUTF8, strlen(dataUTF8) );
1092
1093 int w,h;
1094 pango_layout_get_pixel_size( m_layout, &w, &h );
1095
1096 if (width)
1097 *width = (wxCoord) w;
1098 if (height)
1099 *height = (wxCoord) h;
1100 if (descent)
1101 {
1102 PangoLayoutIter *iter = pango_layout_get_iter(m_layout);
1103 int baseline = pango_layout_iter_get_baseline(iter);
1104 pango_layout_iter_free(iter);
1105 *descent = h - PANGO_PIXELS(baseline);
1106 }
1107
1108 // Reset old font description
1109 if (theFont)
1110 pango_layout_set_font_description( m_layout, m_fontdesc );
1111 }
1112
1113 void wxGnomePrintDC::DoGetSize(int* width, int* height) const
1114 {
1115 // No idea if that is efficient
1116 GnomePrintConfig *config = gnome_print_config_default();
1117
1118 double w,h;
1119 bool result = gnome_print_config_get_page_size( config, &w, &h );
1120
1121 if (!result)
1122 {
1123 // Standard PS resolution DIN A4 size.
1124 w = 595.0;
1125 h = 842.0;
1126 }
1127
1128 if (width)
1129 *width = (int) w;
1130 if (height)
1131 *height = (int) h;
1132 }
1133
1134 void wxGnomePrintDC::DoGetSizeMM(int *width, int *height) const
1135 {
1136 double w,h;
1137
1138 /// Later, for now DIN A4
1139 w = 210.0;
1140 h = 297.0;
1141
1142 if (width)
1143 *width = (int) w;
1144 if (height)
1145 *height = (int) h;
1146 }
1147
1148 wxSize wxGnomePrintDC::GetPPI() const
1149 {
1150 return wxSize(72,72);
1151 }
1152
1153 void wxGnomePrintDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
1154 {
1155 m_signX = (xLeftRight ? 1 : -1);
1156 m_signY = (yBottomUp ? 1 : -1);
1157
1158 ComputeScaleAndOrigin();
1159 }
1160
1161 void wxGnomePrintDC::SetDeviceOrigin( wxCoord x, wxCoord y )
1162 {
1163 int h = 0;
1164 int w = 0;
1165 GetSize( &w, &h );
1166
1167 wxDC::SetDeviceOrigin( x, h-y );
1168 }
1169
1170 void wxGnomePrintDC::SetResolution(int ppi)
1171 {
1172 }
1173
1174 int wxGnomePrintDC::GetResolution()
1175 {
1176 return 72;
1177 }
1178
1179
1180 class wxGnomePrintModule: public wxModule
1181 {
1182 public:
1183 wxGnomePrintModule() {}
1184 bool OnInit() { wxPrintFactory::SetPrintFactory( new wxGnomePrintFactory ); return true; }
1185 void OnExit() { }
1186
1187 private:
1188 DECLARE_DYNAMIC_CLASS(wxGnomePrintModule)
1189 };
1190
1191 IMPLEMENT_DYNAMIC_CLASS(wxGnomePrintModule, wxModule)
1192
1193 #endif
1194 // wxUSE_LIBGNOMEPRINT
wxWidgets (Impactor)