« back to all changes in this revision
Viewing changes to src/ui.c
- browse files at revision 18
- compare with another revision
- download diff
- download tarball
- view history from revision 18
- Committer: Package Import Robot
- Author(s): Alessio Treglia
- Date: 2011-08-30 12:58:27 UTC
- mfrom: (1.3.9 upstream) (14.1.3 sid)
- Revision ID: package-import@ubuntu.com-20110830125827-mwqlif9tedhve29x
Tags: 3.1.5-1
* New upstream release:
- Fix compile warnings
- Port to Vala
- Port to GTK3
- Port to GDBus
- Port to GSettings
- Port to colord
* debian/control:
- Port build-deps to Vala.
* Refresh patches.
* debian/watch: Look for *.bz2 tarballs.
- Fix compile warnings
- Port to Vala
- Port to GTK3
- Port to GDBus
- Port to GSettings
- Port to colord
* debian/control:
- Port build-deps to Vala.
* Refresh patches.
* debian/watch: Look for *.bz2 tarballs.
- files added:
- .pc
- .pc/01-zlib.patch
- .pc/01-zlib.patch/src
- .pc/20-lpi.patch
- .pc/20-lpi.patch/src
- files removed:
- data/simple-scan.schemas.in
- files modified:
- Makefile.in
added
removed
src/ui.c
1
/* ui.c generated by valac 0.13.1, the Vala compiler
2
* generated from ui.vala, do not modify */
3
1
4
/*
2
* Copyright (C) 2009 Canonical Ltd.
5
* Copyright (C) 2009-2011 Canonical Ltd.
3
6
* Author: Robert Ancell <robert.ancell@canonical.com>
4
*
7
*
5
8
* This program is free software: you can redistribute it and/or modify it under
6
9
* the terms of the GNU General Public License as published by the Free Software
7
10
* Foundation, either version 3 of the License, or (at your option) any later
9
12
* license.
10
13
*/
11
14
15
#include <glib.h>
16
#include <glib-object.h>
17
#include <gio/gio.h>
18
#include <gtk/gtk.h>
12
19
#include <stdlib.h>
13
20
#include <string.h>
14
#include <glib/gi18n.h>
15
#include <gtk/gtk.h>
16
#include <gconf/gconf-client.h>
21
#include <glib/gi18n-lib.h>
22
#include <glib/gstdio.h>
23
#include <unistd.h>
24
#include <cairo.h>
25
#include <float.h>
17
26
#include <math.h>
18
#include <unistd.h> // TEMP: Needed for close() in get_temporary_filename()
19
20
#include "ui.h"
21
#include "book-view.h"
22
23
24
#define DEFAULT_TEXT_DPI 150
25
#define DEFAULT_PHOTO_DPI 300
26
27
28
enum {
29
START_SCAN,
30
STOP_SCAN,
31
EMAIL,
32
QUIT,
33
LAST_SIGNAL
34
};
35
static guint signals[LAST_SIGNAL] = { 0, };
36
37
38
struct SimpleScanPrivate
39
{
40
GConfClient *client;
41
42
GtkBuilder *builder;
43
44
GtkWidget *window, *main_vbox;
45
GtkWidget *info_bar, *info_bar_image, *info_bar_label;
46
GtkWidget *info_bar_close_button, *info_bar_change_scanner_button;
47
GtkWidget *page_move_left_menuitem, *page_move_right_menuitem;
48
GtkWidget *page_delete_menuitem, *crop_rotate_menuitem;
49
GtkWidget *save_menuitem, *save_as_menuitem, *save_toolbutton;
50
GtkWidget *stop_menuitem, *stop_toolbutton;
51
52
GtkWidget *text_toolbar_menuitem, *text_menu_menuitem;
53
GtkWidget *photo_toolbar_menuitem, *photo_menu_menuitem;
54
55
GtkWidget *authorize_dialog;
56
GtkWidget *authorize_label;
57
GtkWidget *username_entry, *password_entry;
58
59
GtkWidget *preferences_dialog;
60
GtkWidget *device_combo, *text_dpi_combo, *photo_dpi_combo, *page_side_combo, *paper_size_combo;
61
GtkTreeModel *device_model, *text_dpi_model, *photo_dpi_model, *page_side_model, *paper_size_model;
62
gboolean setting_devices, user_selected_device;
63
64
gboolean have_error;
65
gchar *error_title, *error_text;
66
gboolean error_change_scanner_hint;
67
68
Book *book;
69
gchar *book_uri;
70
71
BookView *book_view;
72
gboolean updating_page_menu;
73
gint default_page_width, default_page_height, default_page_dpi;
74
ScanDirection default_page_scan_direction;
75
76
gchar *document_hint;
77
78
gchar *default_file_name;
79
gboolean scanning;
80
81
gint window_width, window_height;
82
gboolean window_is_maximized;
83
};
84
85
G_DEFINE_TYPE (SimpleScan, ui, G_TYPE_OBJECT);
86
87
static struct
88
{
89
const gchar *key;
90
ScanDirection scan_direction;
91
} scan_direction_keys[] =
92
{
93
{ "top-to-bottom", TOP_TO_BOTTOM },
94
{ "bottom-to-top", BOTTOM_TO_TOP },
95
{ "left-to-right", LEFT_TO_RIGHT },
96
{ "right-to-left", RIGHT_TO_LEFT },
97
{ NULL, 0 }
98
};
99
100
101
static gboolean
102
find_scan_device (SimpleScan *ui, const char *device, GtkTreeIter *iter)
103
{
104
gboolean have_iter = FALSE;
105
106
if (gtk_tree_model_get_iter_first (ui->priv->device_model, iter)) {
107
do {
108
gchar *d;
109
gtk_tree_model_get (ui->priv->device_model, iter, 0, &d, -1);
110
if (strcmp (d, device) == 0)
111
have_iter = TRUE;
112
g_free (d);
113
} while (!have_iter && gtk_tree_model_iter_next (ui->priv->device_model, iter));
114
}
115
116
return have_iter;
117
}
118
119
120
static void
121
show_error_dialog (SimpleScan *ui, const char *error_title, const char *error_text)
122
{
123
GtkWidget *dialog;
124
125
dialog = gtk_message_dialog_new (GTK_WINDOW (ui->priv->window),
126
GTK_DIALOG_MODAL,
127
GTK_MESSAGE_WARNING,
128
GTK_BUTTONS_NONE,
129
"%s", error_title);
130
gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CLOSE, 0);
131
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", error_text);
132
gtk_widget_destroy (dialog);
133
}
134
135
136
void
137
ui_set_default_file_name (SimpleScan *ui, const gchar *default_file_name)
138
{
139
g_free (ui->priv->default_file_name);
140
ui->priv->default_file_name = g_strdup (default_file_name);
141
}
142
143
144
void
145
ui_authorize (SimpleScan *ui, const gchar *resource, gchar **username, gchar **password)
146
{
147
GString *description;
148
149
description = g_string_new ("");
150
g_string_printf (description,
151
/* Label in authorization dialog. '%s' is replaced with the name of the resource requesting authorization */
152
_("Username and password required to access '%s'"),
153
resource);
154
155
gtk_entry_set_text (GTK_ENTRY (ui->priv->username_entry), *username ? *username : "");
156
gtk_entry_set_text (GTK_ENTRY (ui->priv->password_entry), "");
157
gtk_label_set_text (GTK_LABEL (ui->priv->authorize_label), description->str);
158
g_string_free (description, TRUE);
159
160
gtk_widget_show (ui->priv->authorize_dialog);
161
gtk_dialog_run (GTK_DIALOG (ui->priv->authorize_dialog));
162
gtk_widget_hide (ui->priv->authorize_dialog);
163
164
*username = g_strdup (gtk_entry_get_text (GTK_ENTRY (ui->priv->username_entry)));
165
*password = g_strdup (gtk_entry_get_text (GTK_ENTRY (ui->priv->password_entry)));
166
}
167
168
169
void device_combo_changed_cb (GtkWidget *widget, SimpleScan *ui);
170
G_MODULE_EXPORT
171
void
172
device_combo_changed_cb (GtkWidget *widget, SimpleScan *ui)
173
{
174
if (ui->priv->setting_devices)
175
return;
176
ui->priv->user_selected_device = TRUE;
177
}
178
179
180
static void
181
update_info_bar (SimpleScan *ui)
182
{
183
GtkMessageType type;
184
const gchar *title, *text, *image_id;
185
gchar *message;
186
gboolean show_close_button = FALSE;
187
gboolean show_change_scanner_button = FALSE;
188
189
if (ui->priv->have_error) {
190
type = GTK_MESSAGE_ERROR;
191
image_id = GTK_STOCK_DIALOG_ERROR;
192
title = ui->priv->error_title;
193
text = ui->priv->error_text;
194
show_close_button = TRUE;
195
show_change_scanner_button = ui->priv->error_change_scanner_hint;
196
}
197
else if (gtk_tree_model_iter_n_children (ui->priv->device_model, NULL) == 0) {
198
type = GTK_MESSAGE_WARNING;
199
image_id = GTK_STOCK_DIALOG_WARNING;
200
/* Warning displayed when no scanners are detected */
201
title = _("No scanners detected");
202
/* Hint to user on why there are no scanners detected */
203
text = _("Please check your scanner is connected and powered on");
204
}
205
else {
206
gtk_widget_hide (ui->priv->info_bar);
207
return;
208
}
209
210
gtk_info_bar_set_message_type (GTK_INFO_BAR (ui->priv->info_bar), type);
211
gtk_image_set_from_stock (GTK_IMAGE (ui->priv->info_bar_image), image_id, GTK_ICON_SIZE_DIALOG);
212
message = g_strdup_printf ("<big><b>%s</b></big>\n\n%s", title, text);
213
gtk_label_set_markup (GTK_LABEL (ui->priv->info_bar_label), message);
214
g_free (message);
215
gtk_widget_set_visible (ui->priv->info_bar_close_button, show_close_button);
216
gtk_widget_set_visible (ui->priv->info_bar_change_scanner_button, show_change_scanner_button);
217
gtk_widget_show (ui->priv->info_bar);
218
}
219
220
221
void
222
ui_set_scan_devices (SimpleScan *ui, GList *devices)
223
{
224
GList *d;
225
gboolean have_selection = FALSE;
226
gint index;
227
GtkTreeIter iter;
228
229
ui->priv->setting_devices = TRUE;
230
231
/* If the user hasn't chosen a scanner choose the best available one */
232
if (ui->priv->user_selected_device)
233
have_selection = gtk_combo_box_get_active (GTK_COMBO_BOX (ui->priv->device_combo)) >= 0;
234
235
/* Add new devices */
236
index = 0;
237
for (d = devices; d; d = d->next) {
238
ScanDevice *device = (ScanDevice *) d->data;
239
gint n_delete = -1;
240
241
/* Find if already exists */
242
if (gtk_tree_model_iter_nth_child (ui->priv->device_model, &iter, NULL, index)) {
243
gint i = 0;
244
do {
245
gchar *name;
246
gboolean matched;
247
248
gtk_tree_model_get (ui->priv->device_model, &iter, 0, &name, -1);
249
matched = strcmp (name, device->name) == 0;
250
g_free (name);
251
252
if (matched) {
253
n_delete = i;
254
break;
255
}
256
i++;
257
} while (gtk_tree_model_iter_next (ui->priv->device_model, &iter));
258
}
259
260
/* If exists, remove elements up to this one */
261
if (n_delete >= 0) {
262
gint i;
263
264
/* Update label */
265
gtk_list_store_set (GTK_LIST_STORE (ui->priv->device_model), &iter, 1, device->label, -1);
266
267
for (i = 0; i < n_delete; i++) {
268
gtk_tree_model_iter_nth_child (ui->priv->device_model, &iter, NULL, index);
269
gtk_list_store_remove (GTK_LIST_STORE (ui->priv->device_model), &iter);
270
}
271
}
272
else {
273
gtk_list_store_insert (GTK_LIST_STORE (ui->priv->device_model), &iter, index);
274
gtk_list_store_set (GTK_LIST_STORE (ui->priv->device_model), &iter, 0, device->name, 1, device->label, -1);
275
}
276
index++;
277
}
278
279
/* Remove any remaining devices */
280
while (gtk_tree_model_iter_nth_child (ui->priv->device_model, &iter, NULL, index))
281
gtk_list_store_remove (GTK_LIST_STORE (ui->priv->device_model), &iter);
282
283
/* Select the first available device */
284
if (!have_selection && devices != NULL)
285
gtk_combo_box_set_active (GTK_COMBO_BOX (ui->priv->device_combo), 0);
286
287
ui->priv->setting_devices = FALSE;
288
289
update_info_bar (ui);
290
}
291
292
293
static gchar *
294
get_selected_device (SimpleScan *ui)
295
{
296
GtkTreeIter iter;
297
298
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (ui->priv->device_combo), &iter)) {
299
gchar *device;
300
gtk_tree_model_get (ui->priv->device_model, &iter, 0, &device, -1);
301
return device;
302
}
303
304
return NULL;
305
}
306
307
308
void
309
ui_set_selected_device (SimpleScan *ui, const gchar *device)
310
{
311
GtkTreeIter iter;
312
313
if (!find_scan_device (ui, device, &iter))
314
return;
315
316
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (ui->priv->device_combo), &iter);
317
ui->priv->user_selected_device = TRUE;
318
}
319
320
321
static void
322
add_default_page (SimpleScan *ui)
323
{
324
Page *page;
325
326
page = book_append_page (ui->priv->book,
327
ui->priv->default_page_width,
328
ui->priv->default_page_height,
329
ui->priv->default_page_dpi,
330
ui->priv->default_page_scan_direction);
331
book_view_select_page (ui->priv->book_view, page);
332
}
333
334
335
static void
336
on_file_type_changed (GtkTreeSelection *selection, GtkWidget *dialog)
337
{
338
GtkTreeModel *model;
339
GtkTreeIter iter;
340
gchar *path, *filename, *extension, *new_filename;
341
342
if (!gtk_tree_selection_get_selected (selection, &model, &iter))
343
return;
344
345
gtk_tree_model_get (model, &iter, 1, &extension, -1);
346
path = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
347
filename = g_path_get_basename (path);
348
349
/* Replace extension */
350
if (g_strrstr (filename, "."))
351
new_filename = g_strdup_printf ("%.*s%s", (int)(g_strrstr (filename, ".") - filename), filename, extension);
352
else
353
new_filename = g_strdup_printf ("%s%s", filename, extension);
354
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), new_filename);
355
356
g_free (path);
357
g_free (filename);
358
g_free (new_filename);
359
g_free (extension);
360
}
361
362
363
static gchar *
364
choose_file_location (SimpleScan *ui)
365
{
366
GtkWidget *dialog;
367
gint response;
368
GtkFileFilter *filter;
369
GtkWidget *expander, *file_type_view;
370
GtkListStore *file_type_store;
371
GtkTreeIter iter;
372
GtkTreeViewColumn *column;
373
const gchar *extension;
374
gchar *directory, *uri = NULL;
375
gint i;
376
377
struct
378
{
379
gchar *label, *extension;
380
} file_types[] =
381
{
382
/* Save dialog: Label for saving in PDF format */
383
{ _("PDF (multi-page document)"), ".pdf" },
384
/* Save dialog: Label for saving in JPEG format */
385
{ _("JPEG (compressed)"), ".jpg" },
386
/* Save dialog: Label for saving in PNG format */
387
{ _("PNG (lossless)"), ".png" },
388
{ NULL, NULL }
389
};
390
391
/* Get directory to save to */
392
directory = gconf_client_get_string (ui->priv->client, GCONF_DIR "/save_directory", NULL);
393
if (!directory || directory[0] == '\0') {
394
g_free (directory);
395
directory = g_strdup (g_get_user_special_dir (G_USER_DIRECTORY_DOCUMENTS));
396
}
397
398
dialog = gtk_file_chooser_dialog_new (/* Save dialog: Dialog title */
399
_("Save As..."),
400
GTK_WINDOW (ui->priv->window),
401
GTK_FILE_CHOOSER_ACTION_SAVE,
402
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
403
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
404
NULL);
405
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
406
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (dialog), FALSE);
407
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), directory);
408
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), ui->priv->default_file_name);
409
g_free (directory);
410
411
/* Filter to only show images by default */
412
filter = gtk_file_filter_new ();
413
gtk_file_filter_set_name (filter,
414
/* Save dialog: Filter name to show only image files */
415
_("Image Files"));
416
gtk_file_filter_add_pixbuf_formats (filter);
417
gtk_file_filter_add_mime_type (filter, "application/pdf");
418
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
419
filter = gtk_file_filter_new ();
420
gtk_file_filter_set_name (filter,
421
/* Save dialog: Filter name to show all files */
422
_("All Files"));
423
gtk_file_filter_add_pattern (filter, "*");
424
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
425
426
expander = gtk_expander_new_with_mnemonic (/* */
427
_("Select File _Type"));
428
gtk_expander_set_spacing (GTK_EXPANDER (expander), 5);
429
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog), expander);
430
431
extension = strstr (ui->priv->default_file_name, ".");
432
if (!extension)
433
extension = "";
434
435
file_type_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
436
for (i = 0; file_types[i].label; i++) {
437
gtk_list_store_append (file_type_store, &iter);
438
gtk_list_store_set (file_type_store, &iter, 0, file_types[i].label, 1, file_types[i].extension, -1);
439
}
440
441
file_type_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (file_type_store));
442
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (file_type_view), FALSE);
443
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (file_type_view), TRUE);
444
column = gtk_tree_view_column_new_with_attributes ("",
445
gtk_cell_renderer_text_new (),
446
"text", 0, NULL);
447
gtk_tree_view_append_column (GTK_TREE_VIEW (file_type_view), column);
448
gtk_container_add (GTK_CONTAINER (expander), file_type_view);
449
450
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (file_type_store), &iter)) {
451
do {
452
gchar *e;
453
gtk_tree_model_get (GTK_TREE_MODEL (file_type_store), &iter, 1, &e, -1);
454
if (strcmp (extension, e) == 0)
455
gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (file_type_view)), &iter);
456
g_free (e);
457
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (file_type_store), &iter));
458
}
459
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (file_type_view)),
460
"changed",
461
G_CALLBACK (on_file_type_changed),
462
dialog);
463
464
gtk_widget_show_all (expander);
465
466
response = gtk_dialog_run (GTK_DIALOG (dialog));
467
468
if (response == GTK_RESPONSE_ACCEPT)
469
uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog));
470
471
gconf_client_set_string (ui->priv->client, GCONF_DIR "/save_directory",
472
gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog)),
473
NULL);
474
475
gtk_widget_destroy (dialog);
476
477
return uri;
478
}
479
480
481
static gboolean
482
save_document (SimpleScan *ui, gboolean force_choose_location)
483
{
484
gboolean result;
485
gchar *uri, *uri_lower;
486
GError *error = NULL;
487
GFile *file;
488
489
if (ui->priv->book_uri && !force_choose_location)
490
uri = g_strdup (ui->priv->book_uri);
491
else
492
uri = choose_file_location (ui);
493
if (!uri)
494
return FALSE;
495
496
file = g_file_new_for_uri (uri);
497
498
g_debug ("Saving to '%s'", uri);
499
500
uri_lower = g_utf8_strdown (uri, -1);
501
if (g_str_has_suffix (uri_lower, ".pdf"))
502
result = book_save (ui->priv->book, "pdf", file, &error);
503
else if (g_str_has_suffix (uri_lower, ".ps"))
504
result = book_save (ui->priv->book, "ps", file, &error);
505
else if (g_str_has_suffix (uri_lower, ".png"))
506
result = book_save (ui->priv->book, "png", file, &error);
507
else if (g_str_has_suffix (uri_lower, ".tif") || g_str_has_suffix (uri_lower, ".tiff"))
508
result = book_save (ui->priv->book, "tiff", file, &error);
509
else
510
result = book_save (ui->priv->book, "jpeg", file, &error);
511
512
g_free (uri_lower);
513
514
if (result) {
515
g_free (ui->priv->book_uri);
516
ui->priv->book_uri = uri;
517
book_set_needs_saving (ui->priv->book, FALSE);
518
}
519
else {
520
g_free (uri);
521
522
g_warning ("Error saving file: %s", error->message);
523
ui_show_error (ui,
524
/* Title of error dialog when save failed */
525
_("Failed to save file"),
526
error->message,
527
FALSE);
528
g_clear_error (&error);
529
}
530
531
g_object_unref (file);
532
533
return result;
534
}
535
536
537
static gboolean
538
prompt_to_save (SimpleScan *ui, const gchar *title, const gchar *discard_label)
539
{
540
GtkWidget *dialog;
541
gint response;
542
543
if (!book_get_needs_saving (ui->priv->book))
544
return TRUE;
545
546
dialog = gtk_message_dialog_new (GTK_WINDOW (ui->priv->window),
547
GTK_DIALOG_MODAL,
548
GTK_MESSAGE_WARNING,
549
GTK_BUTTONS_NONE,
550
"%s", title);
551
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s",
552
/* Text in dialog warning when a document is about to be lost*/
553
_("If you don't save, changes will be permanently lost."));
554
gtk_dialog_add_button (GTK_DIALOG (dialog), discard_label, GTK_RESPONSE_NO);
555
gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
556
gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_SAVE, GTK_RESPONSE_YES);
557
558
response = gtk_dialog_run (GTK_DIALOG (dialog));
559
gtk_widget_destroy (dialog);
560
561
switch (response) {
562
case GTK_RESPONSE_YES:
563
if (save_document (ui, FALSE))
564
return TRUE;
565
else
566
return FALSE;
567
case GTK_RESPONSE_CANCEL:
568
return FALSE;
569
case GTK_RESPONSE_NO:
570
default:
571
return TRUE;
572
}
573
}
574
575
576
static void
577
clear_document (SimpleScan *ui)
578
{
579
book_clear (ui->priv->book);
580
add_default_page (ui);
581
g_free (ui->priv->book_uri);
582
ui->priv->book_uri = NULL;
583
book_set_needs_saving (ui->priv->book, FALSE);
584
gtk_widget_set_sensitive (ui->priv->save_as_menuitem, FALSE);
585
}
586
587
588
void new_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
589
G_MODULE_EXPORT
590
void
591
new_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
592
{
593
if (!prompt_to_save (ui,
594
/* Text in dialog warning when a document is about to be lost */
595
_("Save current document?"),
596
/* Button in dialog to create new document and discard unsaved document */
597
_("Discard Changes")))
598
return;
599
600
clear_document (ui);
601
}
602
603
604
static void
605
set_document_hint (SimpleScan *ui, const gchar *document_hint)
606
{
607
g_free (ui->priv->document_hint);
608
ui->priv->document_hint = g_strdup (document_hint);
609
610
if (strcmp (document_hint, "text") == 0) {
611
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (ui->priv->text_toolbar_menuitem), TRUE);
612
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (ui->priv->text_menu_menuitem), TRUE);
613
}
614
else if (strcmp (document_hint, "photo") == 0) {
615
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (ui->priv->photo_toolbar_menuitem), TRUE);
616
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (ui->priv->photo_menu_menuitem), TRUE);
617
}
618
}
619
620
621
void text_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
622
G_MODULE_EXPORT
623
void
624
text_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
625
{
626
if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
627
set_document_hint (ui, "text");
628
}
629
630
631
void photo_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
632
G_MODULE_EXPORT
633
void
634
photo_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
635
{
636
if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
637
set_document_hint (ui, "photo");
638
}
639
640
641
static void
642
set_page_side (SimpleScan *ui, const gchar *document_hint)
643
{
644
GtkTreeIter iter;
645
646
if (gtk_tree_model_get_iter_first (ui->priv->page_side_model, &iter)) {
647
do {
648
gchar *d;
649
gboolean have_match;
650
651
gtk_tree_model_get (ui->priv->page_side_model, &iter, 0, &d, -1);
652
have_match = strcmp (d, document_hint) == 0;
653
g_free (d);
654
655
if (have_match) {
656
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (ui->priv->page_side_combo), &iter);
657
return;
658
}
659
} while (gtk_tree_model_iter_next (ui->priv->page_side_model, &iter));
660
}
661
}
662
663
664
static void
665
set_paper_size (SimpleScan *ui, gint width, gint height)
666
{
667
GtkTreeIter iter;
668
gboolean have_iter;
669
670
for (have_iter = gtk_tree_model_get_iter_first (ui->priv->paper_size_model, &iter);
671
have_iter;
672
have_iter = gtk_tree_model_iter_next (ui->priv->paper_size_model, &iter)) {
673
gint w, h;
674
675
gtk_tree_model_get (ui->priv->paper_size_model, &iter, 0, &w, 1, &h, -1);
676
if (w == width && h == height)
677
break;
678
}
679
680
if (!have_iter)
681
have_iter = gtk_tree_model_get_iter_first (ui->priv->paper_size_model, &iter);
682
if (have_iter)
683
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (ui->priv->paper_size_combo), &iter);
684
}
685
686
687
static gint
688
get_text_dpi (SimpleScan *ui)
689
{
690
GtkTreeIter iter;
691
gint dpi = DEFAULT_TEXT_DPI;
692
693
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (ui->priv->text_dpi_combo), &iter))
694
gtk_tree_model_get (ui->priv->text_dpi_model, &iter, 0, &dpi, -1);
695
696
return dpi;
697
}
698
699
700
static gint
701
get_photo_dpi (SimpleScan *ui)
702
{
703
GtkTreeIter iter;
704
gint dpi = DEFAULT_PHOTO_DPI;
705
706
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (ui->priv->photo_dpi_combo), &iter))
707
gtk_tree_model_get (ui->priv->photo_dpi_model, &iter, 0, &dpi, -1);
708
709
return dpi;
710
}
711
712
713
static gchar *
714
get_page_side (SimpleScan *ui)
715
{
716
GtkTreeIter iter;
717
gchar *mode = NULL;
718
719
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (ui->priv->page_side_combo), &iter))
720
gtk_tree_model_get (ui->priv->page_side_model, &iter, 0, &mode, -1);
721
722
return mode;
723
}
724
725
726
static gboolean
727
get_paper_size (SimpleScan *ui, gint *width, gint *height)
728
{
729
GtkTreeIter iter;
730
731
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (ui->priv->paper_size_combo), &iter)) {
732
gtk_tree_model_get (ui->priv->paper_size_model, &iter, 0, width, 1, height, -1);
733
return TRUE;
734
}
735
736
return FALSE;
737
}
738
739
740
static ScanOptions *
741
get_scan_options (SimpleScan *ui)
742
{
743
struct {
744
const gchar *name;
745
ScanMode mode;
746
gint depth;
747
} profiles[] =
748
{
749
{ "text", SCAN_MODE_GRAY, 2 },
750
{ "photo", SCAN_MODE_COLOR, 8 },
751
{ NULL, SCAN_MODE_COLOR, 8 }
752
};
753
gint i;
754
ScanOptions *options;
755
756
/* Find this profile */
757
// FIXME: Move this into scan-profile.c
758
for (i = 0; profiles[i].name && strcmp (profiles[i].name, ui->priv->document_hint) != 0; i++);
759
760
options = g_malloc0 (sizeof (ScanOptions));
761
options->scan_mode = profiles[i].mode;
762
options->depth = profiles[i].depth;
763
if (options->scan_mode == SCAN_MODE_COLOR)
764
options->dpi = get_photo_dpi (ui);
765
else
766
options->dpi = get_text_dpi (ui);
767
get_paper_size (ui, &options->paper_width, &options->paper_height);
768
769
return options;
770
}
771
772
773
void scan_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
774
G_MODULE_EXPORT
775
void
776
scan_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
777
{
778
gchar *device;
779
ScanOptions *options;
780
781
device = get_selected_device (ui);
782
783
options = get_scan_options (ui);
784
options->type = SCAN_SINGLE;
785
g_signal_emit (G_OBJECT (ui), signals[START_SCAN], 0, device, options);
786
g_free (device);
787
g_free (options);
788
}
789
790
791
void stop_scan_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
792
G_MODULE_EXPORT
793
void
794
stop_scan_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
795
{
796
g_signal_emit (G_OBJECT (ui), signals[STOP_SCAN], 0);
797
}
798
799
800
void continuous_scan_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
801
G_MODULE_EXPORT
802
void
803
continuous_scan_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
804
{
805
if (ui->priv->scanning) {
806
g_signal_emit (G_OBJECT (ui), signals[STOP_SCAN], 0);
807
} else {
808
gchar *device, *side;
809
ScanOptions *options;
810
811
device = get_selected_device (ui);
812
options = get_scan_options (ui);
813
side = get_page_side (ui);
814
if (strcmp (side, "front") == 0)
815
options->type = SCAN_ADF_FRONT;
816
else if (strcmp (side, "back") == 0)
817
options->type = SCAN_ADF_BACK;
818
else
819
options->type = SCAN_ADF_BOTH;
820
821
g_signal_emit (G_OBJECT (ui), signals[START_SCAN], 0, device, options);
822
g_free (device);
823
g_free (side);
824
g_free (options);
825
}
826
}
827
828
829
void preferences_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
830
G_MODULE_EXPORT
831
void
832
preferences_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
833
{
834
gtk_window_present (GTK_WINDOW (ui->priv->preferences_dialog));
835
}
836
837
838
gboolean preferences_dialog_delete_event_cb (GtkWidget *widget, SimpleScan *ui);
839
G_MODULE_EXPORT
840
gboolean
841
preferences_dialog_delete_event_cb (GtkWidget *widget, SimpleScan *ui)
842
{
843
return TRUE;
844
}
845
846
847
void preferences_dialog_response_cb (GtkWidget *widget, gint response_id, SimpleScan *ui);
848
G_MODULE_EXPORT
849
void
850
preferences_dialog_response_cb (GtkWidget *widget, gint response_id, SimpleScan *ui)
851
{
852
gtk_widget_hide (ui->priv->preferences_dialog);
853
}
854
855
856
static void
857
update_page_menu (SimpleScan *ui)
858
{
859
Book *book;
860
gint index;
861
862
book = book_view_get_book (ui->priv->book_view);
863
index = book_get_page_index (book, book_view_get_selected (ui->priv->book_view));
864
gtk_widget_set_sensitive (ui->priv->page_move_left_menuitem, index > 0);
865
gtk_widget_set_sensitive (ui->priv->page_move_right_menuitem, index < book_get_n_pages (book) - 1);
866
}
867
868
869
static void
870
page_selected_cb (BookView *view, Page *page, SimpleScan *ui)
871
{
872
char *name = NULL;
873
874
if (page == NULL)
875
return;
876
877
ui->priv->updating_page_menu = TRUE;
878
879
update_page_menu (ui);
880
881
if (page_has_crop (page)) {
882
char *crop_name;
883
884
// FIXME: Make more generic, move into page-size.c and reuse
885
crop_name = page_get_named_crop (page);
886
if (crop_name) {
887
if (strcmp (crop_name, "A4") == 0)
888
name = "a4_menuitem";
889
else if (strcmp (crop_name, "A5") == 0)
890
name = "a5_menuitem";
891
else if (strcmp (crop_name, "A6") == 0)
892
name = "a6_menuitem";
893
else if (strcmp (crop_name, "letter") == 0)
894
name = "letter_menuitem";
895
else if (strcmp (crop_name, "legal") == 0)
896
name = "legal_menuitem";
897
else if (strcmp (crop_name, "4x6") == 0)
898
name = "4x6_menuitem";
899
g_free (crop_name);
900
}
901
else
902
name = "custom_crop_menuitem";
903
}
904
else
905
name = "no_crop_menuitem";
906
907
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (ui->priv->builder, name)), TRUE);
908
gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (gtk_builder_get_object (ui->priv->builder, "crop_toolbutton")), page_has_crop (page));
909
910
ui->priv->updating_page_menu = FALSE;
911
}
912
913
914
// FIXME: Duplicated from simple-scan.c
915
static gchar *
916
get_temporary_filename (const gchar *prefix, const gchar *extension)
917
{
918
gint fd;
919
gchar *filename, *path;
920
GError *error = NULL;
921
922
/* NOTE: I'm not sure if this is a 100% safe strategy to use g_file_open_tmp(), close and
923
* use the filename but it appears to work in practise */
924
925
filename = g_strdup_printf ("%s-XXXXXX.%s", prefix, extension);
926
fd = g_file_open_tmp (filename, &path, &error);
927
g_free (filename);
928
if (fd < 0) {
929
g_warning ("Error saving page for viewing: %s", error->message);
930
g_clear_error (&error);
931
return NULL;
932
}
933
close (fd);
934
935
return path;
936
}
937
938
939
static void
940
show_page_cb (BookView *view, Page *page, SimpleScan *ui)
941
{
942
gchar *path;
943
GFile *file;
944
GdkScreen *screen;
945
GError *error = NULL;
946
947
path = get_temporary_filename ("scanned-page", "tiff");
948
if (!path)
949
return;
950
file = g_file_new_for_path (path);
951
g_free (path);
952
953
screen = gtk_widget_get_screen (GTK_WIDGET (ui->priv->window));
954
955
if (page_save (page, "tiff", file, &error)) {
956
gchar *uri = g_file_get_uri (file);
957
gtk_show_uri (screen, uri, gtk_get_current_event_time (), &error);
958
g_free (uri);
959
}
960
961
g_object_unref (file);
962
963
if (error) {
964
show_error_dialog (ui,
965
/* Error message display when unable to preview image */
966
_("Unable to open image preview application"),
967
error->message);
968
g_clear_error (&error);
969
}
970
}
971
972
973
static void
974
show_page_menu_cb (BookView *view, SimpleScan *ui)
975
{
976
gtk_menu_popup (GTK_MENU (gtk_builder_get_object (ui->priv->builder, "page_menu")), NULL, NULL, NULL, NULL,
977
3, gtk_get_current_event_time());
978
}
979
980
981
void rotate_left_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
982
G_MODULE_EXPORT
983
void
984
rotate_left_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
985
{
986
Page *page;
987
988
if (ui->priv->updating_page_menu)
989
return;
990
page = book_view_get_selected (ui->priv->book_view);
991
page_rotate_left (page);
992
}
993
994
995
void rotate_right_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
996
G_MODULE_EXPORT
997
void
998
rotate_right_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
999
{
1000
Page *page;
1001
1002
if (ui->priv->updating_page_menu)
1003
return;
1004
page = book_view_get_selected (ui->priv->book_view);
1005
page_rotate_right (page);
1006
}
1007
1008
1009
static void
1010
set_crop (SimpleScan *ui, const gchar *crop_name)
1011
{
1012
Page *page;
1013
1014
gtk_widget_set_sensitive (ui->priv->crop_rotate_menuitem, crop_name != NULL);
1015
1016
if (ui->priv->updating_page_menu)
1017
return;
1018
1019
page = book_view_get_selected (ui->priv->book_view);
1020
if (!page)
1021
return;
1022
1023
if (!crop_name) {
1024
page_set_no_crop (page);
1025
return;
1026
}
1027
1028
if (strcmp (crop_name, "custom") == 0) {
1029
gint width, height, crop_width, crop_height;
1030
1031
width = page_get_width (page);
1032
height = page_get_height (page);
1033
1034
crop_width = (int) (width * 0.8 + 0.5);
1035
crop_height = (int) (height * 0.8 + 0.5);
1036
page_set_custom_crop (page, crop_width, crop_height);
1037
page_move_crop (page, (width - crop_width) / 2, (height - crop_height) / 2);
1038
1039
return;
1040
}
1041
1042
page_set_named_crop (page, crop_name);
1043
}
1044
1045
1046
void no_crop_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
1047
G_MODULE_EXPORT
1048
void
1049
no_crop_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
1050
{
1051
if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
1052
set_crop (ui, NULL);
1053
}
1054
1055
1056
void custom_crop_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
1057
G_MODULE_EXPORT
1058
void
1059
custom_crop_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
1060
{
1061
if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
1062
set_crop (ui, "custom");
1063
}
1064
1065
void crop_toolbutton_toggled_cb (GtkWidget *widget, SimpleScan *ui);
1066
G_MODULE_EXPORT
1067
void
1068
crop_toolbutton_toggled_cb (GtkWidget *widget, SimpleScan *ui)
1069
{
1070
if (ui->priv->updating_page_menu)
1071
return;
1072
1073
if (gtk_toggle_tool_button_get_active (GTK_TOGGLE_TOOL_BUTTON (widget)))
1074
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (ui->priv->builder, "custom_crop_menuitem")), TRUE);
1075
else
1076
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (ui->priv->builder, "no_crop_menuitem")), TRUE);
1077
}
1078
1079
1080
void four_by_six_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
1081
G_MODULE_EXPORT
1082
void
1083
four_by_six_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
1084
{
1085
if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
1086
set_crop (ui, "4x6");
1087
}
1088
1089
1090
void legal_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
1091
G_MODULE_EXPORT
1092
void
1093
legal_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
1094
{
1095
if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
1096
set_crop (ui, "legal");
1097
}
1098
1099
1100
void letter_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
1101
G_MODULE_EXPORT
1102
void
1103
letter_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
1104
{
1105
if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
1106
set_crop (ui, "letter");
1107
}
1108
1109
1110
void a6_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
1111
G_MODULE_EXPORT
1112
void
1113
a6_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
1114
{
1115
if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
1116
set_crop (ui, "A6");
1117
}
1118
1119
1120
void a5_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
1121
G_MODULE_EXPORT
1122
void
1123
a5_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
1124
{
1125
if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
1126
set_crop (ui, "A5");
1127
}
1128
1129
1130
void a4_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
1131
G_MODULE_EXPORT
1132
void
1133
a4_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
1134
{
1135
if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
1136
set_crop (ui, "A4");
1137
}
1138
1139
1140
void crop_rotate_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui);
1141
G_MODULE_EXPORT
1142
void
1143
crop_rotate_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui)
1144
{
1145
Page *page;
1146
1147
page = book_view_get_selected (ui->priv->book_view);
1148
if (!page)
1149
return;
1150
1151
page_rotate_crop (page);
1152
}
1153
1154
1155
void page_move_left_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui);
1156
G_MODULE_EXPORT
1157
void
1158
page_move_left_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui)
1159
{
1160
Book *book = book_view_get_book (ui->priv->book_view);
1161
Page *page = book_view_get_selected (ui->priv->book_view);
1162
gint index;
1163
1164
index = book_get_page_index (book, page);
1165
if (index > 0)
1166
book_move_page (book, page, index - 1);
1167
1168
update_page_menu (ui);
1169
}
1170
1171
1172
void page_move_right_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui);
1173
G_MODULE_EXPORT
1174
void
1175
page_move_right_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui)
1176
{
1177
Book *book = book_view_get_book (ui->priv->book_view);
1178
Page *page = book_view_get_selected (ui->priv->book_view);
1179
gint index;
1180
1181
index = book_get_page_index (book, page);
1182
if (index < book_get_n_pages (book) - 1)
1183
book_move_page (book, page, book_get_page_index (book, page) + 1);
1184
1185
update_page_menu (ui);
1186
}
1187
1188
1189
void page_delete_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui);
1190
G_MODULE_EXPORT
1191
void
1192
page_delete_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui)
1193
{
1194
book_delete_page (book_view_get_book (ui->priv->book_view),
1195
book_view_get_selected (ui->priv->book_view));
1196
}
1197
1198
1199
void save_file_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
1200
G_MODULE_EXPORT
1201
void
1202
save_file_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
1203
{
1204
save_document (ui, FALSE);
1205
}
1206
1207
1208
void save_as_file_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
1209
G_MODULE_EXPORT
1210
void
1211
save_as_file_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
1212
{
1213
save_document (ui, TRUE);
1214
}
1215
1216
1217
static void
1218
draw_page (GtkPrintOperation *operation,
1219
GtkPrintContext *print_context,
1220
gint page_number,
1221
SimpleScan *ui)
1222
{
1223
cairo_t *context;
1224
Page *page;
1225
GdkPixbuf *image;
1226
gboolean is_landscape = FALSE;
1227
1228
context = gtk_print_context_get_cairo_context (print_context);
1229
1230
page = book_get_page (ui->priv->book, page_number);
1231
1232
/* Rotate to same aspect */
1233
if (gtk_print_context_get_width (print_context) > gtk_print_context_get_height (print_context))
1234
is_landscape = TRUE;
1235
if (page_is_landscape (page) != is_landscape) {
1236
cairo_translate (context, gtk_print_context_get_width (print_context), 0);
1237
cairo_rotate (context, M_PI_2);
1238
}
1239
1240
cairo_scale (context,
1241
gtk_print_context_get_dpi_x (print_context) / page_get_dpi (page),
1242
gtk_print_context_get_dpi_y (print_context) / page_get_dpi (page));
1243
1244
image = page_get_image (page, TRUE);
1245
gdk_cairo_set_source_pixbuf (context, image, 0, 0);
1246
cairo_paint (context);
1247
1248
g_object_unref (image);
1249
}
1250
1251
1252
void email_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
1253
G_MODULE_EXPORT
1254
void
1255
email_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
1256
{
1257
g_signal_emit (G_OBJECT (ui), signals[EMAIL], 0, ui->priv->document_hint);
1258
}
1259
1260
1261
void print_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
1262
G_MODULE_EXPORT
1263
void
1264
print_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
1265
{
1266
GtkPrintOperation *print;
1267
GtkPrintOperationResult result;
1268
GError *error = NULL;
1269
1270
print = gtk_print_operation_new ();
1271
gtk_print_operation_set_n_pages (print, book_get_n_pages (ui->priv->book));
1272
g_signal_connect (print, "draw-page", G_CALLBACK (draw_page), ui);
1273
1274
result = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
1275
GTK_WINDOW (ui->priv->window), &error);
1276
1277
g_object_unref (print);
1278
}
1279
1280
1281
void help_contents_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui);
1282
G_MODULE_EXPORT
1283
void
1284
help_contents_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui)
1285
{
1286
GdkScreen *screen;
1287
GError *error = NULL;
1288
1289
screen = gtk_widget_get_screen (GTK_WIDGET (ui->priv->window));
1290
gtk_show_uri (screen, "ghelp:simple-scan", gtk_get_current_event_time (), &error);
1291
1292
if (error)
1293
{
1294
show_error_dialog (ui,
1295
/* Error message displayed when unable to launch help browser */
1296
_("Unable to open help file"),
1297
error->message);
1298
g_clear_error (&error);
1299
}
1300
}
1301
1302
1303
void about_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui);
1304
G_MODULE_EXPORT
1305
void
1306
about_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui)
1307
{
1308
const gchar *authors[] = { "Robert Ancell <robert.ancell@canonical.com>", NULL };
1309
1310
/* The license this software is under (GPL3+) */
1311
const char *license = _("This program is free software: you can redistribute it and/or modify\n"
1312
"it under the terms of the GNU General Public License as published by\n"
1313
"the Free Software Foundation, either version 3 of the License, or\n"
1314
"(at your option) any later version.\n"
1315
"\n"
1316
"This program is distributed in the hope that it will be useful,\n"
1317
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1318
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
1319
"GNU General Public License for more details.\n"
1320
"\n"
1321
"You should have received a copy of the GNU General Public License\n"
1322
"along with this program. If not, see <http://www.gnu.org/licenses/>.");
1323
1324
/* Title of about dialog */
1325
const char *title = _("About Simple Scan");
1326
1327
/* Description of program */
1328
const char *description = _("Simple document scanning tool");
1329
1330
gtk_show_about_dialog (GTK_WINDOW (ui->priv->window),
1331
"title", title,
1332
"program-name", "Simple Scan",
1333
"version", VERSION,
1334
"comments", description,
1335
"logo-icon-name", "scanner",
1336
"authors", authors,
1337
"translator-credits", _("translator-credits"),
1338
"website", "https://launchpad.net/simple-scan",
1339
"copyright", "Copyright © 2009 Canonical Ltd.",
1340
"license", license,
1341
"wrap-license", TRUE,
1342
NULL);
1343
}
1344
1345
1346
static gboolean
1347
quit (SimpleScan *ui)
1348
{
1349
char *device;
1350
gint paper_width = 0, paper_height = 0;
1351
gint i;
1352
1353
if (!prompt_to_save (ui,
1354
/* Text in dialog warning when a document is about to be lost */
1355
_("Save document before quitting?"),
1356
/* Button in dialog to quit and discard unsaved document */
1357
_("Quit without Saving")))
1358
return FALSE;
1359
1360
device = get_selected_device (ui);
1361
if (device) {
1362
gconf_client_set_string(ui->priv->client, GCONF_DIR "/selected_device", device, NULL);
1363
g_free (device);
1364
}
1365
1366
gconf_client_set_string (ui->priv->client, GCONF_DIR "/document_type", ui->priv->document_hint, NULL);
1367
gconf_client_set_int (ui->priv->client, GCONF_DIR "/text_dpi", get_text_dpi (ui), NULL);
1368
gconf_client_set_int (ui->priv->client, GCONF_DIR "/photo_dpi", get_photo_dpi (ui), NULL);
1369
gconf_client_set_string (ui->priv->client, GCONF_DIR "/page_side", get_page_side (ui), NULL);
1370
get_paper_size (ui, &paper_width, &paper_height);
1371
gconf_client_set_int (ui->priv->client, GCONF_DIR "/paper_width", paper_width, NULL);
1372
gconf_client_set_int (ui->priv->client, GCONF_DIR "/paper_height", paper_height, NULL);
1373
1374
gconf_client_set_int(ui->priv->client, GCONF_DIR "/window_width", ui->priv->window_width, NULL);
1375
gconf_client_set_int(ui->priv->client, GCONF_DIR "/window_height", ui->priv->window_height, NULL);
1376
gconf_client_set_bool(ui->priv->client, GCONF_DIR "/window_is_maximized", ui->priv->window_is_maximized, NULL);
1377
1378
for (i = 0; scan_direction_keys[i].key != NULL && scan_direction_keys[i].scan_direction != ui->priv->default_page_scan_direction; i++);
1379
if (scan_direction_keys[i].key != NULL)
1380
gconf_client_set_string(ui->priv->client, GCONF_DIR "/scan_direction", scan_direction_keys[i].key, NULL);
1381
gconf_client_set_int (ui->priv->client, GCONF_DIR "/page_width", ui->priv->default_page_width, NULL);
1382
gconf_client_set_int (ui->priv->client, GCONF_DIR "/page_height", ui->priv->default_page_height, NULL);
1383
gconf_client_set_int (ui->priv->client, GCONF_DIR "/page_dpi", ui->priv->default_page_dpi, NULL);
1384
1385
g_signal_emit (G_OBJECT (ui), signals[QUIT], 0);
1386
1387
return TRUE;
1388
}
1389
1390
1391
void quit_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui);
1392
G_MODULE_EXPORT
1393
void
1394
quit_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui)
1395
{
1396
quit (ui);
1397
}
1398
1399
1400
gboolean simple_scan_window_configure_event_cb (GtkWidget *widget, GdkEventConfigure *event, SimpleScan *ui);
1401
G_MODULE_EXPORT
1402
gboolean
1403
simple_scan_window_configure_event_cb (GtkWidget *widget, GdkEventConfigure *event, SimpleScan *ui)
1404
{
1405
if (!ui->priv->window_is_maximized) {
1406
ui->priv->window_width = event->width;
1407
ui->priv->window_height = event->height;
1408
}
1409
1410
return FALSE;
1411
}
1412
1413
1414
static void
1415
info_bar_response_cb (GtkWidget *widget, gint response_id, SimpleScan *ui)
1416
{
1417
if (response_id == 1) {
1418
gtk_widget_grab_focus (ui->priv->device_combo);
1419
gtk_window_present (GTK_WINDOW (ui->priv->preferences_dialog));
1420
}
1421
else {
1422
ui->priv->have_error = FALSE;
1423
g_free (ui->priv->error_title);
1424
ui->priv->error_title = NULL;
1425
g_free (ui->priv->error_text);
1426
ui->priv->error_text = NULL;
1427
update_info_bar (ui);
1428
}
1429
}
1430
1431
1432
gboolean simple_scan_window_window_state_event_cb (GtkWidget *widget, GdkEventWindowState *event, SimpleScan *ui);
1433
G_MODULE_EXPORT
1434
gboolean
1435
simple_scan_window_window_state_event_cb (GtkWidget *widget, GdkEventWindowState *event, SimpleScan *ui)
1436
{
1437
if (event->changed_mask & GDK_WINDOW_STATE_MAXIMIZED)
1438
ui->priv->window_is_maximized = (event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) != 0;
1439
return FALSE;
1440
}
1441
1442
1443
gboolean window_delete_event_cb (GtkWidget *widget, GdkEvent *event, SimpleScan *ui);
1444
G_MODULE_EXPORT
1445
gboolean
1446
window_delete_event_cb (GtkWidget *widget, GdkEvent *event, SimpleScan *ui)
1447
{
1448
return !quit (ui);
1449
}
1450
1451
1452
static void
1453
page_size_changed_cb (Page *page, SimpleScan *ui)
1454
{
1455
ui->priv->default_page_width = page_get_width (page);
1456
ui->priv->default_page_height = page_get_height (page);
1457
ui->priv->default_page_dpi = page_get_dpi (page);
1458
}
1459
1460
1461
static void
1462
page_scan_direction_changed_cb (Page *page, SimpleScan *ui)
1463
{
1464
ui->priv->default_page_scan_direction = page_get_scan_direction (page);
1465
}
1466
1467
1468
static void
1469
page_added_cb (Book *book, Page *page, SimpleScan *ui)
1470
{
1471
ui->priv->default_page_width = page_get_width (page);
1472
ui->priv->default_page_height = page_get_height (page);
1473
ui->priv->default_page_dpi = page_get_dpi (page);
1474
ui->priv->default_page_scan_direction = page_get_scan_direction (page);
1475
g_signal_connect (page, "size-changed", G_CALLBACK (page_size_changed_cb), ui);
1476
g_signal_connect (page, "scan-direction-changed", G_CALLBACK (page_scan_direction_changed_cb), ui);
1477
1478
update_page_menu (ui);
1479
}
1480
1481
1482
static void
1483
page_removed_cb (Book *book, Page *page, SimpleScan *ui)
1484
{
1485
/* If this is the last page add a new blank one */
1486
if (book_get_n_pages (ui->priv->book) == 1)
1487
add_default_page (ui);
1488
1489
update_page_menu (ui);
1490
}
1491
1492
1493
static void
1494
set_dpi_combo (GtkWidget *combo, gint default_dpi, gint current_dpi)
1495
{
1496
struct
1497
{
1498
gint dpi;
1499
const gchar *label;
1500
} scan_resolutions[] =
1501
{
1502
/* Preferences dialog: Label for minimum resolution in resolution list */
1503
{ 75, _("%d dpi (draft)") },
1504
/* Preferences dialog: Label for resolution value in resolution list (dpi = dots per inch) */
1505
{ 150, _("%d dpi") },
1506
{ 300, _("%d dpi") },
1507
{ 600, _("%d dpi") },
1508
/* Preferences dialog: Label for maximum resolution in resolution list */
1509
{ 1200, _("%d dpi (high resolution)") },
1510
{ 2400, _("%d dpi") },
1511
{ -1, NULL }
1512
};
1513
GtkCellRenderer *renderer;
1514
GtkTreeModel *model;
1515
gint i;
1516
1517
renderer = gtk_cell_renderer_text_new();
1518
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
1519
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer, "text", 1);
1520
1521
model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
1522
for (i = 0; scan_resolutions[i].dpi > 0; i++)
1523
{
1524
GtkTreeIter iter;
1525
gchar *label;
1526
gint dpi;
1527
1528
dpi = scan_resolutions[i].dpi;
1529
1530
if (dpi == default_dpi)
1531
label = g_strdup_printf (/* Preferences dialog: Label for default resolution in resolution list */
1532
_("%d dpi (default)"), dpi);
1533
else
1534
label = g_strdup_printf (scan_resolutions[i].label, dpi);
1535
1536
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
1537
gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, dpi, 1, label, -1);
1538
1539
if (dpi == current_dpi)
1540
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo), &iter);
1541
1542
g_free (label);
1543
}
1544
}
1545
1546
1547
static void
1548
needs_saving_cb (Book *book, GParamSpec *param, SimpleScan *ui)
1549
{
1550
gtk_widget_set_sensitive (ui->priv->save_menuitem, book_get_needs_saving (book));
1551
gtk_widget_set_sensitive (ui->priv->save_toolbutton, book_get_needs_saving (book));
1552
if (book_get_needs_saving (book))
1553
gtk_widget_set_sensitive (ui->priv->save_as_menuitem, TRUE);
1554
}
1555
1556
1557
static void
1558
ui_load (SimpleScan *ui)
1559
{
1560
GtkBuilder *builder;
1561
GError *error = NULL;
1562
GtkWidget *hbox;
1563
GtkCellRenderer *renderer;
1564
gchar *device, *document_type, *scan_direction, *page_side;
1565
gint dpi, paper_width, paper_height;
1566
1567
gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (), ICON_DIR);
1568
1569
gtk_window_set_default_icon_name ("scanner");
1570
1571
builder = ui->priv->builder = gtk_builder_new ();
1572
gtk_builder_add_from_file (builder, UI_DIR "simple-scan.ui", &error);
1573
if (error) {
1574
g_critical ("Unable to load UI: %s\n", error->message);
1575
show_error_dialog (ui,
1576
/* Title of dialog when cannot load required files */
1577
_("Files missing"),
1578
/* Description in dialog when cannot load required files */
1579
_("Please check your installation"));
1580
exit (1);
1581
}
1582
gtk_builder_connect_signals (builder, ui);
1583
1584
ui->priv->window = GTK_WIDGET (gtk_builder_get_object (builder, "simple_scan_window"));
1585
ui->priv->main_vbox = GTK_WIDGET (gtk_builder_get_object (builder, "main_vbox"));
1586
ui->priv->page_move_left_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "page_move_left_menuitem"));
1587
ui->priv->page_move_right_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "page_move_right_menuitem"));
1588
ui->priv->page_delete_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "page_delete_menuitem"));
1589
ui->priv->crop_rotate_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "crop_rotate_menuitem"));
1590
ui->priv->save_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "save_menuitem"));
1591
ui->priv->save_as_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "save_as_menuitem"));
1592
ui->priv->save_toolbutton = GTK_WIDGET (gtk_builder_get_object (builder, "save_toolbutton"));
1593
ui->priv->stop_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "stop_scan_menuitem"));
1594
ui->priv->stop_toolbutton = GTK_WIDGET (gtk_builder_get_object (builder, "stop_toolbutton"));
1595
1596
ui->priv->text_toolbar_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "text_toolbutton_menuitem"));
1597
ui->priv->text_menu_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "text_menuitem"));
1598
ui->priv->photo_toolbar_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "photo_toolbutton_menuitem"));
1599
ui->priv->photo_menu_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "photo_menuitem"));
1600
1601
ui->priv->authorize_dialog = GTK_WIDGET (gtk_builder_get_object (builder, "authorize_dialog"));
1602
ui->priv->authorize_label = GTK_WIDGET (gtk_builder_get_object (builder, "authorize_label"));
1603
ui->priv->username_entry = GTK_WIDGET (gtk_builder_get_object (builder, "username_entry"));
1604
ui->priv->password_entry = GTK_WIDGET (gtk_builder_get_object (builder, "password_entry"));
1605
1606
ui->priv->preferences_dialog = GTK_WIDGET (gtk_builder_get_object (builder, "preferences_dialog"));
1607
ui->priv->device_combo = GTK_WIDGET (gtk_builder_get_object (builder, "device_combo"));
1608
ui->priv->device_model = gtk_combo_box_get_model (GTK_COMBO_BOX (ui->priv->device_combo));
1609
ui->priv->text_dpi_combo = GTK_WIDGET (gtk_builder_get_object (builder, "text_dpi_combo"));
1610
ui->priv->text_dpi_model = gtk_combo_box_get_model (GTK_COMBO_BOX (ui->priv->text_dpi_combo));
1611
ui->priv->photo_dpi_combo = GTK_WIDGET (gtk_builder_get_object (builder, "photo_dpi_combo"));
1612
ui->priv->photo_dpi_model = gtk_combo_box_get_model (GTK_COMBO_BOX (ui->priv->photo_dpi_combo));
1613
ui->priv->page_side_combo = GTK_WIDGET (gtk_builder_get_object (builder, "page_side_combo"));
1614
ui->priv->page_side_model = gtk_combo_box_get_model (GTK_COMBO_BOX (ui->priv->page_side_combo));
1615
ui->priv->paper_size_combo = GTK_WIDGET (gtk_builder_get_object (builder, "paper_size_combo"));
1616
ui->priv->paper_size_model = gtk_combo_box_get_model (GTK_COMBO_BOX (ui->priv->paper_size_combo));
1617
1618
/* Add InfoBar (not supported in Glade) */
1619
ui->priv->info_bar = gtk_info_bar_new ();
1620
g_signal_connect (ui->priv->info_bar, "response", G_CALLBACK (info_bar_response_cb), ui);
1621
gtk_box_pack_start (GTK_BOX(ui->priv->main_vbox), ui->priv->info_bar, FALSE, TRUE, 0);
1622
hbox = gtk_hbox_new (FALSE, 12);
1623
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (ui->priv->info_bar))), hbox);
1624
gtk_widget_show (hbox);
1625
1626
ui->priv->info_bar_image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG);
1627
gtk_box_pack_start (GTK_BOX(hbox), ui->priv->info_bar_image, FALSE, TRUE, 0);
1628
gtk_widget_show (ui->priv->info_bar_image);
1629
1630
ui->priv->info_bar_label = gtk_label_new (NULL);
1631
gtk_misc_set_alignment (GTK_MISC (ui->priv->info_bar_label), 0.0, 0.5);
1632
gtk_box_pack_start (GTK_BOX(hbox), ui->priv->info_bar_label, TRUE, TRUE, 0);
1633
gtk_widget_show (ui->priv->info_bar_label);
1634
1635
ui->priv->info_bar_close_button = gtk_info_bar_add_button (GTK_INFO_BAR (ui->priv->info_bar), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
1636
ui->priv->info_bar_change_scanner_button = gtk_info_bar_add_button (GTK_INFO_BAR (ui->priv->info_bar),
1637
/* Button in error infobar to open preferences dialog and change scanner */
1638
_("Change _Scanner"), 1);
1639
1640
GtkTreeIter iter;
1641
gtk_list_store_append (GTK_LIST_STORE (ui->priv->paper_size_model), &iter);
1642
gtk_list_store_set (GTK_LIST_STORE (ui->priv->paper_size_model), &iter, 0, 0, 1, 0, 2,
1643
/* Combo box value for automatic paper size */
1644
_("Automatic"), -1);
1645
gtk_list_store_append (GTK_LIST_STORE (ui->priv->paper_size_model), &iter);
1646
gtk_list_store_set (GTK_LIST_STORE (ui->priv->paper_size_model), &iter, 0, 1050, 1, 1480, 2, "A6", -1);
1647
gtk_list_store_append (GTK_LIST_STORE (ui->priv->paper_size_model), &iter);
1648
gtk_list_store_set (GTK_LIST_STORE (ui->priv->paper_size_model), &iter, 0, 1480, 1, 2100, 2, "A5", -1);
1649
gtk_list_store_append (GTK_LIST_STORE (ui->priv->paper_size_model), &iter);
1650
gtk_list_store_set (GTK_LIST_STORE (ui->priv->paper_size_model), &iter, 0, 2100, 1, 2970, 2, "A4", -1);
1651
gtk_list_store_append (GTK_LIST_STORE (ui->priv->paper_size_model), &iter);
1652
gtk_list_store_set (GTK_LIST_STORE (ui->priv->paper_size_model), &iter, 0, 2159, 1, 2794, 2, "Letter", -1);
1653
gtk_list_store_append (GTK_LIST_STORE (ui->priv->paper_size_model), &iter);
1654
gtk_list_store_set (GTK_LIST_STORE (ui->priv->paper_size_model), &iter, 0, 2159, 1, 3556, 2, "Legal", -1);
1655
gtk_list_store_append (GTK_LIST_STORE (ui->priv->paper_size_model), &iter);
1656
gtk_list_store_set (GTK_LIST_STORE (ui->priv->paper_size_model), &iter, 0, 1016, 1, 1524, 2, "4×6", -1);
1657
1658
dpi = gconf_client_get_int (ui->priv->client, GCONF_DIR "/text_dpi", NULL);
1659
if (dpi <= 0)
1660
dpi = DEFAULT_TEXT_DPI;
1661
set_dpi_combo (ui->priv->text_dpi_combo, DEFAULT_TEXT_DPI, dpi);
1662
dpi = gconf_client_get_int (ui->priv->client, GCONF_DIR "/photo_dpi", NULL);
1663
if (dpi <= 0)
1664
dpi = DEFAULT_PHOTO_DPI;
1665
set_dpi_combo (ui->priv->photo_dpi_combo, DEFAULT_PHOTO_DPI, dpi);
1666
1667
renderer = gtk_cell_renderer_text_new();
1668
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (ui->priv->device_combo), renderer, TRUE);
1669
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (ui->priv->device_combo), renderer, "text", 1);
1670
1671
renderer = gtk_cell_renderer_text_new();
1672
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (ui->priv->page_side_combo), renderer, TRUE);
1673
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (ui->priv->page_side_combo), renderer, "text", 1);
1674
page_side = gconf_client_get_string (ui->priv->client, GCONF_DIR "/page_side", NULL);
1675
if (page_side) {
1676
set_page_side (ui, page_side);
1677
g_free (page_side);
1678
}
1679
1680
renderer = gtk_cell_renderer_text_new();
1681
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (ui->priv->paper_size_combo), renderer, TRUE);
1682
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (ui->priv->paper_size_combo), renderer, "text", 2);
1683
paper_width = gconf_client_get_int (ui->priv->client, GCONF_DIR "/paper_width", NULL);
1684
paper_height = gconf_client_get_int (ui->priv->client, GCONF_DIR "/paper_height", NULL);
1685
set_paper_size (ui, paper_width, paper_height);
1686
1687
device = gconf_client_get_string (ui->priv->client, GCONF_DIR "/selected_device", NULL);
1688
if (device) {
1689
GtkTreeIter iter;
1690
if (find_scan_device (ui, device, &iter))
1691
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (ui->priv->device_combo), &iter);
1692
g_free (device);
1693
}
1694
1695
document_type = gconf_client_get_string (ui->priv->client, GCONF_DIR "/document_type", NULL);
1696
if (document_type) {
1697
set_document_hint (ui, document_type);
1698
g_free (document_type);
1699
}
1700
1701
ui->priv->book_view = book_view_new (ui->priv->book);
1702
gtk_container_set_border_width (GTK_CONTAINER (ui->priv->book_view), 18);
1703
gtk_box_pack_end (GTK_BOX (ui->priv->main_vbox), GTK_WIDGET (ui->priv->book_view), TRUE, TRUE, 0);
1704
g_signal_connect (ui->priv->book_view, "page-selected", G_CALLBACK (page_selected_cb), ui);
1705
g_signal_connect (ui->priv->book_view, "show-page", G_CALLBACK (show_page_cb), ui);
1706
g_signal_connect (ui->priv->book_view, "show-menu", G_CALLBACK (show_page_menu_cb), ui);
1707
gtk_widget_show (GTK_WIDGET (ui->priv->book_view));
1708
1709
/* Find default page details */
1710
scan_direction = gconf_client_get_string(ui->priv->client, GCONF_DIR "/scan_direction", NULL);
1711
ui->priv->default_page_scan_direction = TOP_TO_BOTTOM;
1712
if (scan_direction) {
1713
gint i;
1714
for (i = 0; scan_direction_keys[i].key != NULL && strcmp (scan_direction_keys[i].key, scan_direction) != 0; i++);
1715
if (scan_direction_keys[i].key != NULL)
1716
ui->priv->default_page_scan_direction = scan_direction_keys[i].scan_direction;
1717
g_free (scan_direction);
1718
}
1719
ui->priv->default_page_width = gconf_client_get_int (ui->priv->client, GCONF_DIR "/page_width", NULL);
1720
if (ui->priv->default_page_width <= 0)
1721
ui->priv->default_page_width = 595;
1722
ui->priv->default_page_height = gconf_client_get_int (ui->priv->client, GCONF_DIR "/page_height", NULL);
1723
if (ui->priv->default_page_height <= 0)
1724
ui->priv->default_page_height = 842;
1725
ui->priv->default_page_dpi = gconf_client_get_int (ui->priv->client, GCONF_DIR "/page_dpi", NULL);
1726
if (ui->priv->default_page_dpi <= 0)
1727
ui->priv->default_page_dpi = 72;
1728
1729
/* Restore window size */
1730
ui->priv->window_width = gconf_client_get_int (ui->priv->client, GCONF_DIR "/window_width", NULL);
1731
if (ui->priv->window_width <= 0)
1732
ui->priv->window_width = 600;
1733
ui->priv->window_height = gconf_client_get_int (ui->priv->client, GCONF_DIR "/window_height", NULL);
1734
if (ui->priv->window_height <= 0)
1735
ui->priv->window_height = 400;
1736
g_debug ("Restoring window to %dx%d pixels", ui->priv->window_width, ui->priv->window_height);
1737
gtk_window_set_default_size (GTK_WINDOW (ui->priv->window), ui->priv->window_width, ui->priv->window_height);
1738
ui->priv->window_is_maximized = gconf_client_get_bool (ui->priv->client, GCONF_DIR "/window_is_maximized", NULL);
1739
if (ui->priv->window_is_maximized) {
1740
g_debug ("Restoring window to maximized");
1741
gtk_window_maximize (GTK_WINDOW (ui->priv->window));
1742
}
1743
1744
if (book_get_n_pages (ui->priv->book) == 0)
1745
add_default_page (ui);
1746
book_set_needs_saving (ui->priv->book, FALSE);
1747
g_signal_connect (ui->priv->book, "notify::needs-saving", G_CALLBACK (needs_saving_cb), ui);
1748
}
1749
1750
1751
SimpleScan *
1752
ui_new ()
1753
{
1754
return g_object_new (SIMPLE_SCAN_TYPE, NULL);
1755
}
1756
1757
1758
Book *
1759
ui_get_book (SimpleScan *ui)
1760
{
1761
return g_object_ref (ui->priv->book);
1762
}
1763
1764
1765
void
1766
ui_set_selected_page (SimpleScan *ui, Page *page)
1767
{
1768
book_view_select_page (ui->priv->book_view, page);
1769
}
1770
1771
1772
Page *
1773
ui_get_selected_page (SimpleScan *ui)
1774
{
1775
return book_view_get_selected (ui->priv->book_view);
1776
}
1777
1778
1779
void
1780
ui_set_scanning (SimpleScan *ui, gboolean scanning)
1781
{
1782
ui->priv->scanning = scanning;
1783
gtk_widget_set_sensitive (ui->priv->page_delete_menuitem, !scanning);
1784
gtk_widget_set_sensitive (ui->priv->stop_menuitem, scanning);
1785
gtk_widget_set_sensitive (ui->priv->stop_toolbutton, scanning);
1786
}
1787
1788
1789
void
1790
ui_show_error (SimpleScan *ui, const gchar *error_title, const gchar *error_text, gboolean change_scanner_hint)
1791
{
1792
ui->priv->have_error = TRUE;
1793
g_free (ui->priv->error_title);
1794
ui->priv->error_title = g_strdup (error_title);
1795
g_free (ui->priv->error_text);
1796
ui->priv->error_text = g_strdup (error_text);
1797
ui->priv->error_change_scanner_hint = change_scanner_hint;
1798
update_info_bar (ui);
1799
}
1800
1801
1802
void
1803
ui_start (SimpleScan *ui)
1804
{
1805
gtk_widget_show (ui->priv->window);
1806
}
1807
1808
1809
/* Generated with glib-genmarshal */
1810
static void
1811
g_cclosure_user_marshal_VOID__STRING_POINTER (GClosure *closure,
1812
GValue *return_value G_GNUC_UNUSED,
1813
guint n_param_values,
1814
const GValue *param_values,
1815
gpointer invocation_hint G_GNUC_UNUSED,
1816
gpointer marshal_data)
1817
{
1818
typedef void (*GMarshalFunc_VOID__STRING_POINTER) (gpointer data1,
1819
gconstpointer arg_1,
1820
gconstpointer arg_2,
1821
gpointer data2);
1822
register GMarshalFunc_VOID__STRING_POINTER callback;
1823
register GCClosure *cc = (GCClosure*) closure;
1824
register gpointer data1, data2;
1825
1826
g_return_if_fail (n_param_values == 3);
1827
1828
if (G_CCLOSURE_SWAP_DATA (closure))
1829
{
1830
data1 = closure->data;
1831
data2 = g_value_peek_pointer (param_values + 0);
1832
}
1833
else
1834
{
1835
data1 = g_value_peek_pointer (param_values + 0);
1836
data2 = closure->data;
1837
}
1838
callback = (GMarshalFunc_VOID__STRING_POINTER) (marshal_data ? marshal_data : cc->callback);
1839
1840
callback (data1,
1841
g_value_get_string (param_values + 1),
1842
g_value_get_pointer (param_values + 2),
1843
data2);
1844
}
1845
1846
1847
static void
1848
ui_finalize (GObject *object)
1849
{
1850
SimpleScan *ui = SIMPLE_SCAN (object);
1851
1852
g_object_unref (ui->priv->client);
1853
ui->priv->client = NULL;
1854
g_object_unref (ui->priv->builder);
1855
ui->priv->builder = NULL;
1856
g_object_unref (ui->priv->book);
1857
ui->priv->book = NULL;
1858
gtk_widget_destroy (GTK_WIDGET (ui->priv->book_view));
1859
ui->priv->book_view = NULL;
1860
1861
G_OBJECT_CLASS (ui_parent_class)->finalize (object);
1862
}
1863
1864
1865
static void
1866
ui_class_init (SimpleScanClass *klass)
1867
{
1868
GObjectClass *object_class = G_OBJECT_CLASS (klass);
1869
1870
object_class->finalize = ui_finalize;
1871
1872
signals[START_SCAN] =
1873
g_signal_new ("start-scan",
1874
G_TYPE_FROM_CLASS (klass),
1875
G_SIGNAL_RUN_LAST,
1876
G_STRUCT_OFFSET (SimpleScanClass, start_scan),
1877
NULL, NULL,
1878
g_cclosure_user_marshal_VOID__STRING_POINTER,
1879
G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_POINTER);
1880
signals[STOP_SCAN] =
1881
g_signal_new ("stop-scan",
1882
G_TYPE_FROM_CLASS (klass),
1883
G_SIGNAL_RUN_LAST,
1884
G_STRUCT_OFFSET (SimpleScanClass, stop_scan),
1885
NULL, NULL,
1886
g_cclosure_marshal_VOID__VOID,
1887
G_TYPE_NONE, 0);
1888
signals[EMAIL] =
1889
g_signal_new ("email",
1890
G_TYPE_FROM_CLASS (klass),
1891
G_SIGNAL_RUN_LAST,
1892
G_STRUCT_OFFSET (SimpleScanClass, email),
1893
NULL, NULL,
1894
g_cclosure_marshal_VOID__STRING,
1895
G_TYPE_NONE, 1, G_TYPE_STRING);
1896
signals[QUIT] =
1897
g_signal_new ("quit",
1898
G_TYPE_FROM_CLASS (klass),
1899
G_SIGNAL_RUN_LAST,
1900
G_STRUCT_OFFSET (SimpleScanClass, quit),
1901
NULL, NULL,
1902
g_cclosure_marshal_VOID__VOID,
1903
G_TYPE_NONE, 0);
1904
1905
g_type_class_add_private (klass, sizeof (SimpleScanPrivate));
1906
}
1907
1908
1909
static void
1910
ui_init (SimpleScan *ui)
1911
{
1912
ui->priv = G_TYPE_INSTANCE_GET_PRIVATE (ui, SIMPLE_SCAN_TYPE, SimpleScanPrivate);
1913
1914
ui->priv->book = book_new ();
1915
g_signal_connect (ui->priv->book, "page-removed", G_CALLBACK (page_removed_cb), ui);
1916
g_signal_connect (ui->priv->book, "page-added", G_CALLBACK (page_added_cb), ui);
1917
1918
ui->priv->client = gconf_client_get_default();
1919
gconf_client_add_dir(ui->priv->client, GCONF_DIR, GCONF_CLIENT_PRELOAD_NONE, NULL);
1920
1921
ui->priv->document_hint = g_strdup ("photo");
1922
ui->priv->default_file_name = g_strdup (_("Scanned Document.pdf"));
1923
ui->priv->scanning = FALSE;
1924
ui_load (ui);
1925
}
27
#include <gdk-pixbuf/gdk-pixdata.h>
28
#include <gdk/gdk.h>
29
#include <config.h>
30
#include <gobject/gvaluecollector.h>
31
32
33
#define TYPE_SIMPLE_SCAN (simple_scan_get_type ())
34
#define SIMPLE_SCAN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SIMPLE_SCAN, SimpleScan))
35
#define SIMPLE_SCAN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SIMPLE_SCAN, SimpleScanClass))
36
#define IS_SIMPLE_SCAN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SIMPLE_SCAN))
37
#define IS_SIMPLE_SCAN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SIMPLE_SCAN))
38
#define SIMPLE_SCAN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SIMPLE_SCAN, SimpleScanClass))
39
40
typedef struct _SimpleScan SimpleScan;
41
typedef struct _SimpleScanClass SimpleScanClass;
42
typedef struct _SimpleScanPrivate SimpleScanPrivate;
43
44
#define TYPE_BOOK (book_get_type ())
45
#define BOOK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_BOOK, Book))
46
#define BOOK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_BOOK, BookClass))
47
#define IS_BOOK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_BOOK))
48
#define IS_BOOK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_BOOK))
49
#define BOOK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_BOOK, BookClass))
50
51
typedef struct _Book Book;
52
typedef struct _BookClass BookClass;
53
54
#define TYPE_BOOK_VIEW (book_view_get_type ())
55
#define BOOK_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_BOOK_VIEW, BookView))
56
#define BOOK_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_BOOK_VIEW, BookViewClass))
57
#define IS_BOOK_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_BOOK_VIEW))
58
#define IS_BOOK_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_BOOK_VIEW))
59
#define BOOK_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_BOOK_VIEW, BookViewClass))
60
61
typedef struct _BookView BookView;
62
typedef struct _BookViewClass BookViewClass;
63
64
#define TYPE_SCAN_DIRECTION (scan_direction_get_type ())
65
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
66
#define _g_free0(var) (var = (g_free (var), NULL))
67
#define _book_unref0(var) ((var == NULL) ? NULL : (var = (book_unref (var), NULL)))
68
69
#define TYPE_PAGE (page_get_type ())
70
#define PAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PAGE, Page))
71
#define PAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PAGE, PageClass))
72
#define IS_PAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PAGE))
73
#define IS_PAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PAGE))
74
#define PAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PAGE, PageClass))
75
76
typedef struct _Page Page;
77
typedef struct _PageClass PageClass;
78
79
#define TYPE_SCAN_DEVICE (scan_device_get_type ())
80
#define SCAN_DEVICE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SCAN_DEVICE, ScanDevice))
81
#define SCAN_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SCAN_DEVICE, ScanDeviceClass))
82
#define IS_SCAN_DEVICE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SCAN_DEVICE))
83
#define IS_SCAN_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SCAN_DEVICE))
84
#define SCAN_DEVICE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SCAN_DEVICE, ScanDeviceClass))
85
86
typedef struct _ScanDevice ScanDevice;
87
typedef struct _ScanDeviceClass ScanDeviceClass;
88
typedef struct _ScanDevicePrivate ScanDevicePrivate;
89
#define _scan_device_unref0(var) ((var == NULL) ? NULL : (var = (scan_device_unref (var), NULL)))
90
#define _page_unref0(var) ((var == NULL) ? NULL : (var = (page_unref (var), NULL)))
91
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
92
93
#define TYPE_SCAN_TYPE (scan_type_get_type ())
94
95
#define TYPE_SCAN_OPTIONS (scan_options_get_type ())
96
#define SCAN_OPTIONS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SCAN_OPTIONS, ScanOptions))
97
#define SCAN_OPTIONS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SCAN_OPTIONS, ScanOptionsClass))
98
#define IS_SCAN_OPTIONS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SCAN_OPTIONS))
99
#define IS_SCAN_OPTIONS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SCAN_OPTIONS))
100
#define SCAN_OPTIONS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SCAN_OPTIONS, ScanOptionsClass))
101
102
typedef struct _ScanOptions ScanOptions;
103
typedef struct _ScanOptionsClass ScanOptionsClass;
104
105
#define TYPE_SCAN_MODE (scan_mode_get_type ())
106
typedef struct _ScanOptionsPrivate ScanOptionsPrivate;
107
#define _scan_options_unref0(var) ((var == NULL) ? NULL : (var = (scan_options_unref (var), NULL)))
108
#define _cairo_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_destroy (var), NULL)))
109
typedef struct _ParamSpecSimpleScan ParamSpecSimpleScan;
110
111
struct _SimpleScan {
112
GTypeInstance parent_instance;
113
volatile int ref_count;
114
SimpleScanPrivate * priv;
115
};
116
117
struct _SimpleScanClass {
118
GTypeClass parent_class;
119
void (*finalize) (SimpleScan *self);
120
};
121
122
typedef enum {
123
SCAN_DIRECTION_TOP_TO_BOTTOM,
124
SCAN_DIRECTION_LEFT_TO_RIGHT,
125
SCAN_DIRECTION_BOTTOM_TO_TOP,
126
SCAN_DIRECTION_RIGHT_TO_LEFT
127
} ScanDirection;
128
129
struct _SimpleScanPrivate {
130
GSettings* settings;
131
GtkBuilder* builder;
132
GtkWindow* window;
133
GtkVBox* main_vbox;
134
GtkInfoBar* info_bar;
135
GtkImage* info_bar_image;
136
GtkLabel* info_bar_label;
137
GtkButton* info_bar_close_button;
138
GtkButton* info_bar_change_scanner_button;
139
GtkMenuItem* page_move_left_menuitem;
140
GtkMenuItem* page_move_right_menuitem;
141
GtkMenuItem* page_delete_menuitem;
142
GtkMenuItem* crop_rotate_menuitem;
143
GtkMenuItem* save_menuitem;
144
GtkMenuItem* save_as_menuitem;
145
GtkToolButton* save_toolbutton;
146
GtkMenuItem* stop_menuitem;
147
GtkToolButton* stop_toolbutton;
148
GtkRadioMenuItem* text_toolbar_menuitem;
149
GtkRadioMenuItem* text_menu_menuitem;
150
GtkRadioMenuItem* photo_toolbar_menuitem;
151
GtkRadioMenuItem* photo_menu_menuitem;
152
GtkDialog* authorize_dialog;
153
GtkLabel* authorize_label;
154
GtkEntry* username_entry;
155
GtkEntry* password_entry;
156
GtkDialog* preferences_dialog;
157
GtkComboBox* device_combo;
158
GtkComboBox* text_dpi_combo;
159
GtkComboBox* photo_dpi_combo;
160
GtkComboBox* page_side_combo;
161
GtkComboBox* paper_size_combo;
162
GtkListStore* device_model;
163
GtkListStore* text_dpi_model;
164
GtkListStore* photo_dpi_model;
165
GtkListStore* page_side_model;
166
GtkListStore* paper_size_model;
167
gboolean setting_devices;
168
gboolean user_selected_device;
169
GtkFileChooserDialog* save_dialog;
170
gboolean have_error;
171
gchar* error_title;
172
gchar* error_text;
173
gboolean error_change_scanner_hint;
174
Book* book;
175
gchar* book_uri;
176
BookView* book_view;
177
gboolean updating_page_menu;
178
gint default_page_width;
179
gint default_page_height;
180
gint default_page_dpi;
181
ScanDirection default_page_scan_direction;
182
gchar* document_hint;
183
gchar* default_file_name;
184
gboolean scanning;
185
gint window_width;
186
gint window_height;
187
gboolean window_is_maximized;
188
};
189
190
struct _ScanDevice {
191
GTypeInstance parent_instance;
192
volatile int ref_count;
193
ScanDevicePrivate * priv;
194
gchar* name;
195
gchar* label;
196
};
197
198
struct _ScanDeviceClass {
199
GTypeClass parent_class;
200
void (*finalize) (ScanDevice *self);
201
};
202
203
typedef enum {
204
SCAN_TYPE_SINGLE,
205
SCAN_TYPE_ADF_FRONT,
206
SCAN_TYPE_ADF_BACK,
207
SCAN_TYPE_ADF_BOTH
208
} ScanType;
209
210
typedef enum {
211
SCAN_MODE_DEFAULT,
212
SCAN_MODE_COLOR,
213
SCAN_MODE_GRAY,
214
SCAN_MODE_LINEART
215
} ScanMode;
216
217
struct _ScanOptions {
218
GTypeInstance parent_instance;
219
volatile int ref_count;
220
ScanOptionsPrivate * priv;
221
gint dpi;
222
ScanMode scan_mode;
223
gint depth;
224
ScanType type;
225
gint paper_width;
226
gint paper_height;
227
};
228
229
struct _ScanOptionsClass {
230
GTypeClass parent_class;
231
void (*finalize) (ScanOptions *self);
232
};
233
234
struct _ParamSpecSimpleScan {
235
GParamSpec parent_instance;
236
};
237
238
239
static gpointer simple_scan_parent_class = NULL;
240
241
gpointer simple_scan_ref (gpointer instance);
242
void simple_scan_unref (gpointer instance);
243
GParamSpec* param_spec_simple_scan (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
244
void value_set_simple_scan (GValue* value, gpointer v_object);
245
void value_take_simple_scan (GValue* value, gpointer v_object);
246
gpointer value_get_simple_scan (const GValue* value);
247
GType simple_scan_get_type (void) G_GNUC_CONST;
248
gpointer book_ref (gpointer instance);
249
void book_unref (gpointer instance);
250
GParamSpec* param_spec_book (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
251
void value_set_book (GValue* value, gpointer v_object);
252
void value_take_book (GValue* value, gpointer v_object);
253
gpointer value_get_book (const GValue* value);
254
GType book_get_type (void) G_GNUC_CONST;
255
GType book_view_get_type (void) G_GNUC_CONST;
256
GType scan_direction_get_type (void) G_GNUC_CONST;
257
#define SIMPLE_SCAN_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_SIMPLE_SCAN, SimpleScanPrivate))
258
enum {
259
SIMPLE_SCAN_DUMMY_PROPERTY
260
};
261
#define SIMPLE_SCAN_DEFAULT_TEXT_DPI 150
262
#define SIMPLE_SCAN_DEFAULT_PHOTO_DPI 300
263
SimpleScan* simple_scan_new (void);
264
SimpleScan* simple_scan_construct (GType object_type);
265
Book* book_new (void);
266
Book* book_construct (GType object_type);
267
gpointer page_ref (gpointer instance);
268
void page_unref (gpointer instance);
269
GParamSpec* param_spec_page (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
270
void value_set_page (GValue* value, gpointer v_object);
271
void value_take_page (GValue* value, gpointer v_object);
272
gpointer value_get_page (const GValue* value);
273
GType page_get_type (void) G_GNUC_CONST;
274
static void simple_scan_page_removed_cb (SimpleScan* self, Book* book, Page* page);
275
static void _simple_scan_page_removed_cb_book_page_removed (Book* _sender, Page* page, gpointer self);
276
static void simple_scan_page_added_cb (SimpleScan* self, Book* book, Page* page);
277
static void _simple_scan_page_added_cb_book_page_added (Book* _sender, Page* page, gpointer self);
278
static void simple_scan_load (SimpleScan* self);
279
static gboolean simple_scan_find_scan_device (SimpleScan* self, const gchar* device, GtkTreeIter* iter);
280
static void simple_scan_show_error_dialog (SimpleScan* self, const gchar* error_title, const gchar* error_text);
281
void simple_scan_set_default_file_name (SimpleScan* self, const gchar* default_file_name);
282
void simple_scan_authorize (SimpleScan* self, const gchar* resource, gchar** username, gchar** password);
283
void G_MODULE_EXPORT device_combo_changed_cb (GtkWidget* widget, SimpleScan* self);
284
static void simple_scan_update_info_bar (SimpleScan* self);
285
gpointer scan_device_ref (gpointer instance);
286
void scan_device_unref (gpointer instance);
287
GParamSpec* param_spec_scan_device (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
288
void value_set_scan_device (GValue* value, gpointer v_object);
289
void value_take_scan_device (GValue* value, gpointer v_object);
290
gpointer value_get_scan_device (const GValue* value);
291
GType scan_device_get_type (void) G_GNUC_CONST;
292
void simple_scan_set_scan_devices (SimpleScan* self, GList* devices);
293
static gchar* simple_scan_get_selected_device (SimpleScan* self);
294
void simple_scan_set_selected_device (SimpleScan* self, const gchar* device);
295
static void simple_scan_add_default_page (SimpleScan* self);
296
Page* book_append_page (Book* self, gint width, gint height, gint dpi, ScanDirection scan_direction);
297
void book_view_select_page (BookView* self, Page* page);
298
static void simple_scan_on_file_type_changed (SimpleScan* self, GtkTreeSelection* selection);
299
static gchar* simple_scan_choose_file_location (SimpleScan* self);
300
static void _simple_scan_on_file_type_changed_gtk_tree_selection_changed (GtkTreeSelection* _sender, gpointer self);
301
static gboolean simple_scan_save_document (SimpleScan* self, gboolean force_choose_location);
302
void book_save (Book* self, const gchar* type, GFile* file, GError** error);
303
void simple_scan_show_error (SimpleScan* self, const gchar* error_title, const gchar* error_text, gboolean change_scanner_hint);
304
void book_set_needs_saving (Book* self, gboolean needs_saving);
305
static gboolean simple_scan_prompt_to_save (SimpleScan* self, const gchar* title, const gchar* discard_label);
306
gboolean book_get_needs_saving (Book* self);
307
static void simple_scan_clear_document (SimpleScan* self);
308
void book_clear (Book* self);
309
void G_MODULE_EXPORT new_button_clicked_cb (GtkWidget* widget, SimpleScan* self);
310
static void simple_scan_set_document_hint (SimpleScan* self, const gchar* document_hint);
311
void G_MODULE_EXPORT text_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self);
312
void G_MODULE_EXPORT photo_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self);
313
GType scan_type_get_type (void) G_GNUC_CONST;
314
static void simple_scan_set_page_side (SimpleScan* self, ScanType page_side);
315
static void simple_scan_set_paper_size (SimpleScan* self, gint width, gint height);
316
static gint simple_scan_get_text_dpi (SimpleScan* self);
317
static gint simple_scan_get_photo_dpi (SimpleScan* self);
318
static ScanType simple_scan_get_page_side (SimpleScan* self);
319
static gboolean simple_scan_get_paper_size (SimpleScan* self, gint* width, gint* height);
320
gpointer scan_options_ref (gpointer instance);
321
void scan_options_unref (gpointer instance);
322
GParamSpec* param_spec_scan_options (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
323
void value_set_scan_options (GValue* value, gpointer v_object);
324
void value_take_scan_options (GValue* value, gpointer v_object);
325
gpointer value_get_scan_options (const GValue* value);
326
GType scan_options_get_type (void) G_GNUC_CONST;
327
static ScanOptions* simple_scan_get_scan_options (SimpleScan* self);
328
ScanOptions* scan_options_new (void);
329
ScanOptions* scan_options_construct (GType object_type);
330
GType scan_mode_get_type (void) G_GNUC_CONST;
331
void G_MODULE_EXPORT scan_button_clicked_cb (GtkWidget* widget, SimpleScan* self);
332
void G_MODULE_EXPORT stop_scan_button_clicked_cb (GtkWidget* widget, SimpleScan* self);
333
void G_MODULE_EXPORT continuous_scan_button_clicked_cb (GtkWidget* widget, SimpleScan* self);
334
void G_MODULE_EXPORT preferences_button_clicked_cb (GtkWidget* widget, SimpleScan* self);
335
gboolean G_MODULE_EXPORT preferences_dialog_delete_event_cb (GtkWidget* widget, SimpleScan* self);
336
void G_MODULE_EXPORT preferences_dialog_response_cb (GtkWidget* widget, gint response_id, SimpleScan* self);
337
static void simple_scan_update_page_menu (SimpleScan* self);
338
Page* book_view_get_selected (BookView* self);
339
guint book_get_page_index (Book* self, Page* page);
340
guint book_get_n_pages (Book* self);
341
static void simple_scan_page_selected_cb (SimpleScan* self, BookView* view, Page* page);
342
gboolean page_has_crop (Page* self);
343
gchar* page_get_named_crop (Page* self);
344
static gchar* simple_scan_get_temporary_filename (SimpleScan* self, const gchar* prefix, const gchar* extension);
345
static void simple_scan_show_page_cb (SimpleScan* self, BookView* view, Page* page);
346
void page_save (Page* self, const gchar* type, GFile* file, GError** error);
347
static void simple_scan_show_page_menu_cb (SimpleScan* self, BookView* view);
348
void G_MODULE_EXPORT rotate_left_button_clicked_cb (GtkWidget* widget, SimpleScan* self);
349
void page_rotate_left (Page* self);
350
void G_MODULE_EXPORT rotate_right_button_clicked_cb (GtkWidget* widget, SimpleScan* self);
351
void page_rotate_right (Page* self);
352
static void simple_scan_set_crop (SimpleScan* self, const gchar* crop_name);
353
void page_set_no_crop (Page* self);
354
gint page_get_width (Page* self);
355
gint page_get_height (Page* self);
356
void page_set_custom_crop (Page* self, gint width, gint height);
357
void page_move_crop (Page* self, gint x, gint y);
358
void page_set_named_crop (Page* self, const gchar* name);
359
void G_MODULE_EXPORT no_crop_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self);
360
void G_MODULE_EXPORT custom_crop_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self);
361
void G_MODULE_EXPORT crop_toolbutton_toggled_cb (GtkToggleToolButton* widget, SimpleScan* self);
362
void G_MODULE_EXPORT four_by_six_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self);
363
void G_MODULE_EXPORT legal_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self);
364
void G_MODULE_EXPORT letter_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self);
365
void G_MODULE_EXPORT a6_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self);
366
void G_MODULE_EXPORT a5_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self);
367
void G_MODULE_EXPORT a4_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self);
368
void G_MODULE_EXPORT crop_rotate_menuitem_activate_cb (GtkWidget* widget, SimpleScan* self);
369
void page_rotate_crop (Page* self);
370
void G_MODULE_EXPORT page_move_left_menuitem_activate_cb (GtkWidget* widget, SimpleScan* self);
371
void book_move_page (Book* self, Page* page, guint location);
372
void G_MODULE_EXPORT page_move_right_menuitem_activate_cb (GtkWidget* widget, SimpleScan* self);
373
void G_MODULE_EXPORT page_delete_menuitem_activate_cb (GtkWidget* widget, SimpleScan* self);
374
Book* book_view_get_book (BookView* self);
375
void book_delete_page (Book* self, Page* page);
376
void G_MODULE_EXPORT save_file_button_clicked_cb (GtkWidget* widget, SimpleScan* self);
377
void G_MODULE_EXPORT save_as_file_button_clicked_cb (GtkWidget* widget, SimpleScan* self);
378
static void simple_scan_draw_page (SimpleScan* self, GtkPrintOperation* operation, GtkPrintContext* print_context, gint page_number);
379
Page* book_get_page (Book* self, gint page_number);
380
gboolean page_is_landscape (Page* self);
381
gint page_get_dpi (Page* self);
382
GdkPixbuf* page_get_image (Page* self, gboolean apply_crop);
383
void G_MODULE_EXPORT email_button_clicked_cb (GtkWidget* widget, SimpleScan* self);
384
void G_MODULE_EXPORT print_button_clicked_cb (GtkWidget* widget, SimpleScan* self);
385
static void _simple_scan_draw_page_gtk_print_operation_draw_page (GtkPrintOperation* _sender, GtkPrintContext* context, gint page_nr, gpointer self);
386
void G_MODULE_EXPORT help_contents_menuitem_activate_cb (GtkWidget* widget, SimpleScan* self);
387
void G_MODULE_EXPORT about_menuitem_activate_cb (GtkWidget* widget, SimpleScan* self);
388
static gboolean simple_scan_on_quit (SimpleScan* self);
389
void G_MODULE_EXPORT quit_menuitem_activate_cb (GtkWidget* widget, SimpleScan* self);
390
gboolean G_MODULE_EXPORT simple_scan_window_configure_event_cb (GtkWidget* widget, GdkEventConfigure* event, SimpleScan* self);
391
static void simple_scan_info_bar_response_cb (SimpleScan* self, GtkInfoBar* widget, gint response_id);
392
gboolean G_MODULE_EXPORT simple_scan_window_window_state_event_cb (GtkWidget* widget, GdkEventWindowState* event, SimpleScan* self);
393
gboolean G_MODULE_EXPORT window_delete_event_cb (GtkWidget* widget, GdkEvent* event, SimpleScan* self);
394
static void simple_scan_page_size_changed_cb (SimpleScan* self, Page* page);
395
static void simple_scan_page_scan_direction_changed_cb (SimpleScan* self, Page* page);
396
ScanDirection page_get_scan_direction (Page* self);
397
static void _simple_scan_page_size_changed_cb_page_size_changed (Page* _sender, gpointer self);
398
static void _simple_scan_page_scan_direction_changed_cb_page_scan_direction_changed (Page* _sender, gpointer self);
399
static void simple_scan_set_dpi_combo (SimpleScan* self, GtkComboBox* combo, gint default_dpi, gint current_dpi);
400
static void simple_scan_needs_saving_cb (SimpleScan* self, Book* book);
401
static void _simple_scan_info_bar_response_cb_gtk_info_bar_response (GtkInfoBar* _sender, gint response_id, gpointer self);
402
BookView* book_view_new (Book* book);
403
BookView* book_view_construct (GType object_type, Book* book);
404
static void _simple_scan_page_selected_cb_book_view_page_selected (BookView* _sender, Page* page, gpointer self);
405
static void _simple_scan_show_page_cb_book_view_show_page (BookView* _sender, Page* page, gpointer self);
406
static void _simple_scan_show_page_menu_cb_book_view_show_menu (BookView* _sender, gpointer self);
407
static void _simple_scan_needs_saving_cb_book_needs_saving_changed (Book* _sender, gpointer self);
408
Book* simple_scan_get_book (SimpleScan* self);
409
void simple_scan_set_selected_page (SimpleScan* self, Page* page);
410
Page* simple_scan_get_selected_page (SimpleScan* self);
411
void simple_scan_set_scanning (SimpleScan* self, gboolean scanning);
412
void simple_scan_start (SimpleScan* self);
413
static void g_cclosure_user_marshal_VOID__STRING_SCAN_OPTIONS (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
414
static void simple_scan_finalize (SimpleScan* obj);
415
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
416
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
417
418
419
static void _simple_scan_page_removed_cb_book_page_removed (Book* _sender, Page* page, gpointer self) {
420
simple_scan_page_removed_cb (self, _sender, page);
421
}
422
423
424
static void _simple_scan_page_added_cb_book_page_added (Book* _sender, Page* page, gpointer self) {
425
simple_scan_page_added_cb (self, _sender, page);
426
}
427
428
429
SimpleScan* simple_scan_construct (GType object_type) {
430
SimpleScan* self = NULL;
431
Book* _tmp0_ = NULL;
432
GSettings* _tmp1_ = NULL;
433
self = (SimpleScan*) g_type_create_instance (object_type);
434
_tmp0_ = book_new ();
435
_book_unref0 (self->priv->book);
436
self->priv->book = _tmp0_;
437
g_signal_connect (self->priv->book, "page-removed", (GCallback) _simple_scan_page_removed_cb_book_page_removed, self);
438
g_signal_connect (self->priv->book, "page-added", (GCallback) _simple_scan_page_added_cb_book_page_added, self);
439
_tmp1_ = g_settings_new ("org.gnome.SimpleScan");
440
_g_object_unref0 (self->priv->settings);
441
self->priv->settings = _tmp1_;
442
simple_scan_load (self);
443
return self;
444
}
445
446
447
SimpleScan* simple_scan_new (void) {
448
return simple_scan_construct (TYPE_SIMPLE_SCAN);
449
}
450
451
452
static gboolean simple_scan_find_scan_device (SimpleScan* self, const gchar* device, GtkTreeIter* iter) {
453
GtkTreeIter _iter = {0};
454
gboolean result = FALSE;
455
gboolean have_iter;
456
GtkTreeIter _tmp0_ = {0};
457
gboolean _tmp1_;
458
g_return_val_if_fail (self != NULL, FALSE);
459
g_return_val_if_fail (device != NULL, FALSE);
460
have_iter = FALSE;
461
_tmp1_ = gtk_tree_model_get_iter_first ((GtkTreeModel*) self->priv->device_model, &_tmp0_);
462
_iter = _tmp0_;
463
if (_tmp1_) {
464
{
465
gboolean _tmp2_;
466
_tmp2_ = TRUE;
467
while (TRUE) {
468
gchar* d = NULL;
469
if (!_tmp2_) {
470
gboolean _tmp3_ = FALSE;
471
if (!have_iter) {
472
gboolean _tmp4_;
473
_tmp4_ = gtk_tree_model_iter_next ((GtkTreeModel*) self->priv->device_model, &_iter);
474
_tmp3_ = _tmp4_;
475
} else {
476
_tmp3_ = FALSE;
477
}
478
if (!_tmp3_) {
479
break;
480
}
481
}
482
_tmp2_ = FALSE;
483
gtk_tree_model_get ((GtkTreeModel*) self->priv->device_model, &_iter, 0, &d, -1, -1);
484
if (g_strcmp0 (d, device) == 0) {
485
have_iter = TRUE;
486
}
487
_g_free0 (d);
488
}
489
}
490
}
491
result = have_iter;
492
if (iter) {
493
*iter = _iter;
494
}
495
return result;
496
}
497
498
499
static void simple_scan_show_error_dialog (SimpleScan* self, const gchar* error_title, const gchar* error_text) {
500
GtkMessageDialog* _tmp0_ = NULL;
501
GtkMessageDialog* dialog;
502
g_return_if_fail (self != NULL);
503
g_return_if_fail (error_title != NULL);
504
g_return_if_fail (error_text != NULL);
505
_tmp0_ = (GtkMessageDialog*) gtk_message_dialog_new (self->priv->window, GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, "%s", error_title);
506
dialog = g_object_ref_sink (_tmp0_);
507
gtk_dialog_add_button ((GtkDialog*) dialog, GTK_STOCK_CLOSE, 0);
508
gtk_message_dialog_format_secondary_text (dialog, "%s", error_text, NULL);
509
gtk_widget_destroy ((GtkWidget*) dialog);
510
_g_object_unref0 (dialog);
511
}
512
513
514
void simple_scan_set_default_file_name (SimpleScan* self, const gchar* default_file_name) {
515
gchar* _tmp0_;
516
g_return_if_fail (self != NULL);
517
g_return_if_fail (default_file_name != NULL);
518
_tmp0_ = g_strdup (default_file_name);
519
_g_free0 (self->priv->default_file_name);
520
self->priv->default_file_name = _tmp0_;
521
}
522
523
524
void simple_scan_authorize (SimpleScan* self, const gchar* resource, gchar** username, gchar** password) {
525
gchar* _username = NULL;
526
gchar* _password = NULL;
527
const gchar* _tmp0_ = NULL;
528
gchar* _tmp1_ = NULL;
529
gchar* description;
530
const gchar* _tmp2_ = NULL;
531
gchar* _tmp3_;
532
const gchar* _tmp4_ = NULL;
533
gchar* _tmp5_;
534
g_return_if_fail (self != NULL);
535
g_return_if_fail (resource != NULL);
536
_tmp0_ = _ ("Username and password required to access '%s'");
537
_tmp1_ = g_strdup_printf (_tmp0_, resource);
538
description = _tmp1_;
539
gtk_entry_set_text (self->priv->username_entry, "");
540
gtk_entry_set_text (self->priv->password_entry, "");
541
gtk_label_set_text (self->priv->authorize_label, description);
542
gtk_widget_show ((GtkWidget*) self->priv->authorize_dialog);
543
gtk_dialog_run (self->priv->authorize_dialog);
544
gtk_widget_hide ((GtkWidget*) self->priv->authorize_dialog);
545
_tmp2_ = gtk_entry_get_text (self->priv->username_entry);
546
_tmp3_ = g_strdup (_tmp2_);
547
_g_free0 (_username);
548
_username = _tmp3_;
549
_tmp4_ = gtk_entry_get_text (self->priv->password_entry);
550
_tmp5_ = g_strdup (_tmp4_);
551
_g_free0 (_password);
552
_password = _tmp5_;
553
_g_free0 (description);
554
if (username) {
555
*username = _username;
556
} else {
557
_g_free0 (_username);
558
}
559
if (password) {
560
*password = _password;
561
} else {
562
_g_free0 (_password);
563
}
564
}
565
566
567
void G_MODULE_EXPORT device_combo_changed_cb (GtkWidget* widget, SimpleScan* self) {
568
g_return_if_fail (self != NULL);
569
g_return_if_fail (widget != NULL);
570
if (self->priv->setting_devices) {
571
return;
572
}
573
self->priv->user_selected_device = TRUE;
574
}
575
576
577
static void simple_scan_update_info_bar (SimpleScan* self) {
578
GtkMessageType type = 0;
579
gchar* title = NULL;
580
gchar* text = NULL;
581
gchar* image_id = NULL;
582
gboolean show_close_button;
583
gboolean show_change_scanner_button;
584
gchar* _tmp9_ = NULL;
585
gchar* message;
586
g_return_if_fail (self != NULL);
587
show_close_button = FALSE;
588
show_change_scanner_button = FALSE;
589
if (self->priv->have_error) {
590
gchar* _tmp0_;
591
gchar* _tmp1_;
592
gchar* _tmp2_;
593
type = GTK_MESSAGE_ERROR;
594
_tmp0_ = g_strdup (GTK_STOCK_DIALOG_ERROR);
595
_g_free0 (image_id);
596
image_id = _tmp0_;
597
_tmp1_ = g_strdup (self->priv->error_title);
598
_g_free0 (title);
599
title = _tmp1_;
600
_tmp2_ = g_strdup (self->priv->error_text);
601
_g_free0 (text);
602
text = _tmp2_;
603
show_close_button = TRUE;
604
show_change_scanner_button = self->priv->error_change_scanner_hint;
605
} else {
606
gint _tmp3_;
607
_tmp3_ = gtk_tree_model_iter_n_children ((GtkTreeModel*) self->priv->device_model, NULL);
608
if (_tmp3_ == 0) {
609
gchar* _tmp4_;
610
const gchar* _tmp5_ = NULL;
611
gchar* _tmp6_;
612
const gchar* _tmp7_ = NULL;
613
gchar* _tmp8_;
614
type = GTK_MESSAGE_WARNING;
615
_tmp4_ = g_strdup (GTK_STOCK_DIALOG_WARNING);
616
_g_free0 (image_id);
617
image_id = _tmp4_;
618
_tmp5_ = _ ("No scanners detected");
619
_tmp6_ = g_strdup (_tmp5_);
620
_g_free0 (title);
621
title = _tmp6_;
622
_tmp7_ = _ ("Please check your scanner is connected and powered on");
623
_tmp8_ = g_strdup (_tmp7_);
624
_g_free0 (text);
625
text = _tmp8_;
626
} else {
627
gtk_widget_hide ((GtkWidget*) self->priv->info_bar);
628
_g_free0 (image_id);
629
_g_free0 (text);
630
_g_free0 (title);
631
return;
632
}
633
}
634
gtk_info_bar_set_message_type (self->priv->info_bar, type);
635
gtk_image_set_from_stock (self->priv->info_bar_image, image_id, GTK_ICON_SIZE_DIALOG);
636
_tmp9_ = g_strdup_printf ("<big><b>%s</b></big>\n\n%s", title, text);
637
message = _tmp9_;
638
gtk_label_set_markup (self->priv->info_bar_label, message);
639
gtk_widget_set_visible ((GtkWidget*) self->priv->info_bar_close_button, show_close_button);
640
gtk_widget_set_visible ((GtkWidget*) self->priv->info_bar_change_scanner_button, show_change_scanner_button);
641
gtk_widget_show ((GtkWidget*) self->priv->info_bar);
642
_g_free0 (message);
643
_g_free0 (image_id);
644
_g_free0 (text);
645
_g_free0 (title);
646
}
647
648
649
static gpointer _scan_device_ref0 (gpointer self) {
650
return self ? scan_device_ref (self) : NULL;
651
}
652
653
654
void simple_scan_set_scan_devices (SimpleScan* self, GList* devices) {
655
gboolean have_selection;
656
gint index = 0;
657
GtkTreeIter iter = {0};
658
gboolean _tmp11_ = FALSE;
659
g_return_if_fail (self != NULL);
660
have_selection = FALSE;
661
self->priv->setting_devices = TRUE;
662
if (self->priv->user_selected_device) {
663
gint _tmp0_;
664
_tmp0_ = gtk_combo_box_get_active (self->priv->device_combo);
665
have_selection = _tmp0_ >= 0;
666
}
667
index = 0;
668
{
669
GList* device_collection = NULL;
670
GList* device_it = NULL;
671
device_collection = devices;
672
for (device_it = device_collection; device_it != NULL; device_it = device_it->next) {
673
ScanDevice* _tmp1_;
674
ScanDevice* device = NULL;
675
_tmp1_ = _scan_device_ref0 ((ScanDevice*) device_it->data);
676
device = _tmp1_;
677
{
678
gint n_delete;
679
GtkTreeIter _tmp2_ = {0};
680
gboolean _tmp3_;
681
n_delete = -1;
682
_tmp3_ = gtk_tree_model_iter_nth_child ((GtkTreeModel*) self->priv->device_model, &_tmp2_, NULL, index);
683
iter = _tmp2_;
684
if (_tmp3_) {
685
gint i;
686
i = 0;
687
{
688
gboolean _tmp4_;
689
_tmp4_ = TRUE;
690
while (TRUE) {
691
gchar* name = NULL;
692
gboolean matched = FALSE;
693
if (!_tmp4_) {
694
gboolean _tmp5_;
695
_tmp5_ = gtk_tree_model_iter_next ((GtkTreeModel*) self->priv->device_model, &iter);
696
if (!_tmp5_) {
697
break;
698
}
699
}
700
_tmp4_ = FALSE;
701
gtk_tree_model_get ((GtkTreeModel*) self->priv->device_model, &iter, 0, &name, -1, -1);
702
matched = g_strcmp0 (name, device->name) == 0;
703
if (matched) {
704
n_delete = i;
705
_g_free0 (name);
706
break;
707
}
708
i++;
709
_g_free0 (name);
710
}
711
}
712
}
713
if (n_delete >= 0) {
714
gint i = 0;
715
gtk_list_store_set (self->priv->device_model, &iter, 1, device->label, -1, -1);
716
{
717
gboolean _tmp6_;
718
i = 0;
719
_tmp6_ = TRUE;
720
while (TRUE) {
721
GtkTreeIter _tmp7_ = {0};
722
if (!_tmp6_) {
723
i++;
724
}
725
_tmp6_ = FALSE;
726
if (!(i < n_delete)) {
727
break;
728
}
729
gtk_tree_model_iter_nth_child ((GtkTreeModel*) self->priv->device_model, &_tmp7_, NULL, index);
730
iter = _tmp7_;
731
gtk_list_store_remove (self->priv->device_model, &iter);
732
}
733
}
734
} else {
735
GtkTreeIter _tmp8_ = {0};
736
gtk_list_store_insert (self->priv->device_model, &_tmp8_, index);
737
iter = _tmp8_;
738
gtk_list_store_set (self->priv->device_model, &iter, 0, device->name, 1, device->label, -1, -1);
739
}
740
index++;
741
_scan_device_unref0 (device);
742
}
743
}
744
}
745
while (TRUE) {
746
GtkTreeIter _tmp9_ = {0};
747
gboolean _tmp10_;
748
_tmp10_ = gtk_tree_model_iter_nth_child ((GtkTreeModel*) self->priv->device_model, &_tmp9_, NULL, index);
749
iter = _tmp9_;
750
if (!_tmp10_) {
751
break;
752
}
753
gtk_list_store_remove (self->priv->device_model, &iter);
754
}
755
if (!have_selection) {
756
_tmp11_ = devices != NULL;
757
} else {
758
_tmp11_ = FALSE;
759
}
760
if (_tmp11_) {
761
gtk_combo_box_set_active (self->priv->device_combo, 0);
762
}
763
self->priv->setting_devices = FALSE;
764
simple_scan_update_info_bar (self);
765
}
766
767
768
static gchar* simple_scan_get_selected_device (SimpleScan* self) {
769
gchar* result = NULL;
770
GtkTreeIter iter = {0};
771
GtkTreeIter _tmp0_ = {0};
772
gboolean _tmp1_;
773
g_return_val_if_fail (self != NULL, NULL);
774
_tmp1_ = gtk_combo_box_get_active_iter (self->priv->device_combo, &_tmp0_);
775
iter = _tmp0_;
776
if (_tmp1_) {
777
gchar* device = NULL;
778
gtk_tree_model_get ((GtkTreeModel*) self->priv->device_model, &iter, 0, &device, -1, -1);
779
result = device;
780
return result;
781
}
782
result = NULL;
783
return result;
784
}
785
786
787
void simple_scan_set_selected_device (SimpleScan* self, const gchar* device) {
788
GtkTreeIter iter = {0};
789
GtkTreeIter _tmp0_ = {0};
790
gboolean _tmp1_;
791
g_return_if_fail (self != NULL);
792
g_return_if_fail (device != NULL);
793
_tmp1_ = simple_scan_find_scan_device (self, device, &_tmp0_);
794
iter = _tmp0_;
795
if (!_tmp1_) {
796
return;
797
}
798
gtk_combo_box_set_active_iter (self->priv->device_combo, &iter);
799
self->priv->user_selected_device = TRUE;
800
}
801
802
803
static void simple_scan_add_default_page (SimpleScan* self) {
804
Page* _tmp0_ = NULL;
805
Page* page;
806
g_return_if_fail (self != NULL);
807
_tmp0_ = book_append_page (self->priv->book, self->priv->default_page_width, self->priv->default_page_height, self->priv->default_page_dpi, self->priv->default_page_scan_direction);
808
page = _tmp0_;
809
book_view_select_page (self->priv->book_view, page);
810
_page_unref0 (page);
811
}
812
813
814
static gpointer _g_object_ref0 (gpointer self) {
815
return self ? g_object_ref (self) : NULL;
816
}
817
818
819
static gint string_last_index_of_char (const gchar* self, gunichar c, gint start_index) {
820
gint result = 0;
821
gchar* _tmp0_ = NULL;
822
gchar* _result_;
823
g_return_val_if_fail (self != NULL, 0);
824
_tmp0_ = g_utf8_strrchr (((gchar*) self) + start_index, (gssize) (-1), c);
825
_result_ = _tmp0_;
826
if (_result_ != NULL) {
827
result = (gint) (_result_ - ((gchar*) self));
828
return result;
829
} else {
830
result = -1;
831
return result;
832
}
833
}
834
835
836
static gchar* string_slice (const gchar* self, glong start, glong end) {
837
gchar* result = NULL;
838
gint _tmp0_;
839
glong string_length;
840
gboolean _tmp1_ = FALSE;
841
gboolean _tmp2_ = FALSE;
842
gchar* _tmp3_ = NULL;
843
g_return_val_if_fail (self != NULL, NULL);
844
_tmp0_ = strlen (self);
845
string_length = (glong) _tmp0_;
846
if (start < ((glong) 0)) {
847
start = string_length + start;
848
}
849
if (end < ((glong) 0)) {
850
end = string_length + end;
851
}
852
if (start >= ((glong) 0)) {
853
_tmp1_ = start <= string_length;
854
} else {
855
_tmp1_ = FALSE;
856
}
857
g_return_val_if_fail (_tmp1_, NULL);
858
if (end >= ((glong) 0)) {
859
_tmp2_ = end <= string_length;
860
} else {
861
_tmp2_ = FALSE;
862
}
863
g_return_val_if_fail (_tmp2_, NULL);
864
g_return_val_if_fail (start <= end, NULL);
865
_tmp3_ = g_strndup (((gchar*) self) + start, (gsize) (end - start));
866
result = _tmp3_;
867
return result;
868
}
869
870
871
static void simple_scan_on_file_type_changed (SimpleScan* self, GtkTreeSelection* selection) {
872
GtkTreeModel* model = NULL;
873
GtkTreeIter iter = {0};
874
GtkTreeModel* _tmp0_ = NULL;
875
GtkTreeIter _tmp1_ = {0};
876
gboolean _tmp2_;
877
GtkTreeModel* _tmp3_;
878
gchar* extension = NULL;
879
gchar* _tmp4_ = NULL;
880
gchar* path;
881
gchar* _tmp5_ = NULL;
882
gchar* filename;
883
gint _tmp6_;
884
gint extension_index;
885
gchar* _tmp8_;
886
g_return_if_fail (self != NULL);
887
g_return_if_fail (selection != NULL);
888
_tmp2_ = gtk_tree_selection_get_selected (selection, &_tmp0_, &_tmp1_);
889
_g_object_unref0 (model);
890
_tmp3_ = _g_object_ref0 (_tmp0_);
891
model = _tmp3_;
892
iter = _tmp1_;
893
if (!_tmp2_) {
894
_g_object_unref0 (model);
895
return;
896
}
897
gtk_tree_model_get (model, &iter, 1, &extension, -1, -1);
898
_tmp4_ = gtk_file_chooser_get_filename ((GtkFileChooser*) self->priv->save_dialog);
899
path = _tmp4_;
900
_tmp5_ = g_path_get_basename (path);
901
filename = _tmp5_;
902
_tmp6_ = string_last_index_of_char (filename, (gunichar) '.', 0);
903
extension_index = _tmp6_;
904
if (extension_index >= 0) {
905
gchar* _tmp7_ = NULL;
906
_tmp7_ = string_slice (filename, (glong) 0, (glong) extension_index);
907
_g_free0 (filename);
908
filename = _tmp7_;
909
}
910
_tmp8_ = g_strconcat (filename, extension, NULL);
911
_g_free0 (filename);
912
filename = _tmp8_;
913
gtk_file_chooser_set_current_name ((GtkFileChooser*) self->priv->save_dialog, filename);
914
_g_free0 (filename);
915
_g_free0 (path);
916
_g_free0 (extension);
917
_g_object_unref0 (model);
918
}
919
920
921
static void _simple_scan_on_file_type_changed_gtk_tree_selection_changed (GtkTreeSelection* _sender, gpointer self) {
922
simple_scan_on_file_type_changed (self, _sender);
923
}
924
925
926
static gchar* simple_scan_choose_file_location (SimpleScan* self) {
927
gchar* result = NULL;
928
gchar* directory;
929
gchar* _tmp0_ = NULL;
930
gboolean _tmp1_ = FALSE;
931
const gchar* _tmp4_ = NULL;
932
GtkFileChooserDialog* _tmp5_ = NULL;
933
GtkFileFilter* _tmp6_ = NULL;
934
GtkFileFilter* filter;
935
const gchar* _tmp7_ = NULL;
936
GtkFileFilter* _tmp8_ = NULL;
937
const gchar* _tmp9_ = NULL;
938
const gchar* _tmp10_ = NULL;
939
GtkExpander* _tmp11_ = NULL;
940
GtkExpander* expander;
941
gchar* _tmp12_;
942
gchar* extension;
943
gint _tmp13_;
944
gint index;
945
GtkListStore* _tmp15_ = NULL;
946
GtkListStore* file_type_store;
947
GtkTreeIter iter = {0};
948
GtkTreeIter _tmp16_ = {0};
949
const gchar* _tmp17_ = NULL;
950
GtkTreeIter _tmp18_ = {0};
951
const gchar* _tmp19_ = NULL;
952
GtkTreeIter _tmp20_ = {0};
953
const gchar* _tmp21_ = NULL;
954
GtkTreeView* _tmp22_ = NULL;
955
GtkTreeView* file_type_view;
956
GtkCellRendererText* _tmp23_ = NULL;
957
GtkCellRendererText* _tmp24_;
958
GtkTreeViewColumn* _tmp25_ = NULL;
959
GtkTreeViewColumn* _tmp26_;
960
GtkTreeViewColumn* column;
961
GtkTreeIter _tmp27_ = {0};
962
gboolean _tmp28_;
963
GtkTreeSelection* _tmp32_ = NULL;
964
gint _tmp33_;
965
gint response;
966
gchar* uri;
967
gchar* _tmp35_ = NULL;
968
gchar* _tmp36_;
969
g_return_val_if_fail (self != NULL, NULL);
970
directory = NULL;
971
_tmp0_ = g_settings_get_string (self->priv->settings, "save-directory");
972
_g_free0 (directory);
973
directory = _tmp0_;
974
if (directory == NULL) {
975
_tmp1_ = TRUE;
976
} else {
977
_tmp1_ = g_strcmp0 (directory, "") == 0;
978
}
979
if (_tmp1_) {
980
const gchar* _tmp2_ = NULL;
981
gchar* _tmp3_;
982
_tmp2_ = g_get_user_special_dir (G_USER_DIRECTORY_DOCUMENTS);
983
_tmp3_ = g_strdup (_tmp2_);
984
_g_free0 (directory);
985
directory = _tmp3_;
986
}
987
_tmp4_ = _ ("Save As...");
988
_tmp5_ = (GtkFileChooserDialog*) gtk_file_chooser_dialog_new (_tmp4_, self->priv->window, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL, NULL);
989
_g_object_unref0 (self->priv->save_dialog);
990
self->priv->save_dialog = g_object_ref_sink (_tmp5_);
991
gtk_file_chooser_set_do_overwrite_confirmation ((GtkFileChooser*) self->priv->save_dialog, TRUE);
992
gtk_file_chooser_set_local_only ((GtkFileChooser*) self->priv->save_dialog, FALSE);
993
gtk_file_chooser_set_current_folder ((GtkFileChooser*) self->priv->save_dialog, directory);
994
gtk_file_chooser_set_current_name ((GtkFileChooser*) self->priv->save_dialog, self->priv->default_file_name);
995
_tmp6_ = gtk_file_filter_new ();
996
filter = g_object_ref_sink (_tmp6_);
997
_tmp7_ = _ ("Image Files");
998
gtk_buildable_set_name ((GtkBuildable*) filter, _tmp7_);
999
gtk_file_filter_add_pixbuf_formats (filter);
1000
gtk_file_filter_add_mime_type (filter, "application/pdf");
1001
gtk_file_chooser_add_filter ((GtkFileChooser*) self->priv->save_dialog, filter);
1002
_tmp8_ = gtk_file_filter_new ();
1003
_g_object_unref0 (filter);
1004
filter = g_object_ref_sink (_tmp8_);
1005
_tmp9_ = _ ("All Files");
1006
gtk_buildable_set_name ((GtkBuildable*) filter, _tmp9_);
1007
gtk_file_filter_add_pattern (filter, "*");
1008
gtk_file_chooser_add_filter ((GtkFileChooser*) self->priv->save_dialog, filter);
1009
_tmp10_ = _ ("Select File _Type");
1010
_tmp11_ = (GtkExpander*) gtk_expander_new_with_mnemonic (_tmp10_);
1011
expander = g_object_ref_sink (_tmp11_);
1012
gtk_expander_set_spacing (expander, 5);
1013
gtk_file_chooser_set_extra_widget ((GtkFileChooser*) self->priv->save_dialog, (GtkWidget*) expander);
1014
_tmp12_ = g_strdup ("");
1015
extension = _tmp12_;
1016
_tmp13_ = string_last_index_of_char (self->priv->default_file_name, (gunichar) '.', 0);
1017
index = _tmp13_;
1018
if (index >= 0) {
1019
gchar* _tmp14_ = NULL;
1020
_tmp14_ = string_slice (self->priv->default_file_name, (glong) 0, (glong) index);
1021
_g_free0 (extension);
1022
extension = _tmp14_;
1023
}
1024
_tmp15_ = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
1025
file_type_store = _tmp15_;
1026
gtk_list_store_append (file_type_store, &_tmp16_);
1027
iter = _tmp16_;
1028
_tmp17_ = _ ("PDF (multi-page document)");
1029
gtk_list_store_set (file_type_store, &iter, 0, _tmp17_, 1, ".pdf", -1, -1);
1030
gtk_list_store_append (file_type_store, &_tmp18_);
1031
iter = _tmp18_;
1032
_tmp19_ = _ ("JPEG (compressed)");
1033
gtk_list_store_set (file_type_store, &iter, 0, _tmp19_, 1, ".jpg", -1, -1);
1034
gtk_list_store_append (file_type_store, &_tmp20_);
1035
iter = _tmp20_;
1036
_tmp21_ = _ ("PNG (lossless)");
1037
gtk_list_store_set (file_type_store, &iter, 0, _tmp21_, 1, ".png", -1, -1);
1038
_tmp22_ = (GtkTreeView*) gtk_tree_view_new_with_model ((GtkTreeModel*) file_type_store);
1039
file_type_view = g_object_ref_sink (_tmp22_);
1040
gtk_tree_view_set_headers_visible (file_type_view, FALSE);
1041
gtk_tree_view_set_rules_hint (file_type_view, TRUE);
1042
_tmp23_ = (GtkCellRendererText*) gtk_cell_renderer_text_new ();
1043
_tmp24_ = g_object_ref_sink (_tmp23_);
1044
_tmp25_ = gtk_tree_view_column_new_with_attributes ("", (GtkCellRenderer*) _tmp24_, "text", 0, NULL, NULL);
1045
_tmp26_ = g_object_ref_sink (_tmp25_);
1046
_g_object_unref0 (_tmp24_);
1047
column = _tmp26_;
1048
gtk_tree_view_append_column (file_type_view, column);
1049
gtk_container_add ((GtkContainer*) expander, (GtkWidget*) file_type_view);
1050
_tmp28_ = gtk_tree_model_get_iter_first ((GtkTreeModel*) file_type_store, &_tmp27_);
1051
iter = _tmp27_;
1052
if (_tmp28_) {
1053
{
1054
gboolean _tmp29_;
1055
_tmp29_ = TRUE;
1056
while (TRUE) {
1057
gchar* e = NULL;
1058
if (!_tmp29_) {
1059
gboolean _tmp30_;
1060
_tmp30_ = gtk_tree_model_iter_next ((GtkTreeModel*) file_type_store, &iter);
1061
if (!_tmp30_) {
1062
break;
1063
}
1064
}
1065
_tmp29_ = FALSE;
1066
gtk_tree_model_get ((GtkTreeModel*) file_type_store, &iter, 1, &e, -1, -1);
1067
if (g_strcmp0 (extension, e) == 0) {
1068
GtkTreeSelection* _tmp31_ = NULL;
1069
_tmp31_ = gtk_tree_view_get_selection (file_type_view);
1070
gtk_tree_selection_select_iter (_tmp31_, &iter);
1071
}
1072
_g_free0 (e);
1073
}
1074
}
1075
}
1076
_tmp32_ = gtk_tree_view_get_selection (file_type_view);
1077
g_signal_connect (_tmp32_, "changed", (GCallback) _simple_scan_on_file_type_changed_gtk_tree_selection_changed, self);
1078
gtk_widget_show_all ((GtkWidget*) expander);
1079
_tmp33_ = gtk_dialog_run ((GtkDialog*) self->priv->save_dialog);
1080
response = _tmp33_;
1081
uri = NULL;
1082
if (response == ((gint) GTK_RESPONSE_ACCEPT)) {
1083
gchar* _tmp34_ = NULL;
1084
_tmp34_ = gtk_file_chooser_get_uri ((GtkFileChooser*) self->priv->save_dialog);
1085
_g_free0 (uri);
1086
uri = _tmp34_;
1087
}
1088
_tmp35_ = gtk_file_chooser_get_current_folder ((GtkFileChooser*) self->priv->save_dialog);
1089
_tmp36_ = _tmp35_;
1090
g_settings_set_string (self->priv->settings, "save-directory", _tmp36_);
1091
_g_free0 (_tmp36_);
1092
gtk_widget_destroy ((GtkWidget*) self->priv->save_dialog);
1093
_g_object_unref0 (self->priv->save_dialog);
1094
self->priv->save_dialog = NULL;
1095
result = uri;
1096
_g_object_unref0 (column);
1097
_g_object_unref0 (file_type_view);
1098
_g_object_unref0 (file_type_store);
1099
_g_free0 (extension);
1100
_g_object_unref0 (expander);
1101
_g_object_unref0 (filter);
1102
_g_free0 (directory);
1103
return result;
1104
}
1105
1106
1107
static gboolean simple_scan_save_document (SimpleScan* self, gboolean force_choose_location) {
1108
gboolean result = FALSE;
1109
gchar* uri = NULL;
1110
gboolean _tmp0_ = FALSE;
1111
GFile* _tmp3_ = NULL;
1112
GFile* file;
1113
gchar* _tmp4_ = NULL;
1114
gchar* uri_lower;
1115
gchar* _tmp5_;
1116
gchar* format;
1117
gboolean _tmp6_;
1118
gchar* _tmp17_;
1119
GError * _inner_error_ = NULL;
1120
g_return_val_if_fail (self != NULL, FALSE);
1121
if (self->priv->book_uri != NULL) {
1122
_tmp0_ = !force_choose_location;
1123
} else {
1124
_tmp0_ = FALSE;
1125
}
1126
if (_tmp0_) {
1127
gchar* _tmp1_;
1128
_tmp1_ = g_strdup (self->priv->book_uri);
1129
_g_free0 (uri);
1130
uri = _tmp1_;
1131
} else {
1132
gchar* _tmp2_ = NULL;
1133
_tmp2_ = simple_scan_choose_file_location (self);
1134
_g_free0 (uri);
1135
uri = _tmp2_;
1136
}
1137
if (uri == NULL) {
1138
result = FALSE;
1139
_g_free0 (uri);
1140
return result;
1141
}
1142
_tmp3_ = g_file_new_for_uri (uri);
1143
file = _tmp3_;
1144
g_debug ("ui.vala:445: Saving to '%s'", uri);
1145
_tmp4_ = g_utf8_strdown (uri, (gssize) (-1));
1146
uri_lower = _tmp4_;
1147
_tmp5_ = g_strdup ("jpeg");
1148
format = _tmp5_;
1149
_tmp6_ = g_str_has_suffix (uri_lower, ".pdf");
1150
if (_tmp6_) {
1151
gchar* _tmp7_;
1152
_tmp7_ = g_strdup ("pdf");
1153
_g_free0 (format);
1154
format = _tmp7_;
1155
} else {
1156
gboolean _tmp8_;
1157
_tmp8_ = g_str_has_suffix (uri_lower, ".ps");
1158
if (_tmp8_) {
1159
gchar* _tmp9_;
1160
_tmp9_ = g_strdup ("ps");
1161
_g_free0 (format);
1162
format = _tmp9_;
1163
} else {
1164
gboolean _tmp10_;
1165
_tmp10_ = g_str_has_suffix (uri_lower, ".png");
1166
if (_tmp10_) {
1167
gchar* _tmp11_;
1168
_tmp11_ = g_strdup ("png");
1169
_g_free0 (format);
1170
format = _tmp11_;
1171
} else {
1172
gboolean _tmp12_ = FALSE;
1173
gboolean _tmp13_;
1174
_tmp13_ = g_str_has_suffix (uri_lower, ".tif");
1175
if (_tmp13_) {
1176
_tmp12_ = TRUE;
1177
} else {
1178
gboolean _tmp14_;
1179
_tmp14_ = g_str_has_suffix (uri_lower, ".tiff");
1180
_tmp12_ = _tmp14_;
1181
}
1182
if (_tmp12_) {
1183
gchar* _tmp15_;
1184
_tmp15_ = g_strdup ("tiff");
1185
_g_free0 (format);
1186
format = _tmp15_;
1187
}
1188
}
1189
}
1190
}
1191
{
1192
book_save (self->priv->book, format, file, &_inner_error_);
1193
if (_inner_error_ != NULL) {
1194
goto __catch10_g_error;
1195
}
1196
}
1197
goto __finally10;
1198
__catch10_g_error:
1199
{
1200
GError* e = NULL;
1201
const gchar* _tmp16_ = NULL;
1202
e = _inner_error_;
1203
_inner_error_ = NULL;
1204
g_warning ("ui.vala:464: Error saving file: %s", e->message);
1205
_tmp16_ = _ ("Failed to save file");
1206
simple_scan_show_error (self, _tmp16_, e->message, FALSE);
1207
result = FALSE;
1208
_g_error_free0 (e);
1209
_g_free0 (format);
1210
_g_free0 (uri_lower);
1211
_g_object_unref0 (file);
1212
_g_free0 (uri);
1213
return result;
1214
}
1215
__finally10:
1216
if (_inner_error_ != NULL) {
1217
_g_free0 (format);
1218
_g_free0 (uri_lower);
1219
_g_object_unref0 (file);
1220
_g_free0 (uri);
1221
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
1222
g_clear_error (&_inner_error_);
1223
return FALSE;
1224
}
1225
_tmp17_ = g_strdup (uri);
1226
_g_free0 (self->priv->book_uri);
1227
self->priv->book_uri = _tmp17_;
1228
book_set_needs_saving (self->priv->book, FALSE);
1229
result = TRUE;
1230
_g_free0 (format);
1231
_g_free0 (uri_lower);
1232
_g_object_unref0 (file);
1233
_g_free0 (uri);
1234
return result;
1235
}
1236
1237
1238
static gboolean simple_scan_prompt_to_save (SimpleScan* self, const gchar* title, const gchar* discard_label) {
1239
gboolean result = FALSE;
1240
gboolean _tmp0_;
1241
GtkMessageDialog* _tmp1_ = NULL;
1242
GtkMessageDialog* dialog;
1243
const gchar* _tmp2_ = NULL;
1244
gint _tmp3_;
1245
gint response;
1246
g_return_val_if_fail (self != NULL, FALSE);
1247
g_return_val_if_fail (title != NULL, FALSE);
1248
g_return_val_if_fail (discard_label != NULL, FALSE);
1249
_tmp0_ = book_get_needs_saving (self->priv->book);
1250
if (!_tmp0_) {
1251
result = TRUE;
1252
return result;
1253
}
1254
_tmp1_ = (GtkMessageDialog*) gtk_message_dialog_new (self->priv->window, GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, "%s", title);
1255
dialog = g_object_ref_sink (_tmp1_);
1256
_tmp2_ = _ ("If you don't save, changes will be permanently lost.");
1257
gtk_message_dialog_format_secondary_text (dialog, "%s", _tmp2_, NULL);
1258
gtk_dialog_add_button ((GtkDialog*) dialog, discard_label, (gint) GTK_RESPONSE_NO);
1259
gtk_dialog_add_button ((GtkDialog*) dialog, GTK_STOCK_CANCEL, (gint) GTK_RESPONSE_CANCEL);
1260
gtk_dialog_add_button ((GtkDialog*) dialog, GTK_STOCK_SAVE, (gint) GTK_RESPONSE_YES);
1261
_tmp3_ = gtk_dialog_run ((GtkDialog*) dialog);
1262
response = _tmp3_;
1263
gtk_widget_destroy ((GtkWidget*) dialog);
1264
switch (response) {
1265
case GTK_RESPONSE_YES:
1266
{
1267
gboolean _tmp4_;
1268
_tmp4_ = simple_scan_save_document (self, FALSE);
1269
if (_tmp4_) {
1270
result = TRUE;
1271
_g_object_unref0 (dialog);
1272
return result;
1273
} else {
1274
result = FALSE;
1275
_g_object_unref0 (dialog);
1276
return result;
1277
}
1278
}
1279
case GTK_RESPONSE_CANCEL:
1280
{
1281
result = FALSE;
1282
_g_object_unref0 (dialog);
1283
return result;
1284
}
1285
default:
1286
case GTK_RESPONSE_NO:
1287
{
1288
result = TRUE;
1289
_g_object_unref0 (dialog);
1290
return result;
1291
}
1292
}
1293
_g_object_unref0 (dialog);
1294
}
1295
1296
1297
static void simple_scan_clear_document (SimpleScan* self) {
1298
g_return_if_fail (self != NULL);
1299
book_clear (self->priv->book);
1300
simple_scan_add_default_page (self);
1301
_g_free0 (self->priv->book_uri);
1302
self->priv->book_uri = NULL;
1303
book_set_needs_saving (self->priv->book, FALSE);
1304
gtk_widget_set_sensitive ((GtkWidget*) self->priv->save_as_menuitem, FALSE);
1305
}
1306
1307
1308
void G_MODULE_EXPORT new_button_clicked_cb (GtkWidget* widget, SimpleScan* self) {
1309
const gchar* _tmp0_ = NULL;
1310
const gchar* _tmp1_ = NULL;
1311
gboolean _tmp2_;
1312
g_return_if_fail (self != NULL);
1313
g_return_if_fail (widget != NULL);
1314
_tmp0_ = _ ("Save current document?");
1315
_tmp1_ = _ ("Discard Changes");
1316
_tmp2_ = simple_scan_prompt_to_save (self, _tmp0_, _tmp1_);
1317
if (!_tmp2_) {
1318
return;
1319
}
1320
simple_scan_clear_document (self);
1321
}
1322
1323
1324
static void simple_scan_set_document_hint (SimpleScan* self, const gchar* document_hint) {
1325
gchar* _tmp0_;
1326
g_return_if_fail (self != NULL);
1327
g_return_if_fail (document_hint != NULL);
1328
_tmp0_ = g_strdup (document_hint);
1329
_g_free0 (self->priv->document_hint);
1330
self->priv->document_hint = _tmp0_;
1331
if (g_strcmp0 (document_hint, "text") == 0) {
1332
gtk_check_menu_item_set_active ((GtkCheckMenuItem*) self->priv->text_toolbar_menuitem, TRUE);
1333
gtk_check_menu_item_set_active ((GtkCheckMenuItem*) self->priv->text_menu_menuitem, TRUE);
1334
} else {
1335
if (g_strcmp0 (document_hint, "photo") == 0) {
1336
gtk_check_menu_item_set_active ((GtkCheckMenuItem*) self->priv->photo_toolbar_menuitem, TRUE);
1337
gtk_check_menu_item_set_active ((GtkCheckMenuItem*) self->priv->photo_menu_menuitem, TRUE);
1338
}
1339
}
1340
}
1341
1342
1343
void G_MODULE_EXPORT text_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self) {
1344
gboolean _tmp0_;
1345
g_return_if_fail (self != NULL);
1346
g_return_if_fail (widget != NULL);
1347
_tmp0_ = gtk_check_menu_item_get_active (widget);
1348
if (_tmp0_) {
1349
simple_scan_set_document_hint (self, "text");
1350
}
1351
}
1352
1353
1354
void G_MODULE_EXPORT photo_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self) {
1355
gboolean _tmp0_;
1356
g_return_if_fail (self != NULL);
1357
g_return_if_fail (widget != NULL);
1358
_tmp0_ = gtk_check_menu_item_get_active (widget);
1359
if (_tmp0_) {
1360
simple_scan_set_document_hint (self, "photo");
1361
}
1362
}
1363
1364
1365
static void simple_scan_set_page_side (SimpleScan* self, ScanType page_side) {
1366
GtkTreeIter iter = {0};
1367
GtkTreeIter _tmp0_ = {0};
1368
gboolean _tmp1_;
1369
g_return_if_fail (self != NULL);
1370
_tmp1_ = gtk_tree_model_get_iter_first ((GtkTreeModel*) self->priv->page_side_model, &_tmp0_);
1371
iter = _tmp0_;
1372
if (_tmp1_) {
1373
{
1374
gboolean _tmp2_;
1375
_tmp2_ = TRUE;
1376
while (TRUE) {
1377
gint s = 0;
1378
if (!_tmp2_) {
1379
gboolean _tmp3_;
1380
_tmp3_ = gtk_tree_model_iter_next ((GtkTreeModel*) self->priv->page_side_model, &iter);
1381
if (!_tmp3_) {
1382
break;
1383
}
1384
}
1385
_tmp2_ = FALSE;
1386
gtk_tree_model_get ((GtkTreeModel*) self->priv->page_side_model, &iter, 0, &s, -1, -1);
1387
if (s == ((gint) page_side)) {
1388
gtk_combo_box_set_active_iter (self->priv->page_side_combo, &iter);
1389
return;
1390
}
1391
}
1392
}
1393
}
1394
}
1395
1396
1397
static void simple_scan_set_paper_size (SimpleScan* self, gint width, gint height) {
1398
GtkTreeIter iter = {0};
1399
gboolean have_iter = FALSE;
1400
g_return_if_fail (self != NULL);
1401
{
1402
GtkTreeIter _tmp0_ = {0};
1403
gboolean _tmp1_;
1404
gboolean _tmp2_;
1405
_tmp1_ = gtk_tree_model_get_iter_first ((GtkTreeModel*) self->priv->paper_size_model, &_tmp0_);
1406
iter = _tmp0_;
1407
have_iter = _tmp1_;
1408
_tmp2_ = TRUE;
1409
while (TRUE) {
1410
gint w = 0;
1411
gint h = 0;
1412
gboolean _tmp4_ = FALSE;
1413
if (!_tmp2_) {
1414
gboolean _tmp3_;
1415
_tmp3_ = gtk_tree_model_iter_next ((GtkTreeModel*) self->priv->paper_size_model, &iter);
1416
have_iter = _tmp3_;
1417
}
1418
_tmp2_ = FALSE;
1419
if (!have_iter) {
1420
break;
1421
}
1422
gtk_tree_model_get ((GtkTreeModel*) self->priv->paper_size_model, &iter, 0, &w, 1, &h, -1, -1);
1423
if (w == width) {
1424
_tmp4_ = h == height;
1425
} else {
1426
_tmp4_ = FALSE;
1427
}
1428
if (_tmp4_) {
1429
break;
1430
}
1431
}
1432
}
1433
if (!have_iter) {
1434
GtkTreeIter _tmp5_ = {0};
1435
gboolean _tmp6_;
1436
_tmp6_ = gtk_tree_model_get_iter_first ((GtkTreeModel*) self->priv->paper_size_model, &_tmp5_);
1437
iter = _tmp5_;
1438
have_iter = _tmp6_;
1439
}
1440
if (have_iter) {
1441
gtk_combo_box_set_active_iter (self->priv->paper_size_combo, &iter);
1442
}
1443
}
1444
1445
1446
static gint simple_scan_get_text_dpi (SimpleScan* self) {
1447
gint result = 0;
1448
GtkTreeIter iter = {0};
1449
gint dpi;
1450
GtkTreeIter _tmp0_ = {0};
1451
gboolean _tmp1_;
1452
g_return_val_if_fail (self != NULL, 0);
1453
dpi = SIMPLE_SCAN_DEFAULT_TEXT_DPI;
1454
_tmp1_ = gtk_combo_box_get_active_iter (self->priv->text_dpi_combo, &_tmp0_);
1455
iter = _tmp0_;
1456
if (_tmp1_) {
1457
gtk_tree_model_get ((GtkTreeModel*) self->priv->text_dpi_model, &iter, 0, &dpi, -1, -1);
1458
}
1459
result = dpi;
1460
return result;
1461
}
1462
1463
1464
static gint simple_scan_get_photo_dpi (SimpleScan* self) {
1465
gint result = 0;
1466
GtkTreeIter iter = {0};
1467
gint dpi;
1468
GtkTreeIter _tmp0_ = {0};
1469
gboolean _tmp1_;
1470
g_return_val_if_fail (self != NULL, 0);
1471
dpi = SIMPLE_SCAN_DEFAULT_PHOTO_DPI;
1472
_tmp1_ = gtk_combo_box_get_active_iter (self->priv->photo_dpi_combo, &_tmp0_);
1473
iter = _tmp0_;
1474
if (_tmp1_) {
1475
gtk_tree_model_get ((GtkTreeModel*) self->priv->photo_dpi_model, &iter, 0, &dpi, -1, -1);
1476
}
1477
result = dpi;
1478
return result;
1479
}
1480
1481
1482
static ScanType simple_scan_get_page_side (SimpleScan* self) {
1483
ScanType result = 0;
1484
GtkTreeIter iter = {0};
1485
gint page_side;
1486
GtkTreeIter _tmp0_ = {0};
1487
gboolean _tmp1_;
1488
g_return_val_if_fail (self != NULL, 0);
1489
page_side = (gint) SCAN_TYPE_ADF_BOTH;
1490
_tmp1_ = gtk_combo_box_get_active_iter (self->priv->page_side_combo, &_tmp0_);
1491
iter = _tmp0_;
1492
if (_tmp1_) {
1493
gtk_tree_model_get ((GtkTreeModel*) self->priv->page_side_model, &iter, 0, &page_side, -1, -1);
1494
}
1495
result = (ScanType) page_side;
1496
return result;
1497
}
1498
1499
1500
static gboolean simple_scan_get_paper_size (SimpleScan* self, gint* width, gint* height) {
1501
gint _width = 0;
1502
gint _height = 0;
1503
gboolean result = FALSE;
1504
GtkTreeIter iter = {0};
1505
GtkTreeIter _tmp0_ = {0};
1506
gboolean _tmp1_;
1507
g_return_val_if_fail (self != NULL, FALSE);
1508
_tmp1_ = gtk_combo_box_get_active_iter (self->priv->paper_size_combo, &_tmp0_);
1509
iter = _tmp0_;
1510
if (_tmp1_) {
1511
gtk_tree_model_get ((GtkTreeModel*) self->priv->paper_size_model, &iter, 0, &_width, 1, &_height, -1, -1);
1512
result = TRUE;
1513
if (width) {
1514
*width = _width;
1515
}
1516
if (height) {
1517
*height = _height;
1518
}
1519
return result;
1520
}
1521
result = FALSE;
1522
if (width) {
1523
*width = _width;
1524
}
1525
if (height) {
1526
*height = _height;
1527
}
1528
return result;
1529
}
1530
1531
1532
static ScanOptions* simple_scan_get_scan_options (SimpleScan* self) {
1533
ScanOptions* result = NULL;
1534
ScanOptions* _tmp0_ = NULL;
1535
ScanOptions* options;
1536
gint _tmp3_;
1537
gint _tmp4_;
1538
g_return_val_if_fail (self != NULL, NULL);
1539
_tmp0_ = scan_options_new ();
1540
options = _tmp0_;
1541
if (g_strcmp0 (self->priv->document_hint, "text") == 0) {
1542
gint _tmp1_;
1543
options->scan_mode = SCAN_MODE_GRAY;
1544
_tmp1_ = simple_scan_get_text_dpi (self);
1545
options->dpi = _tmp1_;
1546
options->depth = 2;
1547
} else {
1548
gint _tmp2_;
1549
options->scan_mode = SCAN_MODE_COLOR;
1550
_tmp2_ = simple_scan_get_photo_dpi (self);
1551
options->dpi = _tmp2_;
1552
options->depth = 8;
1553
}
1554
simple_scan_get_paper_size (self, &_tmp3_, &_tmp4_);
1555
options->paper_width = _tmp3_;
1556
options->paper_height = _tmp4_;
1557
result = options;
1558
return result;
1559
}
1560
1561
1562
void G_MODULE_EXPORT scan_button_clicked_cb (GtkWidget* widget, SimpleScan* self) {
1563
ScanOptions* _tmp0_ = NULL;
1564
ScanOptions* options;
1565
gchar* _tmp1_ = NULL;
1566
gchar* _tmp2_;
1567
g_return_if_fail (self != NULL);
1568
g_return_if_fail (widget != NULL);
1569
_tmp0_ = simple_scan_get_scan_options (self);
1570
options = _tmp0_;
1571
options->type = SCAN_TYPE_SINGLE;
1572
_tmp1_ = simple_scan_get_selected_device (self);
1573
_tmp2_ = _tmp1_;
1574
g_signal_emit_by_name (self, "start-scan", _tmp2_, options);
1575
_g_free0 (_tmp2_);
1576
_scan_options_unref0 (options);
1577
}
1578
1579
1580
void G_MODULE_EXPORT stop_scan_button_clicked_cb (GtkWidget* widget, SimpleScan* self) {
1581
g_return_if_fail (self != NULL);
1582
g_return_if_fail (widget != NULL);
1583
g_signal_emit_by_name (self, "stop-scan");
1584
}
1585
1586
1587
void G_MODULE_EXPORT continuous_scan_button_clicked_cb (GtkWidget* widget, SimpleScan* self) {
1588
g_return_if_fail (self != NULL);
1589
g_return_if_fail (widget != NULL);
1590
if (self->priv->scanning) {
1591
g_signal_emit_by_name (self, "stop-scan");
1592
} else {
1593
ScanOptions* _tmp0_ = NULL;
1594
ScanOptions* options;
1595
ScanType _tmp1_;
1596
gchar* _tmp2_ = NULL;
1597
gchar* _tmp3_;
1598
_tmp0_ = simple_scan_get_scan_options (self);
1599
options = _tmp0_;
1600
_tmp1_ = simple_scan_get_page_side (self);
1601
options->type = _tmp1_;
1602
_tmp2_ = simple_scan_get_selected_device (self);
1603
_tmp3_ = _tmp2_;
1604
g_signal_emit_by_name (self, "start-scan", _tmp3_, options);
1605
_g_free0 (_tmp3_);
1606
_scan_options_unref0 (options);
1607
}
1608
}
1609
1610
1611
void G_MODULE_EXPORT preferences_button_clicked_cb (GtkWidget* widget, SimpleScan* self) {
1612
g_return_if_fail (self != NULL);
1613
g_return_if_fail (widget != NULL);
1614
gtk_window_present ((GtkWindow*) self->priv->preferences_dialog);
1615
}
1616
1617
1618
gboolean G_MODULE_EXPORT preferences_dialog_delete_event_cb (GtkWidget* widget, SimpleScan* self) {
1619
gboolean result = FALSE;
1620
g_return_val_if_fail (self != NULL, FALSE);
1621
g_return_val_if_fail (widget != NULL, FALSE);
1622
result = TRUE;
1623
return result;
1624
}
1625
1626
1627
void G_MODULE_EXPORT preferences_dialog_response_cb (GtkWidget* widget, gint response_id, SimpleScan* self) {
1628
g_return_if_fail (self != NULL);
1629
g_return_if_fail (widget != NULL);
1630
gtk_widget_hide ((GtkWidget*) self->priv->preferences_dialog);
1631
}
1632
1633
1634
static void simple_scan_update_page_menu (SimpleScan* self) {
1635
Page* _tmp0_ = NULL;
1636
Page* page;
1637
g_return_if_fail (self != NULL);
1638
_tmp0_ = book_view_get_selected (self->priv->book_view);
1639
page = _tmp0_;
1640
if (page == NULL) {
1641
gtk_widget_set_sensitive ((GtkWidget*) self->priv->page_move_left_menuitem, FALSE);
1642
gtk_widget_set_sensitive ((GtkWidget*) self->priv->page_move_right_menuitem, FALSE);
1643
} else {
1644
guint _tmp1_;
1645
guint index;
1646
guint _tmp2_;
1647
_tmp1_ = book_get_page_index (self->priv->book, page);
1648
index = _tmp1_;
1649
gtk_widget_set_sensitive ((GtkWidget*) self->priv->page_move_left_menuitem, index > ((guint) 0));
1650
_tmp2_ = book_get_n_pages (self->priv->book);
1651
gtk_widget_set_sensitive ((GtkWidget*) self->priv->page_move_right_menuitem, index < (_tmp2_ - 1));
1652
}
1653
_page_unref0 (page);
1654
}
1655
1656
1657
static void simple_scan_page_selected_cb (SimpleScan* self, BookView* view, Page* page) {
1658
gchar* name;
1659
gboolean _tmp0_;
1660
GObject* _tmp10_ = NULL;
1661
GtkRadioMenuItem* _tmp11_;
1662
GtkRadioMenuItem* menuitem;
1663
GObject* _tmp12_ = NULL;
1664
GtkToggleToolButton* _tmp13_;
1665
GtkToggleToolButton* toolbutton;
1666
gboolean _tmp14_;
1667
g_return_if_fail (self != NULL);
1668
g_return_if_fail (view != NULL);
1669
if (page == NULL) {
1670
return;
1671
}
1672
self->priv->updating_page_menu = TRUE;
1673
simple_scan_update_page_menu (self);
1674
name = NULL;
1675
_tmp0_ = page_has_crop (page);
1676
if (_tmp0_) {
1677
gchar* _tmp1_ = NULL;
1678
gchar* crop_name;
1679
_tmp1_ = page_get_named_crop (page);
1680
crop_name = _tmp1_;
1681
if (crop_name != NULL) {
1682
if (g_strcmp0 (crop_name, "A4") == 0) {
1683
gchar* _tmp2_;
1684
_tmp2_ = g_strdup ("a4_menuitem");
1685
_g_free0 (name);
1686
name = _tmp2_;
1687
} else {
1688
if (g_strcmp0 (crop_name, "A5") == 0) {
1689
gchar* _tmp3_;
1690
_tmp3_ = g_strdup ("a5_menuitem");
1691
_g_free0 (name);
1692
name = _tmp3_;
1693
} else {
1694
if (g_strcmp0 (crop_name, "A6") == 0) {
1695
gchar* _tmp4_;
1696
_tmp4_ = g_strdup ("a6_menuitem");
1697
_g_free0 (name);
1698
name = _tmp4_;
1699
} else {
1700
if (g_strcmp0 (crop_name, "letter") == 0) {
1701
gchar* _tmp5_;
1702
_tmp5_ = g_strdup ("letter_menuitem");
1703
_g_free0 (name);
1704
name = _tmp5_;
1705
} else {
1706
if (g_strcmp0 (crop_name, "legal") == 0) {
1707
gchar* _tmp6_;
1708
_tmp6_ = g_strdup ("legal_menuitem");
1709
_g_free0 (name);
1710
name = _tmp6_;
1711
} else {
1712
if (g_strcmp0 (crop_name, "4x6") == 0) {
1713
gchar* _tmp7_;
1714
_tmp7_ = g_strdup ("4x6_menuitem");
1715
_g_free0 (name);
1716
name = _tmp7_;
1717
}
1718
}
1719
}
1720
}
1721
}
1722
}
1723
} else {
1724
gchar* _tmp8_;
1725
_tmp8_ = g_strdup ("custom_crop_menuitem");
1726
_g_free0 (name);
1727
name = _tmp8_;
1728
}
1729
_g_free0 (crop_name);
1730
} else {
1731
gchar* _tmp9_;
1732
_tmp9_ = g_strdup ("no_crop_menuitem");
1733
_g_free0 (name);
1734
name = _tmp9_;
1735
}
1736
_tmp10_ = gtk_builder_get_object (self->priv->builder, name);
1737
_tmp11_ = _g_object_ref0 (GTK_RADIO_MENU_ITEM (_tmp10_));
1738
menuitem = _tmp11_;
1739
gtk_check_menu_item_set_active ((GtkCheckMenuItem*) menuitem, TRUE);
1740
_tmp12_ = gtk_builder_get_object (self->priv->builder, "crop_toolbutton");
1741
_tmp13_ = _g_object_ref0 (GTK_TOGGLE_TOOL_BUTTON (_tmp12_));
1742
toolbutton = _tmp13_;
1743
_tmp14_ = page_has_crop (page);
1744
gtk_toggle_tool_button_set_active (toolbutton, _tmp14_);
1745
self->priv->updating_page_menu = FALSE;
1746
_g_object_unref0 (toolbutton);
1747
_g_object_unref0 (menuitem);
1748
_g_free0 (name);
1749
}
1750
1751
1752
static gchar* simple_scan_get_temporary_filename (SimpleScan* self, const gchar* prefix, const gchar* extension) {
1753
gchar* result = NULL;
1754
gchar* _tmp0_ = NULL;
1755
gchar* filename;
1756
gchar* path = NULL;
1757
GError * _inner_error_ = NULL;
1758
g_return_val_if_fail (self != NULL, NULL);
1759
g_return_val_if_fail (prefix != NULL, NULL);
1760
g_return_val_if_fail (extension != NULL, NULL);
1761
_tmp0_ = g_strdup_printf ("%sXXXXXX.%s", prefix, extension);
1762
filename = _tmp0_;
1763
{
1764
gchar* _tmp1_ = NULL;
1765
gint _tmp2_;
1766
gint fd;
1767
_tmp2_ = g_file_open_tmp (filename, &_tmp1_, &_inner_error_);
1768
_g_free0 (path);
1769
path = _tmp1_;
1770
fd = _tmp2_;
1771
if (_inner_error_ != NULL) {
1772
goto __catch11_g_error;
1773
}
1774
close (fd);
1775
}
1776
goto __finally11;
1777
__catch11_g_error:
1778
{
1779
GError* e = NULL;
1780
e = _inner_error_;
1781
_inner_error_ = NULL;
1782
g_warning ("ui.vala:788: Error saving email attachment: %s", e->message);
1783
result = NULL;
1784
_g_error_free0 (e);
1785
_g_free0 (path);
1786
_g_free0 (filename);
1787
return result;
1788
}
1789
__finally11:
1790
if (_inner_error_ != NULL) {
1791
_g_free0 (path);
1792
_g_free0 (filename);
1793
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
1794
g_clear_error (&_inner_error_);
1795
return NULL;
1796
}
1797
result = path;
1798
_g_free0 (filename);
1799
return result;
1800
}
1801
1802
1803
static void simple_scan_show_page_cb (SimpleScan* self, BookView* view, Page* page) {
1804
gchar* _tmp0_ = NULL;
1805
gchar* path;
1806
GFile* _tmp1_ = NULL;
1807
GFile* file;
1808
GError * _inner_error_ = NULL;
1809
g_return_if_fail (self != NULL);
1810
g_return_if_fail (view != NULL);
1811
g_return_if_fail (page != NULL);
1812
_tmp0_ = simple_scan_get_temporary_filename (self, "scanned-page", "tiff");
1813
path = _tmp0_;
1814
if (path == NULL) {
1815
_g_free0 (path);
1816
return;
1817
}
1818
_tmp1_ = g_file_new_for_path (path);
1819
file = _tmp1_;
1820
{
1821
page_save (page, "tiff", file, &_inner_error_);
1822
if (_inner_error_ != NULL) {
1823
goto __catch12_g_error;
1824
}
1825
}
1826
goto __finally12;
1827
__catch12_g_error:
1828
{
1829
GError* e = NULL;
1830
const gchar* _tmp2_ = NULL;
1831
e = _inner_error_;
1832
_inner_error_ = NULL;
1833
_tmp2_ = _ ("Unable to save image for preview");
1834
simple_scan_show_error_dialog (self, _tmp2_, e->message);
1835
_g_error_free0 (e);
1836
_g_object_unref0 (file);
1837
_g_free0 (path);
1838
return;
1839
}
1840
__finally12:
1841
if (_inner_error_ != NULL) {
1842
_g_object_unref0 (file);
1843
_g_free0 (path);
1844
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
1845
g_clear_error (&_inner_error_);
1846
return;
1847
}
1848
{
1849
GdkScreen* _tmp3_ = NULL;
1850
gchar* _tmp4_ = NULL;
1851
gchar* _tmp5_;
1852
guint32 _tmp6_;
1853
_tmp3_ = gtk_window_get_screen (self->priv->window);
1854
_tmp4_ = g_file_get_uri (file);
1855
_tmp5_ = _tmp4_;
1856
_tmp6_ = gtk_get_current_event_time ();
1857
gtk_show_uri (_tmp3_, _tmp5_, _tmp6_, &_inner_error_);
1858
_g_free0 (_tmp5_);
1859
if (_inner_error_ != NULL) {
1860
goto __catch13_g_error;
1861
}
1862
}
1863
goto __finally13;
1864
__catch13_g_error:
1865
{
1866
GError* e = NULL;
1867
const gchar* _tmp7_ = NULL;
1868
e = _inner_error_;
1869
_inner_error_ = NULL;
1870
_tmp7_ = _ ("Unable to open image preview application");
1871
simple_scan_show_error_dialog (self, _tmp7_, e->message);
1872
_g_error_free0 (e);
1873
}
1874
__finally13:
1875
if (_inner_error_ != NULL) {
1876
_g_object_unref0 (file);
1877
_g_free0 (path);
1878
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
1879
g_clear_error (&_inner_error_);
1880
return;
1881
}
1882
_g_object_unref0 (file);
1883
_g_free0 (path);
1884
}
1885
1886
1887
static void simple_scan_show_page_menu_cb (SimpleScan* self, BookView* view) {
1888
GObject* _tmp0_ = NULL;
1889
GtkMenu* _tmp1_;
1890
GtkMenu* menu;
1891
guint32 _tmp2_;
1892
g_return_if_fail (self != NULL);
1893
g_return_if_fail (view != NULL);
1894
_tmp0_ = gtk_builder_get_object (self->priv->builder, "page_menu");
1895
_tmp1_ = _g_object_ref0 (GTK_MENU (_tmp0_));
1896
menu = _tmp1_;
1897
_tmp2_ = gtk_get_current_event_time ();
1898
gtk_menu_popup (menu, NULL, NULL, NULL, NULL, (guint) 3, _tmp2_);
1899
_g_object_unref0 (menu);
1900
}
1901
1902
1903
void G_MODULE_EXPORT rotate_left_button_clicked_cb (GtkWidget* widget, SimpleScan* self) {
1904
Page* _tmp0_ = NULL;
1905
Page* page;
1906
g_return_if_fail (self != NULL);
1907
g_return_if_fail (widget != NULL);
1908
if (self->priv->updating_page_menu) {
1909
return;
1910
}
1911
_tmp0_ = book_view_get_selected (self->priv->book_view);
1912
page = _tmp0_;
1913
if (page != NULL) {
1914
page_rotate_left (page);
1915
}
1916
_page_unref0 (page);
1917
}
1918
1919
1920
void G_MODULE_EXPORT rotate_right_button_clicked_cb (GtkWidget* widget, SimpleScan* self) {
1921
Page* _tmp0_ = NULL;
1922
Page* page;
1923
g_return_if_fail (self != NULL);
1924
g_return_if_fail (widget != NULL);
1925
if (self->priv->updating_page_menu) {
1926
return;
1927
}
1928
_tmp0_ = book_view_get_selected (self->priv->book_view);
1929
page = _tmp0_;
1930
if (page != NULL) {
1931
page_rotate_right (page);
1932
}
1933
_page_unref0 (page);
1934
}
1935
1936
1937
static void simple_scan_set_crop (SimpleScan* self, const gchar* crop_name) {
1938
Page* _tmp0_ = NULL;
1939
Page* page;
1940
g_return_if_fail (self != NULL);
1941
gtk_widget_set_sensitive ((GtkWidget*) self->priv->crop_rotate_menuitem, crop_name != NULL);
1942
if (self->priv->updating_page_menu) {
1943
return;
1944
}
1945
_tmp0_ = book_view_get_selected (self->priv->book_view);
1946
page = _tmp0_;
1947
if (page == NULL) {
1948
_page_unref0 (page);
1949
return;
1950
}
1951
if (crop_name == NULL) {
1952
page_set_no_crop (page);
1953
_page_unref0 (page);
1954
return;
1955
} else {
1956
if (g_strcmp0 (crop_name, "custom") == 0) {
1957
gint _tmp1_;
1958
gint width;
1959
gint _tmp2_;
1960
gint height;
1961
gint crop_width;
1962
gint crop_height;
1963
_tmp1_ = page_get_width (page);
1964
width = _tmp1_;
1965
_tmp2_ = page_get_height (page);
1966
height = _tmp2_;
1967
crop_width = (gint) ((width * 0.8) + 0.5);
1968
crop_height = (gint) ((height * 0.8) + 0.5);
1969
page_set_custom_crop (page, crop_width, crop_height);
1970
page_move_crop (page, (width - crop_width) / 2, (height - crop_height) / 2);
1971
} else {
1972
page_set_named_crop (page, crop_name);
1973
}
1974
}
1975
_page_unref0 (page);
1976
}
1977
1978
1979
void G_MODULE_EXPORT no_crop_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self) {
1980
gboolean _tmp0_;
1981
g_return_if_fail (self != NULL);
1982
g_return_if_fail (widget != NULL);
1983
_tmp0_ = gtk_check_menu_item_get_active (widget);
1984
if (_tmp0_) {
1985
simple_scan_set_crop (self, NULL);
1986
}
1987
}
1988
1989
1990
void G_MODULE_EXPORT custom_crop_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self) {
1991
gboolean _tmp0_;
1992
g_return_if_fail (self != NULL);
1993
g_return_if_fail (widget != NULL);
1994
_tmp0_ = gtk_check_menu_item_get_active (widget);
1995
if (_tmp0_) {
1996
simple_scan_set_crop (self, "custom");
1997
}
1998
}
1999
2000
2001
void G_MODULE_EXPORT crop_toolbutton_toggled_cb (GtkToggleToolButton* widget, SimpleScan* self) {
2002
GtkRadioMenuItem* menuitem = NULL;
2003
gboolean _tmp0_;
2004
g_return_if_fail (self != NULL);
2005
g_return_if_fail (widget != NULL);
2006
if (self->priv->updating_page_menu) {
2007
return;
2008
}
2009
_tmp0_ = gtk_toggle_tool_button_get_active (widget);
2010
if (_tmp0_) {
2011
GObject* _tmp1_ = NULL;
2012
GtkRadioMenuItem* _tmp2_;
2013
_tmp1_ = gtk_builder_get_object (self->priv->builder, "custom_crop_menuitem");
2014
_tmp2_ = _g_object_ref0 (GTK_RADIO_MENU_ITEM (_tmp1_));
2015
_g_object_unref0 (menuitem);
2016
menuitem = _tmp2_;
2017
} else {
2018
GObject* _tmp3_ = NULL;
2019
GtkRadioMenuItem* _tmp4_;
2020
_tmp3_ = gtk_builder_get_object (self->priv->builder, "no_crop_menuitem");
2021
_tmp4_ = _g_object_ref0 (GTK_RADIO_MENU_ITEM (_tmp3_));
2022
_g_object_unref0 (menuitem);
2023
menuitem = _tmp4_;
2024
}
2025
gtk_check_menu_item_set_active ((GtkCheckMenuItem*) menuitem, TRUE);
2026
_g_object_unref0 (menuitem);
2027
}
2028
2029
2030
void G_MODULE_EXPORT four_by_six_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self) {
2031
gboolean _tmp0_;
2032
g_return_if_fail (self != NULL);
2033
g_return_if_fail (widget != NULL);
2034
_tmp0_ = gtk_check_menu_item_get_active (widget);
2035
if (_tmp0_) {
2036
simple_scan_set_crop (self, "4x6");
2037
}
2038
}
2039
2040
2041
void G_MODULE_EXPORT legal_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self) {
2042
gboolean _tmp0_;
2043
g_return_if_fail (self != NULL);
2044
g_return_if_fail (widget != NULL);
2045
_tmp0_ = gtk_check_menu_item_get_active (widget);
2046
if (_tmp0_) {
2047
simple_scan_set_crop (self, "legal");
2048
}
2049
}
2050
2051
2052
void G_MODULE_EXPORT letter_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self) {
2053
gboolean _tmp0_;
2054
g_return_if_fail (self != NULL);
2055
g_return_if_fail (widget != NULL);
2056
_tmp0_ = gtk_check_menu_item_get_active (widget);
2057
if (_tmp0_) {
2058
simple_scan_set_crop (self, "letter");
2059
}
2060
}
2061
2062
2063
void G_MODULE_EXPORT a6_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self) {
2064
gboolean _tmp0_;
2065
g_return_if_fail (self != NULL);
2066
g_return_if_fail (widget != NULL);
2067
_tmp0_ = gtk_check_menu_item_get_active (widget);
2068
if (_tmp0_) {
2069
simple_scan_set_crop (self, "A6");
2070
}
2071
}
2072
2073
2074
void G_MODULE_EXPORT a5_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self) {
2075
gboolean _tmp0_;
2076
g_return_if_fail (self != NULL);
2077
g_return_if_fail (widget != NULL);
2078
_tmp0_ = gtk_check_menu_item_get_active (widget);
2079
if (_tmp0_) {
2080
simple_scan_set_crop (self, "A5");
2081
}
2082
}
2083
2084
2085
void G_MODULE_EXPORT a4_menuitem_toggled_cb (GtkCheckMenuItem* widget, SimpleScan* self) {
2086
gboolean _tmp0_;
2087
g_return_if_fail (self != NULL);
2088
g_return_if_fail (widget != NULL);
2089
_tmp0_ = gtk_check_menu_item_get_active (widget);
2090
if (_tmp0_) {
2091
simple_scan_set_crop (self, "A4");
2092
}
2093
}
2094
2095
2096
void G_MODULE_EXPORT crop_rotate_menuitem_activate_cb (GtkWidget* widget, SimpleScan* self) {
2097
Page* _tmp0_ = NULL;
2098
Page* page;
2099
g_return_if_fail (self != NULL);
2100
g_return_if_fail (widget != NULL);
2101
_tmp0_ = book_view_get_selected (self->priv->book_view);
2102
page = _tmp0_;
2103
if (page == NULL) {
2104
_page_unref0 (page);
2105
return;
2106
}
2107
page_rotate_crop (page);
2108
_page_unref0 (page);
2109
}
2110
2111
2112
void G_MODULE_EXPORT page_move_left_menuitem_activate_cb (GtkWidget* widget, SimpleScan* self) {
2113
Page* _tmp0_ = NULL;
2114
Page* page;
2115
guint _tmp1_;
2116
guint index;
2117
g_return_if_fail (self != NULL);
2118
g_return_if_fail (widget != NULL);
2119
_tmp0_ = book_view_get_selected (self->priv->book_view);
2120
page = _tmp0_;
2121
_tmp1_ = book_get_page_index (self->priv->book, page);
2122
index = _tmp1_;
2123
if (index > ((guint) 0)) {
2124
book_move_page (self->priv->book, page, index - 1);
2125
}
2126
simple_scan_update_page_menu (self);
2127
_page_unref0 (page);
2128
}
2129
2130
2131
void G_MODULE_EXPORT page_move_right_menuitem_activate_cb (GtkWidget* widget, SimpleScan* self) {
2132
Page* _tmp0_ = NULL;
2133
Page* page;
2134
guint _tmp1_;
2135
guint index;
2136
guint _tmp2_;
2137
g_return_if_fail (self != NULL);
2138
g_return_if_fail (widget != NULL);
2139
_tmp0_ = book_view_get_selected (self->priv->book_view);
2140
page = _tmp0_;
2141
_tmp1_ = book_get_page_index (self->priv->book, page);
2142
index = _tmp1_;
2143
_tmp2_ = book_get_n_pages (self->priv->book);
2144
if (index < (_tmp2_ - 1)) {
2145
guint _tmp3_;
2146
_tmp3_ = book_get_page_index (self->priv->book, page);
2147
book_move_page (self->priv->book, page, _tmp3_ + 1);
2148
}
2149
simple_scan_update_page_menu (self);
2150
_page_unref0 (page);
2151
}
2152
2153
2154
void G_MODULE_EXPORT page_delete_menuitem_activate_cb (GtkWidget* widget, SimpleScan* self) {
2155
Book* _tmp0_ = NULL;
2156
Book* _tmp1_;
2157
Page* _tmp2_ = NULL;
2158
Page* _tmp3_;
2159
g_return_if_fail (self != NULL);
2160
g_return_if_fail (widget != NULL);
2161
_tmp0_ = book_view_get_book (self->priv->book_view);
2162
_tmp1_ = _tmp0_;
2163
_tmp2_ = book_view_get_selected (self->priv->book_view);
2164
_tmp3_ = _tmp2_;
2165
book_delete_page (_tmp1_, _tmp3_);
2166
_page_unref0 (_tmp3_);
2167
_book_unref0 (_tmp1_);
2168
}
2169
2170
2171
void G_MODULE_EXPORT save_file_button_clicked_cb (GtkWidget* widget, SimpleScan* self) {
2172
g_return_if_fail (self != NULL);
2173
g_return_if_fail (widget != NULL);
2174
simple_scan_save_document (self, FALSE);
2175
}
2176
2177
2178
void G_MODULE_EXPORT save_as_file_button_clicked_cb (GtkWidget* widget, SimpleScan* self) {
2179
g_return_if_fail (self != NULL);
2180
g_return_if_fail (widget != NULL);
2181
simple_scan_save_document (self, TRUE);
2182
}
2183
2184
2185
static gpointer _cairo_reference0 (gpointer self) {
2186
return self ? cairo_reference (self) : NULL;
2187
}
2188
2189
2190
static void simple_scan_draw_page (SimpleScan* self, GtkPrintOperation* operation, GtkPrintContext* print_context, gint page_number) {
2191
cairo_t* _tmp0_ = NULL;
2192
cairo_t* _tmp1_;
2193
cairo_t* context;
2194
Page* _tmp2_ = NULL;
2195
Page* page;
2196
gboolean is_landscape;
2197
gdouble _tmp3_;
2198
gdouble _tmp4_;
2199
gboolean _tmp5_;
2200
gdouble _tmp7_;
2201
gint _tmp8_;
2202
gdouble _tmp9_;
2203
gint _tmp10_;
2204
GdkPixbuf* _tmp11_ = NULL;
2205
GdkPixbuf* image;
2206
g_return_if_fail (self != NULL);
2207
g_return_if_fail (operation != NULL);
2208
g_return_if_fail (print_context != NULL);
2209
_tmp0_ = gtk_print_context_get_cairo_context (print_context);
2210
_tmp1_ = _cairo_reference0 (_tmp0_);
2211
context = _tmp1_;
2212
_tmp2_ = book_get_page (self->priv->book, page_number);
2213
page = _tmp2_;
2214
is_landscape = FALSE;
2215
_tmp3_ = gtk_print_context_get_width (print_context);
2216
_tmp4_ = gtk_print_context_get_height (print_context);
2217
if (_tmp3_ > _tmp4_) {
2218
is_landscape = TRUE;
2219
}
2220
_tmp5_ = page_is_landscape (page);
2221
if (_tmp5_ != is_landscape) {
2222
gdouble _tmp6_;
2223
_tmp6_ = gtk_print_context_get_width (print_context);
2224
cairo_translate (context, _tmp6_, (gdouble) 0);
2225
cairo_rotate (context, G_PI_2);
2226
}
2227
_tmp7_ = gtk_print_context_get_dpi_x (print_context);
2228
_tmp8_ = page_get_dpi (page);
2229
_tmp9_ = gtk_print_context_get_dpi_y (print_context);
2230
_tmp10_ = page_get_dpi (page);
2231
cairo_scale (context, _tmp7_ / _tmp8_, _tmp9_ / _tmp10_);
2232
_tmp11_ = page_get_image (page, TRUE);
2233
image = _tmp11_;
2234
gdk_cairo_set_source_pixbuf (context, image, (gdouble) 0, (gdouble) 0);
2235
cairo_paint (context);
2236
_g_object_unref0 (image);
2237
_page_unref0 (page);
2238
_cairo_destroy0 (context);
2239
}
2240
2241
2242
void G_MODULE_EXPORT email_button_clicked_cb (GtkWidget* widget, SimpleScan* self) {
2243
g_return_if_fail (self != NULL);
2244
g_return_if_fail (widget != NULL);
2245
g_signal_emit_by_name (self, "email", self->priv->document_hint);
2246
}
2247
2248
2249
static void _simple_scan_draw_page_gtk_print_operation_draw_page (GtkPrintOperation* _sender, GtkPrintContext* context, gint page_nr, gpointer self) {
2250
simple_scan_draw_page (self, _sender, context, page_nr);
2251
}
2252
2253
2254
void G_MODULE_EXPORT print_button_clicked_cb (GtkWidget* widget, SimpleScan* self) {
2255
GtkPrintOperation* _tmp0_ = NULL;
2256
GtkPrintOperation* print;
2257
guint _tmp1_;
2258
GError * _inner_error_ = NULL;
2259
g_return_if_fail (self != NULL);
2260
g_return_if_fail (widget != NULL);
2261
_tmp0_ = gtk_print_operation_new ();
2262
print = _tmp0_;
2263
_tmp1_ = book_get_n_pages (self->priv->book);
2264
gtk_print_operation_set_n_pages (print, (gint) _tmp1_);
2265
g_signal_connect (print, "draw-page", (GCallback) _simple_scan_draw_page_gtk_print_operation_draw_page, self);
2266
{
2267
gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, self->priv->window, &_inner_error_);
2268
if (_inner_error_ != NULL) {
2269
goto __catch14_g_error;
2270
}
2271
}
2272
goto __finally14;
2273
__catch14_g_error:
2274
{
2275
GError* e = NULL;
2276
e = _inner_error_;
2277
_inner_error_ = NULL;
2278
g_warning ("ui.vala:1044: Error printing: %s", e->message);
2279
_g_error_free0 (e);
2280
}
2281
__finally14:
2282
if (_inner_error_ != NULL) {
2283
_g_object_unref0 (print);
2284
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
2285
g_clear_error (&_inner_error_);
2286
return;
2287
}
2288
_g_object_unref0 (print);
2289
}
2290
2291
2292
void G_MODULE_EXPORT help_contents_menuitem_activate_cb (GtkWidget* widget, SimpleScan* self) {
2293
GError * _inner_error_ = NULL;
2294
g_return_if_fail (self != NULL);
2295
g_return_if_fail (widget != NULL);
2296
{
2297
GdkScreen* _tmp0_ = NULL;
2298
guint32 _tmp1_;
2299
_tmp0_ = gtk_window_get_screen (self->priv->window);
2300
_tmp1_ = gtk_get_current_event_time ();
2301
gtk_show_uri (_tmp0_, "ghelp:simple-scan", _tmp1_, &_inner_error_);
2302
if (_inner_error_ != NULL) {
2303
goto __catch15_g_error;
2304
}
2305
}
2306
goto __finally15;
2307
__catch15_g_error:
2308
{
2309
GError* e = NULL;
2310
const gchar* _tmp2_ = NULL;
2311
e = _inner_error_;
2312
_inner_error_ = NULL;
2313
_tmp2_ = _ ("Unable to open help file");
2314
simple_scan_show_error_dialog (self, _tmp2_, e->message);
2315
_g_error_free0 (e);
2316
}
2317
__finally15:
2318
if (_inner_error_ != NULL) {
2319
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
2320
g_clear_error (&_inner_error_);
2321
return;
2322
}
2323
}
2324
2325
2326
void G_MODULE_EXPORT about_menuitem_activate_cb (GtkWidget* widget, SimpleScan* self) {
2327
gchar* _tmp0_;
2328
gchar** _tmp1_ = NULL;
2329
gchar** authors;
2330
gint authors_length1;
2331
gint _authors_size_;
2332
const gchar* _tmp2_ = NULL;
2333
gchar* _tmp3_;
2334
gchar* license;
2335
const gchar* _tmp4_ = NULL;
2336
gchar* _tmp5_;
2337
gchar* title;
2338
const gchar* _tmp6_ = NULL;
2339
gchar* _tmp7_;
2340
gchar* description;
2341
const gchar* _tmp8_ = NULL;
2342
g_return_if_fail (self != NULL);
2343
g_return_if_fail (widget != NULL);
2344
_tmp0_ = g_strdup ("Robert Ancell <robert.ancell@canonical.com>");
2345
_tmp1_ = g_new0 (gchar*, 1 + 1);
2346
_tmp1_[0] = _tmp0_;
2347
authors = _tmp1_;
2348
authors_length1 = 1;
2349
_authors_size_ = authors_length1;
2350
_tmp2_ = _ ("This program is free software: you can redistribute it and/or modify\n" \
2351
"it under the terms of the GNU General Public License as published by\n" \
2352
"the Free Software Foundation, either version 3 of the License, or\n" \
2353
"(at your option) any later version.\n" \
2354
"\n" \
2355
"This program is distributed in the hope that it will be useful,\n" \
2356
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n" \
2357
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" \
2358
"GNU General Public License for more details.\n" \
2359
"\n" \
2360
"You should have received a copy of the GNU General Public License\n" \
2361
"along with this program. If not, see <http://www.gnu.org/licenses/>.");
2362
_tmp3_ = g_strdup (_tmp2_);
2363
license = _tmp3_;
2364
_tmp4_ = _ ("About Simple Scan");
2365
_tmp5_ = g_strdup (_tmp4_);
2366
title = _tmp5_;
2367
_tmp6_ = _ ("Simple document scanning tool");
2368
_tmp7_ = g_strdup (_tmp6_);
2369
description = _tmp7_;
2370
_tmp8_ = _ ("translator-credits");
2371
gtk_show_about_dialog (self->priv->window, "title", title, "program-name", "Simple Scan", "version", VERSION, "comments", description, "logo-icon-name", "scanner", "authors", authors, "translator-credits", _tmp8_, "website", "https://launchpad.net/simple-scan", "copyright", "Copyright © 2009-2011 Canonical Ltd.", "license", license, "wrap-license", TRUE, NULL, NULL);
2372
_g_free0 (description);
2373
_g_free0 (title);
2374
_g_free0 (license);
2375
authors = (_vala_array_free (authors, authors_length1, (GDestroyNotify) g_free), NULL);
2376
}
2377
2378
2379
static gboolean simple_scan_on_quit (SimpleScan* self) {
2380
gboolean result = FALSE;
2381
const gchar* _tmp0_ = NULL;
2382
const gchar* _tmp1_ = NULL;
2383
gboolean _tmp2_;
2384
gchar* _tmp3_ = NULL;
2385
gchar* device;
2386
gint paper_width;
2387
gint paper_height;
2388
gint _tmp4_;
2389
gint _tmp5_;
2390
gint _tmp6_;
2391
gint _tmp7_;
2392
ScanType _tmp8_;
2393
g_return_val_if_fail (self != NULL, FALSE);
2394
_tmp0_ = _ ("Save document before quitting?");
2395
_tmp1_ = _ ("Quit without Saving");
2396
_tmp2_ = simple_scan_prompt_to_save (self, _tmp0_, _tmp1_);
2397
if (!_tmp2_) {
2398
result = FALSE;
2399
return result;
2400
}
2401
_tmp3_ = simple_scan_get_selected_device (self);
2402
device = _tmp3_;
2403
paper_width = 0;
2404
paper_height = 0;
2405
simple_scan_get_paper_size (self, &_tmp4_, &_tmp5_);
2406
paper_width = _tmp4_;
2407
paper_height = _tmp5_;
2408
if (device != NULL) {
2409
g_settings_set_string (self->priv->settings, "selected-device", device);
2410
}
2411
g_settings_set_string (self->priv->settings, "document-type", self->priv->document_hint);
2412
_tmp6_ = simple_scan_get_text_dpi (self);
2413
g_settings_set_int (self->priv->settings, "text-dpi", _tmp6_);
2414
_tmp7_ = simple_scan_get_photo_dpi (self);
2415
g_settings_set_int (self->priv->settings, "photo-dpi", _tmp7_);
2416
_tmp8_ = simple_scan_get_page_side (self);
2417
g_settings_set_enum (self->priv->settings, "page-side", (gint) _tmp8_);
2418
g_settings_set_int (self->priv->settings, "paper-width", paper_width);
2419
g_settings_set_int (self->priv->settings, "paper-height", paper_height);
2420
g_settings_set_int (self->priv->settings, "window-width", self->priv->window_width);
2421
g_settings_set_int (self->priv->settings, "window-height", self->priv->window_height);
2422
g_settings_set_boolean (self->priv->settings, "window-is-maximized", self->priv->window_is_maximized);
2423
g_settings_set_enum (self->priv->settings, "scan-direction", (gint) self->priv->default_page_scan_direction);
2424
g_settings_set_int (self->priv->settings, "page-width", self->priv->default_page_width);
2425
g_settings_set_int (self->priv->settings, "page-height", self->priv->default_page_height);
2426
g_settings_set_int (self->priv->settings, "page-dpi", self->priv->default_page_dpi);
2427
g_signal_emit_by_name (self, "quit");
2428
result = TRUE;
2429
_g_free0 (device);
2430
return result;
2431
}
2432
2433
2434
void G_MODULE_EXPORT quit_menuitem_activate_cb (GtkWidget* widget, SimpleScan* self) {
2435
g_return_if_fail (self != NULL);
2436
g_return_if_fail (widget != NULL);
2437
simple_scan_on_quit (self);
2438
}
2439
2440
2441
gboolean G_MODULE_EXPORT simple_scan_window_configure_event_cb (GtkWidget* widget, GdkEventConfigure* event, SimpleScan* self) {
2442
gboolean result = FALSE;
2443
g_return_val_if_fail (self != NULL, FALSE);
2444
g_return_val_if_fail (widget != NULL, FALSE);
2445
if (!self->priv->window_is_maximized) {
2446
self->priv->window_width = (*event).width;
2447
self->priv->window_height = (*event).height;
2448
}
2449
result = FALSE;
2450
return result;
2451
}
2452
2453
2454
static void simple_scan_info_bar_response_cb (SimpleScan* self, GtkInfoBar* widget, gint response_id) {
2455
g_return_if_fail (self != NULL);
2456
g_return_if_fail (widget != NULL);
2457
if (response_id == 1) {
2458
gtk_widget_grab_focus ((GtkWidget*) self->priv->device_combo);
2459
gtk_window_present ((GtkWindow*) self->priv->preferences_dialog);
2460
} else {
2461
self->priv->have_error = FALSE;
2462
_g_free0 (self->priv->error_title);
2463
self->priv->error_title = NULL;
2464
_g_free0 (self->priv->error_text);
2465
self->priv->error_text = NULL;
2466
simple_scan_update_info_bar (self);
2467
}
2468
}
2469
2470
2471
gboolean G_MODULE_EXPORT simple_scan_window_window_state_event_cb (GtkWidget* widget, GdkEventWindowState* event, SimpleScan* self) {
2472
gboolean result = FALSE;
2473
g_return_val_if_fail (self != NULL, FALSE);
2474
g_return_val_if_fail (widget != NULL, FALSE);
2475
if (((*event).changed_mask & GDK_WINDOW_STATE_MAXIMIZED) != 0) {
2476
self->priv->window_is_maximized = ((*event).new_window_state & GDK_WINDOW_STATE_MAXIMIZED) != 0;
2477
}
2478
result = FALSE;
2479
return result;
2480
}
2481
2482
2483
gboolean G_MODULE_EXPORT window_delete_event_cb (GtkWidget* widget, GdkEvent* event, SimpleScan* self) {
2484
gboolean result = FALSE;
2485
gboolean _tmp0_;
2486
g_return_val_if_fail (self != NULL, FALSE);
2487
g_return_val_if_fail (widget != NULL, FALSE);
2488
g_return_val_if_fail (event != NULL, FALSE);
2489
_tmp0_ = simple_scan_on_quit (self);
2490
result = !_tmp0_;
2491
return result;
2492
}
2493
2494
2495
static void simple_scan_page_size_changed_cb (SimpleScan* self, Page* page) {
2496
gint _tmp0_;
2497
gint _tmp1_;
2498
gint _tmp2_;
2499
g_return_if_fail (self != NULL);
2500
g_return_if_fail (page != NULL);
2501
_tmp0_ = page_get_width (page);
2502
self->priv->default_page_width = _tmp0_;
2503
_tmp1_ = page_get_height (page);
2504
self->priv->default_page_height = _tmp1_;
2505
_tmp2_ = page_get_dpi (page);
2506
self->priv->default_page_dpi = _tmp2_;
2507
}
2508
2509
2510
static void simple_scan_page_scan_direction_changed_cb (SimpleScan* self, Page* page) {
2511
ScanDirection _tmp0_;
2512
g_return_if_fail (self != NULL);
2513
g_return_if_fail (page != NULL);
2514
_tmp0_ = page_get_scan_direction (page);
2515
self->priv->default_page_scan_direction = _tmp0_;
2516
}
2517
2518
2519
static void _simple_scan_page_size_changed_cb_page_size_changed (Page* _sender, gpointer self) {
2520
simple_scan_page_size_changed_cb (self, _sender);
2521
}
2522
2523
2524
static void _simple_scan_page_scan_direction_changed_cb_page_scan_direction_changed (Page* _sender, gpointer self) {
2525
simple_scan_page_scan_direction_changed_cb (self, _sender);
2526
}
2527
2528
2529
static void simple_scan_page_added_cb (SimpleScan* self, Book* book, Page* page) {
2530
gint _tmp0_;
2531
gint _tmp1_;
2532
gint _tmp2_;
2533
ScanDirection _tmp3_;
2534
g_return_if_fail (self != NULL);
2535
g_return_if_fail (book != NULL);
2536
g_return_if_fail (page != NULL);
2537
_tmp0_ = page_get_width (page);
2538
self->priv->default_page_width = _tmp0_;
2539
_tmp1_ = page_get_height (page);
2540
self->priv->default_page_height = _tmp1_;
2541
_tmp2_ = page_get_dpi (page);
2542
self->priv->default_page_dpi = _tmp2_;
2543
_tmp3_ = page_get_scan_direction (page);
2544
self->priv->default_page_scan_direction = _tmp3_;
2545
g_signal_connect (page, "size-changed", (GCallback) _simple_scan_page_size_changed_cb_page_size_changed, self);
2546
g_signal_connect (page, "scan-direction-changed", (GCallback) _simple_scan_page_scan_direction_changed_cb_page_scan_direction_changed, self);
2547
simple_scan_update_page_menu (self);
2548
}
2549
2550
2551
static void simple_scan_page_removed_cb (SimpleScan* self, Book* book, Page* page) {
2552
guint _tmp0_;
2553
g_return_if_fail (self != NULL);
2554
g_return_if_fail (book != NULL);
2555
g_return_if_fail (page != NULL);
2556
_tmp0_ = book_get_n_pages (book);
2557
if (_tmp0_ == ((guint) 1)) {
2558
simple_scan_add_default_page (self);
2559
}
2560
simple_scan_update_page_menu (self);
2561
}
2562
2563
2564
static void simple_scan_set_dpi_combo (SimpleScan* self, GtkComboBox* combo, gint default_dpi, gint current_dpi) {
2565
GtkCellRendererText* _tmp0_ = NULL;
2566
GtkCellRendererText* renderer;
2567
GtkTreeModel* _tmp1_ = NULL;
2568
GtkListStore* _tmp2_;
2569
GtkListStore* model;
2570
gint* _tmp3_ = NULL;
2571
gint* scan_resolutions;
2572
gint scan_resolutions_length1;
2573
gint _scan_resolutions_size_;
2574
g_return_if_fail (self != NULL);
2575
g_return_if_fail (combo != NULL);
2576
_tmp0_ = (GtkCellRendererText*) gtk_cell_renderer_text_new ();
2577
renderer = g_object_ref_sink (_tmp0_);
2578
gtk_cell_layout_pack_start ((GtkCellLayout*) combo, (GtkCellRenderer*) renderer, TRUE);
2579
gtk_cell_layout_add_attribute ((GtkCellLayout*) combo, (GtkCellRenderer*) renderer, "text", 1);
2580
_tmp1_ = gtk_combo_box_get_model (combo);
2581
_tmp2_ = _g_object_ref0 (GTK_LIST_STORE (_tmp1_));
2582
model = _tmp2_;
2583
_tmp3_ = g_new0 (gint, 6);
2584
_tmp3_[0] = 75;
2585
_tmp3_[1] = 150;
2586
_tmp3_[2] = 300;
2587
_tmp3_[3] = 600;
2588
_tmp3_[4] = 1200;
2589
_tmp3_[5] = 2400;
2590
scan_resolutions = _tmp3_;
2591
scan_resolutions_length1 = 6;
2592
_scan_resolutions_size_ = scan_resolutions_length1;
2593
{
2594
gint* dpi_collection = NULL;
2595
gint dpi_collection_length1 = 0;
2596
gint _dpi_collection_size_ = 0;
2597
gint dpi_it;
2598
dpi_collection = scan_resolutions;
2599
dpi_collection_length1 = scan_resolutions_length1;
2600
for (dpi_it = 0; dpi_it < scan_resolutions_length1; dpi_it = dpi_it + 1) {
2601
gint dpi = 0;
2602
dpi = dpi_collection[dpi_it];
2603
{
2604
gchar* label = NULL;
2605
GtkTreeIter iter = {0};
2606
GtkTreeIter _tmp12_ = {0};
2607
if (dpi == default_dpi) {
2608
const gchar* _tmp4_ = NULL;
2609
gchar* _tmp5_ = NULL;
2610
_tmp4_ = _ ("%d dpi (default)");
2611
_tmp5_ = g_strdup_printf (_tmp4_, dpi);
2612
_g_free0 (label);
2613
label = _tmp5_;
2614
} else {
2615
if (dpi == 75) {
2616
const gchar* _tmp6_ = NULL;
2617
gchar* _tmp7_ = NULL;
2618
_tmp6_ = _ ("%d dpi (draft)");
2619
_tmp7_ = g_strdup_printf (_tmp6_, dpi);
2620
_g_free0 (label);
2621
label = _tmp7_;
2622
} else {
2623
if (dpi == 1200) {
2624
const gchar* _tmp8_ = NULL;
2625
gchar* _tmp9_ = NULL;
2626
_tmp8_ = _ ("%d dpi (high resolution)");
2627
_tmp9_ = g_strdup_printf (_tmp8_, dpi);
2628
_g_free0 (label);
2629
label = _tmp9_;
2630
} else {
2631
const gchar* _tmp10_ = NULL;
2632
gchar* _tmp11_ = NULL;
2633
_tmp10_ = _ ("%d dpi");
2634
_tmp11_ = g_strdup_printf (_tmp10_, dpi);
2635
_g_free0 (label);
2636
label = _tmp11_;
2637
}
2638
}
2639
}
2640
gtk_list_store_append (model, &_tmp12_);
2641
iter = _tmp12_;
2642
gtk_list_store_set (model, &iter, 0, dpi, 1, label, -1, -1);
2643
if (dpi == current_dpi) {
2644
gtk_combo_box_set_active_iter (combo, &iter);
2645
}
2646
_g_free0 (label);
2647
}
2648
}
2649
}
2650
scan_resolutions = (g_free (scan_resolutions), NULL);
2651
_g_object_unref0 (model);
2652
_g_object_unref0 (renderer);
2653
}
2654
2655
2656
static void simple_scan_needs_saving_cb (SimpleScan* self, Book* book) {
2657
gboolean _tmp0_;
2658
gboolean _tmp1_;
2659
gboolean _tmp2_;
2660
g_return_if_fail (self != NULL);
2661
g_return_if_fail (book != NULL);
2662
_tmp0_ = book_get_needs_saving (book);
2663
gtk_widget_set_sensitive ((GtkWidget*) self->priv->save_menuitem, _tmp0_);
2664
_tmp1_ = book_get_needs_saving (book);
2665
gtk_widget_set_sensitive ((GtkWidget*) self->priv->save_toolbutton, _tmp1_);
2666
_tmp2_ = book_get_needs_saving (book);
2667
if (_tmp2_) {
2668
gtk_widget_set_sensitive ((GtkWidget*) self->priv->save_as_menuitem, TRUE);
2669
}
2670
}
2671
2672
2673
static void _simple_scan_info_bar_response_cb_gtk_info_bar_response (GtkInfoBar* _sender, gint response_id, gpointer self) {
2674
simple_scan_info_bar_response_cb (self, _sender, response_id);
2675
}
2676
2677
2678
static void _simple_scan_page_selected_cb_book_view_page_selected (BookView* _sender, Page* page, gpointer self) {
2679
simple_scan_page_selected_cb (self, _sender, page);
2680
}
2681
2682
2683
static void _simple_scan_show_page_cb_book_view_show_page (BookView* _sender, Page* page, gpointer self) {
2684
simple_scan_show_page_cb (self, _sender, page);
2685
}
2686
2687
2688
static void _simple_scan_show_page_menu_cb_book_view_show_menu (BookView* _sender, gpointer self) {
2689
simple_scan_show_page_menu_cb (self, _sender);
2690
}
2691
2692
2693
static void _simple_scan_needs_saving_cb_book_needs_saving_changed (Book* _sender, gpointer self) {
2694
simple_scan_needs_saving_cb (self, _sender);
2695
}
2696
2697
2698
static void simple_scan_load (SimpleScan* self) {
2699
GtkIconTheme* _tmp0_ = NULL;
2700
GtkBuilder* _tmp1_ = NULL;
2701
gchar* _tmp2_ = NULL;
2702
gchar* filename;
2703
GObject* _tmp5_ = NULL;
2704
GtkWindow* _tmp6_;
2705
GObject* _tmp7_ = NULL;
2706
GtkVBox* _tmp8_;
2707
GObject* _tmp9_ = NULL;
2708
GtkMenuItem* _tmp10_;
2709
GObject* _tmp11_ = NULL;
2710
GtkMenuItem* _tmp12_;
2711
GObject* _tmp13_ = NULL;
2712
GtkMenuItem* _tmp14_;
2713
GObject* _tmp15_ = NULL;
2714
GtkMenuItem* _tmp16_;
2715
GObject* _tmp17_ = NULL;
2716
GtkMenuItem* _tmp18_;
2717
GObject* _tmp19_ = NULL;
2718
GtkMenuItem* _tmp20_;
2719
GObject* _tmp21_ = NULL;
2720
GtkToolButton* _tmp22_;
2721
GObject* _tmp23_ = NULL;
2722
GtkMenuItem* _tmp24_;
2723
GObject* _tmp25_ = NULL;
2724
GtkToolButton* _tmp26_;
2725
GObject* _tmp27_ = NULL;
2726
GtkRadioMenuItem* _tmp28_;
2727
GObject* _tmp29_ = NULL;
2728
GtkRadioMenuItem* _tmp30_;
2729
GObject* _tmp31_ = NULL;
2730
GtkRadioMenuItem* _tmp32_;
2731
GObject* _tmp33_ = NULL;
2732
GtkRadioMenuItem* _tmp34_;
2733
GObject* _tmp35_ = NULL;
2734
GtkDialog* _tmp36_;
2735
GObject* _tmp37_ = NULL;
2736
GtkLabel* _tmp38_;
2737
GObject* _tmp39_ = NULL;
2738
GtkEntry* _tmp40_;
2739
GObject* _tmp41_ = NULL;
2740
GtkEntry* _tmp42_;
2741
GObject* _tmp43_ = NULL;
2742
GtkDialog* _tmp44_;
2743
GObject* _tmp45_ = NULL;
2744
GtkComboBox* _tmp46_;
2745
GtkTreeModel* _tmp47_ = NULL;
2746
GtkListStore* _tmp48_;
2747
GObject* _tmp49_ = NULL;
2748
GtkComboBox* _tmp50_;
2749
GtkTreeModel* _tmp51_ = NULL;
2750
GtkListStore* _tmp52_;
2751
GObject* _tmp53_ = NULL;
2752
GtkComboBox* _tmp54_;
2753
GtkTreeModel* _tmp55_ = NULL;
2754
GtkListStore* _tmp56_;
2755
GObject* _tmp57_ = NULL;
2756
GtkComboBox* _tmp58_;
2757
GtkTreeModel* _tmp59_ = NULL;
2758
GtkListStore* _tmp60_;
2759
GObject* _tmp61_ = NULL;
2760
GtkComboBox* _tmp62_;
2761
GtkTreeModel* _tmp63_ = NULL;
2762
GtkListStore* _tmp64_;
2763
GtkInfoBar* _tmp65_ = NULL;
2764
GtkHBox* _tmp66_ = NULL;
2765
GtkHBox* hbox;
2766
GtkWidget* _tmp67_ = NULL;
2767
GtkContainer* _tmp68_;
2768
GtkContainer* content_area;
2769
GtkImage* _tmp69_ = NULL;
2770
GtkLabel* _tmp70_ = NULL;
2771
GtkWidget* _tmp71_ = NULL;
2772
GtkButton* _tmp72_;
2773
const gchar* _tmp73_ = NULL;
2774
GtkWidget* _tmp74_ = NULL;
2775
GtkButton* _tmp75_;
2776
GtkTreeIter iter = {0};
2777
GtkTreeIter _tmp76_ = {0};
2778
const gchar* _tmp77_ = NULL;
2779
GtkTreeIter _tmp78_ = {0};
2780
GtkTreeIter _tmp79_ = {0};
2781
GtkTreeIter _tmp80_ = {0};
2782
GtkTreeIter _tmp81_ = {0};
2783
GtkTreeIter _tmp82_ = {0};
2784
GtkTreeIter _tmp83_ = {0};
2785
gint _tmp84_;
2786
gint dpi;
2787
gint _tmp85_;
2788
GtkCellRendererText* _tmp86_ = NULL;
2789
GtkCellRendererText* renderer;
2790
GtkCellRendererText* _tmp87_ = NULL;
2791
gint _tmp88_;
2792
GtkCellRendererText* _tmp89_ = NULL;
2793
gint _tmp90_;
2794
gint paper_width;
2795
gint _tmp91_;
2796
gint paper_height;
2797
gchar* _tmp92_ = NULL;
2798
gchar* device;
2799
gchar* _tmp95_ = NULL;
2800
gchar* document_type;
2801
BookView* _tmp96_ = NULL;
2802
gint _tmp97_;
2803
gint _tmp98_;
2804
gint _tmp99_;
2805
gint _tmp100_;
2806
gint _tmp101_;
2807
gint _tmp102_;
2808
gboolean _tmp103_;
2809
guint _tmp104_;
2810
GError * _inner_error_ = NULL;
2811
g_return_if_fail (self != NULL);
2812
_tmp0_ = gtk_icon_theme_get_default ();
2813
gtk_icon_theme_append_search_path (_tmp0_, ICON_DIR);
2814
gtk_window_set_default_icon_name ("scanner");
2815
_tmp1_ = gtk_builder_new ();
2816
_g_object_unref0 (self->priv->builder);
2817
self->priv->builder = _tmp1_;
2818
_tmp2_ = g_build_filename (UI_DIR, "simple-scan.ui", NULL, NULL);
2819
filename = _tmp2_;
2820
{
2821
gtk_builder_add_from_file (self->priv->builder, filename, &_inner_error_);
2822
if (_inner_error_ != NULL) {
2823
goto __catch16_g_error;
2824
}
2825
}
2826
goto __finally16;
2827
__catch16_g_error:
2828
{
2829
GError* e = NULL;
2830
const gchar* _tmp3_ = NULL;
2831
const gchar* _tmp4_ = NULL;
2832
e = _inner_error_;
2833
_inner_error_ = NULL;
2834
g_critical ("ui.vala:1261: Unable to load UI %s: %s\n", filename, e->message);
2835
_tmp3_ = _ ("Files missing");
2836
_tmp4_ = _ ("Please check your installation");
2837
simple_scan_show_error_dialog (self, _tmp3_, _tmp4_);
2838
exit (EXIT_FAILURE);
2839
_g_error_free0 (e);
2840
}
2841
__finally16:
2842
if (_inner_error_ != NULL) {
2843
_g_free0 (filename);
2844
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
2845
g_clear_error (&_inner_error_);
2846
return;
2847
}
2848
gtk_builder_connect_signals (self->priv->builder, self);
2849
_tmp5_ = gtk_builder_get_object (self->priv->builder, "simple_scan_window");
2850
_tmp6_ = _g_object_ref0 (GTK_WINDOW (_tmp5_));
2851
_g_object_unref0 (self->priv->window);
2852
self->priv->window = _tmp6_;
2853
_tmp7_ = gtk_builder_get_object (self->priv->builder, "main_vbox");
2854
_tmp8_ = _g_object_ref0 (GTK_VBOX (_tmp7_));
2855
_g_object_unref0 (self->priv->main_vbox);
2856
self->priv->main_vbox = _tmp8_;
2857
_tmp9_ = gtk_builder_get_object (self->priv->builder, "page_move_left_menuitem");
2858
_tmp10_ = _g_object_ref0 (GTK_MENU_ITEM (_tmp9_));
2859
_g_object_unref0 (self->priv->page_move_left_menuitem);
2860
self->priv->page_move_left_menuitem = _tmp10_;
2861
_tmp11_ = gtk_builder_get_object (self->priv->builder, "page_move_right_menuitem");
2862
_tmp12_ = _g_object_ref0 (GTK_MENU_ITEM (_tmp11_));
2863
_g_object_unref0 (self->priv->page_move_right_menuitem);
2864
self->priv->page_move_right_menuitem = _tmp12_;
2865
_tmp13_ = gtk_builder_get_object (self->priv->builder, "page_delete_menuitem");
2866
_tmp14_ = _g_object_ref0 (GTK_MENU_ITEM (_tmp13_));
2867
_g_object_unref0 (self->priv->page_delete_menuitem);
2868
self->priv->page_delete_menuitem = _tmp14_;
2869
_tmp15_ = gtk_builder_get_object (self->priv->builder, "crop_rotate_menuitem");
2870
_tmp16_ = _g_object_ref0 (GTK_MENU_ITEM (_tmp15_));
2871
_g_object_unref0 (self->priv->crop_rotate_menuitem);
2872
self->priv->crop_rotate_menuitem = _tmp16_;
2873
_tmp17_ = gtk_builder_get_object (self->priv->builder, "save_menuitem");
2874
_tmp18_ = _g_object_ref0 (GTK_MENU_ITEM (_tmp17_));
2875
_g_object_unref0 (self->priv->save_menuitem);
2876
self->priv->save_menuitem = _tmp18_;
2877
_tmp19_ = gtk_builder_get_object (self->priv->builder, "save_as_menuitem");
2878
_tmp20_ = _g_object_ref0 (GTK_MENU_ITEM (_tmp19_));
2879
_g_object_unref0 (self->priv->save_as_menuitem);
2880
self->priv->save_as_menuitem = _tmp20_;
2881
_tmp21_ = gtk_builder_get_object (self->priv->builder, "save_toolbutton");
2882
_tmp22_ = _g_object_ref0 (GTK_TOOL_BUTTON (_tmp21_));
2883
_g_object_unref0 (self->priv->save_toolbutton);
2884
self->priv->save_toolbutton = _tmp22_;
2885
_tmp23_ = gtk_builder_get_object (self->priv->builder, "stop_scan_menuitem");
2886
_tmp24_ = _g_object_ref0 (GTK_MENU_ITEM (_tmp23_));
2887
_g_object_unref0 (self->priv->stop_menuitem);
2888
self->priv->stop_menuitem = _tmp24_;
2889
_tmp25_ = gtk_builder_get_object (self->priv->builder, "stop_toolbutton");
2890
_tmp26_ = _g_object_ref0 (GTK_TOOL_BUTTON (_tmp25_));
2891
_g_object_unref0 (self->priv->stop_toolbutton);
2892
self->priv->stop_toolbutton = _tmp26_;
2893
_tmp27_ = gtk_builder_get_object (self->priv->builder, "text_toolbutton_menuitem");
2894
_tmp28_ = _g_object_ref0 (GTK_RADIO_MENU_ITEM (_tmp27_));
2895
_g_object_unref0 (self->priv->text_toolbar_menuitem);
2896
self->priv->text_toolbar_menuitem = _tmp28_;
2897
_tmp29_ = gtk_builder_get_object (self->priv->builder, "text_menuitem");
2898
_tmp30_ = _g_object_ref0 (GTK_RADIO_MENU_ITEM (_tmp29_));
2899
_g_object_unref0 (self->priv->text_menu_menuitem);
2900
self->priv->text_menu_menuitem = _tmp30_;
2901
_tmp31_ = gtk_builder_get_object (self->priv->builder, "photo_toolbutton_menuitem");
2902
_tmp32_ = _g_object_ref0 (GTK_RADIO_MENU_ITEM (_tmp31_));
2903
_g_object_unref0 (self->priv->photo_toolbar_menuitem);
2904
self->priv->photo_toolbar_menuitem = _tmp32_;
2905
_tmp33_ = gtk_builder_get_object (self->priv->builder, "photo_menuitem");
2906
_tmp34_ = _g_object_ref0 (GTK_RADIO_MENU_ITEM (_tmp33_));
2907
_g_object_unref0 (self->priv->photo_menu_menuitem);
2908
self->priv->photo_menu_menuitem = _tmp34_;
2909
_tmp35_ = gtk_builder_get_object (self->priv->builder, "authorize_dialog");
2910
_tmp36_ = _g_object_ref0 (GTK_DIALOG (_tmp35_));
2911
_g_object_unref0 (self->priv->authorize_dialog);
2912
self->priv->authorize_dialog = _tmp36_;
2913
_tmp37_ = gtk_builder_get_object (self->priv->builder, "authorize_label");
2914
_tmp38_ = _g_object_ref0 (GTK_LABEL (_tmp37_));
2915
_g_object_unref0 (self->priv->authorize_label);
2916
self->priv->authorize_label = _tmp38_;
2917
_tmp39_ = gtk_builder_get_object (self->priv->builder, "username_entry");
2918
_tmp40_ = _g_object_ref0 (GTK_ENTRY (_tmp39_));
2919
_g_object_unref0 (self->priv->username_entry);
2920
self->priv->username_entry = _tmp40_;
2921
_tmp41_ = gtk_builder_get_object (self->priv->builder, "password_entry");
2922
_tmp42_ = _g_object_ref0 (GTK_ENTRY (_tmp41_));
2923
_g_object_unref0 (self->priv->password_entry);
2924
self->priv->password_entry = _tmp42_;
2925
_tmp43_ = gtk_builder_get_object (self->priv->builder, "preferences_dialog");
2926
_tmp44_ = _g_object_ref0 (GTK_DIALOG (_tmp43_));
2927
_g_object_unref0 (self->priv->preferences_dialog);
2928
self->priv->preferences_dialog = _tmp44_;
2929
_tmp45_ = gtk_builder_get_object (self->priv->builder, "device_combo");
2930
_tmp46_ = _g_object_ref0 (GTK_COMBO_BOX (_tmp45_));
2931
_g_object_unref0 (self->priv->device_combo);
2932
self->priv->device_combo = _tmp46_;
2933
_tmp47_ = gtk_combo_box_get_model (self->priv->device_combo);
2934
_tmp48_ = _g_object_ref0 (GTK_LIST_STORE (_tmp47_));
2935
_g_object_unref0 (self->priv->device_model);
2936
self->priv->device_model = _tmp48_;
2937
_tmp49_ = gtk_builder_get_object (self->priv->builder, "text_dpi_combo");
2938
_tmp50_ = _g_object_ref0 (GTK_COMBO_BOX (_tmp49_));
2939
_g_object_unref0 (self->priv->text_dpi_combo);
2940
self->priv->text_dpi_combo = _tmp50_;
2941
_tmp51_ = gtk_combo_box_get_model (self->priv->text_dpi_combo);
2942
_tmp52_ = _g_object_ref0 (GTK_LIST_STORE (_tmp51_));
2943
_g_object_unref0 (self->priv->text_dpi_model);
2944
self->priv->text_dpi_model = _tmp52_;
2945
_tmp53_ = gtk_builder_get_object (self->priv->builder, "photo_dpi_combo");
2946
_tmp54_ = _g_object_ref0 (GTK_COMBO_BOX (_tmp53_));
2947
_g_object_unref0 (self->priv->photo_dpi_combo);
2948
self->priv->photo_dpi_combo = _tmp54_;
2949
_tmp55_ = gtk_combo_box_get_model (self->priv->photo_dpi_combo);
2950
_tmp56_ = _g_object_ref0 (GTK_LIST_STORE (_tmp55_));
2951
_g_object_unref0 (self->priv->photo_dpi_model);
2952
self->priv->photo_dpi_model = _tmp56_;
2953
_tmp57_ = gtk_builder_get_object (self->priv->builder, "page_side_combo");
2954
_tmp58_ = _g_object_ref0 (GTK_COMBO_BOX (_tmp57_));
2955
_g_object_unref0 (self->priv->page_side_combo);
2956
self->priv->page_side_combo = _tmp58_;
2957
_tmp59_ = gtk_combo_box_get_model (self->priv->page_side_combo);
2958
_tmp60_ = _g_object_ref0 (GTK_LIST_STORE (_tmp59_));
2959
_g_object_unref0 (self->priv->page_side_model);
2960
self->priv->page_side_model = _tmp60_;
2961
_tmp61_ = gtk_builder_get_object (self->priv->builder, "paper_size_combo");
2962
_tmp62_ = _g_object_ref0 (GTK_COMBO_BOX (_tmp61_));
2963
_g_object_unref0 (self->priv->paper_size_combo);
2964
self->priv->paper_size_combo = _tmp62_;
2965
_tmp63_ = gtk_combo_box_get_model (self->priv->paper_size_combo);
2966
_tmp64_ = _g_object_ref0 (GTK_LIST_STORE (_tmp63_));
2967
_g_object_unref0 (self->priv->paper_size_model);
2968
self->priv->paper_size_model = _tmp64_;
2969
_tmp65_ = (GtkInfoBar*) gtk_info_bar_new ();
2970
_g_object_unref0 (self->priv->info_bar);
2971
self->priv->info_bar = g_object_ref_sink (_tmp65_);
2972
g_signal_connect (self->priv->info_bar, "response", (GCallback) _simple_scan_info_bar_response_cb_gtk_info_bar_response, self);
2973
gtk_box_pack_start ((GtkBox*) self->priv->main_vbox, (GtkWidget*) self->priv->info_bar, FALSE, TRUE, (guint) 0);
2974
_tmp66_ = (GtkHBox*) gtk_hbox_new (FALSE, 12);
2975
hbox = g_object_ref_sink (_tmp66_);
2976
_tmp67_ = gtk_info_bar_get_content_area (self->priv->info_bar);
2977
_tmp68_ = _g_object_ref0 (GTK_CONTAINER (_tmp67_));
2978
content_area = _tmp68_;
2979
gtk_container_add (content_area, (GtkWidget*) hbox);
2980
gtk_widget_show ((GtkWidget*) hbox);
2981
_tmp69_ = (GtkImage*) gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG);
2982
_g_object_unref0 (self->priv->info_bar_image);
2983
self->priv->info_bar_image = g_object_ref_sink (_tmp69_);
2984
gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) self->priv->info_bar_image, FALSE, TRUE, (guint) 0);
2985
gtk_widget_show ((GtkWidget*) self->priv->info_bar_image);
2986
_tmp70_ = (GtkLabel*) gtk_label_new (NULL);
2987
_g_object_unref0 (self->priv->info_bar_label);
2988
self->priv->info_bar_label = g_object_ref_sink (_tmp70_);
2989
gtk_misc_set_alignment ((GtkMisc*) self->priv->info_bar_label, 0.0f, 0.5f);
2990
gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) self->priv->info_bar_label, TRUE, TRUE, (guint) 0);
2991
gtk_widget_show ((GtkWidget*) self->priv->info_bar_label);
2992
_tmp71_ = gtk_info_bar_add_button (self->priv->info_bar, GTK_STOCK_CLOSE, (gint) GTK_RESPONSE_CLOSE);
2993
_tmp72_ = _g_object_ref0 (GTK_BUTTON (_tmp71_));
2994
_g_object_unref0 (self->priv->info_bar_close_button);
2995
self->priv->info_bar_close_button = _tmp72_;
2996
_tmp73_ = _ ("Change _Scanner");
2997
_tmp74_ = gtk_info_bar_add_button (self->priv->info_bar, _tmp73_, 1);
2998
_tmp75_ = _g_object_ref0 (GTK_BUTTON (_tmp74_));
2999
_g_object_unref0 (self->priv->info_bar_change_scanner_button);
3000
self->priv->info_bar_change_scanner_button = _tmp75_;
3001
gtk_list_store_append (self->priv->paper_size_model, &_tmp76_);
3002
iter = _tmp76_;
3003
_tmp77_ = _ ("Automatic");
3004
gtk_list_store_set (self->priv->paper_size_model, &iter, 0, 0, 1, 0, 2, _tmp77_, -1, -1);
3005
gtk_list_store_append (self->priv->paper_size_model, &_tmp78_);
3006
iter = _tmp78_;
3007
gtk_list_store_set (self->priv->paper_size_model, &iter, 0, 1050, 1, 1480, 2, "A6", -1, -1);
3008
gtk_list_store_append (self->priv->paper_size_model, &_tmp79_);
3009
iter = _tmp79_;
3010
gtk_list_store_set (self->priv->paper_size_model, &iter, 0, 1480, 1, 2100, 2, "A5", -1, -1);
3011
gtk_list_store_append (self->priv->paper_size_model, &_tmp80_);
3012
iter = _tmp80_;
3013
gtk_list_store_set (self->priv->paper_size_model, &iter, 0, 2100, 1, 2970, 2, "A4", -1, -1);
3014
gtk_list_store_append (self->priv->paper_size_model, &_tmp81_);
3015
iter = _tmp81_;
3016
gtk_list_store_set (self->priv->paper_size_model, &iter, 0, 2159, 1, 2794, 2, "Letter", -1, -1);
3017
gtk_list_store_append (self->priv->paper_size_model, &_tmp82_);
3018
iter = _tmp82_;
3019
gtk_list_store_set (self->priv->paper_size_model, &iter, 0, 2159, 1, 3556, 2, "Legal", -1, -1);
3020
gtk_list_store_append (self->priv->paper_size_model, &_tmp83_);
3021
iter = _tmp83_;
3022
gtk_list_store_set (self->priv->paper_size_model, &iter, 0, 1016, 1, 1524, 2, "4×6", -1, -1);
3023
_tmp84_ = g_settings_get_int (self->priv->settings, "text-dpi");
3024
dpi = _tmp84_;
3025
if (dpi <= 0) {
3026
dpi = SIMPLE_SCAN_DEFAULT_TEXT_DPI;
3027
}
3028
simple_scan_set_dpi_combo (self, self->priv->text_dpi_combo, SIMPLE_SCAN_DEFAULT_TEXT_DPI, dpi);
3029
_tmp85_ = g_settings_get_int (self->priv->settings, "photo-dpi");
3030
dpi = _tmp85_;
3031
if (dpi <= 0) {
3032
dpi = SIMPLE_SCAN_DEFAULT_PHOTO_DPI;
3033
}
3034
simple_scan_set_dpi_combo (self, self->priv->photo_dpi_combo, SIMPLE_SCAN_DEFAULT_PHOTO_DPI, dpi);
3035
_tmp86_ = (GtkCellRendererText*) gtk_cell_renderer_text_new ();
3036
renderer = g_object_ref_sink (_tmp86_);
3037
gtk_cell_layout_pack_start ((GtkCellLayout*) self->priv->device_combo, (GtkCellRenderer*) renderer, TRUE);
3038
gtk_cell_layout_add_attribute ((GtkCellLayout*) self->priv->device_combo, (GtkCellRenderer*) renderer, "text", 1);
3039
_tmp87_ = (GtkCellRendererText*) gtk_cell_renderer_text_new ();
3040
_g_object_unref0 (renderer);
3041
renderer = g_object_ref_sink (_tmp87_);
3042
gtk_cell_layout_pack_start ((GtkCellLayout*) self->priv->page_side_combo, (GtkCellRenderer*) renderer, TRUE);
3043
gtk_cell_layout_add_attribute ((GtkCellLayout*) self->priv->page_side_combo, (GtkCellRenderer*) renderer, "text", 1);
3044
_tmp88_ = g_settings_get_enum (self->priv->settings, "page-side");
3045
simple_scan_set_page_side (self, (ScanType) _tmp88_);
3046
_tmp89_ = (GtkCellRendererText*) gtk_cell_renderer_text_new ();
3047
_g_object_unref0 (renderer);
3048
renderer = g_object_ref_sink (_tmp89_);
3049
gtk_cell_layout_pack_start ((GtkCellLayout*) self->priv->paper_size_combo, (GtkCellRenderer*) renderer, TRUE);
3050
gtk_cell_layout_add_attribute ((GtkCellLayout*) self->priv->paper_size_combo, (GtkCellRenderer*) renderer, "text", 2);
3051
_tmp90_ = g_settings_get_int (self->priv->settings, "paper-width");
3052
paper_width = _tmp90_;
3053
_tmp91_ = g_settings_get_int (self->priv->settings, "paper-height");
3054
paper_height = _tmp91_;
3055
simple_scan_set_paper_size (self, paper_width, paper_height);
3056
_tmp92_ = g_settings_get_string (self->priv->settings, "selected-device");
3057
device = _tmp92_;
3058
if (device != NULL) {
3059
GtkTreeIter _tmp93_ = {0};
3060
gboolean _tmp94_;
3061
_tmp94_ = simple_scan_find_scan_device (self, device, &_tmp93_);
3062
iter = _tmp93_;
3063
if (_tmp94_) {
3064
gtk_combo_box_set_active_iter (self->priv->device_combo, &iter);
3065
}
3066
}
3067
_tmp95_ = g_settings_get_string (self->priv->settings, "document-type");
3068
document_type = _tmp95_;
3069
if (document_type != NULL) {
3070
simple_scan_set_document_hint (self, document_type);
3071
}
3072
_tmp96_ = book_view_new (self->priv->book);
3073
_g_object_unref0 (self->priv->book_view);
3074
self->priv->book_view = g_object_ref_sink (_tmp96_);
3075
gtk_container_set_border_width ((GtkContainer*) self->priv->book_view, (guint) 18);
3076
gtk_box_pack_end ((GtkBox*) self->priv->main_vbox, (GtkWidget*) self->priv->book_view, TRUE, TRUE, (guint) 0);
3077
g_signal_connect (self->priv->book_view, "page-selected", (GCallback) _simple_scan_page_selected_cb_book_view_page_selected, self);
3078
g_signal_connect (self->priv->book_view, "show-page", (GCallback) _simple_scan_show_page_cb_book_view_show_page, self);
3079
g_signal_connect (self->priv->book_view, "show-menu", (GCallback) _simple_scan_show_page_menu_cb_book_view_show_menu, self);
3080
gtk_widget_show ((GtkWidget*) self->priv->book_view);
3081
_tmp97_ = g_settings_get_enum (self->priv->settings, "scan-direction");
3082
self->priv->default_page_scan_direction = (ScanDirection) _tmp97_;
3083
_tmp98_ = g_settings_get_int (self->priv->settings, "page-width");
3084
self->priv->default_page_width = _tmp98_;
3085
if (self->priv->default_page_width <= 0) {
3086
self->priv->default_page_width = 595;
3087
}
3088
_tmp99_ = g_settings_get_int (self->priv->settings, "page-height");
3089
self->priv->default_page_height = _tmp99_;
3090
if (self->priv->default_page_height <= 0) {
3091
self->priv->default_page_height = 842;
3092
}
3093
_tmp100_ = g_settings_get_int (self->priv->settings, "page-dpi");
3094
self->priv->default_page_dpi = _tmp100_;
3095
if (self->priv->default_page_dpi <= 0) {
3096
self->priv->default_page_dpi = 72;
3097
}
3098
_tmp101_ = g_settings_get_int (self->priv->settings, "window-width");
3099
self->priv->window_width = _tmp101_;
3100
if (self->priv->window_width <= 0) {
3101
self->priv->window_width = 600;
3102
}
3103
_tmp102_ = g_settings_get_int (self->priv->settings, "window-height");
3104
self->priv->window_height = _tmp102_;
3105
if (self->priv->window_height <= 0) {
3106
self->priv->window_height = 400;
3107
}
3108
g_debug ("ui.vala:1407: Restoring window to %dx%d pixels", self->priv->window_width, self->priv->window_height);
3109
gtk_window_set_default_size (self->priv->window, self->priv->window_width, self->priv->window_height);
3110
_tmp103_ = g_settings_get_boolean (self->priv->settings, "window-is-maximized");
3111
self->priv->window_is_maximized = _tmp103_;
3112
if (self->priv->window_is_maximized) {
3113
g_debug ("ui.vala:1412: Restoring window to maximized");
3114
gtk_window_maximize (self->priv->window);
3115
}
3116
_tmp104_ = book_get_n_pages (self->priv->book);
3117
if (_tmp104_ == ((guint) 0)) {
3118
simple_scan_add_default_page (self);
3119
}
3120
book_set_needs_saving (self->priv->book, FALSE);
3121
g_signal_connect (self->priv->book, "needs-saving-changed", (GCallback) _simple_scan_needs_saving_cb_book_needs_saving_changed, self);
3122
_g_free0 (document_type);
3123
_g_free0 (device);
3124
_g_object_unref0 (renderer);
3125
_g_object_unref0 (content_area);
3126
_g_object_unref0 (hbox);
3127
_g_free0 (filename);
3128
}
3129
3130
3131
static gpointer _book_ref0 (gpointer self) {
3132
return self ? book_ref (self) : NULL;
3133
}
3134
3135
3136
Book* simple_scan_get_book (SimpleScan* self) {
3137
Book* result = NULL;
3138
Book* _tmp0_;
3139
g_return_val_if_fail (self != NULL, NULL);
3140
_tmp0_ = _book_ref0 (self->priv->book);
3141
result = _tmp0_;
3142
return result;
3143
}
3144
3145
3146
void simple_scan_set_selected_page (SimpleScan* self, Page* page) {
3147
g_return_if_fail (self != NULL);
3148
g_return_if_fail (page != NULL);
3149
book_view_select_page (self->priv->book_view, page);
3150
}
3151
3152
3153
Page* simple_scan_get_selected_page (SimpleScan* self) {
3154
Page* result = NULL;
3155
Page* _tmp0_ = NULL;
3156
g_return_val_if_fail (self != NULL, NULL);
3157
_tmp0_ = book_view_get_selected (self->priv->book_view);
3158
result = _tmp0_;
3159
return result;
3160
}
3161
3162
3163
void simple_scan_set_scanning (SimpleScan* self, gboolean scanning) {
3164
g_return_if_fail (self != NULL);
3165
self->priv->scanning = scanning;
3166
gtk_widget_set_sensitive ((GtkWidget*) self->priv->page_delete_menuitem, !scanning);
3167
gtk_widget_set_sensitive ((GtkWidget*) self->priv->stop_menuitem, scanning);
3168
gtk_widget_set_sensitive ((GtkWidget*) self->priv->stop_toolbutton, scanning);
3169
}
3170
3171
3172
void simple_scan_show_error (SimpleScan* self, const gchar* error_title, const gchar* error_text, gboolean change_scanner_hint) {
3173
gchar* _tmp0_;
3174
gchar* _tmp1_;
3175
g_return_if_fail (self != NULL);
3176
g_return_if_fail (error_title != NULL);
3177
g_return_if_fail (error_text != NULL);
3178
self->priv->have_error = TRUE;
3179
_tmp0_ = g_strdup (error_title);
3180
_g_free0 (self->priv->error_title);
3181
self->priv->error_title = _tmp0_;
3182
_tmp1_ = g_strdup (error_text);
3183
_g_free0 (self->priv->error_text);
3184
self->priv->error_text = _tmp1_;
3185
self->priv->error_change_scanner_hint = change_scanner_hint;
3186
simple_scan_update_info_bar (self);
3187
}
3188
3189
3190
void simple_scan_start (SimpleScan* self) {
3191
g_return_if_fail (self != NULL);
3192
gtk_widget_show ((GtkWidget*) self->priv->window);
3193
}
3194
3195
3196
static void g_cclosure_user_marshal_VOID__STRING_SCAN_OPTIONS (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
3197
typedef void (*GMarshalFunc_VOID__STRING_SCAN_OPTIONS) (gpointer data1, const char* arg_1, gpointer arg_2, gpointer data2);
3198
register GMarshalFunc_VOID__STRING_SCAN_OPTIONS callback;
3199
register GCClosure * cc;
3200
register gpointer data1;
3201
register gpointer data2;
3202
cc = (GCClosure *) closure;
3203
g_return_if_fail (n_param_values == 3);
3204
if (G_CCLOSURE_SWAP_DATA (closure)) {
3205
data1 = closure->data;
3206
data2 = param_values->data[0].v_pointer;
3207
} else {
3208
data1 = param_values->data[0].v_pointer;
3209
data2 = closure->data;
3210
}
3211
callback = (GMarshalFunc_VOID__STRING_SCAN_OPTIONS) (marshal_data ? marshal_data : cc->callback);
3212
callback (data1, g_value_get_string (param_values + 1), value_get_scan_options (param_values + 2), data2);
3213
}
3214
3215
3216
static void value_simple_scan_init (GValue* value) {
3217
value->data[0].v_pointer = NULL;
3218
}
3219
3220
3221
static void value_simple_scan_free_value (GValue* value) {
3222
if (value->data[0].v_pointer) {
3223
simple_scan_unref (value->data[0].v_pointer);
3224
}
3225
}
3226
3227
3228
static void value_simple_scan_copy_value (const GValue* src_value, GValue* dest_value) {
3229
if (src_value->data[0].v_pointer) {
3230
dest_value->data[0].v_pointer = simple_scan_ref (src_value->data[0].v_pointer);
3231
} else {
3232
dest_value->data[0].v_pointer = NULL;
3233
}
3234
}
3235
3236
3237
static gpointer value_simple_scan_peek_pointer (const GValue* value) {
3238
return value->data[0].v_pointer;
3239
}
3240
3241
3242
static gchar* value_simple_scan_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
3243
if (collect_values[0].v_pointer) {
3244
SimpleScan* object;
3245
object = collect_values[0].v_pointer;
3246
if (object->parent_instance.g_class == NULL) {
3247
return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
3248
} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
3249
return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
3250
}
3251
value->data[0].v_pointer = simple_scan_ref (object);
3252
} else {
3253
value->data[0].v_pointer = NULL;
3254
}
3255
return NULL;
3256
}
3257
3258
3259
static gchar* value_simple_scan_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
3260
SimpleScan** object_p;
3261
object_p = collect_values[0].v_pointer;
3262
if (!object_p) {
3263
return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
3264
}
3265
if (!value->data[0].v_pointer) {
3266
*object_p = NULL;
3267
} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
3268
*object_p = value->data[0].v_pointer;
3269
} else {
3270
*object_p = simple_scan_ref (value->data[0].v_pointer);
3271
}
3272
return NULL;
3273
}
3274
3275
3276
GParamSpec* param_spec_simple_scan (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
3277
ParamSpecSimpleScan* spec;
3278
g_return_val_if_fail (g_type_is_a (object_type, TYPE_SIMPLE_SCAN), NULL);
3279
spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
3280
G_PARAM_SPEC (spec)->value_type = object_type;
3281
return G_PARAM_SPEC (spec);
3282
}
3283
3284
3285
gpointer value_get_simple_scan (const GValue* value) {
3286
g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SIMPLE_SCAN), NULL);
3287
return value->data[0].v_pointer;
3288
}
3289
3290
3291
void value_set_simple_scan (GValue* value, gpointer v_object) {
3292
SimpleScan* old;
3293
g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SIMPLE_SCAN));
3294
old = value->data[0].v_pointer;
3295
if (v_object) {
3296
g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SIMPLE_SCAN));
3297
g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
3298
value->data[0].v_pointer = v_object;
3299
simple_scan_ref (value->data[0].v_pointer);
3300
} else {
3301
value->data[0].v_pointer = NULL;
3302
}
3303
if (old) {
3304
simple_scan_unref (old);
3305
}
3306
}
3307
3308
3309
void value_take_simple_scan (GValue* value, gpointer v_object) {
3310
SimpleScan* old;
3311
g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SIMPLE_SCAN));
3312
old = value->data[0].v_pointer;
3313
if (v_object) {
3314
g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SIMPLE_SCAN));
3315
g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
3316
value->data[0].v_pointer = v_object;
3317
} else {
3318
value->data[0].v_pointer = NULL;
3319
}
3320
if (old) {
3321
simple_scan_unref (old);
3322
}
3323
}
3324
3325
3326
static void simple_scan_class_init (SimpleScanClass * klass) {
3327
simple_scan_parent_class = g_type_class_peek_parent (klass);
3328
SIMPLE_SCAN_CLASS (klass)->finalize = simple_scan_finalize;
3329
g_type_class_add_private (klass, sizeof (SimpleScanPrivate));
3330
g_signal_new ("start_scan", TYPE_SIMPLE_SCAN, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__STRING_SCAN_OPTIONS, G_TYPE_NONE, 2, G_TYPE_STRING, TYPE_SCAN_OPTIONS);
3331
g_signal_new ("stop_scan", TYPE_SIMPLE_SCAN, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
3332
g_signal_new ("email", TYPE_SIMPLE_SCAN, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
3333
g_signal_new ("quit", TYPE_SIMPLE_SCAN, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
3334
}
3335
3336
3337
static void simple_scan_instance_init (SimpleScan * self) {
3338
gchar* _tmp0_;
3339
const gchar* _tmp1_ = NULL;
3340
gchar* _tmp2_;
3341
self->priv = SIMPLE_SCAN_GET_PRIVATE (self);
3342
self->priv->book_uri = NULL;
3343
_tmp0_ = g_strdup ("photo");
3344
self->priv->document_hint = _tmp0_;
3345
_tmp1_ = _ ("Scanned Document.pdf");
3346
_tmp2_ = g_strdup (_tmp1_);
3347
self->priv->default_file_name = _tmp2_;
3348
self->priv->scanning = FALSE;
3349
self->ref_count = 1;
3350
}
3351
3352
3353
static void simple_scan_finalize (SimpleScan* obj) {
3354
SimpleScan * self;
3355
self = SIMPLE_SCAN (obj);
3356
_g_object_unref0 (self->priv->settings);
3357
_g_object_unref0 (self->priv->builder);
3358
_g_object_unref0 (self->priv->window);
3359
_g_object_unref0 (self->priv->main_vbox);
3360
_g_object_unref0 (self->priv->info_bar);
3361
_g_object_unref0 (self->priv->info_bar_image);
3362
_g_object_unref0 (self->priv->info_bar_label);
3363
_g_object_unref0 (self->priv->info_bar_close_button);
3364
_g_object_unref0 (self->priv->info_bar_change_scanner_button);
3365
_g_object_unref0 (self->priv->page_move_left_menuitem);
3366
_g_object_unref0 (self->priv->page_move_right_menuitem);
3367
_g_object_unref0 (self->priv->page_delete_menuitem);
3368
_g_object_unref0 (self->priv->crop_rotate_menuitem);
3369
_g_object_unref0 (self->priv->save_menuitem);
3370
_g_object_unref0 (self->priv->save_as_menuitem);
3371
_g_object_unref0 (self->priv->save_toolbutton);
3372
_g_object_unref0 (self->priv->stop_menuitem);
3373
_g_object_unref0 (self->priv->stop_toolbutton);
3374
_g_object_unref0 (self->priv->text_toolbar_menuitem);
3375
_g_object_unref0 (self->priv->text_menu_menuitem);
3376
_g_object_unref0 (self->priv->photo_toolbar_menuitem);
3377
_g_object_unref0 (self->priv->photo_menu_menuitem);
3378
_g_object_unref0 (self->priv->authorize_dialog);
3379
_g_object_unref0 (self->priv->authorize_label);
3380
_g_object_unref0 (self->priv->username_entry);
3381
_g_object_unref0 (self->priv->password_entry);
3382
_g_object_unref0 (self->priv->preferences_dialog);
3383
_g_object_unref0 (self->priv->device_combo);
3384
_g_object_unref0 (self->priv->text_dpi_combo);
3385
_g_object_unref0 (self->priv->photo_dpi_combo);
3386
_g_object_unref0 (self->priv->page_side_combo);
3387
_g_object_unref0 (self->priv->paper_size_combo);
3388
_g_object_unref0 (self->priv->device_model);
3389
_g_object_unref0 (self->priv->text_dpi_model);
3390
_g_object_unref0 (self->priv->photo_dpi_model);
3391
_g_object_unref0 (self->priv->page_side_model);
3392
_g_object_unref0 (self->priv->paper_size_model);
3393
_g_object_unref0 (self->priv->save_dialog);
3394
_g_free0 (self->priv->error_title);
3395
_g_free0 (self->priv->error_text);
3396
_book_unref0 (self->priv->book);
3397
_g_free0 (self->priv->book_uri);
3398
_g_object_unref0 (self->priv->book_view);
3399
_g_free0 (self->priv->document_hint);
3400
_g_free0 (self->priv->default_file_name);
3401
}
3402
3403
3404
GType simple_scan_get_type (void) {
3405
static volatile gsize simple_scan_type_id__volatile = 0;
3406
if (g_once_init_enter (&simple_scan_type_id__volatile)) {
3407
static const GTypeValueTable g_define_type_value_table = { value_simple_scan_init, value_simple_scan_free_value, value_simple_scan_copy_value, value_simple_scan_peek_pointer, "p", value_simple_scan_collect_value, "p", value_simple_scan_lcopy_value };
3408
static const GTypeInfo g_define_type_info = { sizeof (SimpleScanClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) simple_scan_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SimpleScan), 0, (GInstanceInitFunc) simple_scan_instance_init, &g_define_type_value_table };
3409
static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
3410
GType simple_scan_type_id;
3411
simple_scan_type_id = g_type_register_fundamental (g_type_fundamental_next (), "SimpleScan", &g_define_type_info, &g_define_type_fundamental_info, 0);
3412
g_once_init_leave (&simple_scan_type_id__volatile, simple_scan_type_id);
3413
}
3414
return simple_scan_type_id__volatile;
3415
}
3416
3417
3418
gpointer simple_scan_ref (gpointer instance) {
3419
SimpleScan* self;
3420
self = instance;
3421
g_atomic_int_inc (&self->ref_count);
3422
return instance;
3423
}
3424
3425
3426
void simple_scan_unref (gpointer instance) {
3427
SimpleScan* self;
3428
self = instance;
3429
if (g_atomic_int_dec_and_test (&self->ref_count)) {
3430
SIMPLE_SCAN_GET_CLASS (self)->finalize (self);
3431
g_type_free_instance ((GTypeInstance *) self);
3432
}
3433
}
3434
3435
3436
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
3437
if ((array != NULL) && (destroy_func != NULL)) {
3438
int i;
3439
for (i = 0; i < array_length; i = i + 1) {
3440
if (((gpointer*) array)[i] != NULL) {
3441
destroy_func (((gpointer*) array)[i]);
3442
}
3443
}
3444
}
3445
}
3446
3447
3448
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
3449
_vala_array_destroy (array, array_length, destroy_func);
3450
g_free (array);
3451
}
3452
3453
3454
Loggerhead is a web-based interface for Breezy
Version: 2.0.1