← Back to branch summary

~ubuntu-branches/debian/sid/simple-scan/sid

« back to all changes in this revision

Viewing changes to src/book.c

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2010-04-09 12:41:39 UTC
  • mfrom: (1.1.13 upstream)
  • Revision ID: james.westby@ubuntu.com-20100409124139-7g58r00esfrldzmu
Tags: 0.9.10-1
* New upstream release.
* debian/control:
  - Build-depend on libdbus-glib-1-dev.
  - Recommend imagemagick.
* debian/patches/11_thunderbird_workaround.patch:
  - Workaround Thunderbird/Icedove mail bug.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/book.c
63
63
    Page *page;
64
64
 
65
65
    page = page_new ();
66
 
    page_set_scan_area (page, width, height, dpi);
67
 
    page_set_orientation (page, orientation);
 
66
    page_setup (page, width, height, dpi, orientation);
68
67
 
69
68
    book->priv->pages = g_list_append (book->priv->pages, page);
70
69
 
100
99
}
101
100
 
102
101
 
103
 
static GFileOutputStream *
104
 
open_file (const gchar *uri, GError **error)
105
 
{
106
 
    GFile *file;
107
 
    GFileOutputStream *stream; 
108
 
 
109
 
    file = g_file_new_for_uri (uri);
110
 
    stream = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, error);
111
 
    g_object_unref (file);
112
 
    return stream;
113
 
}
114
 
 
115
 
 
116
 
static gchar *
117
 
make_indexed_uri (const gchar *uri, gint i)
 
102
static GFile *
 
103
make_indexed_file (const gchar *uri, gint i)
118
104
{
119
105
    gchar *basename, *suffix, *indexed_uri;
 
106
    GFile *file;
120
107
 
121
108
    if (i == 0)
122
 
        return g_strdup (uri);
 
109
        return g_file_new_for_uri (uri);
123
110
 
124
111
    basename = g_path_get_basename (uri);
125
112
    suffix = g_strrstr (basename, ".");
129
116
    else
130
117
        indexed_uri = g_strdup_printf ("%s-%d", uri, i);
131
118
    g_free (basename);
132
 
    return indexed_uri;
133
 
}
134
 
 
135
 
 
136
 
gboolean
137
 
book_save_jpeg (Book *book, const gchar *uri, GError **error)
138
 
{
139
 
    GList *iter;
140
 
    gboolean result = TRUE;
141
 
    gint i;
142
 
 
143
 
    for (iter = book->priv->pages, i = 0; iter && result; iter = iter->next, i++) {
144
 
        Page *page = iter->data;
145
 
        gchar *indexed_uri;
146
 
 
147
 
        indexed_uri = make_indexed_uri (uri, i);
148
 
        result = page_save_jpeg (page, indexed_uri, error);
149
 
        g_free (indexed_uri);
150
 
    }
151
 
   
152
 
    return result;
153
 
}
154
 
 
155
 
 
156
 
gboolean
157
 
book_save_png (Book *book, const gchar *uri, GError **error)
158
 
{
159
 
    GList *iter;
160
 
    gboolean result = TRUE;
161
 
    gint i;
162
 
 
163
 
    for (iter = book->priv->pages, i = 0; iter && result; iter = iter->next, i++) {
164
 
        Page *page = iter->data;
165
 
        gchar *indexed_uri;
166
 
 
167
 
        indexed_uri = make_indexed_uri (uri, i);
168
 
        result = page_save_png (page, indexed_uri, error);
169
 
        g_free (indexed_uri);
170
 
    }
171
 
   
172
 
    return result;
173
 
}
174
 
 
175
 
 
176
 
gboolean
177
 
book_save_tiff (Book *book, const gchar *uri, GError **error)
178
 
{
179
 
    GList *iter;
180
 
    gboolean result = TRUE;
181
 
    gint i;
182
 
 
183
 
    for (iter = book->priv->pages, i = 0; iter && result; iter = iter->next, i++) {
184
 
        Page *page = iter->data;
185
 
        gchar *indexed_uri;
186
 
 
187
 
        indexed_uri = make_indexed_uri (uri, i);
188
 
        result = page_save_tiff (page, indexed_uri, error);
189
 
        g_free (indexed_uri);
190
 
    }
 
119
 
 
120
    file = g_file_new_for_uri (indexed_uri);
 
121
    g_free (indexed_uri);
 
122
 
 
123
    return file;
 
124
}
 
125
 
 
126
 
 
127
static gboolean
 
128
book_save_multi_file (Book *book, const gchar *type, GFile *file, GError **error)
 
129
{
 
130
    GList *iter;
 
131
    gboolean result = TRUE;
 
132
    gint i;
 
133
    gchar *uri;
 
134
 
 
135
    uri = g_file_get_uri (file);
 
136
    for (iter = book->priv->pages, i = 0; iter && result; iter = iter->next, i++) {
 
137
        Page *page = iter->data;
 
138
        GFile *file;
 
139
 
 
140
        file = make_indexed_file (uri, i);
 
141
        result = page_save (page, type, file, error);
 
142
        g_object_unref (file);
 
143
    }
 
144
    g_free (uri);
191
145
   
192
146
    return result;
193
147
}
226
180
}
227
181
 
228
182
 
229
 
gboolean
230
 
book_save_ps (Book *book, const gchar *uri, GError **error)
 
183
static gboolean
 
184
book_save_ps (Book *book, GFile *file, GError **error)
231
185
{
232
186
    GFileOutputStream *stream;
233
187
    GList *iter;
234
188
    cairo_surface_t *surface;
235
189
 
236
 
    stream = open_file (uri, error);
 
190
    stream = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, error);
237
191
    if (!stream)
238
192
        return FALSE;
239
193
 
314
268
 
315
269
 
316
270
static gboolean
317
 
book_save_pdf_with_imagemagick (Book *book, const gchar *uri, GError **error)
 
271
book_save_pdf_with_imagemagick (Book *book, GFile *file, GError **error)
318
272
{
319
273
    GList *iter;
320
274
    GString *command_line;
330
284
    for (iter = book->priv->pages; iter && result; iter = iter->next) {
331
285
        Page *page = iter->data;
332
286
        GFile *jpeg_file, *tiff_file;
333
 
        gchar *path, *uri;
 
287
        gchar *path;
334
288
        gint jpeg_size, tiff_size;
335
289
 
336
290
        jpeg_file = get_temporary_file ("simple-scan", "jpg");
337
 
        uri = g_file_get_uri (jpeg_file);
338
 
        result = page_save_jpeg (page, uri, error);
339
 
        g_free (uri);
 
291
        result = page_save (page, "jpeg", jpeg_file, error);
340
292
        jpeg_size = get_file_size (jpeg_file);
341
293
        temporary_files = g_list_append (temporary_files, jpeg_file);
342
294
 
343
295
        tiff_file = get_temporary_file ("simple-scan", "tiff");
344
 
        uri = g_file_get_uri (tiff_file);
345
 
        result = page_save_tiff (page, uri, error);
346
 
        g_free (uri);
 
296
        result = page_save (page, "tiff", tiff_file, error);
347
297
        tiff_size = get_file_size (tiff_file);
348
298
        temporary_files = g_list_append (temporary_files, tiff_file);
349
299
 
379
329
    /* Move to target URI */
380
330
    if (result) {
381
331
        GFile *dest;
382
 
        dest = g_file_new_for_uri (uri);
383
 
        result = g_file_move (output_file, dest, G_FILE_COPY_OVERWRITE, NULL, NULL, NULL, error);
 
332
        result = g_file_move (output_file, file, G_FILE_COPY_OVERWRITE, NULL, NULL, NULL, error);
384
333
        g_object_unref (dest);
385
334
    }
386
335
  
387
336
    /* Delete page files */
388
337
    for (link = temporary_files; link; link = link->next) {
389
 
        GFile *file = link->data;
 
338
        GFile *f = link->data;
390
339
 
391
 
        g_file_delete (file, NULL, NULL);
392
 
        g_object_unref (file);
 
340
        g_file_delete (f, NULL, NULL);
 
341
        g_object_unref (f);
393
342
    }
394
343
    g_list_free (temporary_files);
395
344
 
401
350
}
402
351
 
403
352
 
404
 
gboolean
405
 
book_save_pdf (Book *book, const gchar *uri, GError **error)
 
353
static gboolean
 
354
book_save_pdf (Book *book, GFile *file, GError **error)
406
355
{
407
356
    GFileOutputStream *stream;
408
357
    GList *iter;
413
362
    imagemagick_executable = g_find_program_in_path ("convert");
414
363
    if (imagemagick_executable) {
415
364
        g_free (imagemagick_executable);
416
 
        return book_save_pdf_with_imagemagick (book, uri, error);
 
365
        return book_save_pdf_with_imagemagick (book, file, error);
417
366
    }
418
367
 
419
 
    stream = open_file (uri, error);
 
368
    stream = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, error);
420
369
    if (!stream)
421
370
        return FALSE;
422
371
 
447
396
}
448
397
 
449
398
 
 
399
gboolean
 
400
book_save (Book *book, const gchar *type, GFile *file, GError **error)
 
401
{
 
402
    if (strcmp (type, "jpeg") == 0)
 
403
        return book_save_multi_file (book, "jpeg", file, error);
 
404
    else if (strcmp (type, "png") == 0)
 
405
        return book_save_multi_file (book, "png", file, error);
 
406
    else if (strcmp (type, "tiff") == 0)
 
407
        return book_save_multi_file (book, "tiff", file, error);    
 
408
    else if (strcmp (type, "ps") == 0)
 
409
        return book_save_ps (book, file, error);    
 
410
    else if (strcmp (type, "pdf") == 0)
 
411
        return book_save_pdf (book, file, error);
 
412
    else
 
413
        return FALSE;
 
414
}
 
415
 
 
416
 
450
417
static void
451
418
book_finalize (GObject *object)
452
419
{