summaryrefslogtreecommitdiff
path: root/src/book.c
diff options
context:
space:
mode:
authorAlessio Treglia <alessio@debian.org>2011-08-27 10:54:21 +0200
committerAlessio Treglia <alessio@debian.org>2011-08-27 10:54:21 +0200
commit87ebc2af1f0417b3bc38a233e28ff673eff4fa51 (patch)
tree747dd400400bf7593642d0ab321a4e37df2ee188 /src/book.c
parent0898b615a2ea01bd65aa1d560350b48bd036b5b6 (diff)
Imported Upstream version 3.1.5upstream/3.1.5
Diffstat (limited to 'src/book.c')
-rw-r--r--src/book.c2925
1 files changed, 2168 insertions, 757 deletions
diff --git a/src/book.c b/src/book.c
index de40036..154b6d4 100644
--- a/src/book.c
+++ b/src/book.c
@@ -1,7 +1,10 @@
+/* book.c generated by valac 0.13.1, the Vala compiler
+ * generated from book.vala, do not modify */
+
/*
- * Copyright (C) 2009 Canonical Ltd.
+ * Copyright (C) 2009-2011 Canonical Ltd.
* Author: Robert Ancell <robert.ancell@canonical.com>
- *
+ *
* This program is free software: you can redistribute it and/or modify it under
* the terms of the GNU General Public License as published by the Free Software
* Foundation, either version 3 of the License, or (at your option) any later
@@ -9,870 +12,2278 @@
* license.
*/
-#include <stdio.h>
+#include <glib.h>
+#include <glib-object.h>
+#include <stdlib.h>
#include <string.h>
+#include <gio/gio.h>
+#include <cairo.h>
+#include <gdk-pixbuf/gdk-pixdata.h>
+#include <float.h>
#include <math.h>
+#include <gdk/gdk.h>
+#include <cairo-ps.h>
#include <zlib.h>
#include <jpeglib.h>
-#include <gdk/gdk.h>
-#include <gdk-pixbuf/gdk-pixbuf.h>
-#include <cairo/cairo-pdf.h>
-#include <cairo/cairo-ps.h>
+#include <config.h>
+#include <gobject/gvaluecollector.h>
+
+
+#define TYPE_BOOK (book_get_type ())
+#define BOOK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_BOOK, Book))
+#define BOOK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_BOOK, BookClass))
+#define IS_BOOK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_BOOK))
+#define IS_BOOK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_BOOK))
+#define BOOK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_BOOK, BookClass))
+
+typedef struct _Book Book;
+typedef struct _BookClass BookClass;
+typedef struct _BookPrivate BookPrivate;
+
+#define TYPE_PAGE (page_get_type ())
+#define PAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PAGE, Page))
+#define PAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PAGE, PageClass))
+#define IS_PAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PAGE))
+#define IS_PAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PAGE))
+#define PAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PAGE, PageClass))
+
+typedef struct _Page Page;
+typedef struct _PageClass PageClass;
+#define __g_list_free__page_unref0_0(var) ((var == NULL) ? NULL : (var = (_g_list_free__page_unref0_ (var), NULL)))
+
+#define TYPE_SCAN_DIRECTION (scan_direction_get_type ())
+#define _page_unref0(var) ((var == NULL) ? NULL : (var = (page_unref (var), NULL)))
+#define _g_free0(var) (var = (g_free (var), NULL))
+#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
+#define _cairo_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_destroy (var), NULL)))
+
+#define TYPE_PS_WRITER (ps_writer_get_type ())
+#define PS_WRITER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PS_WRITER, PsWriter))
+#define PS_WRITER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PS_WRITER, PsWriterClass))
+#define IS_PS_WRITER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PS_WRITER))
+#define IS_PS_WRITER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PS_WRITER))
+#define PS_WRITER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PS_WRITER, PsWriterClass))
+
+typedef struct _PsWriter PsWriter;
+typedef struct _PsWriterClass PsWriterClass;
+typedef struct _PsWriterPrivate PsWriterPrivate;
+#define _cairo_surface_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_surface_destroy (var), NULL)))
+#define _ps_writer_unref0(var) ((var == NULL) ? NULL : (var = (ps_writer_unref (var), NULL)))
+
+#define TYPE_PDF_WRITER (pdf_writer_get_type ())
+#define PDF_WRITER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PDF_WRITER, PDFWriter))
+#define PDF_WRITER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PDF_WRITER, PDFWriterClass))
+#define IS_PDF_WRITER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PDF_WRITER))
+#define IS_PDF_WRITER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PDF_WRITER))
+#define PDF_WRITER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PDF_WRITER, PDFWriterClass))
+
+typedef struct _PDFWriter PDFWriter;
+typedef struct _PDFWriterClass PDFWriterClass;
+typedef struct _PDFWriterPrivate PDFWriterPrivate;
+#define _pdf_writer_unref0(var) ((var == NULL) ? NULL : (var = (pdf_writer_unref (var), NULL)))
+typedef struct _ParamSpecBook ParamSpecBook;
+#define _g_list_free0(var) ((var == NULL) ? NULL : (var = (g_list_free (var), NULL)))
+#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
+typedef struct _ParamSpecPDFWriter ParamSpecPDFWriter;
+typedef struct _ParamSpecPsWriter ParamSpecPsWriter;
+
+struct _Book {
+ GTypeInstance parent_instance;
+ volatile int ref_count;
+ BookPrivate * priv;
+};
+
+struct _BookClass {
+ GTypeClass parent_class;
+ void (*finalize) (Book *self);
+};
+
+struct _BookPrivate {
+ GList* pages;
+ gboolean needs_saving;
+};
+
+typedef enum {
+ SCAN_DIRECTION_TOP_TO_BOTTOM,
+ SCAN_DIRECTION_LEFT_TO_RIGHT,
+ SCAN_DIRECTION_BOTTOM_TO_TOP,
+ SCAN_DIRECTION_RIGHT_TO_LEFT
+} ScanDirection;
+
+struct _PsWriter {
+ GTypeInstance parent_instance;
+ volatile int ref_count;
+ PsWriterPrivate * priv;
+ cairo_surface_t* surface;
+ GFileOutputStream* stream;
+};
-#include "book.h"
+struct _PsWriterClass {
+ GTypeClass parent_class;
+ void (*finalize) (PsWriter *self);
+};
-enum {
- PROP_0,
- PROP_NEEDS_SAVING
+struct _PDFWriter {
+ GTypeInstance parent_instance;
+ volatile int ref_count;
+ PDFWriterPrivate * priv;
+ gsize offset;
+ GList* object_offsets;
};
-enum {
- PAGE_ADDED,
- PAGE_REMOVED,
- REORDERED,
- CLEARED,
- LAST_SIGNAL
+struct _PDFWriterClass {
+ GTypeClass parent_class;
+ void (*finalize) (PDFWriter *self);
};
-static guint signals[LAST_SIGNAL] = { 0, };
-struct BookPrivate
-{
- GList *pages;
-
- gboolean needs_saving;
+struct _ParamSpecBook {
+ GParamSpec parent_instance;
};
-G_DEFINE_TYPE (Book, book, G_TYPE_OBJECT);
+struct _PDFWriterPrivate {
+ GFileOutputStream* stream;
+};
+
+struct _ParamSpecPDFWriter {
+ GParamSpec parent_instance;
+};
+
+struct _ParamSpecPsWriter {
+ GParamSpec parent_instance;
+};
+
+
+static gpointer book_parent_class = NULL;
+static gpointer pdf_writer_parent_class = NULL;
+static gpointer ps_writer_parent_class = NULL;
+
+gpointer book_ref (gpointer instance);
+void book_unref (gpointer instance);
+GParamSpec* param_spec_book (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
+void value_set_book (GValue* value, gpointer v_object);
+void value_take_book (GValue* value, gpointer v_object);
+gpointer value_get_book (const GValue* value);
+GType book_get_type (void) G_GNUC_CONST;
+gpointer page_ref (gpointer instance);
+void page_unref (gpointer instance);
+GParamSpec* param_spec_page (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
+void value_set_page (GValue* value, gpointer v_object);
+void value_take_page (GValue* value, gpointer v_object);
+gpointer value_get_page (const GValue* value);
+GType page_get_type (void) G_GNUC_CONST;
+#define BOOK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_BOOK, BookPrivate))
+enum {
+ BOOK_DUMMY_PROPERTY
+};
+static void _page_unref0_ (gpointer var);
+static void _g_list_free__page_unref0_ (GList* self);
+Book* book_new (void);
+Book* book_construct (GType object_type);
+void book_clear (Book* self);
+static void book_page_changed_cb (Book* self, Page* page);
+void book_set_needs_saving (Book* self, gboolean needs_saving);
+GType scan_direction_get_type (void) G_GNUC_CONST;
+Page* book_append_page (Book* self, gint width, gint height, gint dpi, ScanDirection scan_direction);
+Page* page_new (gint width, gint height, gint dpi, ScanDirection scan_direction);
+Page* page_construct (GType object_type, gint width, gint height, gint dpi, ScanDirection scan_direction);
+static void _book_page_changed_cb_page_pixels_changed (Page* _sender, gpointer self);
+static void _book_page_changed_cb_page_crop_changed (Page* _sender, gpointer self);
+void book_move_page (Book* self, Page* page, guint location);
+void book_delete_page (Book* self, Page* page);
+guint book_get_n_pages (Book* self);
+Page* book_get_page (Book* self, gint page_number);
+guint book_get_page_index (Book* self, Page* page);
+static GFile* book_make_indexed_file (Book* self, const gchar* uri, gint i);
+static void book_save_multi_file (Book* self, const gchar* type, GFile* file, GError** error);
+void page_save (Page* self, const gchar* type, GFile* file, GError** error);
+static void book_save_ps_pdf_surface (Book* self, cairo_surface_t* surface, GdkPixbuf* image, gdouble dpi);
+static void book_save_ps (Book* self, GFile* file, GError** error);
+PsWriter* ps_writer_new (GFileOutputStream* stream);
+PsWriter* ps_writer_construct (GType object_type, GFileOutputStream* stream);
+gpointer ps_writer_ref (gpointer instance);
+void ps_writer_unref (gpointer instance);
+GParamSpec* param_spec_ps_writer (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
+void value_set_ps_writer (GValue* value, gpointer v_object);
+void value_take_ps_writer (GValue* value, gpointer v_object);
+gpointer value_get_ps_writer (const GValue* value);
+GType ps_writer_get_type (void) G_GNUC_CONST;
+GdkPixbuf* page_get_image (Page* self, gboolean apply_crop);
+gint page_get_dpi (Page* self);
+static guint8* book_compress_zlib (Book* self, guint8* data, int data_length1, int* result_length1);
+static void book_jpeg_init_cb (struct jpeg_compress_struct* info);
+static gboolean book_jpeg_empty_cb (struct jpeg_compress_struct* info);
+static void book_jpeg_term_cb (struct jpeg_compress_struct* info);
+static guint8* book_compress_jpeg (Book* self, GdkPixbuf* image, gsize* n_written, int* result_length1);
+static void _book_jpeg_init_cb_jpeg_initdestinationfunc (struct jpeg_compress_struct* cinfo);
+static gboolean _book_jpeg_empty_cb_jpeg_emptyoutputbufferfunc (struct jpeg_compress_struct* cinfo);
+static void _book_jpeg_term_cb_jpeg_termdestinationfunc (struct jpeg_compress_struct* cinfo);
+static void book_save_pdf (Book* self, GFile* file, GError** error);
+PDFWriter* pdf_writer_new (GFileOutputStream* stream);
+PDFWriter* pdf_writer_construct (GType object_type, GFileOutputStream* stream);
+gpointer pdf_writer_ref (gpointer instance);
+void pdf_writer_unref (gpointer instance);
+GParamSpec* param_spec_pdf_writer (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
+void value_set_pdf_writer (GValue* value, gpointer v_object);
+void value_take_pdf_writer (GValue* value, gpointer v_object);
+gpointer value_get_pdf_writer (const GValue* value);
+GType pdf_writer_get_type (void) G_GNUC_CONST;
+void pdf_writer_write_string (PDFWriter* self, const gchar* text);
+guint pdf_writer_start_object (PDFWriter* self);
+gboolean page_is_color (Page* self);
+gint page_get_depth (Page* self);
+static guint8* _vala_array_dup1 (guint8* self, int length);
+static guint8* _vala_array_dup2 (guint8* self, int length);
+void pdf_writer_write (PDFWriter* self, guint8* data, int data_length1);
+void book_save (Book* self, const gchar* type, GFile* file, GError** error);
+gboolean book_get_needs_saving (Book* self);
+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);
+static void book_finalize (Book* obj);
+#define PDF_WRITER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_PDF_WRITER, PDFWriterPrivate))
+enum {
+ PDF_WRITER_DUMMY_PROPERTY
+};
+static void pdf_writer_finalize (PDFWriter* obj);
+enum {
+ PS_WRITER_DUMMY_PROPERTY
+};
+static cairo_status_t ps_writer_write_cairo_data (PsWriter* self, guint8* data, int data_length1);
+static cairo_status_t _ps_writer_write_cairo_data_cairo_write_func_t (gpointer self, guchar* data, int data_length1);
+static void ps_writer_finalize (PsWriter* obj);
+
+
+static void _page_unref0_ (gpointer var) {
+ (var == NULL) ? NULL : (var = (page_unref (var), NULL));
+}
+
+
+static void _g_list_free__page_unref0_ (GList* self) {
+ g_list_foreach (self, (GFunc) _page_unref0_, NULL);
+ g_list_free (self);
+}
+
+
+Book* book_construct (GType object_type) {
+ Book* self = NULL;
+ self = (Book*) g_type_create_instance (object_type);
+ return self;
+}
+
+
+Book* book_new (void) {
+ return book_construct (TYPE_BOOK);
+}
+
+
+void book_clear (Book* self) {
+ g_return_if_fail (self != NULL);
+ __g_list_free__page_unref0_0 (self->priv->pages);
+ self->priv->pages = NULL;
+ g_signal_emit_by_name (self, "cleared");
+}
+
+
+static void book_page_changed_cb (Book* self, Page* page) {
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (page != NULL);
+ book_set_needs_saving (self, TRUE);
+}
+
+
+static void _book_page_changed_cb_page_pixels_changed (Page* _sender, gpointer self) {
+ book_page_changed_cb (self, _sender);
+}
+
+
+static void _book_page_changed_cb_page_crop_changed (Page* _sender, gpointer self) {
+ book_page_changed_cb (self, _sender);
+}
+
+
+static gpointer _page_ref0 (gpointer self) {
+ return self ? page_ref (self) : NULL;
+}
+
+
+Page* book_append_page (Book* self, gint width, gint height, gint dpi, ScanDirection scan_direction) {
+ Page* result = NULL;
+ Page* _tmp0_ = NULL;
+ Page* page;
+ Page* _tmp1_;
+ g_return_val_if_fail (self != NULL, NULL);
+ _tmp0_ = page_new (width, height, dpi, scan_direction);
+ page = _tmp0_;
+ g_signal_connect (page, "pixels-changed", (GCallback) _book_page_changed_cb_page_pixels_changed, self);
+ g_signal_connect (page, "crop-changed", (GCallback) _book_page_changed_cb_page_crop_changed, self);
+ _tmp1_ = _page_ref0 (page);
+ self->priv->pages = g_list_append (self->priv->pages, _tmp1_);
+ g_signal_emit_by_name (self, "page-added", page);
+ book_set_needs_saving (self, TRUE);
+ result = page;
+ return result;
+}
+
+
+void book_move_page (Book* self, Page* page, guint location) {
+ Page* _tmp0_;
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (page != NULL);
+ self->priv->pages = g_list_remove (self->priv->pages, page);
+ _tmp0_ = _page_ref0 (page);
+ self->priv->pages = g_list_insert (self->priv->pages, _tmp0_, (gint) location);
+ g_signal_emit_by_name (self, "reordered");
+ book_set_needs_saving (self, TRUE);
+}
+
+
+void book_delete_page (Book* self, Page* page) {
+ guint _tmp0_;
+ guint _tmp1_;
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (page != NULL);
+ g_signal_parse_name ("pixels-changed", TYPE_PAGE, &_tmp0_, NULL, FALSE);
+ 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);
+ g_signal_parse_name ("crop-changed", TYPE_PAGE, &_tmp1_, NULL, FALSE);
+ 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);
+ g_signal_emit_by_name (self, "page-removed", page);
+ self->priv->pages = g_list_remove (self->priv->pages, page);
+ book_set_needs_saving (self, TRUE);
+}
+
+
+guint book_get_n_pages (Book* self) {
+ guint result = 0U;
+ guint _tmp0_;
+ g_return_val_if_fail (self != NULL, 0U);
+ _tmp0_ = g_list_length (self->priv->pages);
+ result = _tmp0_;
+ return result;
+}
+
+
+Page* book_get_page (Book* self, gint page_number) {
+ Page* result = NULL;
+ gconstpointer _tmp1_ = NULL;
+ Page* _tmp2_;
+ g_return_val_if_fail (self != NULL, NULL);
+ if (page_number < 0) {
+ guint _tmp0_;
+ _tmp0_ = g_list_length (self->priv->pages);
+ page_number = ((gint) _tmp0_) + page_number;
+ }
+ _tmp1_ = g_list_nth_data (self->priv->pages, (guint) page_number);
+ _tmp2_ = _page_ref0 ((Page*) _tmp1_);
+ result = _tmp2_;
+ return result;
+}
+
+
+guint book_get_page_index (Book* self, Page* page) {
+ guint result = 0U;
+ gint _tmp0_;
+ g_return_val_if_fail (self != NULL, 0U);
+ g_return_val_if_fail (page != NULL, 0U);
+ _tmp0_ = g_list_index (self->priv->pages, page);
+ result = (guint) _tmp0_;
+ return result;
+}
+
+
+static gint string_last_index_of_char (const gchar* self, gunichar c, gint start_index) {
+ gint result = 0;
+ gchar* _tmp0_ = NULL;
+ gchar* _result_;
+ g_return_val_if_fail (self != NULL, 0);
+ _tmp0_ = g_utf8_strrchr (((gchar*) self) + start_index, (gssize) (-1), c);
+ _result_ = _tmp0_;
+ if (_result_ != NULL) {
+ result = (gint) (_result_ - ((gchar*) self));
+ return result;
+ } else {
+ result = -1;
+ return result;
+ }
+}
+
+
+static gchar* string_slice (const gchar* self, glong start, glong end) {
+ gchar* result = NULL;
+ gint _tmp0_;
+ glong string_length;
+ gboolean _tmp1_ = FALSE;
+ gboolean _tmp2_ = FALSE;
+ gchar* _tmp3_ = NULL;
+ g_return_val_if_fail (self != NULL, NULL);
+ _tmp0_ = strlen (self);
+ string_length = (glong) _tmp0_;
+ if (start < ((glong) 0)) {
+ start = string_length + start;
+ }
+ if (end < ((glong) 0)) {
+ end = string_length + end;
+ }
+ if (start >= ((glong) 0)) {
+ _tmp1_ = start <= string_length;
+ } else {
+ _tmp1_ = FALSE;
+ }
+ g_return_val_if_fail (_tmp1_, NULL);
+ if (end >= ((glong) 0)) {
+ _tmp2_ = end <= string_length;
+ } else {
+ _tmp2_ = FALSE;
+ }
+ g_return_val_if_fail (_tmp2_, NULL);
+ g_return_val_if_fail (start <= end, NULL);
+ _tmp3_ = g_strndup (((gchar*) self) + start, (gsize) (end - start));
+ result = _tmp3_;
+ return result;
+}
+
+
+static GFile* book_make_indexed_file (Book* self, const gchar* uri, gint i) {
+ GFile* result = NULL;
+ gchar* _tmp1_ = NULL;
+ gchar* basename;
+ gchar* _tmp2_;
+ gchar* prefix;
+ gchar* _tmp3_;
+ gchar* suffix;
+ gint _tmp4_;
+ gint extension_index;
+ gchar* _tmp10_ = NULL;
+ gchar* _tmp11_;
+ GFile* _tmp12_ = NULL;
+ GFile* _tmp13_;
+ g_return_val_if_fail (self != NULL, NULL);
+ g_return_val_if_fail (uri != NULL, NULL);
+ if (i == 0) {
+ GFile* _tmp0_ = NULL;
+ _tmp0_ = g_file_new_for_uri (uri);
+ result = _tmp0_;
+ return result;
+ }
+ _tmp1_ = g_path_get_basename (uri);
+ basename = _tmp1_;
+ _tmp2_ = g_strdup (uri);
+ prefix = _tmp2_;
+ _tmp3_ = g_strdup ("");
+ suffix = _tmp3_;
+ _tmp4_ = string_last_index_of_char (basename, (gunichar) '.', 0);
+ extension_index = _tmp4_;
+ if (extension_index >= 0) {
+ gint _tmp5_;
+ gchar* _tmp6_ = NULL;
+ gint _tmp7_;
+ gint _tmp8_;
+ gchar* _tmp9_ = NULL;
+ _tmp5_ = strlen (basename);
+ _tmp6_ = string_slice (basename, (glong) extension_index, (glong) _tmp5_);
+ _g_free0 (suffix);
+ suffix = _tmp6_;
+ _tmp7_ = strlen (uri);
+ _tmp8_ = strlen (suffix);
+ _tmp9_ = string_slice (uri, (glong) 0, (glong) (_tmp7_ - _tmp8_));
+ _g_free0 (prefix);
+ prefix = _tmp9_;
+ }
+ _tmp10_ = g_strdup_printf ("%s-%d%s", prefix, i, suffix);
+ _tmp11_ = _tmp10_;
+ _tmp12_ = g_file_new_for_uri (_tmp11_);
+ _tmp13_ = _tmp12_;
+ _g_free0 (_tmp11_);
+ result = _tmp13_;
+ _g_free0 (suffix);
+ _g_free0 (prefix);
+ _g_free0 (basename);
+ return result;
+}
+
+
+static void book_save_multi_file (Book* self, const gchar* type, GFile* file, GError** error) {
+ gint i;
+ GError * _inner_error_ = NULL;
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (type != NULL);
+ g_return_if_fail (file != NULL);
+ i = 0;
+ {
+ GList* page_collection = NULL;
+ GList* page_it = NULL;
+ page_collection = self->priv->pages;
+ for (page_it = page_collection; page_it != NULL; page_it = page_it->next) {
+ Page* _tmp0_;
+ Page* page = NULL;
+ _tmp0_ = _page_ref0 ((Page*) page_it->data);
+ page = _tmp0_;
+ {
+ gchar* _tmp1_ = NULL;
+ gchar* _tmp2_;
+ GFile* _tmp3_ = NULL;
+ GFile* _tmp4_;
+ _tmp1_ = g_file_get_uri (file);
+ _tmp2_ = _tmp1_;
+ _tmp3_ = book_make_indexed_file (self, _tmp2_, i);
+ _tmp4_ = _tmp3_;
+ page_save (page, type, _tmp4_, &_inner_error_);
+ _g_object_unref0 (_tmp4_);
+ _g_free0 (_tmp2_);
+ if (_inner_error_ != NULL) {
+ g_propagate_error (error, _inner_error_);
+ _page_unref0 (page);
+ return;
+ }
+ i++;
+ _page_unref0 (page);
+ }
+ }
+ }
+}
+
+
+static void book_save_ps_pdf_surface (Book* self, cairo_surface_t* surface, GdkPixbuf* image, gdouble dpi) {
+ cairo_t* _tmp0_ = NULL;
+ cairo_t* context;
+ cairo_pattern_t* _tmp1_ = NULL;
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (surface != NULL);
+ g_return_if_fail (image != NULL);
+ _tmp0_ = cairo_create (surface);
+ context = _tmp0_;
+ cairo_scale (context, 72.0 / dpi, 72.0 / dpi);
+ gdk_cairo_set_source_pixbuf (context, image, (gdouble) 0, (gdouble) 0);
+ _tmp1_ = cairo_get_source (context);
+ cairo_pattern_set_filter (_tmp1_, CAIRO_FILTER_BEST);
+ cairo_paint (context);
+ _cairo_destroy0 (context);
+}
+
+
+static gpointer _cairo_surface_reference0 (gpointer self) {
+ return self ? cairo_surface_reference (self) : NULL;
+}
+
+
+static void book_save_ps (Book* self, GFile* file, GError** error) {
+ GFileOutputStream* _tmp0_ = NULL;
+ GFileOutputStream* stream;
+ PsWriter* _tmp1_ = NULL;
+ PsWriter* writer;
+ cairo_surface_t* _tmp2_;
+ cairo_surface_t* surface;
+ GError * _inner_error_ = NULL;
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (file != NULL);
+ _tmp0_ = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &_inner_error_);
+ stream = _tmp0_;
+ if (_inner_error_ != NULL) {
+ g_propagate_error (error, _inner_error_);
+ return;
+ }
+ _tmp1_ = ps_writer_new (stream);
+ writer = _tmp1_;
+ _tmp2_ = _cairo_surface_reference0 (writer->surface);
+ surface = _tmp2_;
+ {
+ GList* page_collection = NULL;
+ GList* page_it = NULL;
+ page_collection = self->priv->pages;
+ for (page_it = page_collection; page_it != NULL; page_it = page_it->next) {
+ Page* _tmp3_;
+ Page* page = NULL;
+ _tmp3_ = _page_ref0 ((Page*) page_it->data);
+ page = _tmp3_;
+ {
+ GdkPixbuf* _tmp4_ = NULL;
+ GdkPixbuf* image;
+ gint _tmp5_;
+ gint _tmp6_;
+ gdouble width;
+ gint _tmp7_;
+ gint _tmp8_;
+ gdouble height;
+ gint _tmp9_;
+ _tmp4_ = page_get_image (page, TRUE);
+ image = _tmp4_;
+ _tmp5_ = gdk_pixbuf_get_width (image);
+ _tmp6_ = page_get_dpi (page);
+ width = (_tmp5_ * 72.0) / _tmp6_;
+ _tmp7_ = gdk_pixbuf_get_height (image);
+ _tmp8_ = page_get_dpi (page);
+ height = (_tmp7_ * 72.0) / _tmp8_;
+ cairo_ps_surface_set_size (surface, width, height);
+ _tmp9_ = page_get_dpi (page);
+ book_save_ps_pdf_surface (self, surface, image, (gdouble) _tmp9_);
+ cairo_surface_show_page (surface);
+ _g_object_unref0 (image);
+ _page_unref0 (page);
+ }
+ }
+ }
+ _cairo_surface_destroy0 (surface);
+ _ps_writer_unref0 (writer);
+ _g_object_unref0 (stream);
+}
+
+
+static guint8* book_compress_zlib (Book* self, guint8* data, int data_length1, int* result_length1) {
+ guint8* result = NULL;
+ z_stream stream = {0};
+ guint8* _tmp0_ = NULL;
+ guint8* out_data;
+ gint out_data_length1;
+ gint _out_data_size_;
+ guint n_written;
+ gint _tmp3_;
+ guint8* _tmp4_;
+ g_return_val_if_fail (self != NULL, NULL);
+ deflateInit (&stream, (gint) Z_BEST_COMPRESSION);
+ _tmp0_ = g_new0 (guint8, data_length1);
+ out_data = _tmp0_;
+ out_data_length1 = data_length1;
+ _out_data_size_ = out_data_length1;
+ stream.next_in = data;
+ stream.avail_in = data_length1;
+ stream.next_out = out_data;
+ stream.avail_out = out_data_length1;
+ while (TRUE) {
+ gint _tmp1_;
+ if (!(stream.avail_in > ((guint) 0))) {
+ break;
+ }
+ _tmp1_ = deflate (&stream, (gint) Z_FINISH);
+ if (_tmp1_ == ((gint) Z_STREAM_ERROR)) {
+ break;
+ }
+ }
+ if (stream.avail_in > ((guint) 0)) {
+ guint8* _tmp2_;
+ _tmp2_ = NULL;
+ if (result_length1) {
+ *result_length1 = 0;
+ }
+ result = _tmp2_;
+ out_data = (g_free (out_data), NULL);
+ deflateEnd (&stream);
+ return result;
+ }
+ n_written = data_length1 - stream.avail_out;
+ _tmp3_ = (gint) n_written;
+ out_data = g_renew (guint8, out_data, (gint) n_written);
+ (_tmp3_ > out_data_length1) ? memset (out_data + out_data_length1, 0, sizeof (guint8) * (_tmp3_ - out_data_length1)) : NULL;
+ out_data_length1 = _tmp3_;
+ _out_data_size_ = _tmp3_;
+ _tmp4_ = out_data;
+ if (result_length1) {
+ *result_length1 = out_data_length1;
+ }
+ result = _tmp4_;
+ deflateEnd (&stream);
+ return result;
+}
+
+
+static void book_jpeg_init_cb (struct jpeg_compress_struct* info) {
+}
+
+
+static gboolean book_jpeg_empty_cb (struct jpeg_compress_struct* info) {
+ gboolean result = FALSE;
+ result = TRUE;
+ return result;
+}
+
+
+static void book_jpeg_term_cb (struct jpeg_compress_struct* info) {
+}
+
+
+static void _book_jpeg_init_cb_jpeg_initdestinationfunc (struct jpeg_compress_struct* cinfo) {
+ book_jpeg_init_cb (cinfo);
+}
+
+
+static gboolean _book_jpeg_empty_cb_jpeg_emptyoutputbufferfunc (struct jpeg_compress_struct* cinfo) {
+ gboolean result;
+ result = book_jpeg_empty_cb (cinfo);
+ return result;
+}
+
+
+static void _book_jpeg_term_cb_jpeg_termdestinationfunc (struct jpeg_compress_struct* cinfo) {
+ book_jpeg_term_cb (cinfo);
+}
+
+
+static guint8* book_compress_jpeg (Book* self, GdkPixbuf* image, gsize* n_written, int* result_length1) {
+ gsize _n_written = 0UL;
+ guint8* result = NULL;
+ struct jpeg_compress_struct info = {0};
+ struct jpeg_error_mgr jerr = {0};
+ struct jpeg_destination_mgr dest_mgr = {0};
+ struct jpeg_error_mgr* _tmp0_ = NULL;
+ gint _tmp1_;
+ gint _tmp2_;
+ gint max_length;
+ guint8* _tmp3_ = NULL;
+ guint8* data;
+ gint data_length1;
+ gint _data_size_;
+ guint8* _tmp4_ = NULL;
+ guint8* pixels;
+ gint pixels_length1;
+ gint _pixels_size_;
+ guint8* _tmp7_;
+ g_return_val_if_fail (self != NULL, NULL);
+ g_return_val_if_fail (image != NULL, NULL);
+ memset (&info, 0, sizeof (struct jpeg_compress_struct));
+ memset (&jerr, 0, sizeof (struct jpeg_error_mgr));
+ memset (&dest_mgr, 0, sizeof (struct jpeg_destination_mgr));
+ _tmp0_ = jpeg_std_error (&jerr);
+ info.err = _tmp0_;
+ jpeg_create_compress (&info);
+ _tmp1_ = gdk_pixbuf_get_width (image);
+ info.image_width = _tmp1_;
+ _tmp2_ = gdk_pixbuf_get_height (image);
+ info.image_height = _tmp2_;
+ info.input_components = 3;
+ info.in_color_space = JCS_RGB;
+ jpeg_set_defaults (&info);
+ max_length = (info.image_width * info.image_height) * info.input_components;
+ _tmp3_ = g_new0 (guint8, max_length);
+ data = _tmp3_;
+ data_length1 = max_length;
+ _data_size_ = data_length1;
+ dest_mgr.next_output_byte = data;
+ dest_mgr.free_in_buffer = max_length;
+ dest_mgr.init_destination = _book_jpeg_init_cb_jpeg_initdestinationfunc;
+ dest_mgr.empty_output_buffer = _book_jpeg_empty_cb_jpeg_emptyoutputbufferfunc;
+ dest_mgr.term_destination = _book_jpeg_term_cb_jpeg_termdestinationfunc;
+ info.dest = &dest_mgr;
+ jpeg_start_compress (&info, TRUE);
+ _tmp4_ = gdk_pixbuf_get_pixels (image);
+ pixels = _tmp4_;
+ pixels_length1 = -1;
+ _pixels_size_ = pixels_length1;
+ {
+ gint r;
+ r = 0;
+ {
+ gboolean _tmp5_;
+ _tmp5_ = TRUE;
+ while (TRUE) {
+ guint8* row[1] = {0};
+ gint _tmp6_;
+ if (!_tmp5_) {
+ r++;
+ }
+ _tmp5_ = FALSE;
+ if (!(r < info.image_height)) {
+ break;
+ }
+ _tmp6_ = gdk_pixbuf_get_rowstride (image);
+ row[0] = ((guint8*) pixels) + (r * _tmp6_);
+ jpeg_write_scanlines (&info, row, 1);
+ }
+ }
+ }
+ jpeg_finish_compress (&info);
+ _n_written = (gsize) (max_length - dest_mgr.free_in_buffer);
+ _tmp7_ = data;
+ if (result_length1) {
+ *result_length1 = data_length1;
+ }
+ result = _tmp7_;
+ jpeg_destroy_compress (&info);
+ if (n_written) {
+ *n_written = _n_written;
+ }
+ return result;
+}
+
+
+static guint8* _vala_array_dup1 (guint8* self, int length) {
+ return g_memdup (self, length * sizeof (guint8));
+}
+
+
+static guint8* _vala_array_dup2 (guint8* self, int length) {
+ return g_memdup (self, length * sizeof (guint8));
+}
+
+
+static void book_save_pdf (Book* self, GFile* file, GError** error) {
+ GFileOutputStream* _tmp0_ = NULL;
+ GFileOutputStream* stream;
+ PDFWriter* _tmp1_ = NULL;
+ PDFWriter* writer;
+ guint _tmp2_;
+ guint catalog_number;
+ gchar* _tmp3_ = NULL;
+ gchar* _tmp4_;
+ gchar* _tmp5_ = NULL;
+ gchar* _tmp6_;
+ guint _tmp7_;
+ guint pages_number;
+ gchar* _tmp8_ = NULL;
+ gchar* _tmp9_;
+ guint _tmp14_;
+ gchar* _tmp15_ = NULL;
+ gchar* _tmp16_;
+ guint _tmp100_;
+ guint info_number;
+ gchar* _tmp101_ = NULL;
+ gchar* _tmp102_;
+ gchar* _tmp103_ = NULL;
+ gchar* _tmp104_;
+ gsize xref_offset;
+ guint _tmp105_;
+ gchar* _tmp106_ = NULL;
+ gchar* _tmp107_;
+ guint _tmp110_;
+ gchar* _tmp111_ = NULL;
+ gchar* _tmp112_;
+ gchar* _tmp113_ = NULL;
+ gchar* _tmp114_;
+ gchar* _tmp115_ = NULL;
+ gchar* _tmp116_;
+ gchar* _tmp117_ = NULL;
+ gchar* _tmp118_;
+ GError * _inner_error_ = NULL;
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (file != NULL);
+ _tmp0_ = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &_inner_error_);
+ stream = _tmp0_;
+ if (_inner_error_ != NULL) {
+ g_propagate_error (error, _inner_error_);
+ return;
+ }
+ _tmp1_ = pdf_writer_new (stream);
+ writer = _tmp1_;
+ pdf_writer_write_string (writer, "%%PDF-1.3\n");
+ pdf_writer_write_string (writer, "%%\xe2\xe3\xcf\xd3\n");
+ _tmp2_ = pdf_writer_start_object (writer);
+ catalog_number = _tmp2_;
+ _tmp3_ = g_strdup_printf ("%u 0 obj\n", catalog_number);
+ _tmp4_ = _tmp3_;
+ pdf_writer_write_string (writer, _tmp4_);
+ _g_free0 (_tmp4_);
+ pdf_writer_write_string (writer, "<<\n");
+ pdf_writer_write_string (writer, "/Type /Catalog\n");
+ _tmp5_ = g_strdup_printf ("/Pages %u 0 R\n", catalog_number + 1);
+ _tmp6_ = _tmp5_;
+ pdf_writer_write_string (writer, _tmp6_);
+ _g_free0 (_tmp6_);
+ pdf_writer_write_string (writer, ">>\n");
+ pdf_writer_write_string (writer, "endobj\n");
+ pdf_writer_write_string (writer, "\n");
+ _tmp7_ = pdf_writer_start_object (writer);
+ pages_number = _tmp7_;
+ _tmp8_ = g_strdup_printf ("%u 0 obj\n", pages_number);
+ _tmp9_ = _tmp8_;
+ pdf_writer_write_string (writer, _tmp9_);
+ _g_free0 (_tmp9_);
+ pdf_writer_write_string (writer, "<<\n");
+ pdf_writer_write_string (writer, "/Type /Pages\n");
+ pdf_writer_write_string (writer, "/Kids [");
+ {
+ gint i;
+ i = 0;
+ {
+ gboolean _tmp10_;
+ _tmp10_ = TRUE;
+ while (TRUE) {
+ guint _tmp11_;
+ gchar* _tmp12_ = NULL;
+ gchar* _tmp13_;
+ if (!_tmp10_) {
+ i++;
+ }
+ _tmp10_ = FALSE;
+ _tmp11_ = book_get_n_pages (self);
+ if (!(((guint) i) < _tmp11_)) {
+ break;
+ }
+ _tmp12_ = g_strdup_printf (" %u 0 R", (pages_number + 1) + (i * 3));
+ _tmp13_ = _tmp12_;
+ pdf_writer_write_string (writer, _tmp13_);
+ _g_free0 (_tmp13_);
+ }
+ }
+ }
+ pdf_writer_write_string (writer, " ]\n");
+ _tmp14_ = book_get_n_pages (self);
+ _tmp15_ = g_strdup_printf ("/Count %u\n", _tmp14_);
+ _tmp16_ = _tmp15_;
+ pdf_writer_write_string (writer, _tmp16_);
+ _g_free0 (_tmp16_);
+ pdf_writer_write_string (writer, ">>\n");
+ pdf_writer_write_string (writer, "endobj\n");
+ {
+ gint i;
+ i = 0;
+ {
+ gboolean _tmp17_;
+ _tmp17_ = TRUE;
+ while (TRUE) {
+ guint _tmp18_;
+ Page* _tmp19_ = NULL;
+ Page* page;
+ GdkPixbuf* _tmp20_ = NULL;
+ GdkPixbuf* image;
+ gint _tmp21_;
+ gint width;
+ gint _tmp22_;
+ gint height;
+ guint8* _tmp23_ = NULL;
+ guint8* pixels;
+ gint pixels_length1;
+ gint _pixels_size_;
+ gint _tmp24_;
+ gdouble page_width;
+ gint _tmp25_;
+ gdouble page_height;
+ gint depth;
+ gchar* _tmp26_;
+ gchar* color_space;
+ gchar* filter;
+ gchar* _tmp27_ = NULL;
+ gchar* width_buffer;
+ gint width_buffer_length1;
+ gint _width_buffer_size_;
+ gchar* _tmp28_ = NULL;
+ gchar* height_buffer;
+ gint height_buffer_length1;
+ gint _height_buffer_size_;
+ guint8* data = NULL;
+ gint data_length1 = 0;
+ gint _data_size_ = 0;
+ gboolean _tmp29_;
+ gint _tmp52_;
+ guint8* _tmp53_ = NULL;
+ guint8* compressed_data;
+ gint compressed_data_length1;
+ gint _compressed_data_size_;
+ guint _tmp63_;
+ guint number;
+ gchar* _tmp64_ = NULL;
+ gchar* _tmp65_;
+ gchar* _tmp66_ = NULL;
+ gchar* _tmp67_;
+ gchar* _tmp68_ = NULL;
+ gchar* _tmp69_;
+ const gchar* _tmp70_ = NULL;
+ const gchar* _tmp71_ = NULL;
+ gchar* _tmp72_ = NULL;
+ gchar* _tmp73_;
+ gchar* _tmp74_ = NULL;
+ gchar* _tmp75_;
+ guint _tmp76_;
+ gchar* _tmp77_ = NULL;
+ gchar* _tmp78_;
+ gchar* _tmp79_ = NULL;
+ gchar* _tmp80_;
+ gchar* _tmp81_ = NULL;
+ gchar* _tmp82_;
+ gchar* _tmp83_ = NULL;
+ gchar* _tmp84_;
+ gchar* _tmp85_ = NULL;
+ gchar* _tmp86_;
+ gchar* _tmp87_ = NULL;
+ gchar* _tmp88_;
+ const gchar* _tmp91_ = NULL;
+ const gchar* _tmp92_ = NULL;
+ gchar* _tmp93_ = NULL;
+ gchar* command;
+ guint _tmp94_;
+ gchar* _tmp95_ = NULL;
+ gchar* _tmp96_;
+ gint _tmp97_;
+ gchar* _tmp98_ = NULL;
+ gchar* _tmp99_;
+ if (!_tmp17_) {
+ i++;
+ }
+ _tmp17_ = FALSE;
+ _tmp18_ = book_get_n_pages (self);
+ if (!(((guint) i) < _tmp18_)) {
+ break;
+ }
+ _tmp19_ = book_get_page (self, i);
+ page = _tmp19_;
+ _tmp20_ = page_get_image (page, TRUE);
+ image = _tmp20_;
+ _tmp21_ = gdk_pixbuf_get_width (image);
+ width = _tmp21_;
+ _tmp22_ = gdk_pixbuf_get_height (image);
+ height = _tmp22_;
+ _tmp23_ = gdk_pixbuf_get_pixels (image);
+ pixels = _tmp23_;
+ pixels_length1 = -1;
+ _pixels_size_ = pixels_length1;
+ _tmp24_ = page_get_dpi (page);
+ page_width = (width * 72.0) / _tmp24_;
+ _tmp25_ = page_get_dpi (page);
+ page_height = (height * 72.0) / _tmp25_;
+ depth = 8;
+ _tmp26_ = g_strdup ("DeviceRGB");
+ color_space = _tmp26_;
+ filter = NULL;
+ _tmp27_ = g_new0 (gchar, G_ASCII_DTOSTR_BUF_SIZE);
+ width_buffer = _tmp27_;
+ width_buffer_length1 = G_ASCII_DTOSTR_BUF_SIZE;
+ _width_buffer_size_ = width_buffer_length1;
+ _tmp28_ = g_new0 (gchar, G_ASCII_DTOSTR_BUF_SIZE);
+ height_buffer = _tmp28_;
+ height_buffer_length1 = G_ASCII_DTOSTR_BUF_SIZE;
+ _height_buffer_size_ = height_buffer_length1;
+ _tmp29_ = page_is_color (page);
+ if (_tmp29_) {
+ gchar* _tmp30_;
+ gint data_length;
+ guint8* _tmp31_ = NULL;
+ depth = 8;
+ _tmp30_ = g_strdup ("DeviceRGB");
+ _g_free0 (color_space);
+ color_space = _tmp30_;
+ data_length = ((height * width) * 3) + 1;
+ _tmp31_ = g_new0 (guint8, data_length);
+ data = (g_free (data), NULL);
+ data = _tmp31_;
+ data_length1 = data_length;
+ _data_size_ = data_length1;
+ {
+ gint row;
+ row = 0;
+ {
+ gboolean _tmp32_;
+ _tmp32_ = TRUE;
+ while (TRUE) {
+ gint _tmp33_;
+ gint in_offset;
+ gint out_offset;
+ if (!_tmp32_) {
+ row++;
+ }
+ _tmp32_ = FALSE;
+ if (!(row < height)) {
+ break;
+ }
+ _tmp33_ = gdk_pixbuf_get_rowstride (image);
+ in_offset = row * _tmp33_;
+ out_offset = (row * width) * 3;
+ {
+ gint x;
+ x = 0;
+ {
+ gboolean _tmp34_;
+ _tmp34_ = TRUE;
+ while (TRUE) {
+ gint in_o;
+ gint out_o;
+ if (!_tmp34_) {
+ x++;
+ }
+ _tmp34_ = FALSE;
+ if (!(x < width)) {
+ break;
+ }
+ in_o = in_offset + (x * 3);
+ out_o = out_offset + (x * 3);
+ data[out_o] = pixels[in_o];
+ data[out_o + 1] = pixels[in_o + 1];
+ data[out_o + 2] = pixels[in_o + 2];
+ }
+ }
+ }
+ }
+ }
+ }
+ } else {
+ gint _tmp35_;
+ _tmp35_ = page_get_depth (page);
+ if (_tmp35_ == 2) {
+ gint shift_count;
+ gchar* _tmp36_;
+ gint data_length;
+ guint8* _tmp37_ = NULL;
+ gint offset;
+ shift_count = 6;
+ depth = 2;
+ _tmp36_ = g_strdup ("DeviceGray");
+ _g_free0 (color_space);
+ color_space = _tmp36_;
+ data_length = height * (((width * 2) + 7) / 8);
+ _tmp37_ = g_new0 (guint8, data_length);
+ data = (g_free (data), NULL);
+ data = _tmp37_;
+ data_length1 = data_length;
+ _data_size_ = data_length1;
+ offset = 0;
+ data[offset] = (guint8) 0;
+ {
+ gint row;
+ row = 0;
+ {
+ gboolean _tmp38_;
+ _tmp38_ = TRUE;
+ while (TRUE) {
+ gint _tmp39_;
+ gint in_offset;
+ if (!_tmp38_) {
+ row++;
+ }
+ _tmp38_ = FALSE;
+ if (!(row < height)) {
+ break;
+ }
+ if (shift_count != 6) {
+ offset++;
+ data[offset] = (guint8) 0;
+ shift_count = 6;
+ }
+ _tmp39_ = gdk_pixbuf_get_rowstride (image);
+ in_offset = row * _tmp39_;
+ {
+ gint x;
+ x = 0;
+ {
+ gboolean _tmp40_;
+ _tmp40_ = TRUE;
+ while (TRUE) {
+ guint8 p;
+ if (!_tmp40_) {
+ x++;
+ }
+ _tmp40_ = FALSE;
+ if (!(x < width)) {
+ break;
+ }
+ p = pixels[in_offset + (x * 3)];
+ if (((gint) p) >= 192) {
+ data[offset] |= (guint8) (3 << shift_count);
+ } else {
+ if (((gint) p) >= 128) {
+ data[offset] |= (guint8) (2 << shift_count);
+ } else {
+ if (((gint) p) >= 64) {
+ data[offset] |= (guint8) (1 << shift_count);
+ }
+ }
+ }
+ if (shift_count == 0) {
+ offset++;
+ data[offset] = (guint8) 0;
+ shift_count = 6;
+ } else {
+ shift_count = shift_count - 2;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ } else {
+ gint _tmp41_;
+ _tmp41_ = page_get_depth (page);
+ if (_tmp41_ == 1) {
+ gint mask;
+ gchar* _tmp42_;
+ gint data_length;
+ guint8* _tmp43_ = NULL;
+ gint offset;
+ mask = 0x80;
+ depth = 1;
+ _tmp42_ = g_strdup ("DeviceGray");
+ _g_free0 (color_space);
+ color_space = _tmp42_;
+ data_length = height * ((width + 7) / 8);
+ _tmp43_ = g_new0 (guint8, data_length);
+ data = (g_free (data), NULL);
+ data = _tmp43_;
+ data_length1 = data_length;
+ _data_size_ = data_length1;
+ offset = 0;
+ data[offset] = (guint8) 0;
+ {
+ gint row;
+ row = 0;
+ {
+ gboolean _tmp44_;
+ _tmp44_ = TRUE;
+ while (TRUE) {
+ gint _tmp45_;
+ gint in_offset;
+ if (!_tmp44_) {
+ row++;
+ }
+ _tmp44_ = FALSE;
+ if (!(row < height)) {
+ break;
+ }
+ if (mask != 0x80) {
+ offset++;
+ data[offset] = (guint8) 0;
+ mask = 0x80;
+ }
+ _tmp45_ = gdk_pixbuf_get_rowstride (image);
+ in_offset = row * _tmp45_;
+ {
+ gint x;
+ x = 0;
+ {
+ gboolean _tmp46_;
+ _tmp46_ = TRUE;
+ while (TRUE) {
+ if (!_tmp46_) {
+ x++;
+ }
+ _tmp46_ = FALSE;
+ if (!(x < width)) {
+ break;
+ }
+ if (((gint) pixels[in_offset + (x * 3)]) != 0) {
+ data[offset] |= (guint8) mask;
+ }
+ mask = mask >> 1;
+ if (mask == 0) {
+ offset++;
+ data[offset] = (guint8) 0;
+ mask = 0x80;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ } else {
+ gchar* _tmp47_;
+ gint data_length;
+ guint8* _tmp48_ = NULL;
+ depth = 8;
+ _tmp47_ = g_strdup ("DeviceGray");
+ _g_free0 (color_space);
+ color_space = _tmp47_;
+ data_length = (height * width) + 1;
+ _tmp48_ = g_new0 (guint8, data_length);
+ data = (g_free (data), NULL);
+ data = _tmp48_;
+ data_length1 = data_length;
+ _data_size_ = data_length1;
+ {
+ gint row;
+ row = 0;
+ {
+ gboolean _tmp49_;
+ _tmp49_ = TRUE;
+ while (TRUE) {
+ gint _tmp50_;
+ gint in_offset;
+ gint out_offset;
+ if (!_tmp49_) {
+ row++;
+ }
+ _tmp49_ = FALSE;
+ if (!(row < height)) {
+ break;
+ }
+ _tmp50_ = gdk_pixbuf_get_rowstride (image);
+ in_offset = row * _tmp50_;
+ out_offset = row * width;
+ {
+ gint x;
+ x = 0;
+ {
+ gboolean _tmp51_;
+ _tmp51_ = TRUE;
+ while (TRUE) {
+ if (!_tmp51_) {
+ x++;
+ }
+ _tmp51_ = FALSE;
+ if (!(x < width)) {
+ break;
+ }
+ data[out_offset + x] = pixels[in_offset + (x * 3)];
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ _tmp53_ = book_compress_zlib (self, data, data_length1, &_tmp52_);
+ compressed_data = _tmp53_;
+ compressed_data_length1 = _tmp52_;
+ _compressed_data_size_ = compressed_data_length1;
+ if (compressed_data != NULL) {
+ if (depth > 1) {
+ gsize jpeg_length = 0UL;
+ gsize _tmp54_;
+ gint _tmp55_;
+ guint8* _tmp56_ = NULL;
+ guint8* jpeg_data;
+ gint jpeg_data_length1;
+ gint _jpeg_data_size_;
+ _tmp56_ = book_compress_jpeg (self, image, &_tmp54_, &_tmp55_);
+ jpeg_length = _tmp54_;
+ jpeg_data = _tmp56_;
+ jpeg_data_length1 = _tmp55_;
+ _jpeg_data_size_ = jpeg_data_length1;
+ if (jpeg_length < ((gsize) compressed_data_length1)) {
+ gchar* _tmp57_;
+ guint8* _tmp58_;
+ guint8* _tmp59_;
+ _tmp57_ = g_strdup ("DCTDecode");
+ _g_free0 (filter);
+ filter = _tmp57_;
+ _tmp59_ = (_tmp58_ = jpeg_data, (_tmp58_ == NULL) ? ((gpointer) _tmp58_) : _vala_array_dup1 (_tmp58_, jpeg_data_length1));
+ data = (g_free (data), NULL);
+ data = _tmp59_;
+ data_length1 = jpeg_data_length1;
+ _data_size_ = data_length1;
+ }
+ jpeg_data = (g_free (jpeg_data), NULL);
+ }
+ if (filter == NULL) {
+ gchar* _tmp60_;
+ guint8* _tmp61_;
+ guint8* _tmp62_;
+ _tmp60_ = g_strdup ("FlateDecode");
+ _g_free0 (filter);
+ filter = _tmp60_;
+ _tmp62_ = (_tmp61_ = compressed_data, (_tmp61_ == NULL) ? ((gpointer) _tmp61_) : _vala_array_dup2 (_tmp61_, compressed_data_length1));
+ data = (g_free (data), NULL);
+ data = _tmp62_;
+ data_length1 = compressed_data_length1;
+ _data_size_ = data_length1;
+ }
+ }
+ pdf_writer_write_string (writer, "\n");
+ _tmp63_ = pdf_writer_start_object (writer);
+ number = _tmp63_;
+ _tmp64_ = g_strdup_printf ("%u 0 obj\n", number);
+ _tmp65_ = _tmp64_;
+ pdf_writer_write_string (writer, _tmp65_);
+ _g_free0 (_tmp65_);
+ pdf_writer_write_string (writer, "<<\n");
+ pdf_writer_write_string (writer, "/Type /Page\n");
+ _tmp66_ = g_strdup_printf ("/Parent %u 0 R\n", pages_number);
+ _tmp67_ = _tmp66_;
+ pdf_writer_write_string (writer, _tmp67_);
+ _g_free0 (_tmp67_);
+ _tmp68_ = g_strdup_printf ("/Resources << /XObject << /Im%d %u 0 R >> >>\n", i, number + 1);
+ _tmp69_ = _tmp68_;
+ pdf_writer_write_string (writer, _tmp69_);
+ _g_free0 (_tmp69_);
+ _tmp70_ = g_ascii_formatd (width_buffer, width_buffer_length1, "%.2f", page_width);
+ _tmp71_ = g_ascii_formatd (height_buffer, height_buffer_length1, "%.2f", page_height);
+ _tmp72_ = g_strdup_printf ("/MediaBox [ 0 0 %s %s ]\n", _tmp70_, _tmp71_);
+ _tmp73_ = _tmp72_;
+ pdf_writer_write_string (writer, _tmp73_);
+ _g_free0 (_tmp73_);
+ _tmp74_ = g_strdup_printf ("/Contents %u 0 R\n", number + 2);
+ _tmp75_ = _tmp74_;
+ pdf_writer_write_string (writer, _tmp75_);
+ _g_free0 (_tmp75_);
+ pdf_writer_write_string (writer, ">>\n");
+ pdf_writer_write_string (writer, "endobj\n");
+ pdf_writer_write_string (writer, "\n");
+ _tmp76_ = pdf_writer_start_object (writer);
+ number = _tmp76_;
+ _tmp77_ = g_strdup_printf ("%u 0 obj\n", number);
+ _tmp78_ = _tmp77_;
+ pdf_writer_write_string (writer, _tmp78_);
+ _g_free0 (_tmp78_);
+ pdf_writer_write_string (writer, "<<\n");
+ pdf_writer_write_string (writer, "/Type /XObject\n");
+ pdf_writer_write_string (writer, "/Subtype /Image\n");
+ _tmp79_ = g_strdup_printf ("/Width %d\n", width);
+ _tmp80_ = _tmp79_;
+ pdf_writer_write_string (writer, _tmp80_);
+ _g_free0 (_tmp80_);
+ _tmp81_ = g_strdup_printf ("/Height %d\n", height);
+ _tmp82_ = _tmp81_;
+ pdf_writer_write_string (writer, _tmp82_);
+ _g_free0 (_tmp82_);
+ _tmp83_ = g_strdup_printf ("/ColorSpace /%s\n", color_space);
+ _tmp84_ = _tmp83_;
+ pdf_writer_write_string (writer, _tmp84_);
+ _g_free0 (_tmp84_);
+ _tmp85_ = g_strdup_printf ("/BitsPerComponent %d\n", depth);
+ _tmp86_ = _tmp85_;
+ pdf_writer_write_string (writer, _tmp86_);
+ _g_free0 (_tmp86_);
+ _tmp87_ = g_strdup_printf ("/Length %d\n", data_length1);
+ _tmp88_ = _tmp87_;
+ pdf_writer_write_string (writer, _tmp88_);
+ _g_free0 (_tmp88_);
+ if (filter != NULL) {
+ gchar* _tmp89_ = NULL;
+ gchar* _tmp90_;
+ _tmp89_ = g_strdup_printf ("/Filter /%s\n", filter);
+ _tmp90_ = _tmp89_;
+ pdf_writer_write_string (writer, _tmp90_);
+ _g_free0 (_tmp90_);
+ }
+ pdf_writer_write_string (writer, ">>\n");
+ pdf_writer_write_string (writer, "stream\n");
+ pdf_writer_write (writer, data, data_length1);
+ pdf_writer_write_string (writer, "\n");
+ pdf_writer_write_string (writer, "endstream\n");
+ pdf_writer_write_string (writer, "endobj\n");
+ _tmp91_ = g_ascii_formatd (width_buffer, width_buffer_length1, "%f", page_width);
+ _tmp92_ = g_ascii_formatd (height_buffer, height_buffer_length1, "%f", page_height);
+ _tmp93_ = g_strdup_printf ("q\n%s 0 0 %s 0 0 cm\n/Im%d Do\nQ", _tmp91_, _tmp92_, i);
+ command = _tmp93_;
+ pdf_writer_write_string (writer, "\n");
+ _tmp94_ = pdf_writer_start_object (writer);
+ number = _tmp94_;
+ _tmp95_ = g_strdup_printf ("%u 0 obj\n", number);
+ _tmp96_ = _tmp95_;
+ pdf_writer_write_string (writer, _tmp96_);
+ _g_free0 (_tmp96_);
+ pdf_writer_write_string (writer, "<<\n");
+ _tmp97_ = strlen (command);
+ _tmp98_ = g_strdup_printf ("/Length %d\n", _tmp97_ + 1);
+ _tmp99_ = _tmp98_;
+ pdf_writer_write_string (writer, _tmp99_);
+ _g_free0 (_tmp99_);
+ pdf_writer_write_string (writer, ">>\n");
+ pdf_writer_write_string (writer, "stream\n");
+ pdf_writer_write_string (writer, command);
+ pdf_writer_write_string (writer, "\n");
+ pdf_writer_write_string (writer, "endstream\n");
+ pdf_writer_write_string (writer, "endobj\n");
+ _g_free0 (command);
+ compressed_data = (g_free (compressed_data), NULL);
+ data = (g_free (data), NULL);
+ height_buffer = (g_free (height_buffer), NULL);
+ width_buffer = (g_free (width_buffer), NULL);
+ _g_free0 (filter);
+ _g_free0 (color_space);
+ _g_object_unref0 (image);
+ _page_unref0 (page);
+ }
+ }
+ }
+ pdf_writer_write_string (writer, "\n");
+ _tmp100_ = pdf_writer_start_object (writer);
+ info_number = _tmp100_;
+ _tmp101_ = g_strdup_printf ("%u 0 obj\n", info_number);
+ _tmp102_ = _tmp101_;
+ pdf_writer_write_string (writer, _tmp102_);
+ _g_free0 (_tmp102_);
+ pdf_writer_write_string (writer, "<<\n");
+ _tmp103_ = g_strdup_printf ("/Creator (Simple Scan %s)\n", VERSION);
+ _tmp104_ = _tmp103_;
+ pdf_writer_write_string (writer, _tmp104_);
+ _g_free0 (_tmp104_);
+ pdf_writer_write_string (writer, ">>\n");
+ pdf_writer_write_string (writer, "endobj\n");
+ xref_offset = writer->offset;
+ pdf_writer_write_string (writer, "xref\n");
+ _tmp105_ = g_list_length (writer->object_offsets);
+ _tmp106_ = g_strdup_printf ("1 %zu\n", (gsize) _tmp105_);
+ _tmp107_ = _tmp106_;
+ pdf_writer_write_string (writer, _tmp107_);
+ _g_free0 (_tmp107_);
+ {
+ GList* offset_collection = NULL;
+ GList* offset_it = NULL;
+ offset_collection = writer->object_offsets;
+ for (offset_it = offset_collection; offset_it != NULL; offset_it = offset_it->next) {
+ guint offset = 0U;
+ offset = GPOINTER_TO_UINT (offset_it->data);
+ {
+ gchar* _tmp108_ = NULL;
+ gchar* _tmp109_;
+ _tmp108_ = g_strdup_printf ("%010zu 0000 n\n", (gsize) offset);
+ _tmp109_ = _tmp108_;
+ pdf_writer_write_string (writer, _tmp109_);
+ _g_free0 (_tmp109_);
+ }
+ }
+ }
+ pdf_writer_write_string (writer, "trailer\n");
+ pdf_writer_write_string (writer, "<<\n");
+ _tmp110_ = g_list_length (writer->object_offsets);
+ _tmp111_ = g_strdup_printf ("/Size %zu\n", (gsize) _tmp110_);
+ _tmp112_ = _tmp111_;
+ pdf_writer_write_string (writer, _tmp112_);
+ _g_free0 (_tmp112_);
+ _tmp113_ = g_strdup_printf ("/Info %u 0 R\n", info_number);
+ _tmp114_ = _tmp113_;
+ pdf_writer_write_string (writer, _tmp114_);
+ _g_free0 (_tmp114_);
+ _tmp115_ = g_strdup_printf ("/Root %u 0 R\n", catalog_number);
+ _tmp116_ = _tmp115_;
+ pdf_writer_write_string (writer, _tmp116_);
+ _g_free0 (_tmp116_);
+ pdf_writer_write_string (writer, ">>\n");
+ pdf_writer_write_string (writer, "startxref\n");
+ _tmp117_ = g_strdup_printf ("%zu\n", xref_offset);
+ _tmp118_ = _tmp117_;
+ pdf_writer_write_string (writer, _tmp118_);
+ _g_free0 (_tmp118_);
+ pdf_writer_write_string (writer, "%%%%EOF\n");
+ _pdf_writer_unref0 (writer);
+ _g_object_unref0 (stream);
+}
+
+
+void book_save (Book* self, const gchar* type, GFile* file, GError** error) {
+ gint _tmp0_;
+ GError * _inner_error_ = NULL;
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (type != NULL);
+ g_return_if_fail (file != NULL);
+ _tmp0_ = g_strcmp0 (type, "jpeg");
+ if (_tmp0_ == 0) {
+ book_save_multi_file (self, "jpeg", file, &_inner_error_);
+ if (_inner_error_ != NULL) {
+ g_propagate_error (error, _inner_error_);
+ return;
+ }
+ } else {
+ gint _tmp1_;
+ _tmp1_ = g_strcmp0 (type, "png");
+ if (_tmp1_ == 0) {
+ book_save_multi_file (self, "png", file, &_inner_error_);
+ if (_inner_error_ != NULL) {
+ g_propagate_error (error, _inner_error_);
+ return;
+ }
+ } else {
+ gint _tmp2_;
+ _tmp2_ = g_strcmp0 (type, "tiff");
+ if (_tmp2_ == 0) {
+ book_save_multi_file (self, "tiff", file, &_inner_error_);
+ if (_inner_error_ != NULL) {
+ g_propagate_error (error, _inner_error_);
+ return;
+ }
+ } else {
+ gint _tmp3_;
+ _tmp3_ = g_strcmp0 (type, "ps");
+ if (_tmp3_ == 0) {
+ book_save_ps (self, file, &_inner_error_);
+ if (_inner_error_ != NULL) {
+ g_propagate_error (error, _inner_error_);
+ return;
+ }
+ } else {
+ gint _tmp4_;
+ _tmp4_ = g_strcmp0 (type, "pdf");
+ if (_tmp4_ == 0) {
+ book_save_pdf (self, file, &_inner_error_);
+ if (_inner_error_ != NULL) {
+ g_propagate_error (error, _inner_error_);
+ return;
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+
+void book_set_needs_saving (Book* self, gboolean needs_saving) {
+ gboolean needed_saving;
+ g_return_if_fail (self != NULL);
+ needed_saving = self->priv->needs_saving;
+ self->priv->needs_saving = needs_saving;
+ if (needed_saving != needs_saving) {
+ g_signal_emit_by_name (self, "needs-saving-changed");
+ }
+}
+
+
+gboolean book_get_needs_saving (Book* self) {
+ gboolean result = FALSE;
+ g_return_val_if_fail (self != NULL, FALSE);
+ result = self->priv->needs_saving;
+ return result;
+}
+
+
+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) {
+ typedef void (*GMarshalFunc_VOID__PAGE) (gpointer data1, gpointer arg_1, gpointer data2);
+ register GMarshalFunc_VOID__PAGE callback;
+ register GCClosure * cc;
+ register gpointer data1;
+ register gpointer data2;
+ cc = (GCClosure *) closure;
+ g_return_if_fail (n_param_values == 2);
+ if (G_CCLOSURE_SWAP_DATA (closure)) {
+ data1 = closure->data;
+ data2 = param_values->data[0].v_pointer;
+ } else {
+ data1 = param_values->data[0].v_pointer;
+ data2 = closure->data;
+ }
+ callback = (GMarshalFunc_VOID__PAGE) (marshal_data ? marshal_data : cc->callback);
+ callback (data1, value_get_page (param_values + 1), data2);
+}
+
+
+static void value_book_init (GValue* value) {
+ value->data[0].v_pointer = NULL;
+}
+
+
+static void value_book_free_value (GValue* value) {
+ if (value->data[0].v_pointer) {
+ book_unref (value->data[0].v_pointer);
+ }
+}
+
+
+static void value_book_copy_value (const GValue* src_value, GValue* dest_value) {
+ if (src_value->data[0].v_pointer) {
+ dest_value->data[0].v_pointer = book_ref (src_value->data[0].v_pointer);
+ } else {
+ dest_value->data[0].v_pointer = NULL;
+ }
+}
+
+
+static gpointer value_book_peek_pointer (const GValue* value) {
+ return value->data[0].v_pointer;
+}
+
+
+static gchar* value_book_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
+ if (collect_values[0].v_pointer) {
+ Book* object;
+ object = collect_values[0].v_pointer;
+ if (object->parent_instance.g_class == NULL) {
+ return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
+ } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
+ return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
+ }
+ value->data[0].v_pointer = book_ref (object);
+ } else {
+ value->data[0].v_pointer = NULL;
+ }
+ return NULL;
+}
+
+
+static gchar* value_book_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
+ Book** object_p;
+ object_p = collect_values[0].v_pointer;
+ if (!object_p) {
+ return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+ }
+ if (!value->data[0].v_pointer) {
+ *object_p = NULL;
+ } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
+ *object_p = value->data[0].v_pointer;
+ } else {
+ *object_p = book_ref (value->data[0].v_pointer);
+ }
+ return NULL;
+}
+
+
+GParamSpec* param_spec_book (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
+ ParamSpecBook* spec;
+ g_return_val_if_fail (g_type_is_a (object_type, TYPE_BOOK), NULL);
+ spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
+ G_PARAM_SPEC (spec)->value_type = object_type;
+ return G_PARAM_SPEC (spec);
+}
+
+
+gpointer value_get_book (const GValue* value) {
+ g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BOOK), NULL);
+ return value->data[0].v_pointer;
+}
+
+
+void value_set_book (GValue* value, gpointer v_object) {
+ Book* old;
+ g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BOOK));
+ old = value->data[0].v_pointer;
+ if (v_object) {
+ g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_BOOK));
+ g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
+ value->data[0].v_pointer = v_object;
+ book_ref (value->data[0].v_pointer);
+ } else {
+ value->data[0].v_pointer = NULL;
+ }
+ if (old) {
+ book_unref (old);
+ }
+}
-Book *
-book_new ()
-{
- return g_object_new (BOOK_TYPE, NULL);
+void value_take_book (GValue* value, gpointer v_object) {
+ Book* old;
+ g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BOOK));
+ old = value->data[0].v_pointer;
+ if (v_object) {
+ g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_BOOK));
+ g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
+ value->data[0].v_pointer = v_object;
+ } else {
+ value->data[0].v_pointer = NULL;
+ }
+ if (old) {
+ book_unref (old);
+ }
}
-void
-book_clear (Book *book)
-{
- GList *iter;
- for (iter = book->priv->pages; iter; iter = iter->next) {
- Page *page = iter->data;
- g_object_unref (page);
- }
- g_list_free (book->priv->pages);
- book->priv->pages = NULL;
- g_signal_emit (book, signals[CLEARED], 0);
+static void book_class_init (BookClass * klass) {
+ book_parent_class = g_type_class_peek_parent (klass);
+ BOOK_CLASS (klass)->finalize = book_finalize;
+ g_type_class_add_private (klass, sizeof (BookPrivate));
+ 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);
+ 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);
+ g_signal_new ("reordered", TYPE_BOOK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+ g_signal_new ("cleared", TYPE_BOOK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+ g_signal_new ("needs_saving_changed", TYPE_BOOK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
}
-static void
-page_changed_cb (Page *page, Book *book)
-{
- book_set_needs_saving (book, TRUE);
+static void book_instance_init (Book * self) {
+ self->priv = BOOK_GET_PRIVATE (self);
+ self->ref_count = 1;
}
-Page *
-book_append_page (Book *book, gint width, gint height, gint dpi, ScanDirection scan_direction)
-{
- Page *page;
+static void book_finalize (Book* obj) {
+ Book * self;
+ self = BOOK (obj);
+ __g_list_free__page_unref0_0 (self->priv->pages);
+}
- page = page_new (width, height, dpi, scan_direction);
- g_signal_connect (page, "pixels-changed", G_CALLBACK (page_changed_cb), book);
- g_signal_connect (page, "crop-changed", G_CALLBACK (page_changed_cb), book);
- book->priv->pages = g_list_append (book->priv->pages, page);
+GType book_get_type (void) {
+ static volatile gsize book_type_id__volatile = 0;
+ if (g_once_init_enter (&book_type_id__volatile)) {
+ 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 };
+ 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 };
+ 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) };
+ GType book_type_id;
+ book_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Book", &g_define_type_info, &g_define_type_fundamental_info, 0);
+ g_once_init_leave (&book_type_id__volatile, book_type_id);
+ }
+ return book_type_id__volatile;
+}
- g_signal_emit (book, signals[PAGE_ADDED], 0, page);
-
- book_set_needs_saving (book, TRUE);
- return page;
+gpointer book_ref (gpointer instance) {
+ Book* self;
+ self = instance;
+ g_atomic_int_inc (&self->ref_count);
+ return instance;
}
-void
-book_move_page (Book *book, Page *page, gint location)
-{
- book->priv->pages = g_list_remove (book->priv->pages, page);
- book->priv->pages = g_list_insert (book->priv->pages, page, location);
+void book_unref (gpointer instance) {
+ Book* self;
+ self = instance;
+ if (g_atomic_int_dec_and_test (&self->ref_count)) {
+ BOOK_GET_CLASS (self)->finalize (self);
+ g_type_free_instance ((GTypeInstance *) self);
+ }
+}
- g_signal_emit (book, signals[REORDERED], 0, page);
- book_set_needs_saving (book, TRUE);
+static gpointer _g_object_ref0 (gpointer self) {
+ return self ? g_object_ref (self) : NULL;
}
-void
-book_delete_page (Book *book, Page *page)
-{
- g_signal_handlers_disconnect_by_func (page, page_changed_cb, book);
+PDFWriter* pdf_writer_construct (GType object_type, GFileOutputStream* stream) {
+ PDFWriter* self = NULL;
+ GFileOutputStream* _tmp0_;
+ g_return_val_if_fail (stream != NULL, NULL);
+ self = (PDFWriter*) g_type_create_instance (object_type);
+ _tmp0_ = _g_object_ref0 (stream);
+ _g_object_unref0 (self->priv->stream);
+ self->priv->stream = _tmp0_;
+ return self;
+}
- g_signal_emit (book, signals[PAGE_REMOVED], 0, page);
- book->priv->pages = g_list_remove (book->priv->pages, page);
- g_object_unref (page);
+PDFWriter* pdf_writer_new (GFileOutputStream* stream) {
+ return pdf_writer_construct (TYPE_PDF_WRITER, stream);
+}
+
- book_set_needs_saving (book, TRUE);
+void pdf_writer_write (PDFWriter* self, guint8* data, int data_length1) {
+ GError * _inner_error_ = NULL;
+ g_return_if_fail (self != NULL);
+ {
+ g_output_stream_write_all ((GOutputStream*) self->priv->stream, data, (gsize) data_length1, NULL, NULL, &_inner_error_);
+ if (_inner_error_ != NULL) {
+ goto __catch0_g_error;
+ }
+ }
+ goto __finally0;
+ __catch0_g_error:
+ {
+ GError* e = NULL;
+ e = _inner_error_;
+ _inner_error_ = NULL;
+ g_warning ("book.vala:529: Error writing PDF: %s", e->message);
+ _g_error_free0 (e);
+ }
+ __finally0:
+ if (_inner_error_ != NULL) {
+ 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);
+ g_clear_error (&_inner_error_);
+ return;
+ }
+ self->offset = self->offset + data_length1;
}
-gint
-book_get_n_pages (Book *book)
-{
- return g_list_length (book->priv->pages);
+static gchar* string_to_utf8 (const gchar* self, int* result_length1) {
+ gchar* result = NULL;
+ gint _tmp0_;
+ gchar* _tmp1_ = NULL;
+ gchar* _result_;
+ gint _result__length1;
+ gint __result__size_;
+ gint _tmp2_;
+ gchar* _tmp3_;
+ g_return_val_if_fail (self != NULL, NULL);
+ _tmp0_ = strlen (self);
+ _tmp1_ = g_new0 (gchar, _tmp0_ + 1);
+ _result_ = _tmp1_;
+ _result__length1 = _tmp0_ + 1;
+ __result__size_ = _result__length1;
+ _result__length1--;
+ _tmp2_ = strlen (self);
+ memcpy (_result_, self, (gsize) _tmp2_);
+ _tmp3_ = _result_;
+ if (result_length1) {
+ *result_length1 = _result__length1;
+ }
+ result = _tmp3_;
+ return result;
}
-Page *
-book_get_page (Book *book, gint page_number)
-{
- if (page_number < 0)
- page_number = g_list_length (book->priv->pages) + page_number;
- return g_list_nth_data (book->priv->pages, page_number);
+void pdf_writer_write_string (PDFWriter* self, const gchar* text) {
+ gint _tmp0_;
+ gchar* _tmp1_ = NULL;
+ guint8* _tmp2_;
+ gint _tmp2__length1;
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (text != NULL);
+ _tmp1_ = string_to_utf8 (text, &_tmp0_);
+ _tmp2_ = (guint8*) _tmp1_;
+ _tmp2__length1 = _tmp0_;
+ pdf_writer_write (self, _tmp2_, _tmp0_);
+ _tmp2_ = (g_free (_tmp2_), NULL);
}
-gint
-book_get_page_index (Book *book, Page *page)
-{
- return g_list_index (book->priv->pages, page);
+guint pdf_writer_start_object (PDFWriter* self) {
+ guint result = 0U;
+ guint _tmp0_;
+ g_return_val_if_fail (self != NULL, 0U);
+ self->object_offsets = g_list_append (self->object_offsets, GUINT_TO_POINTER ((guint) self->offset));
+ _tmp0_ = g_list_length (self->object_offsets);
+ result = _tmp0_;
+ return result;
}
-static GFile *
-make_indexed_file (const gchar *uri, gint i)
-{
- gchar *basename, *suffix, *indexed_uri;
- GFile *file;
+static void value_pdf_writer_init (GValue* value) {
+ value->data[0].v_pointer = NULL;
+}
+
- if (i == 0)
- return g_file_new_for_uri (uri);
+static void value_pdf_writer_free_value (GValue* value) {
+ if (value->data[0].v_pointer) {
+ pdf_writer_unref (value->data[0].v_pointer);
+ }
+}
- basename = g_path_get_basename (uri);
- suffix = g_strrstr (basename, ".");
- if (suffix)
- indexed_uri = g_strdup_printf ("%.*s-%d%s", (int) (strlen (uri) - strlen (suffix)), uri, i, suffix);
- else
- indexed_uri = g_strdup_printf ("%s-%d", uri, i);
- g_free (basename);
+static void value_pdf_writer_copy_value (const GValue* src_value, GValue* dest_value) {
+ if (src_value->data[0].v_pointer) {
+ dest_value->data[0].v_pointer = pdf_writer_ref (src_value->data[0].v_pointer);
+ } else {
+ dest_value->data[0].v_pointer = NULL;
+ }
+}
- file = g_file_new_for_uri (indexed_uri);
- g_free (indexed_uri);
- return file;
+static gpointer value_pdf_writer_peek_pointer (const GValue* value) {
+ return value->data[0].v_pointer;
}
-static gboolean
-book_save_multi_file (Book *book, const gchar *type, GFile *file, GError **error)
-{
- GList *iter;
- gboolean result = TRUE;
- gint i;
- gchar *uri;
+static gchar* value_pdf_writer_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
+ if (collect_values[0].v_pointer) {
+ PDFWriter* object;
+ object = collect_values[0].v_pointer;
+ if (object->parent_instance.g_class == NULL) {
+ return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
+ } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
+ return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
+ }
+ value->data[0].v_pointer = pdf_writer_ref (object);
+ } else {
+ value->data[0].v_pointer = NULL;
+ }
+ return NULL;
+}
- uri = g_file_get_uri (file);
- for (iter = book->priv->pages, i = 0; iter && result; iter = iter->next, i++) {
- Page *page = iter->data;
- GFile *file;
- file = make_indexed_file (uri, i);
- result = page_save (page, type, file, error);
- g_object_unref (file);
- }
- g_free (uri);
-
- return result;
+static gchar* value_pdf_writer_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
+ PDFWriter** object_p;
+ object_p = collect_values[0].v_pointer;
+ if (!object_p) {
+ return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+ }
+ if (!value->data[0].v_pointer) {
+ *object_p = NULL;
+ } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
+ *object_p = value->data[0].v_pointer;
+ } else {
+ *object_p = pdf_writer_ref (value->data[0].v_pointer);
+ }
+ return NULL;
}
-static void
-save_ps_pdf_surface (cairo_surface_t *surface, GdkPixbuf *image, gdouble dpi)
-{
- cairo_t *context;
-
- context = cairo_create (surface);
+GParamSpec* param_spec_pdf_writer (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
+ ParamSpecPDFWriter* spec;
+ g_return_val_if_fail (g_type_is_a (object_type, TYPE_PDF_WRITER), NULL);
+ spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
+ G_PARAM_SPEC (spec)->value_type = object_type;
+ return G_PARAM_SPEC (spec);
+}
- cairo_scale (context, 72.0 / dpi, 72.0 / dpi);
- gdk_cairo_set_source_pixbuf (context, image, 0, 0);
- cairo_pattern_set_filter (cairo_get_source (context), CAIRO_FILTER_BEST);
- cairo_paint (context);
- cairo_destroy (context);
+gpointer value_get_pdf_writer (const GValue* value) {
+ g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_PDF_WRITER), NULL);
+ return value->data[0].v_pointer;
}
-static cairo_status_t
-write_cairo_data (GFileOutputStream *stream, unsigned char *data, unsigned int length)
-{
- gboolean result;
- GError *error = NULL;
+void value_set_pdf_writer (GValue* value, gpointer v_object) {
+ PDFWriter* old;
+ g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_PDF_WRITER));
+ old = value->data[0].v_pointer;
+ if (v_object) {
+ g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_PDF_WRITER));
+ g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
+ value->data[0].v_pointer = v_object;
+ pdf_writer_ref (value->data[0].v_pointer);
+ } else {
+ value->data[0].v_pointer = NULL;
+ }
+ if (old) {
+ pdf_writer_unref (old);
+ }
+}
- result = g_output_stream_write_all (G_OUTPUT_STREAM (stream), data, length, NULL, NULL, &error);
-
- if (error) {
- g_warning ("Error writing data: %s", error->message);
- g_error_free (error);
- }
- return result ? CAIRO_STATUS_SUCCESS : CAIRO_STATUS_WRITE_ERROR;
+void value_take_pdf_writer (GValue* value, gpointer v_object) {
+ PDFWriter* old;
+ g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_PDF_WRITER));
+ old = value->data[0].v_pointer;
+ if (v_object) {
+ g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_PDF_WRITER));
+ g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
+ value->data[0].v_pointer = v_object;
+ } else {
+ value->data[0].v_pointer = NULL;
+ }
+ if (old) {
+ pdf_writer_unref (old);
+ }
}
-static gboolean
-book_save_ps (Book *book, GFile *file, GError **error)
-{
- GFileOutputStream *stream;
- GList *iter;
- cairo_surface_t *surface;
+static void pdf_writer_class_init (PDFWriterClass * klass) {
+ pdf_writer_parent_class = g_type_class_peek_parent (klass);
+ PDF_WRITER_CLASS (klass)->finalize = pdf_writer_finalize;
+ g_type_class_add_private (klass, sizeof (PDFWriterPrivate));
+}
- stream = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, error);
- if (!stream)
- return FALSE;
- surface = cairo_ps_surface_create_for_stream ((cairo_write_func_t) write_cairo_data,
- stream, 0, 0);
+static void pdf_writer_instance_init (PDFWriter * self) {
+ self->priv = PDF_WRITER_GET_PRIVATE (self);
+ self->offset = (gsize) 0;
+ self->ref_count = 1;
+}
- for (iter = book->priv->pages; iter; iter = iter->next) {
- Page *page = iter->data;
- double width, height;
- GdkPixbuf *image;
- image = page_get_image (page, TRUE);
+static void pdf_writer_finalize (PDFWriter* obj) {
+ PDFWriter * self;
+ self = PDF_WRITER (obj);
+ _g_list_free0 (self->object_offsets);
+ _g_object_unref0 (self->priv->stream);
+}
- width = gdk_pixbuf_get_width (image) * 72.0 / page_get_dpi (page);
- height = gdk_pixbuf_get_height (image) * 72.0 / page_get_dpi (page);
- cairo_ps_surface_set_size (surface, width, height);
- save_ps_pdf_surface (surface, image, page_get_dpi (page));
- cairo_surface_show_page (surface);
-
- g_object_unref (image);
- }
- cairo_surface_destroy (surface);
+GType pdf_writer_get_type (void) {
+ static volatile gsize pdf_writer_type_id__volatile = 0;
+ if (g_once_init_enter (&pdf_writer_type_id__volatile)) {
+ 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 };
+ 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 };
+ 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) };
+ GType pdf_writer_type_id;
+ pdf_writer_type_id = g_type_register_fundamental (g_type_fundamental_next (), "PDFWriter", &g_define_type_info, &g_define_type_fundamental_info, 0);
+ g_once_init_leave (&pdf_writer_type_id__volatile, pdf_writer_type_id);
+ }
+ return pdf_writer_type_id__volatile;
+}
- g_object_unref (stream);
- return TRUE;
+gpointer pdf_writer_ref (gpointer instance) {
+ PDFWriter* self;
+ self = instance;
+ g_atomic_int_inc (&self->ref_count);
+ return instance;
}
-typedef struct
-{
- int offset;
- int n_objects;
- GList *object_offsets;
- GFileOutputStream *stream;
-} PDFWriter;
+void pdf_writer_unref (gpointer instance) {
+ PDFWriter* self;
+ self = instance;
+ if (g_atomic_int_dec_and_test (&self->ref_count)) {
+ PDF_WRITER_GET_CLASS (self)->finalize (self);
+ g_type_free_instance ((GTypeInstance *) self);
+ }
+}
-static PDFWriter *
-pdf_writer_new (GFileOutputStream *stream)
-{
- PDFWriter *writer;
- writer = g_malloc0 (sizeof (PDFWriter));
- writer->stream = g_object_ref (stream);
- return writer;
+static cairo_status_t _ps_writer_write_cairo_data_cairo_write_func_t (gpointer self, guchar* data, int data_length1) {
+ cairo_status_t result;
+ result = ps_writer_write_cairo_data (self, data, data_length1);
+ return result;
}
-static void
-pdf_writer_free (PDFWriter *writer)
-{
- g_object_unref (writer->stream);
- g_list_free (writer->object_offsets);
- g_free (writer);
+PsWriter* ps_writer_construct (GType object_type, GFileOutputStream* stream) {
+ PsWriter* self = NULL;
+ GFileOutputStream* _tmp0_;
+ cairo_surface_t* _tmp1_ = NULL;
+ g_return_val_if_fail (stream != NULL, NULL);
+ self = (PsWriter*) g_type_create_instance (object_type);
+ _tmp0_ = _g_object_ref0 (stream);
+ _g_object_unref0 (self->stream);
+ self->stream = _tmp0_;
+ _tmp1_ = cairo_ps_surface_create_for_stream (_ps_writer_write_cairo_data_cairo_write_func_t, self, (gdouble) 0, (gdouble) 0);
+ _cairo_surface_destroy0 (self->surface);
+ self->surface = _tmp1_;
+ return self;
}
-static void
-pdf_write (PDFWriter *writer, const unsigned char *data, size_t length)
-{
- g_output_stream_write_all (G_OUTPUT_STREAM (writer->stream), data, length, NULL, NULL, NULL);
- writer->offset += length;
+PsWriter* ps_writer_new (GFileOutputStream* stream) {
+ return ps_writer_construct (TYPE_PS_WRITER, stream);
}
-static void
-pdf_printf (PDFWriter *writer, const char *format, ...)
-{
- va_list args;
- gchar *string;
+static cairo_status_t ps_writer_write_cairo_data (PsWriter* self, guint8* data, int data_length1) {
+ cairo_status_t result = 0;
+ GError * _inner_error_ = NULL;
+ g_return_val_if_fail (self != NULL, 0);
+ {
+ g_output_stream_write_all ((GOutputStream*) self->stream, data, (gsize) data_length1, NULL, NULL, &_inner_error_);
+ if (_inner_error_ != NULL) {
+ goto __catch1_g_error;
+ }
+ }
+ goto __finally1;
+ __catch1_g_error:
+ {
+ GError* e = NULL;
+ e = _inner_error_;
+ _inner_error_ = NULL;
+ g_warning ("book.vala:565: Error writing data: %s", e->message);
+ result = CAIRO_STATUS_WRITE_ERROR;
+ _g_error_free0 (e);
+ return result;
+ }
+ __finally1:
+ if (_inner_error_ != NULL) {
+ 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);
+ g_clear_error (&_inner_error_);
+ return 0;
+ }
+ result = CAIRO_STATUS_SUCCESS;
+ return result;
+}
- va_start (args, format);
- string = g_strdup_vprintf (format, args);
- va_end (args);
- pdf_write (writer, (unsigned char *)string, strlen (string));
- g_free (string);
+static void value_ps_writer_init (GValue* value) {
+ value->data[0].v_pointer = NULL;
}
-static int
-pdf_start_object (PDFWriter *writer)
-{
- writer->n_objects++;
- writer->object_offsets = g_list_append (writer->object_offsets, GINT_TO_POINTER (writer->offset));
- return writer->n_objects;
+static void value_ps_writer_free_value (GValue* value) {
+ if (value->data[0].v_pointer) {
+ ps_writer_unref (value->data[0].v_pointer);
+ }
}
-static guchar *
-compress_zlib (guchar *data, size_t length, size_t *n_written)
-{
- z_stream stream;
- guchar *out_data;
+static void value_ps_writer_copy_value (const GValue* src_value, GValue* dest_value) {
+ if (src_value->data[0].v_pointer) {
+ dest_value->data[0].v_pointer = ps_writer_ref (src_value->data[0].v_pointer);
+ } else {
+ dest_value->data[0].v_pointer = NULL;
+ }
+}
- out_data = g_malloc (sizeof (guchar) * length);
- stream.zalloc = Z_NULL;
- stream.zfree = Z_NULL;
- stream.opaque = Z_NULL;
- if (deflateInit (&stream, Z_BEST_COMPRESSION) != Z_OK)
- return NULL;
+static gpointer value_ps_writer_peek_pointer (const GValue* value) {
+ return value->data[0].v_pointer;
+}
- stream.next_in = data;
- stream.avail_in = length;
- stream.next_out = out_data;
- stream.avail_out = length;
- while (stream.avail_in > 0) {
- if (deflate (&stream, Z_FINISH) == Z_STREAM_ERROR)
- break;
- }
- deflateEnd (&stream);
+static gchar* value_ps_writer_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
+ if (collect_values[0].v_pointer) {
+ PsWriter* object;
+ object = collect_values[0].v_pointer;
+ if (object->parent_instance.g_class == NULL) {
+ return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
+ } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
+ return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
+ }
+ value->data[0].v_pointer = ps_writer_ref (object);
+ } else {
+ value->data[0].v_pointer = NULL;
+ }
+ return NULL;
+}
+
- if (stream.avail_in > 0) {
- g_free (out_data);
- return NULL;
- }
+static gchar* value_ps_writer_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
+ PsWriter** object_p;
+ object_p = collect_values[0].v_pointer;
+ if (!object_p) {
+ return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+ }
+ if (!value->data[0].v_pointer) {
+ *object_p = NULL;
+ } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
+ *object_p = value->data[0].v_pointer;
+ } else {
+ *object_p = ps_writer_ref (value->data[0].v_pointer);
+ }
+ return NULL;
+}
- *n_written = length - stream.avail_out;
- return out_data;
+GParamSpec* param_spec_ps_writer (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
+ ParamSpecPsWriter* spec;
+ g_return_val_if_fail (g_type_is_a (object_type, TYPE_PS_WRITER), NULL);
+ spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
+ G_PARAM_SPEC (spec)->value_type = object_type;
+ return G_PARAM_SPEC (spec);
}
-
-
-static void jpeg_init_cb (struct jpeg_compress_struct *info) {}
-static boolean jpeg_empty_cb (struct jpeg_compress_struct *info) { return TRUE; }
-static void jpeg_term_cb (struct jpeg_compress_struct *info) {}
-
-static guchar *
-compress_jpeg (GdkPixbuf *image, size_t *n_written)
-{
- struct jpeg_compress_struct info;
- struct jpeg_error_mgr jerr;
- struct jpeg_destination_mgr dest_mgr;
- int r;
- guchar *pixels;
- guchar *data;
- size_t max_length;
-
- info.err = jpeg_std_error (&jerr);
- jpeg_create_compress (&info);
-
- pixels = gdk_pixbuf_get_pixels (image);
- info.image_width = gdk_pixbuf_get_width (image);
- info.image_height = gdk_pixbuf_get_height (image);
- info.input_components = 3;
- info.in_color_space = JCS_RGB; /* TODO: JCS_GRAYSCALE? */
- jpeg_set_defaults (&info);
-
- max_length = info.image_width * info.image_height * info.input_components;
- data = g_malloc (sizeof (guchar) * max_length);
- dest_mgr.next_output_byte = data;
- dest_mgr.free_in_buffer = max_length;
- dest_mgr.init_destination = jpeg_init_cb;
- dest_mgr.empty_output_buffer = jpeg_empty_cb;
- dest_mgr.term_destination = jpeg_term_cb;
- info.dest = &dest_mgr;
-
- jpeg_start_compress (&info, TRUE);
- for (r = 0; r < info.image_height; r++) {
- JSAMPROW row[1];
- row[0] = pixels + r * gdk_pixbuf_get_rowstride (image);
- jpeg_write_scanlines (&info, row, 1);
- }
- jpeg_finish_compress (&info);
- *n_written = max_length - dest_mgr.free_in_buffer;
-
- jpeg_destroy_compress (&info);
-
- return data;
-}
-
-
-static gboolean
-book_save_pdf (Book *book, GFile *file, GError **error)
-{
- GFileOutputStream *stream;
- PDFWriter *writer;
- int catalog_number, pages_number, info_number;
- int xref_offset;
- int i;
-
- stream = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, error);
- if (!stream)
- return FALSE;
-
- writer = pdf_writer_new (stream);
- g_object_unref (stream);
-
- /* Header */
- pdf_printf (writer, "%%PDF-1.3\n");
-
- /* Comment with binary as recommended so file is treated as binary */
- pdf_printf (writer, "%%\xe2\xe3\xcf\xd3\n");
-
- /* Catalog */
- catalog_number = pdf_start_object (writer);
- pdf_printf (writer, "%d 0 obj\n", catalog_number);
- pdf_printf (writer, "<<\n");
- pdf_printf (writer, "/Type /Catalog\n");
- //FIXMEpdf_printf (writer, "/Metadata %d 0 R\n", catalog_number + 1);
- pdf_printf (writer, "/Pages %d 0 R\n", catalog_number + 1); //+2
- pdf_printf (writer, ">>\n");
- pdf_printf (writer, "endobj\n");
-
- /* Metadata */
- /* FIXME pdf_printf (writer, "\n");
- number = pdf_start_object (writer);
- pdf_printf (writer, "%d 0 obj\n", number);
- pdf_printf (writer, "<<\n");
- pdf_printf (writer, "/Type /Metadata\n");
- pdf_printf (writer, "/Subtype /XML\n");
- pdf_printf (writer, "/Length %d\n", ...);
- pdf_printf (writer, ">>\n");
- pdf_printf (writer, "stream\n");
- // ...
- pdf_printf (writer, "\n");
- pdf_printf (writer, "endstream\n");
- pdf_printf (writer, "endobj\n");*/
-
- /* Pages */
- pdf_printf (writer, "\n");
- pages_number = pdf_start_object (writer);
- pdf_printf (writer, "%d 0 obj\n", pages_number);
- pdf_printf (writer, "<<\n");
- pdf_printf (writer, "/Type /Pages\n");
- pdf_printf (writer, "/Kids [");
- for (i = 0; i < book_get_n_pages (book); i++) {
- pdf_printf (writer, " %d 0 R", pages_number + 1 + (i*3));
- }
- pdf_printf (writer, " ]\n");
- pdf_printf (writer, "/Count %d\n", book_get_n_pages (book));
- pdf_printf (writer, ">>\n");
- pdf_printf (writer, "endobj\n");
-
- for (i = 0; i < book_get_n_pages (book); i++) {
- int number, width, height, depth;
- size_t data_length, compressed_length;
- Page *page;
- GdkPixbuf *image;
- guchar *pixels, *data, *compressed_data;
- gchar *command, width_buffer[G_ASCII_DTOSTR_BUF_SIZE], height_buffer[G_ASCII_DTOSTR_BUF_SIZE];
- const gchar *color_space, *filter = NULL;
- float page_width, page_height;
-
- page = book_get_page (book, i);
- image = page_get_image (page, TRUE);
- width = gdk_pixbuf_get_width (image);
- height = gdk_pixbuf_get_height (image);
- pixels = gdk_pixbuf_get_pixels (image);
- page_width = width * 72. / page_get_dpi (page);
- page_height = height * 72. / page_get_dpi (page);
-
- if (page_is_color (page)) {
- int row;
-
- depth = 8;
- color_space = "DeviceRGB";
- data_length = height * width * 3 + 1;
- data = g_malloc (sizeof (guchar) * data_length);
- for (row = 0; row < height; row++) {
- int x;
- guchar *in_line, *out_line;
-
- in_line = pixels + row * gdk_pixbuf_get_rowstride (image);
- out_line = data + row * width * 3;
- for (x = 0; x < width; x++) {
- guchar *in_p = in_line + x*3;
- guchar *out_p = out_line + x*3;
-
- out_p[0] = in_p[0];
- out_p[1] = in_p[1];
- out_p[2] = in_p[2];
- }
- }
- }
- else if (page_get_depth (page) == 2) {
- int row, shift_count = 6;
- guchar *write_ptr;
-
- depth = 2;
- color_space = "DeviceGray";
- data_length = height * ((width * 2 + 7) / 8);
- data = g_malloc (sizeof (guchar) * data_length);
- write_ptr = data;
- write_ptr[0] = 0;
- for (row = 0; row < height; row++) {
- int x;
- guchar *in_line;
-
- /* Pad to the next line */
- if (shift_count != 6) {
- write_ptr++;
- write_ptr[0] = 0;
- shift_count = 6;
- }
-
- in_line = pixels + row * gdk_pixbuf_get_rowstride (image);
- for (x = 0; x < width; x++) {
- guchar *in_p = in_line + x*3;
- if (in_p[0] >= 192)
- write_ptr[0] |= 3 << shift_count;
- else if (in_p[0] >= 128)
- write_ptr[0] |= 2 << shift_count;
- else if (in_p[0] >= 64)
- write_ptr[0] |= 1 << shift_count;
- if (shift_count == 0) {
- write_ptr++;
- write_ptr[0] = 0;
- shift_count = 6;
- }
- else
- shift_count -= 2;
- }
- }
- }
- else if (page_get_depth (page) == 1) {
- int row, mask = 0x80;
- guchar *write_ptr;
-
- depth = 1;
- color_space = "DeviceGray";
- data_length = height * ((width + 7) / 8);
- data = g_malloc (sizeof (guchar) * data_length);
- write_ptr = data;
- write_ptr[0] = 0;
- for (row = 0; row < height; row++) {
- int x;
- guchar *in_line;
-
- /* Pad to the next line */
- if (mask != 0x80) {
- write_ptr++;
- write_ptr[0] = 0;
- mask = 0x80;
- }
-
- in_line = pixels + row * gdk_pixbuf_get_rowstride (image);
- for (x = 0; x < width; x++) {
- guchar *in_p = in_line + x*3;
- if (in_p[0] != 0)
- write_ptr[0] |= mask;
- mask >>= 1;
- if (mask == 0) {
- write_ptr++;
- write_ptr[0] = 0;
- mask = 0x80;
- }
- }
- }
- }
- else {
- int row;
-
- depth = 8;
- color_space = "DeviceGray";
- data_length = height * width + 1;
- data = g_malloc (sizeof (guchar) * data_length);
- for (row = 0; row < height; row++) {
- int x;
- guchar *in_line, *out_line;
-
- in_line = pixels + row * gdk_pixbuf_get_rowstride (image);
- out_line = data + row * width;
- for (x = 0; x < width; x++) {
- guchar *in_p = in_line + x*3;
- guchar *out_p = out_line + x;
-
- out_p[0] = in_p[0];
- }
- }
- }
-
- /* Compress data */
- compressed_data = compress_zlib (data, data_length, &compressed_length);
- if (compressed_data) {
- /* Try if JPEG compression is better */
- if (depth > 1) {
- guchar *jpeg_data;
- size_t jpeg_length;
-
- jpeg_data = compress_jpeg (image, &jpeg_length);
- if (jpeg_length < compressed_length) {
- filter = "DCTDecode";
- g_free (data);
- g_free (compressed_data);
- data = jpeg_data;
- data_length = jpeg_length;
- }
- }
-
- if (!filter) {
- filter = "FlateDecode";
- g_free (data);
- data = compressed_data;
- data_length = compressed_length;
- }
- }
-
- /* Page */
- pdf_printf (writer, "\n");
- number = pdf_start_object (writer);
- pdf_printf (writer, "%d 0 obj\n", number);
- pdf_printf (writer, "<<\n");
- pdf_printf (writer, "/Type /Page\n");
- pdf_printf (writer, "/Parent %d 0 R\n", pages_number);
- pdf_printf (writer, "/Resources << /XObject << /Im%d %d 0 R >> >>\n", i, number+1);
- pdf_printf (writer, "/MediaBox [ 0 0 %s %s ]\n",
- g_ascii_formatd (width_buffer, sizeof (width_buffer), "%.2f", page_width),
- g_ascii_formatd (height_buffer, sizeof (height_buffer), "%.2f", page_height));
- pdf_printf (writer, "/Contents %d 0 R\n", number+2);
- pdf_printf (writer, ">>\n");
- pdf_printf (writer, "endobj\n");
-
- /* Page image */
- pdf_printf (writer, "\n");
- number = pdf_start_object (writer);
- pdf_printf (writer, "%d 0 obj\n", number);
- pdf_printf (writer, "<<\n");
- pdf_printf (writer, "/Type /XObject\n");
- pdf_printf (writer, "/Subtype /Image\n");
- pdf_printf (writer, "/Width %d\n", width);
- pdf_printf (writer, "/Height %d\n", height);
- pdf_printf (writer, "/ColorSpace /%s\n", color_space);
- pdf_printf (writer, "/BitsPerComponent %d\n", depth);
- pdf_printf (writer, "/Length %d\n", data_length);
- if (filter)
- pdf_printf (writer, "/Filter /%s\n", filter);
- pdf_printf (writer, ">>\n");
- pdf_printf (writer, "stream\n");
- pdf_write (writer, data, data_length);
- g_free (data);
- pdf_printf (writer, "\n");
- pdf_printf (writer, "endstream\n");
- pdf_printf (writer, "endobj\n");
-
- /* Page contents */
- command = g_strdup_printf ("q\n"
- "%s 0 0 %s 0 0 cm\n"
- "/Im%d Do\n"
- "Q",
- g_ascii_formatd (width_buffer, sizeof (width_buffer), "%f", page_width),
- g_ascii_formatd (height_buffer, sizeof (height_buffer), "%f", page_height),
- i);
- pdf_printf (writer, "\n");
- number = pdf_start_object (writer);
- pdf_printf (writer, "%d 0 obj\n", number);
- pdf_printf (writer, "<<\n");
- pdf_printf (writer, "/Length %d\n", strlen (command) + 1);
- pdf_printf (writer, ">>\n");
- pdf_printf (writer, "stream\n");
- pdf_write (writer, (unsigned char *)command, strlen (command));
- pdf_printf (writer, "\n");
- pdf_printf (writer, "endstream\n");
- pdf_printf (writer, "endobj\n");
- g_free (command);
-
- g_object_unref (image);
- }
-
- /* Info */
- pdf_printf (writer, "\n");
- info_number = pdf_start_object (writer);
- pdf_printf (writer, "%d 0 obj\n", info_number);
- pdf_printf (writer, "<<\n");
- pdf_printf (writer, "/Creator (Simple Scan " VERSION ")\n");
- pdf_printf (writer, ">>\n");
- pdf_printf (writer, "endobj\n");
-
- /* Cross-reference table */
- xref_offset = writer->offset;
- pdf_printf (writer, "xref\n");
- pdf_printf (writer, "1 %d\n", writer->n_objects);
- GList *link;
- for (link = writer->object_offsets; link != NULL; link = link->next) {
- int offset = GPOINTER_TO_INT (link->data);
- pdf_printf (writer, "%010d 0000 n\n", offset);
- }
-
- /* Trailer */
- pdf_printf (writer, "trailer\n");
- pdf_printf (writer, "<<\n");
- pdf_printf (writer, "/Size %d\n", writer->n_objects);
- pdf_printf (writer, "/Info %d 0 R\n", info_number);
- pdf_printf (writer, "/Root %d 0 R\n", catalog_number);
- //FIXME: pdf_printf (writer, "/ID [<...> <...>]\n");
- pdf_printf (writer, ">>\n");
- pdf_printf (writer, "startxref\n");
- pdf_printf (writer, "%d\n", xref_offset);
- pdf_printf (writer, "%%%%EOF\n");
-
- pdf_writer_free (writer);
-
- return TRUE;
-}
-
-
-gboolean
-book_save (Book *book, const gchar *type, GFile *file, GError **error)
-{
- gboolean result = FALSE;
-
- if (strcmp (type, "jpeg") == 0)
- result = book_save_multi_file (book, "jpeg", file, error);
- else if (strcmp (type, "png") == 0)
- result = book_save_multi_file (book, "png", file, error);
- else if (strcmp (type, "tiff") == 0)
- result = book_save_multi_file (book, "tiff", file, error);
- else if (strcmp (type, "ps") == 0)
- result = book_save_ps (book, file, error);
- else if (strcmp (type, "pdf") == 0)
- result = book_save_pdf (book, file, error);
-
- return result;
-}
-
-
-void
-book_set_needs_saving (Book *book, gboolean needs_saving)
-{
- gboolean needed_saving = book->priv->needs_saving;
- book->priv->needs_saving = needs_saving;
- if (needed_saving != needs_saving)
- g_object_notify (G_OBJECT (book), "needs-saving");
-}
-
-
-gboolean
-book_get_needs_saving (Book *book)
-{
- return book->priv->needs_saving;
-}
-
-
-static void
-book_set_property (GObject *object,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec)
-{
- Book *self;
-
- self = BOOK (object);
-
- switch (prop_id) {
- case PROP_NEEDS_SAVING:
- book_set_needs_saving (self, g_value_get_boolean (value));
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
- break;
- }
-}
-
-
-static void
-book_get_property (GObject *object,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec)
-{
- Book *self;
-
- self = BOOK (object);
-
- switch (prop_id) {
- case PROP_NEEDS_SAVING:
- g_value_set_boolean (value, book_get_needs_saving (self));
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
- break;
- }
-}
-
-
-static void
-book_finalize (GObject *object)
-{
- Book *book = BOOK (object);
- book_clear (book);
- G_OBJECT_CLASS (book_parent_class)->finalize (object);
-}
-
-
-static void
-book_class_init (BookClass *klass)
-{
- GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
- object_class->get_property = book_get_property;
- object_class->set_property = book_set_property;
- object_class->finalize = book_finalize;
-
- g_object_class_install_property (object_class,
- PROP_NEEDS_SAVING,
- g_param_spec_boolean ("needs-saving",
- "needs-saving",
- "TRUE if this book needs saving",
- FALSE,
- G_PARAM_READWRITE));
-
- signals[PAGE_ADDED] =
- g_signal_new ("page-added",
- G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (BookClass, page_added),
- NULL, NULL,
- g_cclosure_marshal_VOID__OBJECT,
- G_TYPE_NONE, 1, page_get_type ());
- signals[PAGE_REMOVED] =
- g_signal_new ("page-removed",
- G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (BookClass, page_removed),
- NULL, NULL,
- g_cclosure_marshal_VOID__OBJECT,
- G_TYPE_NONE, 1, page_get_type ());
- signals[REORDERED] =
- g_signal_new ("reordered",
- G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (BookClass, reordered),
- NULL, NULL,
- g_cclosure_marshal_VOID__VOID,
- G_TYPE_NONE, 0);
- signals[CLEARED] =
- g_signal_new ("cleared",
- G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (BookClass, cleared),
- NULL, NULL,
- g_cclosure_marshal_VOID__VOID,
- G_TYPE_NONE, 0);
-
- g_type_class_add_private (klass, sizeof (BookPrivate));
-}
-
-
-static void
-book_init (Book *book)
-{
- book->priv = G_TYPE_INSTANCE_GET_PRIVATE (book, BOOK_TYPE, BookPrivate);
+
+
+gpointer value_get_ps_writer (const GValue* value) {
+ g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_PS_WRITER), NULL);
+ return value->data[0].v_pointer;
}
+
+
+void value_set_ps_writer (GValue* value, gpointer v_object) {
+ PsWriter* old;
+ g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_PS_WRITER));
+ old = value->data[0].v_pointer;
+ if (v_object) {
+ g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_PS_WRITER));
+ g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
+ value->data[0].v_pointer = v_object;
+ ps_writer_ref (value->data[0].v_pointer);
+ } else {
+ value->data[0].v_pointer = NULL;
+ }
+ if (old) {
+ ps_writer_unref (old);
+ }
+}
+
+
+void value_take_ps_writer (GValue* value, gpointer v_object) {
+ PsWriter* old;
+ g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_PS_WRITER));
+ old = value->data[0].v_pointer;
+ if (v_object) {
+ g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_PS_WRITER));
+ g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
+ value->data[0].v_pointer = v_object;
+ } else {
+ value->data[0].v_pointer = NULL;
+ }
+ if (old) {
+ ps_writer_unref (old);
+ }
+}
+
+
+static void ps_writer_class_init (PsWriterClass * klass) {
+ ps_writer_parent_class = g_type_class_peek_parent (klass);
+ PS_WRITER_CLASS (klass)->finalize = ps_writer_finalize;
+}
+
+
+static void ps_writer_instance_init (PsWriter * self) {
+ self->ref_count = 1;
+}
+
+
+static void ps_writer_finalize (PsWriter* obj) {
+ PsWriter * self;
+ self = PS_WRITER (obj);
+ _cairo_surface_destroy0 (self->surface);
+ _g_object_unref0 (self->stream);
+}
+
+
+GType ps_writer_get_type (void) {
+ static volatile gsize ps_writer_type_id__volatile = 0;
+ if (g_once_init_enter (&ps_writer_type_id__volatile)) {
+ 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 };
+ 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 };
+ 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) };
+ GType ps_writer_type_id;
+ ps_writer_type_id = g_type_register_fundamental (g_type_fundamental_next (), "PsWriter", &g_define_type_info, &g_define_type_fundamental_info, 0);
+ g_once_init_leave (&ps_writer_type_id__volatile, ps_writer_type_id);
+ }
+ return ps_writer_type_id__volatile;
+}
+
+
+gpointer ps_writer_ref (gpointer instance) {
+ PsWriter* self;
+ self = instance;
+ g_atomic_int_inc (&self->ref_count);
+ return instance;
+}
+
+
+void ps_writer_unref (gpointer instance) {
+ PsWriter* self;
+ self = instance;
+ if (g_atomic_int_dec_and_test (&self->ref_count)) {
+ PS_WRITER_GET_CLASS (self)->finalize (self);
+ g_type_free_instance ((GTypeInstance *) self);
+ }
+}
+
+
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-26 08:23:21 +0000