← Back to branch summary

~ubuntu-branches/ubuntu/lucid/tomboy/lucid-proposed

« back to all changes in this revision

Viewing changes to Tomboy/Addins/PrintNotes/gedit-print.c

  • Committer: Bazaar Package Importer
  • Author(s): Pedro Fragoso
  • Date: 2009-02-17 03:08:19 UTC
  • mto: This revision was merged to the branch mainline in revision 15.
  • Revision ID: james.westby@ubuntu.com-20090217030819-1d2alonbx1lf1vp6
Tags: upstream-0.13.5
Import upstream version 0.13.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
Tomboy/Addins/PrintNotes/gedit-print.c
1
 
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
2
 
/*
3
 
 * gedit-print.c
4
 
 * This file is part of gedit
5
 
 *
6
 
 * Copyright (C) 2000, 2001 Chema Celorio, Paolo Maggi
7
 
 * Copyright (C) 2002  Paolo Maggi  
8
 
 *
9
 
 * This program is free software; you can redistribute it and/or modify
10
 
 * it under the terms of the GNU General Public License as published by
11
 
 * the Free Software Foundation; either version 2 of the License, or
12
 
 * (at your option) any later version.
13
 
 *
14
 
 * This program is distributed in the hope that it will be useful,
15
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
 
 * GNU General Public License for more details.
18
 
 *
19
 
 * You should have received a copy of the GNU General Public License
20
 
 * along with this program; if not, write to the Free Software
21
 
 * Foundation, Inc., 59 Temple Place, Suite 330, 
22
 
 * Boston, MA 02111-1307, USA. 
23
 
 */
24
 
 
25
 
/*
26
 
 * Modified by the gedit Team, 1998-2002. See the AUTHORS file for a 
27
 
 * list of people on the gedit Team.  
28
 
 * See the ChangeLog files for a list of changes. 
29
 
 */
30
 
 
31
 
#ifdef HAVE_CONFIG_H
32
 
#include <config.h>
33
 
#endif
34
 
 
35
 
#include <sys/types.h>
36
 
#include <sys/stat.h>
37
 
#include <fcntl.h>
38
 
#include <unistd.h>
39
 
#include <string.h>     /* For strlen */
40
 
 
41
 
#include <glib/gi18n.h>
42
 
#include <libgnomeprintui/gnome-print-dialog.h>
43
 
#include <libgnomeprintui/gnome-print-job-preview.h>
44
 
 
45
 
#include "gedit-print.h"
46
 
#include "gtksourceprintjob.h"
47
 
 
48
 
#ifdef DEBUG
49
 
#  define DEBUG_PRINT "DEBUG_PRINT: %s"
50
 
#  define gedit_debug(x, y) g_warning(x, y)
51
 
#else
52
 
#  define gedit_debug(x, y) do {} while (FALSE);
53
 
#endif
54
 
 
55
 
enum
56
 
{
57
 
        PREVIEW_NO,
58
 
        PREVIEW,
59
 
        PREVIEW_FROM_DIALOG
60
 
};
61
 
 
62
 
typedef struct _GeditPrintJobInfo       GeditPrintJobInfo;
63
 
 
64
 
struct _GeditPrintJobInfo 
65
 
{
66
 
        GtkTextBuffer     *doc;
67
 
        
68
 
        GtkSourcePrintJob *pjob;
69
 
                
70
 
        gint               preview;
71
 
 
72
 
        gint               range_type;
73
 
 
74
 
        gint               first_line_to_print;
75
 
        gint               last_line_to_print;
76
 
 
77
 
        /* Popup dialog */
78
 
        GtkWidget         *dialog;
79
 
        GtkWidget         *label;
80
 
        GtkWidget         *progressbar;
81
 
 
82
 
        GtkWindow         *parent;
83
 
};
84
 
 
85
 
static GeditPrintJobInfo* gedit_print_job_info_new      (GtkTextView       *view);
86
 
static void gedit_print_job_info_destroy                (GeditPrintJobInfo *pji, 
87
 
                                                         gboolean           save_config);
88
 
static void gedit_print_real                            (GeditPrintJobInfo *pji, 
89
 
                                                         GtkTextIter       *start, 
90
 
                                                         GtkTextIter       *end, 
91
 
                                                         GtkWindow         *parent);
92
 
static void gedit_print_preview_real                    (GeditPrintJobInfo *pji, 
93
 
                                                         GtkTextIter       *start, 
94
 
                                                         GtkTextIter       *end, 
95
 
                                                         GtkWindow         *parent);
96
 
 
97
 
 
98
 
static void
99
 
gedit_print_job_info_destroy (GeditPrintJobInfo *pji, gboolean save_config)
100
 
{
101
 
        gedit_debug (DEBUG_PRINT, "");
102
 
 
103
 
        g_return_if_fail (pji != NULL);
104
 
 
105
 
        if (pji->pjob != NULL)
106
 
                g_object_unref (pji->pjob);
107
 
 
108
 
        g_free (pji);
109
 
}
110
 
 
111
 
static GtkWidget *
112
 
get_print_dialog (GeditPrintJobInfo *pji, GtkWindow *parent)
113
 
{
114
 
        GtkWidget *dialog;
115
 
        gint selection_flag;
116
 
        gint lines;
117
 
        GnomePrintConfig *config;
118
 
 
119
 
        gedit_debug (DEBUG_PRINT, "");
120
 
 
121
 
        g_return_val_if_fail (pji != NULL, NULL);
122
 
        
123
 
        if (!gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (pji->doc), NULL, NULL))
124
 
                selection_flag = GNOME_PRINT_RANGE_SELECTION_UNSENSITIVE;
125
 
        else
126
 
                selection_flag = GNOME_PRINT_RANGE_SELECTION;
127
 
        
128
 
        g_return_val_if_fail(pji->pjob != NULL, NULL);
129
 
        config = gtk_source_print_job_get_config (pji->pjob);
130
 
        
131
 
        dialog = g_object_new (GNOME_TYPE_PRINT_DIALOG, "print_config", config, NULL);
132
 
        
133
 
        gnome_print_dialog_construct (GNOME_PRINT_DIALOG (dialog), 
134
 
                                      (guchar *) _("Print"),
135
 
                                      GNOME_PRINT_DIALOG_RANGE | GNOME_PRINT_DIALOG_COPIES);
136
 
 
137
 
        lines = gtk_text_buffer_get_line_count (GTK_TEXT_BUFFER (pji->doc));
138
 
 
139
 
        gnome_print_dialog_construct_range_any ( GNOME_PRINT_DIALOG (dialog),
140
 
                                                 (GNOME_PRINT_RANGE_ALL | selection_flag), 
141
 
                                                 NULL, NULL, NULL);
142
 
 
143
 
        gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
144
 
 
145
 
        gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); 
146
 
        gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE);
147
 
 
148
 
        return dialog;
149
 
}
150
 
 
151
 
static void
152
 
gedit_print_dialog_response (GtkWidget *dialog, int response, GeditPrintJobInfo *pji)
153
 
{
154
 
        GtkTextIter start, end;
155
 
 
156
 
        pji->range_type = gnome_print_dialog_get_range (GNOME_PRINT_DIALOG (dialog));
157
 
        gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (pji->doc), &start, &end);
158
 
 
159
 
        switch (pji->range_type)
160
 
        {
161
 
        case GNOME_PRINT_RANGE_ALL:
162
 
                break;
163
 
 
164
 
        case GNOME_PRINT_RANGE_SELECTION:
165
 
                gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (pji->doc),
166
 
                                                      &start, &end);
167
 
                break;
168
 
 
169
 
        default:
170
 
                g_return_if_reached ();
171
 
        }
172
 
 
173
 
        switch (response)
174
 
        {
175
 
        case GNOME_PRINT_DIALOG_RESPONSE_PRINT:
176
 
                gedit_debug (DEBUG_PRINT, "Print button pressed.");
177
 
                pji->preview = PREVIEW_NO;
178
 
                gedit_print_real (pji, &start, &end, 
179
 
                                  gtk_window_get_transient_for (GTK_WINDOW (dialog)));
180
 
                gtk_widget_destroy (dialog);
181
 
                break;
182
 
 
183
 
        case GNOME_PRINT_DIALOG_RESPONSE_PREVIEW:
184
 
                gedit_debug (DEBUG_PRINT, "Preview button pressed.");
185
 
                pji->preview = PREVIEW_FROM_DIALOG;
186
 
                gedit_print_preview_real (pji, &start, &end, GTK_WINDOW (dialog));
187
 
                break;
188
 
 
189
 
        default:
190
 
                gtk_widget_destroy (dialog);
191
 
                gedit_print_job_info_destroy (pji, FALSE);
192
 
        }
193
 
} 
194
 
 
195
 
static void
196
 
show_printing_dialog (GeditPrintJobInfo *pji, GtkWindow *parent)
197
 
{
198
 
        GtkWidget *window;
199
 
        GtkWidget *frame;
200
 
        GtkWidget *hbox;
201
 
        GtkWidget *image;
202
 
        GtkWidget *vbox;
203
 
        GtkWidget *label;
204
 
        GtkWidget *progressbar;
205
 
 
206
 
        window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
207
 
        gtk_window_set_modal (GTK_WINDOW (window), TRUE);
208
 
        gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
209
 
        gtk_window_set_destroy_with_parent (GTK_WINDOW (window), TRUE);
210
 
        gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER_ON_PARENT);
211
 
                
212
 
        gtk_window_set_decorated (GTK_WINDOW (window), FALSE);
213
 
        gtk_window_set_skip_taskbar_hint (GTK_WINDOW (window), TRUE);
214
 
        gtk_window_set_skip_pager_hint (GTK_WINDOW (window), TRUE);
215
 
 
216
 
        gtk_window_set_transient_for (GTK_WINDOW (window), parent);
217
 
 
218
 
        frame = gtk_frame_new (NULL);
219
 
        gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
220
 
        gtk_container_add (GTK_CONTAINER (window), frame);
221
 
 
222
 
        hbox = gtk_hbox_new (FALSE, 12);
223
 
        gtk_container_add (GTK_CONTAINER (frame), hbox);
224
 
        gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
225
 
 
226
 
        image = gtk_image_new_from_stock ("gtk-print", GTK_ICON_SIZE_DIALOG);
227
 
        gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
228
 
 
229
 
        vbox = gtk_vbox_new (FALSE, 12);
230
 
        gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
231
 
 
232
 
        label = gtk_label_new (_("Preparing pages..."));
233
 
        gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
234
 
        gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
235
 
        gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
236
 
 
237
 
        progressbar = gtk_progress_bar_new ();
238
 
        gtk_box_pack_start (GTK_BOX (vbox), progressbar, FALSE, FALSE, 0);
239
 
        
240
 
        pji->dialog = window;
241
 
        pji->label = label;
242
 
        pji->progressbar = progressbar;
243
 
        
244
 
        gtk_widget_show_all (pji->dialog);
245
 
 
246
 
        /* Update UI */
247
 
        while (gtk_events_pending ())
248
 
                gtk_main_iteration ();
249
 
}
250
 
 
251
 
static void
252
 
page_cb (GtkSourcePrintJob *job, GeditPrintJobInfo *pji)
253
 
{
254
 
        gchar *str;
255
 
        gint page_num = gtk_source_print_job_get_page (pji->pjob);
256
 
        gint total = gtk_source_print_job_get_page_count (pji->pjob);
257
 
 
258
 
        if (pji->preview != PREVIEW_NO)
259
 
                str = g_strdup_printf (_("Rendering page %d of %d..."), page_num, total);
260
 
        else
261
 
                str = g_strdup_printf (_("Printing page %d of %d..."), page_num, total);
262
 
 
263
 
        gtk_label_set_label (GTK_LABEL (pji->label), str);
264
 
        g_free (str);
265
 
 
266
 
        gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (pji->progressbar), 
267
 
                                       1.0 * page_num / total);
268
 
 
269
 
        /* Update UI */
270
 
        while (gtk_events_pending ())
271
 
                gtk_main_iteration ();
272
 
 
273
 
}
274
 
 
275
 
static void
276
 
preview_finished_cb (GtkSourcePrintJob *job, GeditPrintJobInfo *pji)
277
 
{
278
 
        GnomePrintJob *gjob;
279
 
        GtkWidget *preview = NULL;
280
 
 
281
 
        gjob = gtk_source_print_job_get_print_job (job);
282
 
 
283
 
        preview = gnome_print_job_preview_new (gjob, (guchar *) _("Print preview"));
284
 
        if (pji->parent != NULL)
285
 
        {
286
 
                gtk_window_set_transient_for (GTK_WINDOW (preview), pji->parent);
287
 
                gtk_window_set_modal (GTK_WINDOW (preview), TRUE);
288
 
        }
289
 
        
290
 
        g_object_unref (gjob);
291
 
 
292
 
        gtk_widget_destroy (pji->dialog);
293
 
 
294
 
        if (pji->preview == PREVIEW)
295
 
                gedit_print_job_info_destroy (pji, FALSE);
296
 
        else
297
 
        {
298
 
                g_signal_handlers_disconnect_by_func (pji->pjob, (GCallback) page_cb, pji);
299
 
                g_signal_handlers_disconnect_by_func (pji->pjob, (GCallback) preview_finished_cb, pji);
300
 
        }
301
 
        
302
 
        gtk_widget_show (preview);
303
 
}
304
 
 
305
 
static void
306
 
print_finished_cb (GtkSourcePrintJob *job, GeditPrintJobInfo *pji)
307
 
{
308
 
        GnomePrintJob *gjob;
309
 
 
310
 
        gjob = gtk_source_print_job_get_print_job (job);
311
 
 
312
 
        gnome_print_job_print (gjob);
313
 
        
314
 
        g_object_unref (gjob);
315
 
 
316
 
        gtk_widget_destroy (pji->dialog);
317
 
 
318
 
        gedit_print_job_info_destroy (pji, TRUE);
319
 
}
320
 
 
321
 
void 
322
 
gedit_print (GtkTextView *view)
323
 
{
324
 
        GeditPrintJobInfo *pji;
325
 
        GtkWidget *dialog;
326
 
 
327
 
        gedit_debug (DEBUG_PRINT, "");
328
 
 
329
 
        g_return_if_fail (view != NULL);
330
 
 
331
 
        pji = gedit_print_job_info_new (view);
332
 
        pji->preview = PREVIEW_NO;
333
 
 
334
 
        dialog = get_print_dialog (pji, GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (view))));
335
 
        
336
 
        g_signal_connect (dialog, "response",
337
 
                          G_CALLBACK (gedit_print_dialog_response),
338
 
                          pji);
339
 
 
340
 
        gtk_widget_show (dialog);
341
 
}
342
 
 
343
 
static void 
344
 
gedit_print_preview_real (GeditPrintJobInfo *pji, 
345
 
                          GtkTextIter       *start, 
346
 
                          GtkTextIter       *end, 
347
 
                          GtkWindow         *parent)
348
 
{
349
 
        show_printing_dialog (pji, parent);
350
 
 
351
 
        pji->parent = parent;
352
 
 
353
 
        g_signal_connect (pji->pjob, "begin_page", (GCallback) page_cb, pji);
354
 
        g_signal_connect (pji->pjob, "finished", (GCallback) preview_finished_cb, pji);
355
 
 
356
 
        if (!gtk_source_print_job_print_range_async (pji->pjob, start, end))
357
 
        {
358
 
                /* FIXME */
359
 
                g_warning ("Async print failed");
360
 
                gtk_widget_destroy (pji->dialog);
361
 
        }
362
 
}
363
 
 
364
 
static void 
365
 
gedit_print_real (GeditPrintJobInfo *pji, 
366
 
                  GtkTextIter       *start, 
367
 
                  GtkTextIter       *end, 
368
 
                  GtkWindow         *parent)
369
 
{
370
 
        show_printing_dialog (pji, parent);
371
 
 
372
 
        g_signal_connect (pji->pjob, "begin_page", (GCallback) page_cb, pji);
373
 
        g_signal_connect (pji->pjob, "finished", (GCallback) print_finished_cb, pji);
374
 
 
375
 
        if (!gtk_source_print_job_print_range_async (pji->pjob, start, end))
376
 
        {
377
 
                /* FIXME */
378
 
                g_warning ("Async print failed");
379
 
                gtk_widget_destroy (pji->dialog);
380
 
        }
381
 
}
382
 
 
383
 
void 
384
 
gedit_print_preview (GtkTextView *view)
385
 
{
386
 
        GeditPrintJobInfo *pji;
387
 
        GtkTextIter start, end;
388
 
 
389
 
        gedit_debug (DEBUG_PRINT, "");
390
 
                
391
 
        g_return_if_fail (view != NULL);
392
 
 
393
 
        pji = gedit_print_job_info_new (view);
394
 
 
395
 
        gtk_text_buffer_get_bounds (pji->doc, &start, &end);
396
 
 
397
 
        pji->preview = PREVIEW;
398
 
        gedit_print_preview_real (pji, &start, &end, 
399
 
                                  GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (view))));
400
 
}
401
 
 
402
 
static GeditPrintJobInfo *
403
 
gedit_print_job_info_new (GtkTextView* view)
404
 
{       
405
 
        GtkSourcePrintJob *pjob;
406
 
        GnomePrintConfig *config;
407
 
        GeditPrintJobInfo *pji;
408
 
        PangoContext *pango_context;
409
 
        PangoFontDescription *font_desc;
410
 
        GtkTextBuffer *buffer;
411
 
        
412
 
        gedit_debug (DEBUG_PRINT, "");
413
 
        
414
 
        g_return_val_if_fail (view != NULL, NULL);
415
 
 
416
 
        buffer = gtk_text_view_get_buffer (view);
417
 
        g_return_val_if_fail (buffer != NULL, NULL);
418
 
 
419
 
        config = gnome_print_config_default ();
420
 
        g_return_val_if_fail (config != NULL, NULL);
421
 
 
422
 
        gnome_print_config_set_int (config, (const guchar *) GNOME_PRINT_KEY_NUM_COPIES, 1);
423
 
        gnome_print_config_set_boolean (config, (const guchar *) GNOME_PRINT_KEY_COLLATE, FALSE);
424
 
 
425
 
        pjob = gtk_source_print_job_new_with_buffer (config, buffer);
426
 
        gnome_print_config_unref (config);
427
 
 
428
 
        gtk_source_print_job_set_highlight (pjob, TRUE);
429
 
        gtk_source_print_job_set_print_numbers (pjob, FALSE);
430
 
        gtk_source_print_job_set_wrap_mode (pjob, gtk_text_view_get_wrap_mode (view));
431
 
        gtk_source_print_job_set_tabs_width (pjob, 8);
432
 
        
433
 
        gtk_source_print_job_set_footer_format (pjob,
434
 
                                                _("Page %N of %Q"), 
435
 
                                                NULL, 
436
 
                                                /* xgettext:no-c-format */
437
 
                                                _("%A %x, %X"), 
438
 
                                                TRUE);
439
 
 
440
 
        gtk_source_print_job_set_print_header (pjob, FALSE);
441
 
        gtk_source_print_job_set_print_footer (pjob, TRUE);
442
 
 
443
 
        pango_context = gtk_widget_get_pango_context (GTK_WIDGET (view));
444
 
        font_desc = pango_context_get_font_description (pango_context);
445
 
 
446
 
        gtk_source_print_job_set_font_desc (pjob, font_desc);
447
 
 
448
 
        pji = g_new0 (GeditPrintJobInfo, 1);
449
 
 
450
 
        pji->pjob = pjob;
451
 
 
452
 
        pji->doc = buffer;
453
 
        pji->preview = PREVIEW_NO;
454
 
        pji->range_type = GNOME_PRINT_RANGE_ALL;
455
 
 
456
 
        return pji;
457
 
}
458