« back to all changes in this revision
Viewing changes to src/book.c
- browse files at revision 40
- compare with another revision
- download diff
- download tarball
- view history from revision 40
- Committer: Bazaar Package Importer
- Author(s): Martin Pitt
- Date: 2011-08-22 14:39:00 UTC
- mfrom: (1.1.26 upstream)
- Revision ID: james.westby@ubuntu.com-20110822143900-mas00fbdm5evsv8a
Tags: 3.1.3-0ubuntu1
* New upstream release.
* debian/control: Update build-deps as per configure.ac: valac (>= 0.13.0),
GTK 2 → 3, drop libgconf2-dev.
* debian/watch: Look for *.tar.bz2.
* 01-zlib.patch: Update for new upstream version.
* Disable 20-lpi.patch for now, needs porting to vala.
* debian/control: Update build-deps as per configure.ac: valac (>= 0.13.0),
GTK 2 → 3, drop libgconf2-dev.
* debian/watch: Look for *.tar.bz2.
* 01-zlib.patch: Update for new upstream version.
* Disable 20-lpi.patch for now, needs porting to vala.
- files added:
- compile
- files removed:
- .pc/20-lpi.patch
- .pc/20-lpi.patch/src
- files modified:
- .pc/01-zlib.patch/configure.ac
added
removed
src/book.c
1
/* book.c generated by valac 0.13.0, the Vala compiler
2
* generated from book.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
12
#include <stdio.h>
15
#include <glib.h>
16
#include <glib-object.h>
17
#include <stdlib.h>
13
18
#include <string.h>
19
#include <gio/gio.h>
20
#include <cairo.h>
21
#include <gdk-pixbuf/gdk-pixdata.h>
22
#include <float.h>
14
23
#include <math.h>
24
#include <gdk/gdk.h>
25
#include <cairo-ps.h>
15
26
#include <zlib.h>
16
27
#include <jpeglib.h>
17
#include <gdk/gdk.h>
18
#include <gdk-pixbuf/gdk-pixbuf.h>
19
#include <cairo/cairo-pdf.h>
20
#include <cairo/cairo-ps.h>
21
22
#include "book.h"
23
24
enum {
25
PROP_0,
26
PROP_NEEDS_SAVING
27
};
28
29
enum {
30
PAGE_ADDED,
31
PAGE_REMOVED,
32
REORDERED,
33
CLEARED,
34
LAST_SIGNAL
35
};
36
static guint signals[LAST_SIGNAL] = { 0, };
37
38
struct BookPrivate
39
{
40
GList *pages;
41
42
gboolean needs_saving;
43
};
44
45
G_DEFINE_TYPE (Book, book, G_TYPE_OBJECT);
46
47
48
Book *
49
book_new ()
50
{
51
return g_object_new (BOOK_TYPE, NULL);
52
}
53
54
55
void
56
book_clear (Book *book)
57
{
58
GList *iter;
59
for (iter = book->priv->pages; iter; iter = iter->next) {
60
Page *page = iter->data;
61
g_object_unref (page);
62
}
63
g_list_free (book->priv->pages);
64
book->priv->pages = NULL;
65
g_signal_emit (book, signals[CLEARED], 0);
66
}
67
68
69
static void
70
page_changed_cb (Page *page, Book *book)
71
{
72
book_set_needs_saving (book, TRUE);
73
}
74
75
76
Page *
77
book_append_page (Book *book, gint width, gint height, gint dpi, ScanDirection scan_direction)
78
{
79
Page *page;
80
81
page = page_new (width, height, dpi, scan_direction);
82
g_signal_connect (page, "pixels-changed", G_CALLBACK (page_changed_cb), book);
83
g_signal_connect (page, "crop-changed", G_CALLBACK (page_changed_cb), book);
84
85
book->priv->pages = g_list_append (book->priv->pages, page);
86
87
g_signal_emit (book, signals[PAGE_ADDED], 0, page);
88
89
book_set_needs_saving (book, TRUE);
90
91
return page;
92
}
93
94
95
void
96
book_move_page (Book *book, Page *page, gint location)
97
{
98
book->priv->pages = g_list_remove (book->priv->pages, page);
99
book->priv->pages = g_list_insert (book->priv->pages, page, location);
100
101
g_signal_emit (book, signals[REORDERED], 0, page);
102
103
book_set_needs_saving (book, TRUE);
104
}
105
106
107
void
108
book_delete_page (Book *book, Page *page)
109
{
110
g_signal_handlers_disconnect_by_func (page, page_changed_cb, book);
111
112
g_signal_emit (book, signals[PAGE_REMOVED], 0, page);
113
114
book->priv->pages = g_list_remove (book->priv->pages, page);
115
g_object_unref (page);
116
117
book_set_needs_saving (book, TRUE);
118
}
119
120
121
gint
122
book_get_n_pages (Book *book)
123
{
124
return g_list_length (book->priv->pages);
125
}
126
127
128
Page *
129
book_get_page (Book *book, gint page_number)
130
{
131
if (page_number < 0)
132
page_number = g_list_length (book->priv->pages) + page_number;
133
return g_list_nth_data (book->priv->pages, page_number);
134
}
135
136
137
gint
138
book_get_page_index (Book *book, Page *page)
139
{
140
return g_list_index (book->priv->pages, page);
141
}
142
143
144
static GFile *
145
make_indexed_file (const gchar *uri, gint i)
146
{
147
gchar *basename, *suffix, *indexed_uri;
148
GFile *file;
149
150
if (i == 0)
151
return g_file_new_for_uri (uri);
152
153
basename = g_path_get_basename (uri);
154
suffix = g_strrstr (basename, ".");
155
156
if (suffix)
157
indexed_uri = g_strdup_printf ("%.*s-%d%s", (int) (strlen (uri) - strlen (suffix)), uri, i, suffix);
158
else
159
indexed_uri = g_strdup_printf ("%s-%d", uri, i);
160
g_free (basename);
161
162
file = g_file_new_for_uri (indexed_uri);
163
g_free (indexed_uri);
164
165
return file;
166
}
167
168
169
static gboolean
170
book_save_multi_file (Book *book, const gchar *type, GFile *file, GError **error)
171
{
172
GList *iter;
173
gboolean result = TRUE;
174
gint i;
175
gchar *uri;
176
177
uri = g_file_get_uri (file);
178
for (iter = book->priv->pages, i = 0; iter && result; iter = iter->next, i++) {
179
Page *page = iter->data;
180
GFile *file;
181
182
file = make_indexed_file (uri, i);
183
result = page_save (page, type, file, error);
184
g_object_unref (file);
185
}
186
g_free (uri);
187
188
return result;
189
}
190
191
192
static void
193
save_ps_pdf_surface (cairo_surface_t *surface, GdkPixbuf *image, gdouble dpi)
194
{
195
cairo_t *context;
196
197
context = cairo_create (surface);
198
199
cairo_scale (context, 72.0 / dpi, 72.0 / dpi);
200
gdk_cairo_set_source_pixbuf (context, image, 0, 0);
201
cairo_pattern_set_filter (cairo_get_source (context), CAIRO_FILTER_BEST);
202
cairo_paint (context);
203
204
cairo_destroy (context);
205
}
206
207
208
static cairo_status_t
209
write_cairo_data (GFileOutputStream *stream, unsigned char *data, unsigned int length)
210
{
211
gboolean result;
212
GError *error = NULL;
213
214
result = g_output_stream_write_all (G_OUTPUT_STREAM (stream), data, length, NULL, NULL, &error);
215
216
if (error) {
217
g_warning ("Error writing data: %s", error->message);
218
g_error_free (error);
219
}
220
221
return result ? CAIRO_STATUS_SUCCESS : CAIRO_STATUS_WRITE_ERROR;
222
}
223
224
225
static gboolean
226
book_save_ps (Book *book, GFile *file, GError **error)
227
{
228
GFileOutputStream *stream;
229
GList *iter;
230
cairo_surface_t *surface;
231
232
stream = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, error);
233
if (!stream)
234
return FALSE;
235
236
surface = cairo_ps_surface_create_for_stream ((cairo_write_func_t) write_cairo_data,
237
stream, 0, 0);
238
239
for (iter = book->priv->pages; iter; iter = iter->next) {
240
Page *page = iter->data;
241
double width, height;
242
GdkPixbuf *image;
243
244
image = page_get_image (page, TRUE);
245
246
width = gdk_pixbuf_get_width (image) * 72.0 / page_get_dpi (page);
247
height = gdk_pixbuf_get_height (image) * 72.0 / page_get_dpi (page);
248
cairo_ps_surface_set_size (surface, width, height);
249
save_ps_pdf_surface (surface, image, page_get_dpi (page));
250
cairo_surface_show_page (surface);
251
252
g_object_unref (image);
253
}
254
255
cairo_surface_destroy (surface);
256
257
g_object_unref (stream);
258
259
return TRUE;
260
}
261
262
263
typedef struct
264
{
265
int offset;
266
int n_objects;
267
GList *object_offsets;
268
GFileOutputStream *stream;
269
} PDFWriter;
270
271
272
static PDFWriter *
273
pdf_writer_new (GFileOutputStream *stream)
274
{
275
PDFWriter *writer;
276
writer = g_malloc0 (sizeof (PDFWriter));
277
writer->stream = g_object_ref (stream);
278
return writer;
279
}
280
281
282
static void
283
pdf_writer_free (PDFWriter *writer)
284
{
285
g_object_unref (writer->stream);
286
g_list_free (writer->object_offsets);
287
g_free (writer);
288
}
289
290
291
static void
292
pdf_write (PDFWriter *writer, const unsigned char *data, size_t length)
293
{
294
g_output_stream_write_all (G_OUTPUT_STREAM (writer->stream), data, length, NULL, NULL, NULL);
295
writer->offset += length;
296
}
297
298
299
static void
300
pdf_printf (PDFWriter *writer, const char *format, ...)
301
{
302
va_list args;
303
gchar *string;
304
305
va_start (args, format);
306
string = g_strdup_vprintf (format, args);
307
va_end (args);
308
pdf_write (writer, (unsigned char *)string, strlen (string));
309
310
g_free (string);
311
}
312
313
314
static int
315
pdf_start_object (PDFWriter *writer)
316
{
317
writer->n_objects++;
318
writer->object_offsets = g_list_append (writer->object_offsets, GINT_TO_POINTER (writer->offset));
319
return writer->n_objects;
320
}
321
322
323
static guchar *
324
compress_zlib (guchar *data, size_t length, size_t *n_written)
325
{
326
z_stream stream;
327
guchar *out_data;
328
329
out_data = g_malloc (sizeof (guchar) * length);
330
331
stream.zalloc = Z_NULL;
332
stream.zfree = Z_NULL;
333
stream.opaque = Z_NULL;
334
if (deflateInit (&stream, Z_BEST_COMPRESSION) != Z_OK)
335
return NULL;
336
337
stream.next_in = data;
338
stream.avail_in = length;
339
stream.next_out = out_data;
340
stream.avail_out = length;
341
while (stream.avail_in > 0) {
342
if (deflate (&stream, Z_FINISH) == Z_STREAM_ERROR)
343
break;
344
}
345
346
deflateEnd (&stream);
347
348
if (stream.avail_in > 0) {
349
g_free (out_data);
350
return NULL;
351
}
352
353
*n_written = length - stream.avail_out;
354
355
return out_data;
356
}
357
358
359
static void jpeg_init_cb (struct jpeg_compress_struct *info) {}
360
static boolean jpeg_empty_cb (struct jpeg_compress_struct *info) { return TRUE; }
361
static void jpeg_term_cb (struct jpeg_compress_struct *info) {}
362
363
static guchar *
364
compress_jpeg (GdkPixbuf *image, size_t *n_written)
365
{
366
struct jpeg_compress_struct info;
367
struct jpeg_error_mgr jerr;
368
struct jpeg_destination_mgr dest_mgr;
369
int r;
370
guchar *pixels;
371
guchar *data;
372
size_t max_length;
373
374
info.err = jpeg_std_error (&jerr);
375
jpeg_create_compress (&info);
376
377
pixels = gdk_pixbuf_get_pixels (image);
378
info.image_width = gdk_pixbuf_get_width (image);
379
info.image_height = gdk_pixbuf_get_height (image);
380
info.input_components = 3;
381
info.in_color_space = JCS_RGB; /* TODO: JCS_GRAYSCALE? */
382
jpeg_set_defaults (&info);
383
384
max_length = info.image_width * info.image_height * info.input_components;
385
data = g_malloc (sizeof (guchar) * max_length);
386
dest_mgr.next_output_byte = data;
387
dest_mgr.free_in_buffer = max_length;
388
dest_mgr.init_destination = jpeg_init_cb;
389
dest_mgr.empty_output_buffer = jpeg_empty_cb;
390
dest_mgr.term_destination = jpeg_term_cb;
391
info.dest = &dest_mgr;
392
393
jpeg_start_compress (&info, TRUE);
394
for (r = 0; r < info.image_height; r++) {
395
JSAMPROW row[1];
396
row[0] = pixels + r * gdk_pixbuf_get_rowstride (image);
397
jpeg_write_scanlines (&info, row, 1);
398
}
399
jpeg_finish_compress (&info);
400
*n_written = max_length - dest_mgr.free_in_buffer;
401
402
jpeg_destroy_compress (&info);
403
404
return data;
405
}
406
407
408
static gboolean
409
book_save_pdf (Book *book, GFile *file, GError **error)
410
{
411
GFileOutputStream *stream;
412
PDFWriter *writer;
413
int catalog_number, pages_number, info_number;
414
int xref_offset;
415
int i;
416
417
stream = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, error);
418
if (!stream)
419
return FALSE;
420
421
writer = pdf_writer_new (stream);
422
g_object_unref (stream);
423
424
/* Header */
425
pdf_printf (writer, "%%PDF-1.3\n");
426
427
/* Comment with binary as recommended so file is treated as binary */
428
pdf_printf (writer, "%%\xe2\xe3\xcf\xd3\n");
429
430
/* Catalog */
431
catalog_number = pdf_start_object (writer);
432
pdf_printf (writer, "%d 0 obj\n", catalog_number);
433
pdf_printf (writer, "<<\n");
434
pdf_printf (writer, "/Type /Catalog\n");
435
//FIXMEpdf_printf (writer, "/Metadata %d 0 R\n", catalog_number + 1);
436
pdf_printf (writer, "/Pages %d 0 R\n", catalog_number + 1); //+2
437
pdf_printf (writer, ">>\n");
438
pdf_printf (writer, "endobj\n");
439
440
/* Metadata */
441
/* FIXME pdf_printf (writer, "\n");
442
number = pdf_start_object (writer);
443
pdf_printf (writer, "%d 0 obj\n", number);
444
pdf_printf (writer, "<<\n");
445
pdf_printf (writer, "/Type /Metadata\n");
446
pdf_printf (writer, "/Subtype /XML\n");
447
pdf_printf (writer, "/Length %d\n", ...);
448
pdf_printf (writer, ">>\n");
449
pdf_printf (writer, "stream\n");
450
// ...
451
pdf_printf (writer, "\n");
452
pdf_printf (writer, "endstream\n");
453
pdf_printf (writer, "endobj\n");*/
454
455
/* Pages */
456
pdf_printf (writer, "\n");
457
pages_number = pdf_start_object (writer);
458
pdf_printf (writer, "%d 0 obj\n", pages_number);
459
pdf_printf (writer, "<<\n");
460
pdf_printf (writer, "/Type /Pages\n");
461
pdf_printf (writer, "/Kids [");
462
for (i = 0; i < book_get_n_pages (book); i++) {
463
pdf_printf (writer, " %d 0 R", pages_number + 1 + (i*3));
464
}
465
pdf_printf (writer, " ]\n");
466
pdf_printf (writer, "/Count %d\n", book_get_n_pages (book));
467
pdf_printf (writer, ">>\n");
468
pdf_printf (writer, "endobj\n");
469
470
for (i = 0; i < book_get_n_pages (book); i++) {
471
int number, width, height, depth;
472
size_t data_length, compressed_length;
473
Page *page;
474
GdkPixbuf *image;
475
guchar *pixels, *data, *compressed_data;
476
gchar *command, width_buffer[G_ASCII_DTOSTR_BUF_SIZE], height_buffer[G_ASCII_DTOSTR_BUF_SIZE];
477
const gchar *color_space, *filter = NULL;
478
float page_width, page_height;
479
480
page = book_get_page (book, i);
481
image = page_get_image (page, TRUE);
482
width = gdk_pixbuf_get_width (image);
483
height = gdk_pixbuf_get_height (image);
484
pixels = gdk_pixbuf_get_pixels (image);
485
page_width = width * 72. / page_get_dpi (page);
486
page_height = height * 72. / page_get_dpi (page);
487
488
if (page_is_color (page)) {
489
int row;
490
491
depth = 8;
492
color_space = "DeviceRGB";
493
data_length = height * width * 3 + 1;
494
data = g_malloc (sizeof (guchar) * data_length);
495
for (row = 0; row < height; row++) {
496
int x;
497
guchar *in_line, *out_line;
498
499
in_line = pixels + row * gdk_pixbuf_get_rowstride (image);
500
out_line = data + row * width * 3;
501
for (x = 0; x < width; x++) {
502
guchar *in_p = in_line + x*3;
503
guchar *out_p = out_line + x*3;
504
505
out_p[0] = in_p[0];
506
out_p[1] = in_p[1];
507
out_p[2] = in_p[2];
508
}
509
}
510
}
511
else if (page_get_depth (page) == 2) {
512
int row, shift_count = 6;
513
guchar *write_ptr;
514
515
depth = 2;
516
color_space = "DeviceGray";
517
data_length = height * ((width * 2 + 7) / 8);
518
data = g_malloc (sizeof (guchar) * data_length);
519
write_ptr = data;
520
write_ptr[0] = 0;
521
for (row = 0; row < height; row++) {
522
int x;
523
guchar *in_line;
524
525
/* Pad to the next line */
526
if (shift_count != 6) {
527
write_ptr++;
528
write_ptr[0] = 0;
529
shift_count = 6;
530
}
531
532
in_line = pixels + row * gdk_pixbuf_get_rowstride (image);
533
for (x = 0; x < width; x++) {
534
guchar *in_p = in_line + x*3;
535
if (in_p[0] >= 192)
536
write_ptr[0] |= 3 << shift_count;
537
else if (in_p[0] >= 128)
538
write_ptr[0] |= 2 << shift_count;
539
else if (in_p[0] >= 64)
540
write_ptr[0] |= 1 << shift_count;
541
if (shift_count == 0) {
542
write_ptr++;
543
write_ptr[0] = 0;
544
shift_count = 6;
545
}
546
else
547
shift_count -= 2;
548
}
549
}
550
}
551
else if (page_get_depth (page) == 1) {
552
int row, mask = 0x80;
553
guchar *write_ptr;
554
555
depth = 1;
556
color_space = "DeviceGray";
557
data_length = height * ((width + 7) / 8);
558
data = g_malloc (sizeof (guchar) * data_length);
559
write_ptr = data;
560
write_ptr[0] = 0;
561
for (row = 0; row < height; row++) {
562
int x;
563
guchar *in_line;
564
565
/* Pad to the next line */
566
if (mask != 0x80) {
567
write_ptr++;
568
write_ptr[0] = 0;
569
mask = 0x80;
570
}
571
572
in_line = pixels + row * gdk_pixbuf_get_rowstride (image);
573
for (x = 0; x < width; x++) {
574
guchar *in_p = in_line + x*3;
575
if (in_p[0] != 0)
576
write_ptr[0] |= mask;
577
mask >>= 1;
578
if (mask == 0) {
579
write_ptr++;
580
write_ptr[0] = 0;
581
mask = 0x80;
582
}
583
}
584
}
585
}
586
else {
587
int row;
588
589
depth = 8;
590
color_space = "DeviceGray";
591
data_length = height * width + 1;
592
data = g_malloc (sizeof (guchar) * data_length);
593
for (row = 0; row < height; row++) {
594
int x;
595
guchar *in_line, *out_line;
596
597
in_line = pixels + row * gdk_pixbuf_get_rowstride (image);
598
out_line = data + row * width;
599
for (x = 0; x < width; x++) {
600
guchar *in_p = in_line + x*3;
601
guchar *out_p = out_line + x;
602
603
out_p[0] = in_p[0];
604
}
605
}
606
}
607
608
/* Compress data */
609
compressed_data = compress_zlib (data, data_length, &compressed_length);
610
if (compressed_data) {
611
/* Try if JPEG compression is better */
612
if (depth > 1) {
613
guchar *jpeg_data;
614
size_t jpeg_length;
615
616
jpeg_data = compress_jpeg (image, &jpeg_length);
617
if (jpeg_length < compressed_length) {
618
filter = "DCTDecode";
619
g_free (data);
620
g_free (compressed_data);
621
data = jpeg_data;
622
data_length = jpeg_length;
623
}
624
}
625
626
if (!filter) {
627
filter = "FlateDecode";
628
g_free (data);
629
data = compressed_data;
630
data_length = compressed_length;
631
}
632
}
633
634
/* Page */
635
pdf_printf (writer, "\n");
636
number = pdf_start_object (writer);
637
pdf_printf (writer, "%d 0 obj\n", number);
638
pdf_printf (writer, "<<\n");
639
pdf_printf (writer, "/Type /Page\n");
640
pdf_printf (writer, "/Parent %d 0 R\n", pages_number);
641
pdf_printf (writer, "/Resources << /XObject << /Im%d %d 0 R >> >>\n", i, number+1);
642
pdf_printf (writer, "/MediaBox [ 0 0 %s %s ]\n",
643
g_ascii_formatd (width_buffer, sizeof (width_buffer), "%.2f", page_width),
644
g_ascii_formatd (height_buffer, sizeof (height_buffer), "%.2f", page_height));
645
pdf_printf (writer, "/Contents %d 0 R\n", number+2);
646
pdf_printf (writer, ">>\n");
647
pdf_printf (writer, "endobj\n");
648
649
/* Page image */
650
pdf_printf (writer, "\n");
651
number = pdf_start_object (writer);
652
pdf_printf (writer, "%d 0 obj\n", number);
653
pdf_printf (writer, "<<\n");
654
pdf_printf (writer, "/Type /XObject\n");
655
pdf_printf (writer, "/Subtype /Image\n");
656
pdf_printf (writer, "/Width %d\n", width);
657
pdf_printf (writer, "/Height %d\n", height);
658
pdf_printf (writer, "/ColorSpace /%s\n", color_space);
659
pdf_printf (writer, "/BitsPerComponent %d\n", depth);
660
pdf_printf (writer, "/Length %d\n", data_length);
661
if (filter)
662
pdf_printf (writer, "/Filter /%s\n", filter);
663
pdf_printf (writer, ">>\n");
664
pdf_printf (writer, "stream\n");
665
pdf_write (writer, data, data_length);
666
g_free (data);
667
pdf_printf (writer, "\n");
668
pdf_printf (writer, "endstream\n");
669
pdf_printf (writer, "endobj\n");
670
671
/* Page contents */
672
command = g_strdup_printf ("q\n"
673
"%s 0 0 %s 0 0 cm\n"
674
"/Im%d Do\n"
675
"Q",
676
g_ascii_formatd (width_buffer, sizeof (width_buffer), "%f", page_width),
677
g_ascii_formatd (height_buffer, sizeof (height_buffer), "%f", page_height),
678
i);
679
pdf_printf (writer, "\n");
680
number = pdf_start_object (writer);
681
pdf_printf (writer, "%d 0 obj\n", number);
682
pdf_printf (writer, "<<\n");
683
pdf_printf (writer, "/Length %d\n", strlen (command) + 1);
684
pdf_printf (writer, ">>\n");
685
pdf_printf (writer, "stream\n");
686
pdf_write (writer, (unsigned char *)command, strlen (command));
687
pdf_printf (writer, "\n");
688
pdf_printf (writer, "endstream\n");
689
pdf_printf (writer, "endobj\n");
690
g_free (command);
691
692
g_object_unref (image);
693
}
694
695
/* Info */
696
pdf_printf (writer, "\n");
697
info_number = pdf_start_object (writer);
698
pdf_printf (writer, "%d 0 obj\n", info_number);
699
pdf_printf (writer, "<<\n");
700
pdf_printf (writer, "/Creator (Simple Scan " VERSION ")\n");
701
pdf_printf (writer, ">>\n");
702
pdf_printf (writer, "endobj\n");
703
704
/* Cross-reference table */
705
xref_offset = writer->offset;
706
pdf_printf (writer, "xref\n");
707
pdf_printf (writer, "1 %d\n", writer->n_objects);
708
GList *link;
709
for (link = writer->object_offsets; link != NULL; link = link->next) {
710
int offset = GPOINTER_TO_INT (link->data);
711
pdf_printf (writer, "%010d 0000 n\n", offset);
712
}
713
714
/* Trailer */
715
pdf_printf (writer, "trailer\n");
716
pdf_printf (writer, "<<\n");
717
pdf_printf (writer, "/Size %d\n", writer->n_objects);
718
pdf_printf (writer, "/Info %d 0 R\n", info_number);
719
pdf_printf (writer, "/Root %d 0 R\n", catalog_number);
720
//FIXME: pdf_printf (writer, "/ID [<...> <...>]\n");
721
pdf_printf (writer, ">>\n");
722
pdf_printf (writer, "startxref\n");
723
pdf_printf (writer, "%d\n", xref_offset);
724
pdf_printf (writer, "%%%%EOF\n");
725
726
pdf_writer_free (writer);
727
728
return TRUE;
729
}
730
731
732
gboolean
733
book_save (Book *book, const gchar *type, GFile *file, GError **error)
734
{
735
gboolean result = FALSE;
736
737
if (strcmp (type, "jpeg") == 0)
738
result = book_save_multi_file (book, "jpeg", file, error);
739
else if (strcmp (type, "png") == 0)
740
result = book_save_multi_file (book, "png", file, error);
741
else if (strcmp (type, "tiff") == 0)
742
result = book_save_multi_file (book, "tiff", file, error);
743
else if (strcmp (type, "ps") == 0)
744
result = book_save_ps (book, file, error);
745
else if (strcmp (type, "pdf") == 0)
746
result = book_save_pdf (book, file, error);
747
748
return result;
749
}
750
751
752
void
753
book_set_needs_saving (Book *book, gboolean needs_saving)
754
{
755
gboolean needed_saving = book->priv->needs_saving;
756
book->priv->needs_saving = needs_saving;
757
if (needed_saving != needs_saving)
758
g_object_notify (G_OBJECT (book), "needs-saving");
759
}
760
761
762
gboolean
763
book_get_needs_saving (Book *book)
764
{
765
return book->priv->needs_saving;
766
}
767
768
769
static void
770
book_set_property (GObject *object,
771
guint prop_id,
772
const GValue *value,
773
GParamSpec *pspec)
774
{
775
Book *self;
776
777
self = BOOK (object);
778
779
switch (prop_id) {
780
case PROP_NEEDS_SAVING:
781
book_set_needs_saving (self, g_value_get_boolean (value));
782
break;
783
default:
784
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
785
break;
786
}
787
}
788
789
790
static void
791
book_get_property (GObject *object,
792
guint prop_id,
793
GValue *value,
794
GParamSpec *pspec)
795
{
796
Book *self;
797
798
self = BOOK (object);
799
800
switch (prop_id) {
801
case PROP_NEEDS_SAVING:
802
g_value_set_boolean (value, book_get_needs_saving (self));
803
break;
804
default:
805
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
806
break;
807
}
808
}
809
810
811
static void
812
book_finalize (GObject *object)
813
{
814
Book *book = BOOK (object);
815
book_clear (book);
816
G_OBJECT_CLASS (book_parent_class)->finalize (object);
817
}
818
819
820
static void
821
book_class_init (BookClass *klass)
822
{
823
GObjectClass *object_class = G_OBJECT_CLASS (klass);
824
825
object_class->get_property = book_get_property;
826
object_class->set_property = book_set_property;
827
object_class->finalize = book_finalize;
828
829
g_object_class_install_property (object_class,
830
PROP_NEEDS_SAVING,
831
g_param_spec_boolean ("needs-saving",
832
"needs-saving",
833
"TRUE if this book needs saving",
834
FALSE,
835
G_PARAM_READWRITE));
836
837
signals[PAGE_ADDED] =
838
g_signal_new ("page-added",
839
G_TYPE_FROM_CLASS (klass),
840
G_SIGNAL_RUN_LAST,
841
G_STRUCT_OFFSET (BookClass, page_added),
842
NULL, NULL,
843
g_cclosure_marshal_VOID__OBJECT,
844
G_TYPE_NONE, 1, page_get_type ());
845
signals[PAGE_REMOVED] =
846
g_signal_new ("page-removed",
847
G_TYPE_FROM_CLASS (klass),
848
G_SIGNAL_RUN_LAST,
849
G_STRUCT_OFFSET (BookClass, page_removed),
850
NULL, NULL,
851
g_cclosure_marshal_VOID__OBJECT,
852
G_TYPE_NONE, 1, page_get_type ());
853
signals[REORDERED] =
854
g_signal_new ("reordered",
855
G_TYPE_FROM_CLASS (klass),
856
G_SIGNAL_RUN_LAST,
857
G_STRUCT_OFFSET (BookClass, reordered),
858
NULL, NULL,
859
g_cclosure_marshal_VOID__VOID,
860
G_TYPE_NONE, 0);
861
signals[CLEARED] =
862
g_signal_new ("cleared",
863
G_TYPE_FROM_CLASS (klass),
864
G_SIGNAL_RUN_LAST,
865
G_STRUCT_OFFSET (BookClass, cleared),
866
NULL, NULL,
867
g_cclosure_marshal_VOID__VOID,
868
G_TYPE_NONE, 0);
869
870
g_type_class_add_private (klass, sizeof (BookPrivate));
871
}
872
873
874
static void
875
book_init (Book *book)
876
{
877
book->priv = G_TYPE_INSTANCE_GET_PRIVATE (book, BOOK_TYPE, BookPrivate);
878
}
28
#include <config.h>
29
#include <gobject/gvaluecollector.h>
30
31
32
#define TYPE_BOOK (book_get_type ())
33
#define BOOK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_BOOK, Book))
34
#define BOOK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_BOOK, BookClass))
35
#define IS_BOOK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_BOOK))
36
#define IS_BOOK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_BOOK))
37
#define BOOK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_BOOK, BookClass))
38
39
typedef struct _Book Book;
40
typedef struct _BookClass BookClass;
41
typedef struct _BookPrivate BookPrivate;
42
43
#define TYPE_PAGE (page_get_type ())
44
#define PAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PAGE, Page))
45
#define PAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PAGE, PageClass))
46
#define IS_PAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PAGE))
47
#define IS_PAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PAGE))
48
#define PAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PAGE, PageClass))
49
50
typedef struct _Page Page;
51
typedef struct _PageClass PageClass;
52
#define __g_list_free__page_unref0_0(var) ((var == NULL) ? NULL : (var = (_g_list_free__page_unref0_ (var), NULL)))
53
54
#define TYPE_SCAN_DIRECTION (scan_direction_get_type ())
55
#define _page_unref0(var) ((var == NULL) ? NULL : (var = (page_unref (var), NULL)))
56
#define _g_free0(var) (var = (g_free (var), NULL))
57
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
58
#define _cairo_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_destroy (var), NULL)))
59
60
#define TYPE_PS_WRITER (ps_writer_get_type ())
61
#define PS_WRITER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PS_WRITER, PsWriter))
62
#define PS_WRITER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PS_WRITER, PsWriterClass))
63
#define IS_PS_WRITER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PS_WRITER))
64
#define IS_PS_WRITER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PS_WRITER))
65
#define PS_WRITER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PS_WRITER, PsWriterClass))
66
67
typedef struct _PsWriter PsWriter;
68
typedef struct _PsWriterClass PsWriterClass;
69
typedef struct _PsWriterPrivate PsWriterPrivate;
70
#define _cairo_surface_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_surface_destroy (var), NULL)))
71
#define _ps_writer_unref0(var) ((var == NULL) ? NULL : (var = (ps_writer_unref (var), NULL)))
72
73
#define TYPE_PDF_WRITER (pdf_writer_get_type ())
74
#define PDF_WRITER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PDF_WRITER, PDFWriter))
75
#define PDF_WRITER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PDF_WRITER, PDFWriterClass))
76
#define IS_PDF_WRITER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PDF_WRITER))
77
#define IS_PDF_WRITER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PDF_WRITER))
78
#define PDF_WRITER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PDF_WRITER, PDFWriterClass))
79
80
typedef struct _PDFWriter PDFWriter;
81
typedef struct _PDFWriterClass PDFWriterClass;
82
typedef struct _PDFWriterPrivate PDFWriterPrivate;
83
#define _pdf_writer_unref0(var) ((var == NULL) ? NULL : (var = (pdf_writer_unref (var), NULL)))
84
typedef struct _ParamSpecBook ParamSpecBook;
85
#define _g_list_free0(var) ((var == NULL) ? NULL : (var = (g_list_free (var), NULL)))
86
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
87
typedef struct _ParamSpecPDFWriter ParamSpecPDFWriter;
88
typedef struct _ParamSpecPsWriter ParamSpecPsWriter;
89
90
struct _Book {
91
GTypeInstance parent_instance;
92
volatile int ref_count;
93
BookPrivate * priv;
94
};
95
96
struct _BookClass {
97
GTypeClass parent_class;
98
void (*finalize) (Book *self);
99
};
100
101
struct _BookPrivate {
102
GList* pages;
103
gboolean needs_saving;
104
};
105
106
typedef enum {
107
SCAN_DIRECTION_TOP_TO_BOTTOM,
108
SCAN_DIRECTION_LEFT_TO_RIGHT,
109
SCAN_DIRECTION_BOTTOM_TO_TOP,
110
SCAN_DIRECTION_RIGHT_TO_LEFT
111
} ScanDirection;
112
113
struct _PsWriter {
114
GTypeInstance parent_instance;
115
volatile int ref_count;
116
PsWriterPrivate * priv;
117
cairo_surface_t* surface;
118
GFileOutputStream* stream;
119
};
120
121
struct _PsWriterClass {
122
GTypeClass parent_class;
123
void (*finalize) (PsWriter *self);
124
};
125
126
struct _PDFWriter {
127
GTypeInstance parent_instance;
128
volatile int ref_count;
129
PDFWriterPrivate * priv;
130
gsize offset;
131
GList* object_offsets;
132
};
133
134
struct _PDFWriterClass {
135
GTypeClass parent_class;
136
void (*finalize) (PDFWriter *self);
137
};
138
139
struct _ParamSpecBook {
140
GParamSpec parent_instance;
141
};
142
143
struct _PDFWriterPrivate {
144
GFileOutputStream* stream;
145
};
146
147
struct _ParamSpecPDFWriter {
148
GParamSpec parent_instance;
149
};
150
151
struct _ParamSpecPsWriter {
152
GParamSpec parent_instance;
153
};
154
155
156
static gpointer book_parent_class = NULL;
157
static gpointer pdf_writer_parent_class = NULL;
158
static gpointer ps_writer_parent_class = NULL;
159
160
gpointer book_ref (gpointer instance);
161
void book_unref (gpointer instance);
162
GParamSpec* param_spec_book (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
163
void value_set_book (GValue* value, gpointer v_object);
164
void value_take_book (GValue* value, gpointer v_object);
165
gpointer value_get_book (const GValue* value);
166
GType book_get_type (void) G_GNUC_CONST;
167
gpointer page_ref (gpointer instance);
168
void page_unref (gpointer instance);
169
GParamSpec* param_spec_page (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
170
void value_set_page (GValue* value, gpointer v_object);
171
void value_take_page (GValue* value, gpointer v_object);
172
gpointer value_get_page (const GValue* value);
173
GType page_get_type (void) G_GNUC_CONST;
174
#define BOOK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_BOOK, BookPrivate))
175
enum {
176
BOOK_DUMMY_PROPERTY
177
};
178
static void _page_unref0_ (gpointer var);
179
static void _g_list_free__page_unref0_ (GList* self);
180
Book* book_new (void);
181
Book* book_construct (GType object_type);
182
void book_clear (Book* self);
183
static void book_page_changed_cb (Book* self, Page* page);
184
void book_set_needs_saving (Book* self, gboolean needs_saving);
185
GType scan_direction_get_type (void) G_GNUC_CONST;
186
Page* book_append_page (Book* self, gint width, gint height, gint dpi, ScanDirection scan_direction);
187
Page* page_new (gint width, gint height, gint dpi, ScanDirection scan_direction);
188
Page* page_construct (GType object_type, gint width, gint height, gint dpi, ScanDirection scan_direction);
189
static void _book_page_changed_cb_page_pixels_changed (Page* _sender, gpointer self);
190
static void _book_page_changed_cb_page_crop_changed (Page* _sender, gpointer self);
191
void book_move_page (Book* self, Page* page, guint location);
192
void book_delete_page (Book* self, Page* page);
193
guint book_get_n_pages (Book* self);
194
Page* book_get_page (Book* self, gint page_number);
195
guint book_get_page_index (Book* self, Page* page);
196
static GFile* book_make_indexed_file (Book* self, const gchar* uri, gint i);
197
static void book_save_multi_file (Book* self, const gchar* type, GFile* file, GError** error);
198
void page_save (Page* self, const gchar* type, GFile* file, GError** error);
199
static void book_save_ps_pdf_surface (Book* self, cairo_surface_t* surface, GdkPixbuf* image, gdouble dpi);
200
static void book_save_ps (Book* self, GFile* file, GError** error);
201
PsWriter* ps_writer_new (GFileOutputStream* stream);
202
PsWriter* ps_writer_construct (GType object_type, GFileOutputStream* stream);
203
gpointer ps_writer_ref (gpointer instance);
204
void ps_writer_unref (gpointer instance);
205
GParamSpec* param_spec_ps_writer (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
206
void value_set_ps_writer (GValue* value, gpointer v_object);
207
void value_take_ps_writer (GValue* value, gpointer v_object);
208
gpointer value_get_ps_writer (const GValue* value);
209
GType ps_writer_get_type (void) G_GNUC_CONST;
210
GdkPixbuf* page_get_image (Page* self, gboolean apply_crop);
211
gint page_get_dpi (Page* self);
212
static guint8* book_compress_zlib (Book* self, guint8* data, int data_length1, int* result_length1);
213
static void book_jpeg_init_cb (struct jpeg_compress_struct* info);
214
static gboolean book_jpeg_empty_cb (struct jpeg_compress_struct* info);
215
static void book_jpeg_term_cb (struct jpeg_compress_struct* info);
216
static guint8* book_compress_jpeg (Book* self, GdkPixbuf* image, gsize* n_written, int* result_length1);
217
static void _book_jpeg_init_cb_jpeg_initdestinationfunc (struct jpeg_compress_struct* cinfo);
218
static gboolean _book_jpeg_empty_cb_jpeg_emptyoutputbufferfunc (struct jpeg_compress_struct* cinfo);
219
static void _book_jpeg_term_cb_jpeg_termdestinationfunc (struct jpeg_compress_struct* cinfo);
220
static void book_save_pdf (Book* self, GFile* file, GError** error);
221
PDFWriter* pdf_writer_new (GFileOutputStream* stream);
222
PDFWriter* pdf_writer_construct (GType object_type, GFileOutputStream* stream);
223
gpointer pdf_writer_ref (gpointer instance);
224
void pdf_writer_unref (gpointer instance);
225
GParamSpec* param_spec_pdf_writer (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
226
void value_set_pdf_writer (GValue* value, gpointer v_object);
227
void value_take_pdf_writer (GValue* value, gpointer v_object);
228
gpointer value_get_pdf_writer (const GValue* value);
229
GType pdf_writer_get_type (void) G_GNUC_CONST;
230
void pdf_writer_write_string (PDFWriter* self, const gchar* text);
231
guint pdf_writer_start_object (PDFWriter* self);
232
gboolean page_is_color (Page* self);
233
gint page_get_depth (Page* self);
234
static guint8* _vala_array_dup1 (guint8* self, int length);
235
static guint8* _vala_array_dup2 (guint8* self, int length);
236
void pdf_writer_write (PDFWriter* self, guint8* data, int data_length1);
237
void book_save (Book* self, const gchar* type, GFile* file, GError** error);
238
gboolean book_get_needs_saving (Book* self);
239
static void g_cclosure_user_marshal_VOID__PAGE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
240
static void book_finalize (Book* obj);
241
#define PDF_WRITER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_PDF_WRITER, PDFWriterPrivate))
242
enum {
243
PDF_WRITER_DUMMY_PROPERTY
244
};
245
static void pdf_writer_finalize (PDFWriter* obj);
246
enum {
247
PS_WRITER_DUMMY_PROPERTY
248
};
249
static cairo_status_t ps_writer_write_cairo_data (PsWriter* self, guint8* data, int data_length1);
250
static cairo_status_t _ps_writer_write_cairo_data_cairo_write_func_t (gpointer self, guchar* data, int data_length1);
251
static void ps_writer_finalize (PsWriter* obj);
252
253
254
static void _page_unref0_ (gpointer var) {
255
(var == NULL) ? NULL : (var = (page_unref (var), NULL));
256
}
257
258
259
static void _g_list_free__page_unref0_ (GList* self) {
260
g_list_foreach (self, (GFunc) _page_unref0_, NULL);
261
g_list_free (self);
262
}
263
264
265
Book* book_construct (GType object_type) {
266
Book* self = NULL;
267
self = (Book*) g_type_create_instance (object_type);
268
return self;
269
}
270
271
272
Book* book_new (void) {
273
return book_construct (TYPE_BOOK);
274
}
275
276
277
void book_clear (Book* self) {
278
g_return_if_fail (self != NULL);
279
__g_list_free__page_unref0_0 (self->priv->pages);
280
self->priv->pages = NULL;
281
g_signal_emit_by_name (self, "cleared");
282
}
283
284
285
static void book_page_changed_cb (Book* self, Page* page) {
286
g_return_if_fail (self != NULL);
287
g_return_if_fail (page != NULL);
288
book_set_needs_saving (self, TRUE);
289
}
290
291
292
static void _book_page_changed_cb_page_pixels_changed (Page* _sender, gpointer self) {
293
book_page_changed_cb (self, _sender);
294
}
295
296
297
static void _book_page_changed_cb_page_crop_changed (Page* _sender, gpointer self) {
298
book_page_changed_cb (self, _sender);
299
}
300
301
302
static gpointer _page_ref0 (gpointer self) {
303
return self ? page_ref (self) : NULL;
304
}
305
306
307
Page* book_append_page (Book* self, gint width, gint height, gint dpi, ScanDirection scan_direction) {
308
Page* result = NULL;
309
Page* _tmp0_ = NULL;
310
Page* page;
311
Page* _tmp1_;
312
g_return_val_if_fail (self != NULL, NULL);
313
_tmp0_ = page_new (width, height, dpi, scan_direction);
314
page = _tmp0_;
315
g_signal_connect (page, "pixels-changed", (GCallback) _book_page_changed_cb_page_pixels_changed, self);
316
g_signal_connect (page, "crop-changed", (GCallback) _book_page_changed_cb_page_crop_changed, self);
317
_tmp1_ = _page_ref0 (page);
318
self->priv->pages = g_list_append (self->priv->pages, _tmp1_);
319
g_signal_emit_by_name (self, "page-added", page);
320
book_set_needs_saving (self, TRUE);
321
result = page;
322
return result;
323
}
324
325
326
void book_move_page (Book* self, Page* page, guint location) {
327
Page* _tmp0_;
328
g_return_if_fail (self != NULL);
329
g_return_if_fail (page != NULL);
330
self->priv->pages = g_list_remove (self->priv->pages, page);
331
_tmp0_ = _page_ref0 (page);
332
self->priv->pages = g_list_insert (self->priv->pages, _tmp0_, (gint) location);
333
g_signal_emit_by_name (self, "reordered");
334
book_set_needs_saving (self, TRUE);
335
}
336
337
338
void book_delete_page (Book* self, Page* page) {
339
guint _tmp0_;
340
guint _tmp1_;
341
g_return_if_fail (self != NULL);
342
g_return_if_fail (page != NULL);
343
g_signal_parse_name ("pixels-changed", TYPE_PAGE, &_tmp0_, NULL, FALSE);
344
g_signal_handlers_disconnect_matched (page, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _book_page_changed_cb_page_pixels_changed, self);
345
g_signal_parse_name ("crop-changed", TYPE_PAGE, &_tmp1_, NULL, FALSE);
346
g_signal_handlers_disconnect_matched (page, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp1_, 0, NULL, (GCallback) _book_page_changed_cb_page_crop_changed, self);
347
g_signal_emit_by_name (self, "page-removed", page);
348
self->priv->pages = g_list_remove (self->priv->pages, page);
349
book_set_needs_saving (self, TRUE);
350
}
351
352
353
guint book_get_n_pages (Book* self) {
354
guint result = 0U;
355
guint _tmp0_;
356
g_return_val_if_fail (self != NULL, 0U);
357
_tmp0_ = g_list_length (self->priv->pages);
358
result = _tmp0_;
359
return result;
360
}
361
362
363
Page* book_get_page (Book* self, gint page_number) {
364
Page* result = NULL;
365
gconstpointer _tmp1_ = NULL;
366
Page* _tmp2_;
367
g_return_val_if_fail (self != NULL, NULL);
368
if (page_number < 0) {
369
guint _tmp0_;
370
_tmp0_ = g_list_length (self->priv->pages);
371
page_number = ((gint) _tmp0_) + page_number;
372
}
373
_tmp1_ = g_list_nth_data (self->priv->pages, (guint) page_number);
374
_tmp2_ = _page_ref0 ((Page*) _tmp1_);
375
result = _tmp2_;
376
return result;
377
}
378
379
380
guint book_get_page_index (Book* self, Page* page) {
381
guint result = 0U;
382
gint _tmp0_;
383
g_return_val_if_fail (self != NULL, 0U);
384
g_return_val_if_fail (page != NULL, 0U);
385
_tmp0_ = g_list_index (self->priv->pages, page);
386
result = (guint) _tmp0_;
387
return result;
388
}
389
390
391
static gint string_last_index_of_char (const gchar* self, gunichar c, gint start_index) {
392
gint result = 0;
393
gchar* _tmp0_ = NULL;
394
gchar* _result_;
395
g_return_val_if_fail (self != NULL, 0);
396
_tmp0_ = g_utf8_strrchr (((gchar*) self) + start_index, (gssize) (-1), c);
397
_result_ = _tmp0_;
398
if (_result_ != NULL) {
399
result = (gint) (_result_ - ((gchar*) self));
400
return result;
401
} else {
402
result = -1;
403
return result;
404
}
405
}
406
407
408
static gchar* string_slice (const gchar* self, glong start, glong end) {
409
gchar* result = NULL;
410
gint _tmp0_;
411
glong string_length;
412
gboolean _tmp1_ = FALSE;
413
gboolean _tmp2_ = FALSE;
414
gchar* _tmp3_ = NULL;
415
g_return_val_if_fail (self != NULL, NULL);
416
_tmp0_ = strlen (self);
417
string_length = (glong) _tmp0_;
418
if (start < 0) {
419
start = string_length + start;
420
}
421
if (end < 0) {
422
end = string_length + end;
423
}
424
if (start >= 0) {
425
_tmp1_ = start <= string_length;
426
} else {
427
_tmp1_ = FALSE;
428
}
429
g_return_val_if_fail (_tmp1_, NULL);
430
if (end >= 0) {
431
_tmp2_ = end <= string_length;
432
} else {
433
_tmp2_ = FALSE;
434
}
435
g_return_val_if_fail (_tmp2_, NULL);
436
g_return_val_if_fail (start <= end, NULL);
437
_tmp3_ = g_strndup (((gchar*) self) + start, (gsize) (end - start));
438
result = _tmp3_;
439
return result;
440
}
441
442
443
static GFile* book_make_indexed_file (Book* self, const gchar* uri, gint i) {
444
GFile* result = NULL;
445
gchar* _tmp1_ = NULL;
446
gchar* basename;
447
gchar* _tmp2_;
448
gchar* prefix;
449
gchar* _tmp3_;
450
gchar* suffix;
451
gint _tmp4_;
452
gint extension_index;
453
gchar* _tmp10_ = NULL;
454
gchar* _tmp11_;
455
GFile* _tmp12_ = NULL;
456
GFile* _tmp13_;
457
g_return_val_if_fail (self != NULL, NULL);
458
g_return_val_if_fail (uri != NULL, NULL);
459
if (i == 0) {
460
GFile* _tmp0_ = NULL;
461
_tmp0_ = g_file_new_for_uri (uri);
462
result = _tmp0_;
463
return result;
464
}
465
_tmp1_ = g_path_get_basename (uri);
466
basename = _tmp1_;
467
_tmp2_ = g_strdup (uri);
468
prefix = _tmp2_;
469
_tmp3_ = g_strdup ("");
470
suffix = _tmp3_;
471
_tmp4_ = string_last_index_of_char (basename, (gunichar) '.', 0);
472
extension_index = _tmp4_;
473
if (extension_index >= 0) {
474
gint _tmp5_;
475
gchar* _tmp6_ = NULL;
476
gint _tmp7_;
477
gint _tmp8_;
478
gchar* _tmp9_ = NULL;
479
_tmp5_ = strlen (basename);
480
_tmp6_ = string_slice (basename, (glong) extension_index, (glong) _tmp5_);
481
_g_free0 (suffix);
482
suffix = _tmp6_;
483
_tmp7_ = strlen (uri);
484
_tmp8_ = strlen (suffix);
485
_tmp9_ = string_slice (uri, (glong) 0, (glong) (_tmp7_ - _tmp8_));
486
_g_free0 (prefix);
487
prefix = _tmp9_;
488
}
489
_tmp10_ = g_strdup_printf ("%s-%d%s", prefix, i, suffix);
490
_tmp11_ = _tmp10_;
491
_tmp12_ = g_file_new_for_uri (_tmp11_);
492
_tmp13_ = _tmp12_;
493
_g_free0 (_tmp11_);
494
result = _tmp13_;
495
_g_free0 (suffix);
496
_g_free0 (prefix);
497
_g_free0 (basename);
498
return result;
499
}
500
501
502
static void book_save_multi_file (Book* self, const gchar* type, GFile* file, GError** error) {
503
gint i;
504
GError * _inner_error_ = NULL;
505
g_return_if_fail (self != NULL);
506
g_return_if_fail (type != NULL);
507
g_return_if_fail (file != NULL);
508
i = 0;
509
{
510
GList* page_collection = NULL;
511
GList* page_it = NULL;
512
page_collection = self->priv->pages;
513
for (page_it = page_collection; page_it != NULL; page_it = page_it->next) {
514
Page* _tmp0_;
515
Page* page = NULL;
516
_tmp0_ = _page_ref0 ((Page*) page_it->data);
517
page = _tmp0_;
518
{
519
gchar* _tmp1_ = NULL;
520
gchar* _tmp2_;
521
GFile* _tmp3_ = NULL;
522
GFile* _tmp4_;
523
_tmp1_ = g_file_get_uri (file);
524
_tmp2_ = _tmp1_;
525
_tmp3_ = book_make_indexed_file (self, _tmp2_, i);
526
_tmp4_ = _tmp3_;
527
page_save (page, type, _tmp4_, &_inner_error_);
528
_g_object_unref0 (_tmp4_);
529
_g_free0 (_tmp2_);
530
if (_inner_error_ != NULL) {
531
g_propagate_error (error, _inner_error_);
532
_page_unref0 (page);
533
return;
534
}
535
i++;
536
_page_unref0 (page);
537
}
538
}
539
}
540
}
541
542
543
static void book_save_ps_pdf_surface (Book* self, cairo_surface_t* surface, GdkPixbuf* image, gdouble dpi) {
544
cairo_t* _tmp0_ = NULL;
545
cairo_t* context;
546
cairo_pattern_t* _tmp1_ = NULL;
547
g_return_if_fail (self != NULL);
548
g_return_if_fail (surface != NULL);
549
g_return_if_fail (image != NULL);
550
_tmp0_ = cairo_create (surface);
551
context = _tmp0_;
552
cairo_scale (context, 72.0 / dpi, 72.0 / dpi);
553
gdk_cairo_set_source_pixbuf (context, image, (gdouble) 0, (gdouble) 0);
554
_tmp1_ = cairo_get_source (context);
555
cairo_pattern_set_filter (_tmp1_, CAIRO_FILTER_BEST);
556
cairo_paint (context);
557
_cairo_destroy0 (context);
558
}
559
560
561
static gpointer _cairo_surface_reference0 (gpointer self) {
562
return self ? cairo_surface_reference (self) : NULL;
563
}
564
565
566
static void book_save_ps (Book* self, GFile* file, GError** error) {
567
GFileOutputStream* _tmp0_ = NULL;
568
GFileOutputStream* stream;
569
PsWriter* _tmp1_ = NULL;
570
PsWriter* writer;
571
cairo_surface_t* _tmp2_;
572
cairo_surface_t* surface;
573
GError * _inner_error_ = NULL;
574
g_return_if_fail (self != NULL);
575
g_return_if_fail (file != NULL);
576
_tmp0_ = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &_inner_error_);
577
stream = _tmp0_;
578
if (_inner_error_ != NULL) {
579
g_propagate_error (error, _inner_error_);
580
return;
581
}
582
_tmp1_ = ps_writer_new (stream);
583
writer = _tmp1_;
584
_tmp2_ = _cairo_surface_reference0 (writer->surface);
585
surface = _tmp2_;
586
{
587
GList* page_collection = NULL;
588
GList* page_it = NULL;
589
page_collection = self->priv->pages;
590
for (page_it = page_collection; page_it != NULL; page_it = page_it->next) {
591
Page* _tmp3_;
592
Page* page = NULL;
593
_tmp3_ = _page_ref0 ((Page*) page_it->data);
594
page = _tmp3_;
595
{
596
GdkPixbuf* _tmp4_ = NULL;
597
GdkPixbuf* image;
598
gint _tmp5_;
599
gint _tmp6_;
600
gdouble width;
601
gint _tmp7_;
602
gint _tmp8_;
603
gdouble height;
604
gint _tmp9_;
605
_tmp4_ = page_get_image (page, TRUE);
606
image = _tmp4_;
607
_tmp5_ = gdk_pixbuf_get_width (image);
608
_tmp6_ = page_get_dpi (page);
609
width = (_tmp5_ * 72.0) / _tmp6_;
610
_tmp7_ = gdk_pixbuf_get_height (image);
611
_tmp8_ = page_get_dpi (page);
612
height = (_tmp7_ * 72.0) / _tmp8_;
613
cairo_ps_surface_set_size (surface, width, height);
614
_tmp9_ = page_get_dpi (page);
615
book_save_ps_pdf_surface (self, surface, image, (gdouble) _tmp9_);
616
cairo_surface_show_page (surface);
617
_g_object_unref0 (image);
618
_page_unref0 (page);
619
}
620
}
621
}
622
_cairo_surface_destroy0 (surface);
623
_ps_writer_unref0 (writer);
624
_g_object_unref0 (stream);
625
}
626
627
628
static guint8* book_compress_zlib (Book* self, guint8* data, int data_length1, int* result_length1) {
629
guint8* result = NULL;
630
z_stream stream = {0};
631
guint8* _tmp0_ = NULL;
632
guint8* out_data;
633
gint out_data_length1;
634
gint _out_data_size_;
635
guint n_written;
636
gint _tmp3_;
637
guint8* _tmp4_;
638
g_return_val_if_fail (self != NULL, NULL);
639
deflateInit (&stream, (gint) Z_BEST_COMPRESSION);
640
_tmp0_ = g_new0 (guint8, data_length1);
641
out_data = _tmp0_;
642
out_data_length1 = data_length1;
643
_out_data_size_ = out_data_length1;
644
stream.next_in = data;
645
stream.avail_in = data_length1;
646
stream.next_out = out_data;
647
stream.avail_out = out_data_length1;
648
while (TRUE) {
649
gint _tmp1_;
650
if (!(stream.avail_in > 0)) {
651
break;
652
}
653
_tmp1_ = deflate (&stream, (gint) Z_FINISH);
654
if (_tmp1_ == Z_STREAM_ERROR) {
655
break;
656
}
657
}
658
if (stream.avail_in > 0) {
659
gpointer _tmp2_;
660
_tmp2_ = NULL;
661
if (result_length1) {
662
*result_length1 = 0;
663
}
664
result = _tmp2_;
665
out_data = (g_free (out_data), NULL);
666
deflateEnd (&stream);
667
return result;
668
}
669
n_written = data_length1 - stream.avail_out;
670
_tmp3_ = (gint) n_written;
671
out_data = g_renew (guint8, out_data, (gint) n_written);
672
(_tmp3_ > out_data_length1) ? memset (out_data + out_data_length1, 0, sizeof (guint8) * (_tmp3_ - out_data_length1)) : NULL;
673
out_data_length1 = _tmp3_;
674
_out_data_size_ = _tmp3_;
675
_tmp4_ = out_data;
676
if (result_length1) {
677
*result_length1 = out_data_length1;
678
}
679
result = _tmp4_;
680
deflateEnd (&stream);
681
return result;
682
}
683
684
685
static void book_jpeg_init_cb (struct jpeg_compress_struct* info) {
686
}
687
688
689
static gboolean book_jpeg_empty_cb (struct jpeg_compress_struct* info) {
690
gboolean result = FALSE;
691
result = TRUE;
692
return result;
693
}
694
695
696
static void book_jpeg_term_cb (struct jpeg_compress_struct* info) {
697
}
698
699
700
static void _book_jpeg_init_cb_jpeg_initdestinationfunc (struct jpeg_compress_struct* cinfo) {
701
book_jpeg_init_cb (cinfo);
702
}
703
704
705
static gboolean _book_jpeg_empty_cb_jpeg_emptyoutputbufferfunc (struct jpeg_compress_struct* cinfo) {
706
gboolean result;
707
result = book_jpeg_empty_cb (cinfo);
708
return result;
709
}
710
711
712
static void _book_jpeg_term_cb_jpeg_termdestinationfunc (struct jpeg_compress_struct* cinfo) {
713
book_jpeg_term_cb (cinfo);
714
}
715
716
717
static guint8* book_compress_jpeg (Book* self, GdkPixbuf* image, gsize* n_written, int* result_length1) {
718
gsize _n_written = 0UL;
719
guint8* result = NULL;
720
struct jpeg_compress_struct info = {0};
721
struct jpeg_error_mgr jerr = {0};
722
struct jpeg_destination_mgr dest_mgr = {0};
723
struct jpeg_error_mgr* _tmp0_ = NULL;
724
gint _tmp1_;
725
gint _tmp2_;
726
gint max_length;
727
guint8* _tmp3_ = NULL;
728
guint8* data;
729
gint data_length1;
730
gint _data_size_;
731
guint8* _tmp4_ = NULL;
732
guint8* pixels;
733
gint pixels_length1;
734
gint _pixels_size_;
735
guint8* _tmp7_;
736
g_return_val_if_fail (self != NULL, NULL);
737
g_return_val_if_fail (image != NULL, NULL);
738
memset (&info, 0, sizeof (struct jpeg_compress_struct));
739
memset (&jerr, 0, sizeof (struct jpeg_error_mgr));
740
memset (&dest_mgr, 0, sizeof (struct jpeg_destination_mgr));
741
_tmp0_ = jpeg_std_error (&jerr);
742
info.err = _tmp0_;
743
jpeg_create_compress (&info);
744
_tmp1_ = gdk_pixbuf_get_width (image);
745
info.image_width = _tmp1_;
746
_tmp2_ = gdk_pixbuf_get_height (image);
747
info.image_height = _tmp2_;
748
info.input_components = 3;
749
info.in_color_space = JCS_RGB;
750
jpeg_set_defaults (&info);
751
max_length = (info.image_width * info.image_height) * info.input_components;
752
_tmp3_ = g_new0 (guint8, max_length);
753
data = _tmp3_;
754
data_length1 = max_length;
755
_data_size_ = data_length1;
756
dest_mgr.next_output_byte = data;
757
dest_mgr.free_in_buffer = max_length;
758
dest_mgr.init_destination = _book_jpeg_init_cb_jpeg_initdestinationfunc;
759
dest_mgr.empty_output_buffer = _book_jpeg_empty_cb_jpeg_emptyoutputbufferfunc;
760
dest_mgr.term_destination = _book_jpeg_term_cb_jpeg_termdestinationfunc;
761
info.dest = &dest_mgr;
762
jpeg_start_compress (&info, TRUE);
763
_tmp4_ = gdk_pixbuf_get_pixels (image);
764
pixels = _tmp4_;
765
pixels_length1 = -1;
766
_pixels_size_ = pixels_length1;
767
{
768
gint r;
769
r = 0;
770
{
771
gboolean _tmp5_;
772
_tmp5_ = TRUE;
773
while (TRUE) {
774
guint8* row[1] = {0};
775
gint _tmp6_;
776
if (!_tmp5_) {
777
r++;
778
}
779
_tmp5_ = FALSE;
780
if (!(r < info.image_height)) {
781
break;
782
}
783
_tmp6_ = gdk_pixbuf_get_rowstride (image);
784
row[0] = ((guint8*) pixels) + (r * _tmp6_);
785
jpeg_write_scanlines (&info, row, 1);
786
}
787
}
788
}
789
jpeg_finish_compress (&info);
790
_n_written = (gsize) (max_length - dest_mgr.free_in_buffer);
791
_tmp7_ = data;
792
if (result_length1) {
793
*result_length1 = data_length1;
794
}
795
result = _tmp7_;
796
jpeg_destroy_compress (&info);
797
if (n_written) {
798
*n_written = _n_written;
799
}
800
return result;
801
}
802
803
804
static guint8* _vala_array_dup1 (guint8* self, int length) {
805
return g_memdup (self, length * sizeof (guint8));
806
}
807
808
809
static guint8* _vala_array_dup2 (guint8* self, int length) {
810
return g_memdup (self, length * sizeof (guint8));
811
}
812
813
814
static void book_save_pdf (Book* self, GFile* file, GError** error) {
815
GFileOutputStream* _tmp0_ = NULL;
816
GFileOutputStream* stream;
817
PDFWriter* _tmp1_ = NULL;
818
PDFWriter* writer;
819
guint _tmp2_;
820
guint catalog_number;
821
gchar* _tmp3_ = NULL;
822
gchar* _tmp4_;
823
gchar* _tmp5_ = NULL;
824
gchar* _tmp6_;
825
guint _tmp7_;
826
guint pages_number;
827
gchar* _tmp8_ = NULL;
828
gchar* _tmp9_;
829
guint _tmp14_;
830
gchar* _tmp15_ = NULL;
831
gchar* _tmp16_;
832
guint _tmp100_;
833
guint info_number;
834
gchar* _tmp101_ = NULL;
835
gchar* _tmp102_;
836
gchar* _tmp103_ = NULL;
837
gchar* _tmp104_;
838
gsize xref_offset;
839
guint _tmp105_;
840
gchar* _tmp106_ = NULL;
841
gchar* _tmp107_;
842
guint _tmp110_;
843
gchar* _tmp111_ = NULL;
844
gchar* _tmp112_;
845
gchar* _tmp113_ = NULL;
846
gchar* _tmp114_;
847
gchar* _tmp115_ = NULL;
848
gchar* _tmp116_;
849
gchar* _tmp117_ = NULL;
850
gchar* _tmp118_;
851
GError * _inner_error_ = NULL;
852
g_return_if_fail (self != NULL);
853
g_return_if_fail (file != NULL);
854
_tmp0_ = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &_inner_error_);
855
stream = _tmp0_;
856
if (_inner_error_ != NULL) {
857
g_propagate_error (error, _inner_error_);
858
return;
859
}
860
_tmp1_ = pdf_writer_new (stream);
861
writer = _tmp1_;
862
pdf_writer_write_string (writer, "%%PDF-1.3\n");
863
pdf_writer_write_string (writer, "%%\xe2\xe3\xcf\xd3\n");
864
_tmp2_ = pdf_writer_start_object (writer);
865
catalog_number = _tmp2_;
866
_tmp3_ = g_strdup_printf ("%u 0 obj\n", catalog_number);
867
_tmp4_ = _tmp3_;
868
pdf_writer_write_string (writer, _tmp4_);
869
_g_free0 (_tmp4_);
870
pdf_writer_write_string (writer, "<<\n");
871
pdf_writer_write_string (writer, "/Type /Catalog\n");
872
_tmp5_ = g_strdup_printf ("/Pages %u 0 R\n", catalog_number + 1);
873
_tmp6_ = _tmp5_;
874
pdf_writer_write_string (writer, _tmp6_);
875
_g_free0 (_tmp6_);
876
pdf_writer_write_string (writer, ">>\n");
877
pdf_writer_write_string (writer, "endobj\n");
878
pdf_writer_write_string (writer, "\n");
879
_tmp7_ = pdf_writer_start_object (writer);
880
pages_number = _tmp7_;
881
_tmp8_ = g_strdup_printf ("%u 0 obj\n", pages_number);
882
_tmp9_ = _tmp8_;
883
pdf_writer_write_string (writer, _tmp9_);
884
_g_free0 (_tmp9_);
885
pdf_writer_write_string (writer, "<<\n");
886
pdf_writer_write_string (writer, "/Type /Pages\n");
887
pdf_writer_write_string (writer, "/Kids [");
888
{
889
gint i;
890
i = 0;
891
{
892
gboolean _tmp10_;
893
_tmp10_ = TRUE;
894
while (TRUE) {
895
guint _tmp11_;
896
gchar* _tmp12_ = NULL;
897
gchar* _tmp13_;
898
if (!_tmp10_) {
899
i++;
900
}
901
_tmp10_ = FALSE;
902
_tmp11_ = book_get_n_pages (self);
903
if (!(i < _tmp11_)) {
904
break;
905
}
906
_tmp12_ = g_strdup_printf (" %u 0 R", (pages_number + 1) + (i * 3));
907
_tmp13_ = _tmp12_;
908
pdf_writer_write_string (writer, _tmp13_);
909
_g_free0 (_tmp13_);
910
}
911
}
912
}
913
pdf_writer_write_string (writer, " ]\n");
914
_tmp14_ = book_get_n_pages (self);
915
_tmp15_ = g_strdup_printf ("/Count %u\n", _tmp14_);
916
_tmp16_ = _tmp15_;
917
pdf_writer_write_string (writer, _tmp16_);
918
_g_free0 (_tmp16_);
919
pdf_writer_write_string (writer, ">>\n");
920
pdf_writer_write_string (writer, "endobj\n");
921
{
922
gint i;
923
i = 0;
924
{
925
gboolean _tmp17_;
926
_tmp17_ = TRUE;
927
while (TRUE) {
928
guint _tmp18_;
929
Page* _tmp19_ = NULL;
930
Page* page;
931
GdkPixbuf* _tmp20_ = NULL;
932
GdkPixbuf* image;
933
gint _tmp21_;
934
gint width;
935
gint _tmp22_;
936
gint height;
937
guint8* _tmp23_ = NULL;
938
guint8* pixels;
939
gint pixels_length1;
940
gint _pixels_size_;
941
gint _tmp24_;
942
gdouble page_width;
943
gint _tmp25_;
944
gdouble page_height;
945
gint depth;
946
gchar* _tmp26_;
947
gchar* color_space;
948
gchar* filter;
949
gchar* _tmp27_ = NULL;
950
gchar* width_buffer;
951
gint width_buffer_length1;
952
gint _width_buffer_size_;
953
gchar* _tmp28_ = NULL;
954
gchar* height_buffer;
955
gint height_buffer_length1;
956
gint _height_buffer_size_;
957
guint8* data = NULL;
958
gint data_length1 = 0;
959
gint _data_size_ = 0;
960
gboolean _tmp29_;
961
gint _tmp52_;
962
guint8* _tmp53_ = NULL;
963
guint8* compressed_data;
964
gint compressed_data_length1;
965
gint _compressed_data_size_;
966
guint _tmp63_;
967
guint number;
968
gchar* _tmp64_ = NULL;
969
gchar* _tmp65_;
970
gchar* _tmp66_ = NULL;
971
gchar* _tmp67_;
972
gchar* _tmp68_ = NULL;
973
gchar* _tmp69_;
974
const gchar* _tmp70_ = NULL;
975
const gchar* _tmp71_ = NULL;
976
gchar* _tmp72_ = NULL;
977
gchar* _tmp73_;
978
gchar* _tmp74_ = NULL;
979
gchar* _tmp75_;
980
guint _tmp76_;
981
gchar* _tmp77_ = NULL;
982
gchar* _tmp78_;
983
gchar* _tmp79_ = NULL;
984
gchar* _tmp80_;
985
gchar* _tmp81_ = NULL;
986
gchar* _tmp82_;
987
gchar* _tmp83_ = NULL;
988
gchar* _tmp84_;
989
gchar* _tmp85_ = NULL;
990
gchar* _tmp86_;
991
gchar* _tmp87_ = NULL;
992
gchar* _tmp88_;
993
const gchar* _tmp91_ = NULL;
994
const gchar* _tmp92_ = NULL;
995
gchar* _tmp93_ = NULL;
996
gchar* command;
997
guint _tmp94_;
998
gchar* _tmp95_ = NULL;
999
gchar* _tmp96_;
1000
gint _tmp97_;
1001
gchar* _tmp98_ = NULL;
1002
gchar* _tmp99_;
1003
if (!_tmp17_) {
1004
i++;
1005
}
1006
_tmp17_ = FALSE;
1007
_tmp18_ = book_get_n_pages (self);
1008
if (!(i < _tmp18_)) {
1009
break;
1010
}
1011
_tmp19_ = book_get_page (self, i);
1012
page = _tmp19_;
1013
_tmp20_ = page_get_image (page, TRUE);
1014
image = _tmp20_;
1015
_tmp21_ = gdk_pixbuf_get_width (image);
1016
width = _tmp21_;
1017
_tmp22_ = gdk_pixbuf_get_height (image);
1018
height = _tmp22_;
1019
_tmp23_ = gdk_pixbuf_get_pixels (image);
1020
pixels = _tmp23_;
1021
pixels_length1 = -1;
1022
_pixels_size_ = pixels_length1;
1023
_tmp24_ = page_get_dpi (page);
1024
page_width = (width * 72.0) / _tmp24_;
1025
_tmp25_ = page_get_dpi (page);
1026
page_height = (height * 72.0) / _tmp25_;
1027
depth = 8;
1028
_tmp26_ = g_strdup ("DeviceRGB");
1029
color_space = _tmp26_;
1030
filter = NULL;
1031
_tmp27_ = g_new0 (gchar, G_ASCII_DTOSTR_BUF_SIZE);
1032
width_buffer = _tmp27_;
1033
width_buffer_length1 = G_ASCII_DTOSTR_BUF_SIZE;
1034
_width_buffer_size_ = width_buffer_length1;
1035
_tmp28_ = g_new0 (gchar, G_ASCII_DTOSTR_BUF_SIZE);
1036
height_buffer = _tmp28_;
1037
height_buffer_length1 = G_ASCII_DTOSTR_BUF_SIZE;
1038
_height_buffer_size_ = height_buffer_length1;
1039
_tmp29_ = page_is_color (page);
1040
if (_tmp29_) {
1041
gchar* _tmp30_;
1042
gint data_length;
1043
guint8* _tmp31_ = NULL;
1044
depth = 8;
1045
_tmp30_ = g_strdup ("DeviceRGB");
1046
_g_free0 (color_space);
1047
color_space = _tmp30_;
1048
data_length = ((height * width) * 3) + 1;
1049
_tmp31_ = g_new0 (guint8, data_length);
1050
data = (g_free (data), NULL);
1051
data = _tmp31_;
1052
data_length1 = data_length;
1053
_data_size_ = data_length1;
1054
{
1055
gint row;
1056
row = 0;
1057
{
1058
gboolean _tmp32_;
1059
_tmp32_ = TRUE;
1060
while (TRUE) {
1061
gint _tmp33_;
1062
gint in_offset;
1063
gint out_offset;
1064
if (!_tmp32_) {
1065
row++;
1066
}
1067
_tmp32_ = FALSE;
1068
if (!(row < height)) {
1069
break;
1070
}
1071
_tmp33_ = gdk_pixbuf_get_rowstride (image);
1072
in_offset = row * _tmp33_;
1073
out_offset = (row * width) * 3;
1074
{
1075
gint x;
1076
x = 0;
1077
{
1078
gboolean _tmp34_;
1079
_tmp34_ = TRUE;
1080
while (TRUE) {
1081
gint in_o;
1082
gint out_o;
1083
if (!_tmp34_) {
1084
x++;
1085
}
1086
_tmp34_ = FALSE;
1087
if (!(x < width)) {
1088
break;
1089
}
1090
in_o = in_offset + (x * 3);
1091
out_o = out_offset + (x * 3);
1092
data[out_o] = pixels[in_o];
1093
data[out_o + 1] = pixels[in_o + 1];
1094
data[out_o + 2] = pixels[in_o + 2];
1095
}
1096
}
1097
}
1098
}
1099
}
1100
}
1101
} else {
1102
gint _tmp35_;
1103
_tmp35_ = page_get_depth (page);
1104
if (_tmp35_ == 2) {
1105
gint shift_count;
1106
gchar* _tmp36_;
1107
gint data_length;
1108
guint8* _tmp37_ = NULL;
1109
gint offset;
1110
shift_count = 6;
1111
depth = 2;
1112
_tmp36_ = g_strdup ("DeviceGray");
1113
_g_free0 (color_space);
1114
color_space = _tmp36_;
1115
data_length = height * (((width * 2) + 7) / 8);
1116
_tmp37_ = g_new0 (guint8, data_length);
1117
data = (g_free (data), NULL);
1118
data = _tmp37_;
1119
data_length1 = data_length;
1120
_data_size_ = data_length1;
1121
offset = 0;
1122
data[offset] = (guint8) 0;
1123
{
1124
gint row;
1125
row = 0;
1126
{
1127
gboolean _tmp38_;
1128
_tmp38_ = TRUE;
1129
while (TRUE) {
1130
gint _tmp39_;
1131
gint in_offset;
1132
if (!_tmp38_) {
1133
row++;
1134
}
1135
_tmp38_ = FALSE;
1136
if (!(row < height)) {
1137
break;
1138
}
1139
if (shift_count != 6) {
1140
offset++;
1141
data[offset] = (guint8) 0;
1142
shift_count = 6;
1143
}
1144
_tmp39_ = gdk_pixbuf_get_rowstride (image);
1145
in_offset = row * _tmp39_;
1146
{
1147
gint x;
1148
x = 0;
1149
{
1150
gboolean _tmp40_;
1151
_tmp40_ = TRUE;
1152
while (TRUE) {
1153
guint8 p;
1154
if (!_tmp40_) {
1155
x++;
1156
}
1157
_tmp40_ = FALSE;
1158
if (!(x < width)) {
1159
break;
1160
}
1161
p = pixels[in_offset + (x * 3)];
1162
if (p >= 192) {
1163
data[offset] |= (guint8) (3 << shift_count);
1164
} else {
1165
if (p >= 128) {
1166
data[offset] |= (guint8) (2 << shift_count);
1167
} else {
1168
if (p >= 64) {
1169
data[offset] |= (guint8) (1 << shift_count);
1170
}
1171
}
1172
}
1173
if (shift_count == 0) {
1174
offset++;
1175
data[offset] = (guint8) 0;
1176
shift_count = 6;
1177
} else {
1178
shift_count = shift_count - 2;
1179
}
1180
}
1181
}
1182
}
1183
}
1184
}
1185
}
1186
} else {
1187
gint _tmp41_;
1188
_tmp41_ = page_get_depth (page);
1189
if (_tmp41_ == 1) {
1190
gint mask;
1191
gchar* _tmp42_;
1192
gint data_length;
1193
guint8* _tmp43_ = NULL;
1194
gint offset;
1195
mask = 0x80;
1196
depth = 1;
1197
_tmp42_ = g_strdup ("DeviceGray");
1198
_g_free0 (color_space);
1199
color_space = _tmp42_;
1200
data_length = height * ((width + 7) / 8);
1201
_tmp43_ = g_new0 (guint8, data_length);
1202
data = (g_free (data), NULL);
1203
data = _tmp43_;
1204
data_length1 = data_length;
1205
_data_size_ = data_length1;
1206
offset = 0;
1207
data[offset] = (guint8) 0;
1208
{
1209
gint row;
1210
row = 0;
1211
{
1212
gboolean _tmp44_;
1213
_tmp44_ = TRUE;
1214
while (TRUE) {
1215
gint _tmp45_;
1216
gint in_offset;
1217
if (!_tmp44_) {
1218
row++;
1219
}
1220
_tmp44_ = FALSE;
1221
if (!(row < height)) {
1222
break;
1223
}
1224
if (mask != 0x80) {
1225
offset++;
1226
data[offset] = (guint8) 0;
1227
mask = 0x80;
1228
}
1229
_tmp45_ = gdk_pixbuf_get_rowstride (image);
1230
in_offset = row * _tmp45_;
1231
{
1232
gint x;
1233
x = 0;
1234
{
1235
gboolean _tmp46_;
1236
_tmp46_ = TRUE;
1237
while (TRUE) {
1238
if (!_tmp46_) {
1239
x++;
1240
}
1241
_tmp46_ = FALSE;
1242
if (!(x < width)) {
1243
break;
1244
}
1245
if (pixels[in_offset + (x * 3)] != 0) {
1246
data[offset] |= (guint8) mask;
1247
}
1248
mask = mask >> 1;
1249
if (mask == 0) {
1250
offset++;
1251
data[offset] = (guint8) 0;
1252
mask = 0x80;
1253
}
1254
}
1255
}
1256
}
1257
}
1258
}
1259
}
1260
} else {
1261
gchar* _tmp47_;
1262
gint data_length;
1263
guint8* _tmp48_ = NULL;
1264
depth = 8;
1265
_tmp47_ = g_strdup ("DeviceGray");
1266
_g_free0 (color_space);
1267
color_space = _tmp47_;
1268
data_length = (height * width) + 1;
1269
_tmp48_ = g_new0 (guint8, data_length);
1270
data = (g_free (data), NULL);
1271
data = _tmp48_;
1272
data_length1 = data_length;
1273
_data_size_ = data_length1;
1274
{
1275
gint row;
1276
row = 0;
1277
{
1278
gboolean _tmp49_;
1279
_tmp49_ = TRUE;
1280
while (TRUE) {
1281
gint _tmp50_;
1282
gint in_offset;
1283
gint out_offset;
1284
if (!_tmp49_) {
1285
row++;
1286
}
1287
_tmp49_ = FALSE;
1288
if (!(row < height)) {
1289
break;
1290
}
1291
_tmp50_ = gdk_pixbuf_get_rowstride (image);
1292
in_offset = row * _tmp50_;
1293
out_offset = row * width;
1294
{
1295
gint x;
1296
x = 0;
1297
{
1298
gboolean _tmp51_;
1299
_tmp51_ = TRUE;
1300
while (TRUE) {
1301
if (!_tmp51_) {
1302
x++;
1303
}
1304
_tmp51_ = FALSE;
1305
if (!(x < width)) {
1306
break;
1307
}
1308
data[out_offset + x] = pixels[in_offset + (x * 3)];
1309
}
1310
}
1311
}
1312
}
1313
}
1314
}
1315
}
1316
}
1317
}
1318
_tmp53_ = book_compress_zlib (self, data, data_length1, &_tmp52_);
1319
compressed_data = _tmp53_;
1320
compressed_data_length1 = _tmp52_;
1321
_compressed_data_size_ = compressed_data_length1;
1322
if (compressed_data != NULL) {
1323
if (depth > 1) {
1324
gsize jpeg_length = 0UL;
1325
gsize _tmp54_;
1326
gint _tmp55_;
1327
guint8* _tmp56_ = NULL;
1328
guint8* jpeg_data;
1329
gint jpeg_data_length1;
1330
gint _jpeg_data_size_;
1331
_tmp56_ = book_compress_jpeg (self, image, &_tmp54_, &_tmp55_);
1332
jpeg_length = _tmp54_;
1333
jpeg_data = _tmp56_;
1334
jpeg_data_length1 = _tmp55_;
1335
_jpeg_data_size_ = jpeg_data_length1;
1336
if (jpeg_length < compressed_data_length1) {
1337
gchar* _tmp57_;
1338
guint8* _tmp58_;
1339
guint8* _tmp59_;
1340
_tmp57_ = g_strdup ("DCTDecode");
1341
_g_free0 (filter);
1342
filter = _tmp57_;
1343
_tmp59_ = (_tmp58_ = jpeg_data, (_tmp58_ == NULL) ? ((gpointer) _tmp58_) : _vala_array_dup1 (_tmp58_, jpeg_data_length1));
1344
data = (g_free (data), NULL);
1345
data = _tmp59_;
1346
data_length1 = jpeg_data_length1;
1347
_data_size_ = data_length1;
1348
}
1349
jpeg_data = (g_free (jpeg_data), NULL);
1350
}
1351
if (filter == NULL) {
1352
gchar* _tmp60_;
1353
guint8* _tmp61_;
1354
guint8* _tmp62_;
1355
_tmp60_ = g_strdup ("FlateDecode");
1356
_g_free0 (filter);
1357
filter = _tmp60_;
1358
_tmp62_ = (_tmp61_ = compressed_data, (_tmp61_ == NULL) ? ((gpointer) _tmp61_) : _vala_array_dup2 (_tmp61_, compressed_data_length1));
1359
data = (g_free (data), NULL);
1360
data = _tmp62_;
1361
data_length1 = compressed_data_length1;
1362
_data_size_ = data_length1;
1363
}
1364
}
1365
pdf_writer_write_string (writer, "\n");
1366
_tmp63_ = pdf_writer_start_object (writer);
1367
number = _tmp63_;
1368
_tmp64_ = g_strdup_printf ("%u 0 obj\n", number);
1369
_tmp65_ = _tmp64_;
1370
pdf_writer_write_string (writer, _tmp65_);
1371
_g_free0 (_tmp65_);
1372
pdf_writer_write_string (writer, "<<\n");
1373
pdf_writer_write_string (writer, "/Type /Page\n");
1374
_tmp66_ = g_strdup_printf ("/Parent %u 0 R\n", pages_number);
1375
_tmp67_ = _tmp66_;
1376
pdf_writer_write_string (writer, _tmp67_);
1377
_g_free0 (_tmp67_);
1378
_tmp68_ = g_strdup_printf ("/Resources << /XObject << /Im%d %u 0 R >> >>\n", i, number + 1);
1379
_tmp69_ = _tmp68_;
1380
pdf_writer_write_string (writer, _tmp69_);
1381
_g_free0 (_tmp69_);
1382
_tmp70_ = g_ascii_formatd (width_buffer, width_buffer_length1, "%.2f", page_width);
1383
_tmp71_ = g_ascii_formatd (height_buffer, height_buffer_length1, "%.2f", page_height);
1384
_tmp72_ = g_strdup_printf ("/MediaBox [ 0 0 %s %s ]\n", _tmp70_, _tmp71_);
1385
_tmp73_ = _tmp72_;
1386
pdf_writer_write_string (writer, _tmp73_);
1387
_g_free0 (_tmp73_);
1388
_tmp74_ = g_strdup_printf ("/Contents %u 0 R\n", number + 2);
1389
_tmp75_ = _tmp74_;
1390
pdf_writer_write_string (writer, _tmp75_);
1391
_g_free0 (_tmp75_);
1392
pdf_writer_write_string (writer, ">>\n");
1393
pdf_writer_write_string (writer, "endobj\n");
1394
pdf_writer_write_string (writer, "\n");
1395
_tmp76_ = pdf_writer_start_object (writer);
1396
number = _tmp76_;
1397
_tmp77_ = g_strdup_printf ("%u 0 obj\n", number);
1398
_tmp78_ = _tmp77_;
1399
pdf_writer_write_string (writer, _tmp78_);
1400
_g_free0 (_tmp78_);
1401
pdf_writer_write_string (writer, "<<\n");
1402
pdf_writer_write_string (writer, "/Type /XObject\n");
1403
pdf_writer_write_string (writer, "/Subtype /Image\n");
1404
_tmp79_ = g_strdup_printf ("/Width %d\n", width);
1405
_tmp80_ = _tmp79_;
1406
pdf_writer_write_string (writer, _tmp80_);
1407
_g_free0 (_tmp80_);
1408
_tmp81_ = g_strdup_printf ("/Height %d\n", height);
1409
_tmp82_ = _tmp81_;
1410
pdf_writer_write_string (writer, _tmp82_);
1411
_g_free0 (_tmp82_);
1412
_tmp83_ = g_strdup_printf ("/ColorSpace /%s\n", color_space);
1413
_tmp84_ = _tmp83_;
1414
pdf_writer_write_string (writer, _tmp84_);
1415
_g_free0 (_tmp84_);
1416
_tmp85_ = g_strdup_printf ("/BitsPerComponent %d\n", depth);
1417
_tmp86_ = _tmp85_;
1418
pdf_writer_write_string (writer, _tmp86_);
1419
_g_free0 (_tmp86_);
1420
_tmp87_ = g_strdup_printf ("/Length %d\n", data_length1);
1421
_tmp88_ = _tmp87_;
1422
pdf_writer_write_string (writer, _tmp88_);
1423
_g_free0 (_tmp88_);
1424
if (filter != NULL) {
1425
gchar* _tmp89_ = NULL;
1426
gchar* _tmp90_;
1427
_tmp89_ = g_strdup_printf ("/Filter /%s\n", filter);
1428
_tmp90_ = _tmp89_;
1429
pdf_writer_write_string (writer, _tmp90_);
1430
_g_free0 (_tmp90_);
1431
}
1432
pdf_writer_write_string (writer, ">>\n");
1433
pdf_writer_write_string (writer, "stream\n");
1434
pdf_writer_write (writer, data, data_length1);
1435
pdf_writer_write_string (writer, "\n");
1436
pdf_writer_write_string (writer, "endstream\n");
1437
pdf_writer_write_string (writer, "endobj\n");
1438
_tmp91_ = g_ascii_formatd (width_buffer, width_buffer_length1, "%f", page_width);
1439
_tmp92_ = g_ascii_formatd (height_buffer, height_buffer_length1, "%f", page_height);
1440
_tmp93_ = g_strdup_printf ("q\n%s 0 0 %s 0 0 cm\n/Im%d Do\nQ", _tmp91_, _tmp92_, i);
1441
command = _tmp93_;
1442
pdf_writer_write_string (writer, "\n");
1443
_tmp94_ = pdf_writer_start_object (writer);
1444
number = _tmp94_;
1445
_tmp95_ = g_strdup_printf ("%u 0 obj\n", number);
1446
_tmp96_ = _tmp95_;
1447
pdf_writer_write_string (writer, _tmp96_);
1448
_g_free0 (_tmp96_);
1449
pdf_writer_write_string (writer, "<<\n");
1450
_tmp97_ = strlen (command);
1451
_tmp98_ = g_strdup_printf ("/Length %d\n", _tmp97_ + 1);
1452
_tmp99_ = _tmp98_;
1453
pdf_writer_write_string (writer, _tmp99_);
1454
_g_free0 (_tmp99_);
1455
pdf_writer_write_string (writer, ">>\n");
1456
pdf_writer_write_string (writer, "stream\n");
1457
pdf_writer_write_string (writer, command);
1458
pdf_writer_write_string (writer, "\n");
1459
pdf_writer_write_string (writer, "endstream\n");
1460
pdf_writer_write_string (writer, "endobj\n");
1461
_g_free0 (command);
1462
compressed_data = (g_free (compressed_data), NULL);
1463
data = (g_free (data), NULL);
1464
height_buffer = (g_free (height_buffer), NULL);
1465
width_buffer = (g_free (width_buffer), NULL);
1466
_g_free0 (filter);
1467
_g_free0 (color_space);
1468
_g_object_unref0 (image);
1469
_page_unref0 (page);
1470
}
1471
}
1472
}
1473
pdf_writer_write_string (writer, "\n");
1474
_tmp100_ = pdf_writer_start_object (writer);
1475
info_number = _tmp100_;
1476
_tmp101_ = g_strdup_printf ("%u 0 obj\n", info_number);
1477
_tmp102_ = _tmp101_;
1478
pdf_writer_write_string (writer, _tmp102_);
1479
_g_free0 (_tmp102_);
1480
pdf_writer_write_string (writer, "<<\n");
1481
_tmp103_ = g_strdup_printf ("/Creator (Simple Scan %s)\n", VERSION);
1482
_tmp104_ = _tmp103_;
1483
pdf_writer_write_string (writer, _tmp104_);
1484
_g_free0 (_tmp104_);
1485
pdf_writer_write_string (writer, ">>\n");
1486
pdf_writer_write_string (writer, "endobj\n");
1487
xref_offset = writer->offset;
1488
pdf_writer_write_string (writer, "xref\n");
1489
_tmp105_ = g_list_length (writer->object_offsets);
1490
_tmp106_ = g_strdup_printf ("1 %zu\n", (gsize) _tmp105_);
1491
_tmp107_ = _tmp106_;
1492
pdf_writer_write_string (writer, _tmp107_);
1493
_g_free0 (_tmp107_);
1494
{
1495
GList* offset_collection = NULL;
1496
GList* offset_it = NULL;
1497
offset_collection = writer->object_offsets;
1498
for (offset_it = offset_collection; offset_it != NULL; offset_it = offset_it->next) {
1499
guint offset = 0U;
1500
offset = GPOINTER_TO_UINT (offset_it->data);
1501
{
1502
gchar* _tmp108_ = NULL;
1503
gchar* _tmp109_;
1504
_tmp108_ = g_strdup_printf ("%010zu 0000 n\n", (gsize) offset);
1505
_tmp109_ = _tmp108_;
1506
pdf_writer_write_string (writer, _tmp109_);
1507
_g_free0 (_tmp109_);
1508
}
1509
}
1510
}
1511
pdf_writer_write_string (writer, "trailer\n");
1512
pdf_writer_write_string (writer, "<<\n");
1513
_tmp110_ = g_list_length (writer->object_offsets);
1514
_tmp111_ = g_strdup_printf ("/Size %zu\n", (gsize) _tmp110_);
1515
_tmp112_ = _tmp111_;
1516
pdf_writer_write_string (writer, _tmp112_);
1517
_g_free0 (_tmp112_);
1518
_tmp113_ = g_strdup_printf ("/Info %u 0 R\n", info_number);
1519
_tmp114_ = _tmp113_;
1520
pdf_writer_write_string (writer, _tmp114_);
1521
_g_free0 (_tmp114_);
1522
_tmp115_ = g_strdup_printf ("/Root %u 0 R\n", catalog_number);
1523
_tmp116_ = _tmp115_;
1524
pdf_writer_write_string (writer, _tmp116_);
1525
_g_free0 (_tmp116_);
1526
pdf_writer_write_string (writer, ">>\n");
1527
pdf_writer_write_string (writer, "startxref\n");
1528
_tmp117_ = g_strdup_printf ("%zu\n", xref_offset);
1529
_tmp118_ = _tmp117_;
1530
pdf_writer_write_string (writer, _tmp118_);
1531
_g_free0 (_tmp118_);
1532
pdf_writer_write_string (writer, "%%%%EOF\n");
1533
_pdf_writer_unref0 (writer);
1534
_g_object_unref0 (stream);
1535
}
1536
1537
1538
void book_save (Book* self, const gchar* type, GFile* file, GError** error) {
1539
gint _tmp0_;
1540
GError * _inner_error_ = NULL;
1541
g_return_if_fail (self != NULL);
1542
g_return_if_fail (type != NULL);
1543
g_return_if_fail (file != NULL);
1544
_tmp0_ = g_strcmp0 (type, "jpeg");
1545
if (_tmp0_ == 0) {
1546
book_save_multi_file (self, "jpeg", file, &_inner_error_);
1547
if (_inner_error_ != NULL) {
1548
g_propagate_error (error, _inner_error_);
1549
return;
1550
}
1551
} else {
1552
gint _tmp1_;
1553
_tmp1_ = g_strcmp0 (type, "png");
1554
if (_tmp1_ == 0) {
1555
book_save_multi_file (self, "png", file, &_inner_error_);
1556
if (_inner_error_ != NULL) {
1557
g_propagate_error (error, _inner_error_);
1558
return;
1559
}
1560
} else {
1561
gint _tmp2_;
1562
_tmp2_ = g_strcmp0 (type, "tiff");
1563
if (_tmp2_ == 0) {
1564
book_save_multi_file (self, "tiff", file, &_inner_error_);
1565
if (_inner_error_ != NULL) {
1566
g_propagate_error (error, _inner_error_);
1567
return;
1568
}
1569
} else {
1570
gint _tmp3_;
1571
_tmp3_ = g_strcmp0 (type, "ps");
1572
if (_tmp3_ == 0) {
1573
book_save_ps (self, file, &_inner_error_);
1574
if (_inner_error_ != NULL) {
1575
g_propagate_error (error, _inner_error_);
1576
return;
1577
}
1578
} else {
1579
gint _tmp4_;
1580
_tmp4_ = g_strcmp0 (type, "pdf");
1581
if (_tmp4_ == 0) {
1582
book_save_pdf (self, file, &_inner_error_);
1583
if (_inner_error_ != NULL) {
1584
g_propagate_error (error, _inner_error_);
1585
return;
1586
}
1587
}
1588
}
1589
}
1590
}
1591
}
1592
}
1593
1594
1595
void book_set_needs_saving (Book* self, gboolean needs_saving) {
1596
gboolean needed_saving;
1597
g_return_if_fail (self != NULL);
1598
needed_saving = self->priv->needs_saving;
1599
self->priv->needs_saving = needs_saving;
1600
if (needed_saving != needs_saving) {
1601
g_signal_emit_by_name (self, "needs-saving-changed");
1602
}
1603
}
1604
1605
1606
gboolean book_get_needs_saving (Book* self) {
1607
gboolean result = FALSE;
1608
g_return_val_if_fail (self != NULL, FALSE);
1609
result = self->priv->needs_saving;
1610
return result;
1611
}
1612
1613
1614
static void g_cclosure_user_marshal_VOID__PAGE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
1615
typedef void (*GMarshalFunc_VOID__PAGE) (gpointer data1, gpointer arg_1, gpointer data2);
1616
register GMarshalFunc_VOID__PAGE callback;
1617
register GCClosure * cc;
1618
register gpointer data1;
1619
register gpointer data2;
1620
cc = (GCClosure *) closure;
1621
g_return_if_fail (n_param_values == 2);
1622
if (G_CCLOSURE_SWAP_DATA (closure)) {
1623
data1 = closure->data;
1624
data2 = param_values->data[0].v_pointer;
1625
} else {
1626
data1 = param_values->data[0].v_pointer;
1627
data2 = closure->data;
1628
}
1629
callback = (GMarshalFunc_VOID__PAGE) (marshal_data ? marshal_data : cc->callback);
1630
callback (data1, value_get_page (param_values + 1), data2);
1631
}
1632
1633
1634
static void value_book_init (GValue* value) {
1635
value->data[0].v_pointer = NULL;
1636
}
1637
1638
1639
static void value_book_free_value (GValue* value) {
1640
if (value->data[0].v_pointer) {
1641
book_unref (value->data[0].v_pointer);
1642
}
1643
}
1644
1645
1646
static void value_book_copy_value (const GValue* src_value, GValue* dest_value) {
1647
if (src_value->data[0].v_pointer) {
1648
dest_value->data[0].v_pointer = book_ref (src_value->data[0].v_pointer);
1649
} else {
1650
dest_value->data[0].v_pointer = NULL;
1651
}
1652
}
1653
1654
1655
static gpointer value_book_peek_pointer (const GValue* value) {
1656
return value->data[0].v_pointer;
1657
}
1658
1659
1660
static gchar* value_book_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
1661
if (collect_values[0].v_pointer) {
1662
Book* object;
1663
object = collect_values[0].v_pointer;
1664
if (object->parent_instance.g_class == NULL) {
1665
return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
1666
} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
1667
return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
1668
}
1669
value->data[0].v_pointer = book_ref (object);
1670
} else {
1671
value->data[0].v_pointer = NULL;
1672
}
1673
return NULL;
1674
}
1675
1676
1677
static gchar* value_book_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
1678
Book** object_p;
1679
object_p = collect_values[0].v_pointer;
1680
if (!object_p) {
1681
return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
1682
}
1683
if (!value->data[0].v_pointer) {
1684
*object_p = NULL;
1685
} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
1686
*object_p = value->data[0].v_pointer;
1687
} else {
1688
*object_p = book_ref (value->data[0].v_pointer);
1689
}
1690
return NULL;
1691
}
1692
1693
1694
GParamSpec* param_spec_book (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
1695
ParamSpecBook* spec;
1696
g_return_val_if_fail (g_type_is_a (object_type, TYPE_BOOK), NULL);
1697
spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
1698
G_PARAM_SPEC (spec)->value_type = object_type;
1699
return G_PARAM_SPEC (spec);
1700
}
1701
1702
1703
gpointer value_get_book (const GValue* value) {
1704
g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BOOK), NULL);
1705
return value->data[0].v_pointer;
1706
}
1707
1708
1709
void value_set_book (GValue* value, gpointer v_object) {
1710
Book* old;
1711
g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BOOK));
1712
old = value->data[0].v_pointer;
1713
if (v_object) {
1714
g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_BOOK));
1715
g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
1716
value->data[0].v_pointer = v_object;
1717
book_ref (value->data[0].v_pointer);
1718
} else {
1719
value->data[0].v_pointer = NULL;
1720
}
1721
if (old) {
1722
book_unref (old);
1723
}
1724
}
1725
1726
1727
void value_take_book (GValue* value, gpointer v_object) {
1728
Book* old;
1729
g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BOOK));
1730
old = value->data[0].v_pointer;
1731
if (v_object) {
1732
g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_BOOK));
1733
g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
1734
value->data[0].v_pointer = v_object;
1735
} else {
1736
value->data[0].v_pointer = NULL;
1737
}
1738
if (old) {
1739
book_unref (old);
1740
}
1741
}
1742
1743
1744
static void book_class_init (BookClass * klass) {
1745
book_parent_class = g_type_class_peek_parent (klass);
1746
BOOK_CLASS (klass)->finalize = book_finalize;
1747
g_type_class_add_private (klass, sizeof (BookPrivate));
1748
g_signal_new ("page_added", TYPE_BOOK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__PAGE, G_TYPE_NONE, 1, TYPE_PAGE);
1749
g_signal_new ("page_removed", TYPE_BOOK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__PAGE, G_TYPE_NONE, 1, TYPE_PAGE);
1750
g_signal_new ("reordered", TYPE_BOOK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
1751
g_signal_new ("cleared", TYPE_BOOK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
1752
g_signal_new ("needs_saving_changed", TYPE_BOOK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
1753
}
1754
1755
1756
static void book_instance_init (Book * self) {
1757
self->priv = BOOK_GET_PRIVATE (self);
1758
self->ref_count = 1;
1759
}
1760
1761
1762
static void book_finalize (Book* obj) {
1763
Book * self;
1764
self = BOOK (obj);
1765
__g_list_free__page_unref0_0 (self->priv->pages);
1766
}
1767
1768
1769
GType book_get_type (void) {
1770
static volatile gsize book_type_id__volatile = 0;
1771
if (g_once_init_enter (&book_type_id__volatile)) {
1772
static const GTypeValueTable g_define_type_value_table = { value_book_init, value_book_free_value, value_book_copy_value, value_book_peek_pointer, "p", value_book_collect_value, "p", value_book_lcopy_value };
1773
static const GTypeInfo g_define_type_info = { sizeof (BookClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) book_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Book), 0, (GInstanceInitFunc) book_instance_init, &g_define_type_value_table };
1774
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) };
1775
GType book_type_id;
1776
book_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Book", &g_define_type_info, &g_define_type_fundamental_info, 0);
1777
g_once_init_leave (&book_type_id__volatile, book_type_id);
1778
}
1779
return book_type_id__volatile;
1780
}
1781
1782
1783
gpointer book_ref (gpointer instance) {
1784
Book* self;
1785
self = instance;
1786
g_atomic_int_inc (&self->ref_count);
1787
return instance;
1788
}
1789
1790
1791
void book_unref (gpointer instance) {
1792
Book* self;
1793
self = instance;
1794
if (g_atomic_int_dec_and_test (&self->ref_count)) {
1795
BOOK_GET_CLASS (self)->finalize (self);
1796
g_type_free_instance ((GTypeInstance *) self);
1797
}
1798
}
1799
1800
1801
static gpointer _g_object_ref0 (gpointer self) {
1802
return self ? g_object_ref (self) : NULL;
1803
}
1804
1805
1806
PDFWriter* pdf_writer_construct (GType object_type, GFileOutputStream* stream) {
1807
PDFWriter* self = NULL;
1808
GFileOutputStream* _tmp0_;
1809
g_return_val_if_fail (stream != NULL, NULL);
1810
self = (PDFWriter*) g_type_create_instance (object_type);
1811
_tmp0_ = _g_object_ref0 (stream);
1812
_g_object_unref0 (self->priv->stream);
1813
self->priv->stream = _tmp0_;
1814
return self;
1815
}
1816
1817
1818
PDFWriter* pdf_writer_new (GFileOutputStream* stream) {
1819
return pdf_writer_construct (TYPE_PDF_WRITER, stream);
1820
}
1821
1822
1823
void pdf_writer_write (PDFWriter* self, guint8* data, int data_length1) {
1824
GError * _inner_error_ = NULL;
1825
g_return_if_fail (self != NULL);
1826
{
1827
g_output_stream_write_all ((GOutputStream*) self->priv->stream, data, (gsize) data_length1, NULL, NULL, &_inner_error_);
1828
if (_inner_error_ != NULL) {
1829
goto __catch0_g_error;
1830
}
1831
}
1832
goto __finally0;
1833
__catch0_g_error:
1834
{
1835
GError* e = NULL;
1836
e = _inner_error_;
1837
_inner_error_ = NULL;
1838
g_warning ("book.vala:529: Error writing PDF: %s", e->message);
1839
_g_error_free0 (e);
1840
}
1841
__finally0:
1842
if (_inner_error_ != NULL) {
1843
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);
1844
g_clear_error (&_inner_error_);
1845
return;
1846
}
1847
self->offset = self->offset + data_length1;
1848
}
1849
1850
1851
static gchar* string_to_utf8 (const gchar* self, int* result_length1) {
1852
gchar* result = NULL;
1853
gint _tmp0_;
1854
gchar* _tmp1_ = NULL;
1855
gchar* _result_;
1856
gint _result__length1;
1857
gint __result__size_;
1858
gint _tmp2_;
1859
gchar* _tmp3_;
1860
g_return_val_if_fail (self != NULL, NULL);
1861
_tmp0_ = strlen (self);
1862
_tmp1_ = g_new0 (gchar, _tmp0_ + 1);
1863
_result_ = _tmp1_;
1864
_result__length1 = _tmp0_ + 1;
1865
__result__size_ = _result__length1;
1866
_result__length1--;
1867
_tmp2_ = strlen (self);
1868
memcpy (_result_, self, (gsize) _tmp2_);
1869
_tmp3_ = _result_;
1870
if (result_length1) {
1871
*result_length1 = _result__length1;
1872
}
1873
result = _tmp3_;
1874
return result;
1875
}
1876
1877
1878
void pdf_writer_write_string (PDFWriter* self, const gchar* text) {
1879
gint _tmp0_;
1880
gchar* _tmp1_ = NULL;
1881
guint8* _tmp2_;
1882
gint _tmp2__length1;
1883
g_return_if_fail (self != NULL);
1884
g_return_if_fail (text != NULL);
1885
_tmp1_ = string_to_utf8 (text, &_tmp0_);
1886
_tmp2_ = (guint8*) _tmp1_;
1887
_tmp2__length1 = _tmp0_;
1888
pdf_writer_write (self, _tmp2_, _tmp0_);
1889
_tmp2_ = (g_free (_tmp2_), NULL);
1890
}
1891
1892
1893
guint pdf_writer_start_object (PDFWriter* self) {
1894
guint result = 0U;
1895
guint _tmp0_;
1896
g_return_val_if_fail (self != NULL, 0U);
1897
self->object_offsets = g_list_append (self->object_offsets, GUINT_TO_POINTER ((guint) self->offset));
1898
_tmp0_ = g_list_length (self->object_offsets);
1899
result = _tmp0_;
1900
return result;
1901
}
1902
1903
1904
static void value_pdf_writer_init (GValue* value) {
1905
value->data[0].v_pointer = NULL;
1906
}
1907
1908
1909
static void value_pdf_writer_free_value (GValue* value) {
1910
if (value->data[0].v_pointer) {
1911
pdf_writer_unref (value->data[0].v_pointer);
1912
}
1913
}
1914
1915
1916
static void value_pdf_writer_copy_value (const GValue* src_value, GValue* dest_value) {
1917
if (src_value->data[0].v_pointer) {
1918
dest_value->data[0].v_pointer = pdf_writer_ref (src_value->data[0].v_pointer);
1919
} else {
1920
dest_value->data[0].v_pointer = NULL;
1921
}
1922
}
1923
1924
1925
static gpointer value_pdf_writer_peek_pointer (const GValue* value) {
1926
return value->data[0].v_pointer;
1927
}
1928
1929
1930
static gchar* value_pdf_writer_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
1931
if (collect_values[0].v_pointer) {
1932
PDFWriter* object;
1933
object = collect_values[0].v_pointer;
1934
if (object->parent_instance.g_class == NULL) {
1935
return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
1936
} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
1937
return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
1938
}
1939
value->data[0].v_pointer = pdf_writer_ref (object);
1940
} else {
1941
value->data[0].v_pointer = NULL;
1942
}
1943
return NULL;
1944
}
1945
1946
1947
static gchar* value_pdf_writer_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
1948
PDFWriter** object_p;
1949
object_p = collect_values[0].v_pointer;
1950
if (!object_p) {
1951
return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
1952
}
1953
if (!value->data[0].v_pointer) {
1954
*object_p = NULL;
1955
} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
1956
*object_p = value->data[0].v_pointer;
1957
} else {
1958
*object_p = pdf_writer_ref (value->data[0].v_pointer);
1959
}
1960
return NULL;
1961
}
1962
1963
1964
GParamSpec* param_spec_pdf_writer (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
1965
ParamSpecPDFWriter* spec;
1966
g_return_val_if_fail (g_type_is_a (object_type, TYPE_PDF_WRITER), NULL);
1967
spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
1968
G_PARAM_SPEC (spec)->value_type = object_type;
1969
return G_PARAM_SPEC (spec);
1970
}
1971
1972
1973
gpointer value_get_pdf_writer (const GValue* value) {
1974
g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_PDF_WRITER), NULL);
1975
return value->data[0].v_pointer;
1976
}
1977
1978
1979
void value_set_pdf_writer (GValue* value, gpointer v_object) {
1980
PDFWriter* old;
1981
g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_PDF_WRITER));
1982
old = value->data[0].v_pointer;
1983
if (v_object) {
1984
g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_PDF_WRITER));
1985
g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
1986
value->data[0].v_pointer = v_object;
1987
pdf_writer_ref (value->data[0].v_pointer);
1988
} else {
1989
value->data[0].v_pointer = NULL;
1990
}
1991
if (old) {
1992
pdf_writer_unref (old);
1993
}
1994
}
1995
1996
1997
void value_take_pdf_writer (GValue* value, gpointer v_object) {
1998
PDFWriter* old;
1999
g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_PDF_WRITER));
2000
old = value->data[0].v_pointer;
2001
if (v_object) {
2002
g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_PDF_WRITER));
2003
g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
2004
value->data[0].v_pointer = v_object;
2005
} else {
2006
value->data[0].v_pointer = NULL;
2007
}
2008
if (old) {
2009
pdf_writer_unref (old);
2010
}
2011
}
2012
2013
2014
static void pdf_writer_class_init (PDFWriterClass * klass) {
2015
pdf_writer_parent_class = g_type_class_peek_parent (klass);
2016
PDF_WRITER_CLASS (klass)->finalize = pdf_writer_finalize;
2017
g_type_class_add_private (klass, sizeof (PDFWriterPrivate));
2018
}
2019
2020
2021
static void pdf_writer_instance_init (PDFWriter * self) {
2022
self->priv = PDF_WRITER_GET_PRIVATE (self);
2023
self->offset = (gsize) 0;
2024
self->ref_count = 1;
2025
}
2026
2027
2028
static void pdf_writer_finalize (PDFWriter* obj) {
2029
PDFWriter * self;
2030
self = PDF_WRITER (obj);
2031
_g_list_free0 (self->object_offsets);
2032
_g_object_unref0 (self->priv->stream);
2033
}
2034
2035
2036
GType pdf_writer_get_type (void) {
2037
static volatile gsize pdf_writer_type_id__volatile = 0;
2038
if (g_once_init_enter (&pdf_writer_type_id__volatile)) {
2039
static const GTypeValueTable g_define_type_value_table = { value_pdf_writer_init, value_pdf_writer_free_value, value_pdf_writer_copy_value, value_pdf_writer_peek_pointer, "p", value_pdf_writer_collect_value, "p", value_pdf_writer_lcopy_value };
2040
static const GTypeInfo g_define_type_info = { sizeof (PDFWriterClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) pdf_writer_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (PDFWriter), 0, (GInstanceInitFunc) pdf_writer_instance_init, &g_define_type_value_table };
2041
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) };
2042
GType pdf_writer_type_id;
2043
pdf_writer_type_id = g_type_register_fundamental (g_type_fundamental_next (), "PDFWriter", &g_define_type_info, &g_define_type_fundamental_info, 0);
2044
g_once_init_leave (&pdf_writer_type_id__volatile, pdf_writer_type_id);
2045
}
2046
return pdf_writer_type_id__volatile;
2047
}
2048
2049
2050
gpointer pdf_writer_ref (gpointer instance) {
2051
PDFWriter* self;
2052
self = instance;
2053
g_atomic_int_inc (&self->ref_count);
2054
return instance;
2055
}
2056
2057
2058
void pdf_writer_unref (gpointer instance) {
2059
PDFWriter* self;
2060
self = instance;
2061
if (g_atomic_int_dec_and_test (&self->ref_count)) {
2062
PDF_WRITER_GET_CLASS (self)->finalize (self);
2063
g_type_free_instance ((GTypeInstance *) self);
2064
}
2065
}
2066
2067
2068
static cairo_status_t _ps_writer_write_cairo_data_cairo_write_func_t (gpointer self, guchar* data, int data_length1) {
2069
cairo_status_t result;
2070
result = ps_writer_write_cairo_data (self, data, data_length1);
2071
return result;
2072
}
2073
2074
2075
PsWriter* ps_writer_construct (GType object_type, GFileOutputStream* stream) {
2076
PsWriter* self = NULL;
2077
GFileOutputStream* _tmp0_;
2078
cairo_surface_t* _tmp1_ = NULL;
2079
g_return_val_if_fail (stream != NULL, NULL);
2080
self = (PsWriter*) g_type_create_instance (object_type);
2081
_tmp0_ = _g_object_ref0 (stream);
2082
_g_object_unref0 (self->stream);
2083
self->stream = _tmp0_;
2084
_tmp1_ = cairo_ps_surface_create_for_stream (_ps_writer_write_cairo_data_cairo_write_func_t, self, (gdouble) 0, (gdouble) 0);
2085
_cairo_surface_destroy0 (self->surface);
2086
self->surface = _tmp1_;
2087
return self;
2088
}
2089
2090
2091
PsWriter* ps_writer_new (GFileOutputStream* stream) {
2092
return ps_writer_construct (TYPE_PS_WRITER, stream);
2093
}
2094
2095
2096
static cairo_status_t ps_writer_write_cairo_data (PsWriter* self, guint8* data, int data_length1) {
2097
cairo_status_t result = 0;
2098
GError * _inner_error_ = NULL;
2099
g_return_val_if_fail (self != NULL, 0);
2100
{
2101
g_output_stream_write_all ((GOutputStream*) self->stream, data, (gsize) data_length1, NULL, NULL, &_inner_error_);
2102
if (_inner_error_ != NULL) {
2103
goto __catch1_g_error;
2104
}
2105
}
2106
goto __finally1;
2107
__catch1_g_error:
2108
{
2109
GError* e = NULL;
2110
e = _inner_error_;
2111
_inner_error_ = NULL;
2112
g_warning ("book.vala:565: Error writing data: %s", e->message);
2113
result = CAIRO_STATUS_WRITE_ERROR;
2114
_g_error_free0 (e);
2115
return result;
2116
}
2117
__finally1:
2118
if (_inner_error_ != NULL) {
2119
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);
2120
g_clear_error (&_inner_error_);
2121
return 0;
2122
}
2123
result = CAIRO_STATUS_SUCCESS;
2124
return result;
2125
}
2126
2127
2128
static void value_ps_writer_init (GValue* value) {
2129
value->data[0].v_pointer = NULL;
2130
}
2131
2132
2133
static void value_ps_writer_free_value (GValue* value) {
2134
if (value->data[0].v_pointer) {
2135
ps_writer_unref (value->data[0].v_pointer);
2136
}
2137
}
2138
2139
2140
static void value_ps_writer_copy_value (const GValue* src_value, GValue* dest_value) {
2141
if (src_value->data[0].v_pointer) {
2142
dest_value->data[0].v_pointer = ps_writer_ref (src_value->data[0].v_pointer);
2143
} else {
2144
dest_value->data[0].v_pointer = NULL;
2145
}
2146
}
2147
2148
2149
static gpointer value_ps_writer_peek_pointer (const GValue* value) {
2150
return value->data[0].v_pointer;
2151
}
2152
2153
2154
static gchar* value_ps_writer_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
2155
if (collect_values[0].v_pointer) {
2156
PsWriter* object;
2157
object = collect_values[0].v_pointer;
2158
if (object->parent_instance.g_class == NULL) {
2159
return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
2160
} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
2161
return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
2162
}
2163
value->data[0].v_pointer = ps_writer_ref (object);
2164
} else {
2165
value->data[0].v_pointer = NULL;
2166
}
2167
return NULL;
2168
}
2169
2170
2171
static gchar* value_ps_writer_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
2172
PsWriter** object_p;
2173
object_p = collect_values[0].v_pointer;
2174
if (!object_p) {
2175
return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
2176
}
2177
if (!value->data[0].v_pointer) {
2178
*object_p = NULL;
2179
} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
2180
*object_p = value->data[0].v_pointer;
2181
} else {
2182
*object_p = ps_writer_ref (value->data[0].v_pointer);
2183
}
2184
return NULL;
2185
}
2186
2187
2188
GParamSpec* param_spec_ps_writer (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
2189
ParamSpecPsWriter* spec;
2190
g_return_val_if_fail (g_type_is_a (object_type, TYPE_PS_WRITER), NULL);
2191
spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
2192
G_PARAM_SPEC (spec)->value_type = object_type;
2193
return G_PARAM_SPEC (spec);
2194
}
2195
2196
2197
gpointer value_get_ps_writer (const GValue* value) {
2198
g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_PS_WRITER), NULL);
2199
return value->data[0].v_pointer;
2200
}
2201
2202
2203
void value_set_ps_writer (GValue* value, gpointer v_object) {
2204
PsWriter* old;
2205
g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_PS_WRITER));
2206
old = value->data[0].v_pointer;
2207
if (v_object) {
2208
g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_PS_WRITER));
2209
g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
2210
value->data[0].v_pointer = v_object;
2211
ps_writer_ref (value->data[0].v_pointer);
2212
} else {
2213
value->data[0].v_pointer = NULL;
2214
}
2215
if (old) {
2216
ps_writer_unref (old);
2217
}
2218
}
2219
2220
2221
void value_take_ps_writer (GValue* value, gpointer v_object) {
2222
PsWriter* old;
2223
g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_PS_WRITER));
2224
old = value->data[0].v_pointer;
2225
if (v_object) {
2226
g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_PS_WRITER));
2227
g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
2228
value->data[0].v_pointer = v_object;
2229
} else {
2230
value->data[0].v_pointer = NULL;
2231
}
2232
if (old) {
2233
ps_writer_unref (old);
2234
}
2235
}
2236
2237
2238
static void ps_writer_class_init (PsWriterClass * klass) {
2239
ps_writer_parent_class = g_type_class_peek_parent (klass);
2240
PS_WRITER_CLASS (klass)->finalize = ps_writer_finalize;
2241
}
2242
2243
2244
static void ps_writer_instance_init (PsWriter * self) {
2245
self->ref_count = 1;
2246
}
2247
2248
2249
static void ps_writer_finalize (PsWriter* obj) {
2250
PsWriter * self;
2251
self = PS_WRITER (obj);
2252
_cairo_surface_destroy0 (self->surface);
2253
_g_object_unref0 (self->stream);
2254
}
2255
2256
2257
GType ps_writer_get_type (void) {
2258
static volatile gsize ps_writer_type_id__volatile = 0;
2259
if (g_once_init_enter (&ps_writer_type_id__volatile)) {
2260
static const GTypeValueTable g_define_type_value_table = { value_ps_writer_init, value_ps_writer_free_value, value_ps_writer_copy_value, value_ps_writer_peek_pointer, "p", value_ps_writer_collect_value, "p", value_ps_writer_lcopy_value };
2261
static const GTypeInfo g_define_type_info = { sizeof (PsWriterClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ps_writer_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (PsWriter), 0, (GInstanceInitFunc) ps_writer_instance_init, &g_define_type_value_table };
2262
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) };
2263
GType ps_writer_type_id;
2264
ps_writer_type_id = g_type_register_fundamental (g_type_fundamental_next (), "PsWriter", &g_define_type_info, &g_define_type_fundamental_info, 0);
2265
g_once_init_leave (&ps_writer_type_id__volatile, ps_writer_type_id);
2266
}
2267
return ps_writer_type_id__volatile;
2268
}
2269
2270
2271
gpointer ps_writer_ref (gpointer instance) {
2272
PsWriter* self;
2273
self = instance;
2274
g_atomic_int_inc (&self->ref_count);
2275
return instance;
2276
}
2277
2278
2279
void ps_writer_unref (gpointer instance) {
2280
PsWriter* self;
2281
self = instance;
2282
if (g_atomic_int_dec_and_test (&self->ref_count)) {
2283
PS_WRITER_GET_CLASS (self)->finalize (self);
2284
g_type_free_instance ((GTypeInstance *) self);
2285
}
2286
}
2287
2288
2289
Loggerhead is a web-based interface for Breezy
Version: 2.0.1