diff options
Diffstat (limited to 'plug-ins/common/file-pdf-load.c')
| -rw-r--r-- | plug-ins/common/file-pdf-load.c | 2077 |
1 files changed, 2077 insertions, 0 deletions
diff --git a/plug-ins/common/file-pdf-load.c b/plug-ins/common/file-pdf-load.c new file mode 100644 index 0000000..93bff28 --- /dev/null +++ b/plug-ins/common/file-pdf-load.c @@ -0,0 +1,2077 @@ +/* GIMP - The GNU Image Manipulation Program + * + * file-pdf-load.c - PDF file loader + * + * Copyright (C) 2005 Nathan Summers + * + * Some code in render_page_to_surface() borrowed from + * poppler.git/glib/poppler-page.cc. + * + * 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 version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <string.h> + +#include <libgimp/gimp.h> +#include <libgimp/gimpui.h> + +#undef GTK_DISABLE_SINGLE_INCLUDES +#include <poppler.h> +#define GTK_DISABLE_SINGLE_INCLUDES + +#include "libgimp/stdplugins-intl.h" + + +#define LOAD_PROC "file-pdf-load" +#define LOAD2_PROC "file-pdf-load2" +#define LOAD_THUMB_PROC "file-pdf-load-thumb" +#define PLUG_IN_BINARY "file-pdf-load" +#define PLUG_IN_ROLE "gimp-file-pdf-load" + +#define THUMBNAIL_SIZE 128 + +#define GIMP_PLUGIN_PDF_LOAD_ERROR gimp_plugin_pdf_load_error_quark () +static GQuark +gimp_plugin_pdf_load_error_quark (void) +{ + return g_quark_from_static_string ("gimp-plugin-pdf-load-error-quark"); +} + +/* Structs for the load dialog */ +typedef struct +{ + GimpPageSelectorTarget target; + gdouble resolution; + gboolean antialias; + gboolean reverse_order; + gchar *PDF_password; + gboolean white_background; +} PdfLoadVals; + +static PdfLoadVals loadvals = +{ + GIMP_PAGE_SELECTOR_TARGET_LAYERS, + 300.00, /* resolution in dpi */ + TRUE, /* antialias */ + FALSE, /* reverse_order */ + NULL, /* pdf_password */ + TRUE, /* white_background */ +}; + +typedef struct +{ + gint n_pages; + gint *pages; +} PdfSelectedPages; + +/* Declare local functions */ +static void query (void); +static void run (const gchar *name, + gint nparams, + const GimpParam *param, + gint *nreturn_vals, + GimpParam **return_vals); + +static gint32 load_image (PopplerDocument *doc, + const gchar *filename, + GimpRunMode run_mode, + GimpPageSelectorTarget target, + gdouble resolution, + gboolean antialias, + gboolean white_background, + gboolean reverse_order, + PdfSelectedPages *pages); + +static GimpPDBStatusType load_dialog (PopplerDocument *doc, + PdfSelectedPages *pages); + +static PopplerDocument * open_document (const gchar *filename, + const gchar *PDF_password, + GimpRunMode run_mode, + GError **error); + +static cairo_surface_t * get_thumb_surface (PopplerDocument *doc, + gint page, + gint preferred_size, + gboolean white_background); + +static GdkPixbuf * get_thumb_pixbuf (PopplerDocument *doc, + gint page, + gint preferred_size, + gboolean white_background); + +static gint32 layer_from_surface (gint32 image, + const gchar *layer_name, + gint position, + cairo_surface_t *surface, + gdouble progress_start, + gdouble progress_scale); + +/** + ** the following was formerly part of + ** gimpresolutionentry.h and gimpresolutionentry.c, + ** moved here because this is the only thing that uses + ** it, and it is undesirable to maintain all that api. + ** Most unused functions have been removed. + **/ +#define GIMP_TYPE_RESOLUTION_ENTRY (gimp_resolution_entry_get_type ()) +#define GIMP_RESOLUTION_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_RESOLUTION_ENTRY, GimpResolutionEntry)) +#define GIMP_RESOLUTION_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_RESOLUTION_ENTRY, GimpResolutionEntryClass)) +#define GIMP_IS_RESOLUTION_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_RESOLUTION_ENTRY)) +#define GIMP_IS_RESOLUTION_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_RESOLUTION_ENTRY)) +#define GIMP_RESOLUTION_ENTRY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_RESOLUTION_ENTRY, GimpResolutionEntryClass)) + + +typedef struct _GimpResolutionEntry GimpResolutionEntry; +typedef struct _GimpResolutionEntryClass GimpResolutionEntryClass; + +typedef struct _GimpResolutionEntryField GimpResolutionEntryField; + +struct _GimpResolutionEntryField +{ + GimpResolutionEntry *gre; + GimpResolutionEntryField *corresponding; + + gboolean size; + + GtkWidget *label; + + guint changed_signal; + + GtkAdjustment *adjustment; + GtkWidget *spinbutton; + + gdouble phy_size; + + gdouble value; + gdouble min_value; + gdouble max_value; + + gint stop_recursion; +}; + + +struct _GimpResolutionEntry +{ + GtkTable parent_instance; + + GimpUnit size_unit; + GimpUnit unit; + + GtkWidget *unitmenu; + GtkWidget *chainbutton; + + GimpResolutionEntryField width; + GimpResolutionEntryField height; + GimpResolutionEntryField x; + GimpResolutionEntryField y; + +}; + +struct _GimpResolutionEntryClass +{ + GtkTableClass parent_class; + + void (* value_changed) (GimpResolutionEntry *gse); + void (* refval_changed) (GimpResolutionEntry *gse); + void (* unit_changed) (GimpResolutionEntry *gse); +}; + + +GType gimp_resolution_entry_get_type (void) G_GNUC_CONST; + +GtkWidget * gimp_resolution_entry_new (const gchar *width_label, + gdouble width, + const gchar *height_label, + gdouble height, + GimpUnit size_unit, + const gchar *res_label, + gdouble initial_res, + GimpUnit initial_unit); + +GtkWidget * gimp_resolution_entry_attach_label (GimpResolutionEntry *gre, + const gchar *text, + gint row, + gint column, + gfloat alignment); + +gdouble gimp_resolution_entry_get_x_in_dpi (GimpResolutionEntry *gre); + +gdouble gimp_resolution_entry_get_y_in_dpi (GimpResolutionEntry *gre); + + +/* signal callback convenience functions */ +void gimp_resolution_entry_update_x_in_dpi (GimpResolutionEntry *gre, + gpointer data); + +void gimp_resolution_entry_update_y_in_dpi (GimpResolutionEntry *gre, + gpointer data); + + +enum +{ + WIDTH_CHANGED, + HEIGHT_CHANGED, + X_CHANGED, + Y_CHANGED, + UNIT_CHANGED, + LAST_SIGNAL +}; + +static void gimp_resolution_entry_class_init (GimpResolutionEntryClass *class); +static void gimp_resolution_entry_init (GimpResolutionEntry *gre); + +static void gimp_resolution_entry_update_value (GimpResolutionEntryField *gref, + gdouble value); +static void gimp_resolution_entry_value_callback (GtkWidget *widget, + gpointer data); +static void gimp_resolution_entry_update_unit (GimpResolutionEntry *gre, + GimpUnit unit); +static void gimp_resolution_entry_unit_callback (GtkWidget *widget, + GimpResolutionEntry *gre); + +static void gimp_resolution_entry_field_init (GimpResolutionEntry *gre, + GimpResolutionEntryField *gref, + GimpResolutionEntryField *corresponding, + guint changed_signal, + gdouble initial_val, + GimpUnit initial_unit, + gboolean size, + gint spinbutton_width); + +static void gimp_resolution_entry_format_label (GimpResolutionEntry *gre, + GtkWidget *label, + gdouble size); + +/** + ** end of gimpresolutionentry stuff + ** the actual code can be found at the end of this file + **/ +const GimpPlugInInfo PLUG_IN_INFO = +{ + NULL, /* init_proc */ + NULL, /* quit_proc */ + query, /* query_proc */ + run, /* run_proc */ +}; + + +MAIN () + +static void +query (void) +{ + static const GimpParamDef load_args[] = + { + { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, + { GIMP_PDB_STRING, "filename", "The name of the file to load" }, + { GIMP_PDB_STRING, "raw-filename", "The name entered" } + }; + + static const GimpParamDef load2_args[] = + { + { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, + { GIMP_PDB_STRING, "filename", "The name of the file to load" }, + { GIMP_PDB_STRING, "raw-filename", "The name entered" }, + { GIMP_PDB_STRING, "pdf-password", "The password to decrypt the encrypted PDF file" }, + { GIMP_PDB_INT32, "n-pages", "Number of pages to load (0 for all)" }, + { GIMP_PDB_INT32ARRAY,"pages", "The pages to load in the expected order" }, + /* XXX: Nice to have API at some point, but needs work + { GIMP_PDB_INT32, "resolution", "Resolution to rasterize to (dpi)" }, + { GIMP_PDB_INT32, "antialiasing", "Use anti-aliasing" }, */ + }; + + static const GimpParamDef load_return_vals[] = + { + { GIMP_PDB_IMAGE, "image", "Output image" } + }; + + static const GimpParamDef thumb_args[] = + { + { GIMP_PDB_STRING, "filename", "The name of the file to load" }, + { GIMP_PDB_INT32, "thumb-size", "Preferred thumbnail size" } + }; + + static const GimpParamDef thumb_return_vals[] = + { + { GIMP_PDB_IMAGE, "image", "Thumbnail image" }, + { GIMP_PDB_INT32, "image-width", "Width of full-sized image" }, + { GIMP_PDB_INT32, "image-height", "Height of full-sized image" }, + { GIMP_PDB_INT32, "image-type", "Image type" }, + { GIMP_PDB_INT32, "num-layers", "Number of pages" } + }; + + gimp_install_procedure (LOAD_PROC, + "Load file in PDF format", + "Loads files in Adobe's Portable Document Format. " + "PDF is designed to be easily processed by a variety " + "of different platforms, and is a distant cousin of " + "PostScript.\n" + "If the PDF document has multiple pages, only the first " + "page will be loaded. Call file_pdf_load2() to load " + "several pages as layers.", + "Nathan Summers", + "Nathan Summers", + "2005", + N_("Portable Document Format"), + NULL, + GIMP_PLUGIN, + G_N_ELEMENTS (load_args), + G_N_ELEMENTS (load_return_vals), + load_args, load_return_vals); + + gimp_install_procedure (LOAD2_PROC, + "Load file in PDF format", + "Loads files in Adobe's Portable Document Format. " + "PDF is designed to be easily processed by a variety " + "of different platforms, and is a distant cousin of " + "PostScript.\n" + "This procedure adds extra parameters to " + "file-pdf-load to open encrypted PDF and to allow " + "multiple page loading.", + "Nathan Summers, Lionel N.", + "Nathan Summers, Lionel N.", + "2005, 2017", + N_("Portable Document Format"), + NULL, + GIMP_PLUGIN, + G_N_ELEMENTS (load2_args), + G_N_ELEMENTS (load_return_vals), + load2_args, load_return_vals); + + gimp_register_file_handler_mime (LOAD2_PROC, "application/pdf"); + gimp_register_magic_load_handler (LOAD2_PROC, + "pdf", + "", + "0, string,%PDF-"); + + gimp_install_procedure (LOAD_THUMB_PROC, + "Loads a preview from a PDF file.", + "Loads a small preview of the first page of the PDF " + "format file. Uses the embedded thumbnail if " + "present.", + "Nathan Summers", + "Nathan Summers", + "2005", + NULL, + NULL, + GIMP_PLUGIN, + G_N_ELEMENTS (thumb_args), + G_N_ELEMENTS (thumb_return_vals), + thumb_args, thumb_return_vals); + + gimp_register_thumbnail_loader (LOAD2_PROC, LOAD_THUMB_PROC); +} + +static void +run (const gchar *name, + gint nparams, + const GimpParam *param, + gint *nreturn_vals, + GimpParam **return_vals) +{ + static GimpParam values[7]; + GimpPDBStatusType status = GIMP_PDB_SUCCESS; + gint32 image_ID = -1; + PopplerDocument *doc = NULL; + GError *error = NULL; + + INIT_I18N (); + gegl_init (NULL, NULL); + + *nreturn_vals = 1; + *return_vals = values; + + values[0].type = GIMP_PDB_STATUS; + values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; + + if (strcmp (name, LOAD_PROC) == 0 || strcmp (name, LOAD2_PROC) == 0) + { + PdfSelectedPages pages = { 0, NULL }; + GimpRunMode run_mode; + + run_mode = param[0].data.d_int32; + switch (run_mode) + { + case GIMP_RUN_INTERACTIVE: + /* Possibly retrieve last settings */ + if (strcmp (name, LOAD_PROC) == 0) + { + gimp_get_data (LOAD_PROC, &loadvals); + } + else if (strcmp (name, LOAD2_PROC) == 0) + { + gimp_get_data (LOAD2_PROC, &loadvals); + } + gimp_ui_init (PLUG_IN_BINARY, FALSE); + doc = open_document (param[1].data.d_string, + loadvals.PDF_password, + run_mode, &error); + + if (!doc) + { + status = GIMP_PDB_EXECUTION_ERROR; + break; + } + + status = load_dialog (doc, &pages); + if (status == GIMP_PDB_SUCCESS) + { + if (strcmp (name, LOAD_PROC) == 0) + { + gimp_set_data (LOAD_PROC, &loadvals, sizeof(loadvals)); + } + else if (strcmp (name, LOAD2_PROC) == 0) + { + gimp_set_data (LOAD2_PROC, &loadvals, sizeof(loadvals)); + } + } + break; + + case GIMP_RUN_WITH_LAST_VALS: + /* FIXME: implement last vals mode */ + status = GIMP_PDB_EXECUTION_ERROR; + break; + + case GIMP_RUN_NONINTERACTIVE: + if (strcmp (name, LOAD_PROC) == 0) + { + doc = open_document (param[1].data.d_string, + NULL, run_mode, &error); + } + else if (strcmp (name, LOAD2_PROC) == 0) + { + doc = open_document (param[1].data.d_string, + param[3].data.d_string, + run_mode, &error); + } + + if (doc) + { + PopplerPage *test_page = poppler_document_get_page (doc, 0); + + if (test_page) + { + if (strcmp (name, LOAD2_PROC) != 0) + { + /* For retrocompatibility, file-pdf-load always + * just loads the first page. */ + pages.n_pages = 1; + pages.pages = g_new (gint, 1); + pages.pages[0] = 0; + + g_object_unref (test_page); + } + else + { + gint i; + gint doc_n_pages; + + doc_n_pages = poppler_document_get_n_pages (doc); + /* The number of imported pages may be bigger than + * the number of pages from the original document. + * Indeed it is possible to duplicate some pages + * by setting the same number several times in the + * "pages" argument. + * Not ceiling this value is *not* an error. + */ + pages.n_pages = param[4].data.d_int32; + if (pages.n_pages <= 0) + { + pages.n_pages = doc_n_pages; + pages.pages = g_new (gint, pages.n_pages); + for (i = 0; i < pages.n_pages; i++) + pages.pages[i] = i; + } + else + { + pages.pages = g_new (gint, pages.n_pages); + for (i = 0; i < pages.n_pages; i++) + { + if (param[5].data.d_int32array[i] >= doc_n_pages) + { + status = GIMP_PDB_EXECUTION_ERROR; + g_set_error (&error, GIMP_PLUGIN_PDF_LOAD_ERROR, 0, + /* TRANSLATORS: first argument is file name, + * second is out-of-range page number, third is + * number of pages. Specify order as in English if needed. + */ + ngettext ("PDF document '%1$s' has %3$d page. Page %2$d is out of range.", + "PDF document '%1$s' has %3$d pages. Page %2$d is out of range.", + doc_n_pages), + param[1].data.d_string, + param[5].data.d_int32array[i], + doc_n_pages); + break; + } + else + { + pages.pages[i] = param[5].data.d_int32array[i]; + } + } + } + g_object_unref (test_page); + } + } + else + { + status = GIMP_PDB_EXECUTION_ERROR; + g_object_unref (doc); + } + } + else + { + status = GIMP_PDB_EXECUTION_ERROR; + } + break; + } + + if (status == GIMP_PDB_SUCCESS) + { + image_ID = load_image (doc, param[1].data.d_string, + run_mode, + loadvals.target, + loadvals.resolution, + loadvals.antialias, + loadvals.white_background, + loadvals.reverse_order, + &pages); + + if (image_ID != -1) + { + *nreturn_vals = 2; + values[1].type = GIMP_PDB_IMAGE; + values[1].data.d_image = image_ID; + } + else + { + status = GIMP_PDB_EXECUTION_ERROR; + } + } + + if (doc) + g_object_unref (doc); + + g_free (pages.pages); + } + else if (strcmp (name, LOAD_THUMB_PROC) == 0) + { + if (nparams < 2) + { + status = GIMP_PDB_CALLING_ERROR; + } + else + { + gdouble width = 0; + gdouble height = 0; + gdouble scale; + gint32 image = -1; + gint num_pages = 0; + cairo_surface_t *surface = NULL; + + /* Possibly retrieve last settings */ + if (strcmp (name, LOAD_PROC) == 0) + { + gimp_get_data (LOAD_PROC, &loadvals); + } + else if (strcmp (name, LOAD2_PROC) == 0) + { + gimp_get_data (LOAD2_PROC, &loadvals); + } + + doc = open_document (param[0].data.d_string, + loadvals.PDF_password, + GIMP_RUN_NONINTERACTIVE, + &error); + + if (doc) + { + PopplerPage *page = poppler_document_get_page (doc, 0); + + if (page) + { + poppler_page_get_size (page, &width, &height); + + g_object_unref (page); + } + + num_pages = poppler_document_get_n_pages (doc); + + surface = get_thumb_surface (doc, 0, param[1].data.d_int32, TRUE); + + g_object_unref (doc); + } + + if (surface) + { + image = gimp_image_new (cairo_image_surface_get_width (surface), + cairo_image_surface_get_height (surface), + GIMP_RGB); + + gimp_image_undo_disable (image); + + + layer_from_surface (image, "thumbnail", 0, surface, 0.0, 1.0); + cairo_surface_destroy (surface); + + gimp_image_undo_enable (image); + gimp_image_clean_all (image); + } + + scale = loadvals.resolution / gimp_unit_get_factor (GIMP_UNIT_POINT); + + width *= scale; + height *= scale; + + if (image != -1) + { + *nreturn_vals = 6; + + values[1].type = GIMP_PDB_IMAGE; + values[1].data.d_image = image; + values[2].type = GIMP_PDB_INT32; + values[2].data.d_int32 = width; + values[3].type = GIMP_PDB_INT32; + values[3].data.d_int32 = height; + values[4].type = GIMP_PDB_INT32; + values[4].data.d_int32 = GIMP_RGB_IMAGE; + values[5].type = GIMP_PDB_INT32; + values[5].data.d_int32 = num_pages; + } + else + { + status = GIMP_PDB_EXECUTION_ERROR; + } + } + + } + else + { + status = GIMP_PDB_CALLING_ERROR; + } + + if (status != GIMP_PDB_SUCCESS && error) + { + *nreturn_vals = 2; + values[1].type = GIMP_PDB_STRING; + values[1].data.d_string = error->message; + } + + values[0].data.d_status = status; + + gegl_exit (); +} + +static PopplerDocument* +open_document (const gchar *filename, + const gchar *PDF_password, + GimpRunMode run_mode, + GError **load_error) +{ + PopplerDocument *doc; + GFile *file; + GError *error = NULL; + + file = g_file_new_for_path (filename); + doc = poppler_document_new_from_gfile (file, PDF_password, NULL, &error); + + if (run_mode == GIMP_RUN_INTERACTIVE) + { + GtkWidget *label; + + label = gtk_label_new (_("PDF is password protected, please input the password:")); + while (error && + error->domain == POPPLER_ERROR && + error->code == POPPLER_ERROR_ENCRYPTED) + { + GtkWidget *vbox; + GtkWidget *dialog; + GtkWidget *entry; + gint run; + + dialog = gimp_dialog_new (_("Encrypted PDF"), PLUG_IN_ROLE, + NULL, 0, + NULL, NULL, + _("_Cancel"), GTK_RESPONSE_CANCEL, + _("_OK"), GTK_RESPONSE_OK, + NULL); + gimp_window_set_transient (GTK_WINDOW (dialog)); + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); + gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); + gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), + vbox, TRUE, TRUE, 0); + entry = gtk_entry_new (); + gtk_entry_set_visibility (GTK_ENTRY (entry), FALSE); + gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE); + gtk_container_add (GTK_CONTAINER (vbox), label); + gtk_container_add (GTK_CONTAINER (vbox), entry); + + gtk_widget_show_all (dialog); + + run = gimp_dialog_run (GIMP_DIALOG (dialog)); + if (run == GTK_RESPONSE_OK) + { + g_clear_error (&error); + doc = poppler_document_new_from_gfile (file, + gtk_entry_get_text (GTK_ENTRY (entry)), + NULL, &error); + } + label = gtk_label_new (_("Wrong password! Please input the right one:")); + gtk_widget_destroy (dialog); + if (run == GTK_RESPONSE_CANCEL || run == GTK_RESPONSE_DELETE_EVENT) + { + break; + } + } + gtk_widget_destroy (label); + } + g_object_unref (file); + + /* We can't g_mapped_file_unref(mapped_file) as apparently doc has + * references to data in there. No big deal, this is just a + * short-lived plug-in. + */ + if (! doc) + { + g_set_error (load_error, G_FILE_ERROR, G_FILE_ERROR_FAILED, + _("Could not load '%s': %s"), + gimp_filename_to_utf8 (filename), + error->message); + g_error_free (error); + return NULL; + } + + return doc; +} + +/* FIXME: Remove this someday when we depend fully on GTK+ >= 3 */ + +#if (!GTK_CHECK_VERSION (3, 0, 0)) + +static cairo_format_t +gdk_cairo_format_for_content (cairo_content_t content) +{ + switch (content) + { + case CAIRO_CONTENT_COLOR: + return CAIRO_FORMAT_RGB24; + case CAIRO_CONTENT_ALPHA: + return CAIRO_FORMAT_A8; + case CAIRO_CONTENT_COLOR_ALPHA: + default: + return CAIRO_FORMAT_ARGB32; + } +} + +static cairo_surface_t * +gdk_cairo_surface_coerce_to_image (cairo_surface_t *surface, + cairo_content_t content, + int src_x, + int src_y, + int width, + int height) +{ + cairo_surface_t *copy; + cairo_t *cr; + + copy = cairo_image_surface_create (gdk_cairo_format_for_content (content), + width, + height); + + cr = cairo_create (copy); + cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); + cairo_set_source_surface (cr, surface, -src_x, -src_y); + cairo_paint (cr); + cairo_destroy (cr); + + return copy; +} + +static void +convert_alpha (guchar *dest_data, + int dest_stride, + guchar *src_data, + int src_stride, + int src_x, + int src_y, + int width, + int height) +{ + int x, y; + + src_data += src_stride * src_y + src_x * 4; + + for (y = 0; y < height; y++) { + guint32 *src = (guint32 *) src_data; + + for (x = 0; x < width; x++) { + guint alpha = src[x] >> 24; + + if (alpha == 0) + { + dest_data[x * 4 + 0] = 0; + dest_data[x * 4 + 1] = 0; + dest_data[x * 4 + 2] = 0; + } + else + { + dest_data[x * 4 + 0] = (((src[x] & 0xff0000) >> 16) * 255 + alpha / 2) / alpha; + dest_data[x * 4 + 1] = (((src[x] & 0x00ff00) >> 8) * 255 + alpha / 2) / alpha; + dest_data[x * 4 + 2] = (((src[x] & 0x0000ff) >> 0) * 255 + alpha / 2) / alpha; + } + dest_data[x * 4 + 3] = alpha; + } + + src_data += src_stride; + dest_data += dest_stride; + } +} + +static void +convert_no_alpha (guchar *dest_data, + int dest_stride, + guchar *src_data, + int src_stride, + int src_x, + int src_y, + int width, + int height) +{ + int x, y; + + src_data += src_stride * src_y + src_x * 4; + + for (y = 0; y < height; y++) { + guint32 *src = (guint32 *) src_data; + + for (x = 0; x < width; x++) { + dest_data[x * 3 + 0] = src[x] >> 16; + dest_data[x * 3 + 1] = src[x] >> 8; + dest_data[x * 3 + 2] = src[x]; + } + + src_data += src_stride; + dest_data += dest_stride; + } +} + +/** + * gdk_pixbuf_get_from_surface: + * @surface: surface to copy from + * @src_x: Source X coordinate within @surface + * @src_y: Source Y coordinate within @surface + * @width: Width in pixels of region to get + * @height: Height in pixels of region to get + * + * Transfers image data from a #cairo_surface_t and converts it to an RGB(A) + * representation inside a #GdkPixbuf. This allows you to efficiently read + * individual pixels from cairo surfaces. For #GdkWindows, use + * gdk_pixbuf_get_from_window() instead. + * + * This function will create an RGB pixbuf with 8 bits per channel. + * The pixbuf will contain an alpha channel if the @surface contains one. + * + * Return value: (transfer full): A newly-created pixbuf with a reference + * count of 1, or %NULL on error + */ +static GdkPixbuf * +gdk_pixbuf_get_from_surface (cairo_surface_t *surface, + gint src_x, + gint src_y, + gint width, + gint height) +{ + cairo_content_t content; + GdkPixbuf *dest; + + /* General sanity checks */ + g_return_val_if_fail (surface != NULL, NULL); + g_return_val_if_fail (width > 0 && height > 0, NULL); + + content = cairo_surface_get_content (surface) | CAIRO_CONTENT_COLOR; + dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB, + !!(content & CAIRO_CONTENT_ALPHA), + 8, + width, height); + + surface = gdk_cairo_surface_coerce_to_image (surface, content, + src_x, src_y, + width, height); + cairo_surface_flush (surface); + if (cairo_surface_status (surface) || dest == NULL) + { + cairo_surface_destroy (surface); + return NULL; + } + + if (gdk_pixbuf_get_has_alpha (dest)) + convert_alpha (gdk_pixbuf_get_pixels (dest), + gdk_pixbuf_get_rowstride (dest), + cairo_image_surface_get_data (surface), + cairo_image_surface_get_stride (surface), + 0, 0, + width, height); + else + convert_no_alpha (gdk_pixbuf_get_pixels (dest), + gdk_pixbuf_get_rowstride (dest), + cairo_image_surface_get_data (surface), + cairo_image_surface_get_stride (surface), + 0, 0, + width, height); + + cairo_surface_destroy (surface); + return dest; +} + +#endif + +static gint32 +layer_from_surface (gint32 image, + const gchar *layer_name, + gint position, + cairo_surface_t *surface, + gdouble progress_start, + gdouble progress_scale) +{ + gint32 layer; + + layer = gimp_layer_new_from_surface (image, layer_name, surface, + progress_start, + progress_start + progress_scale); + gimp_image_insert_layer (image, layer, -1, position); + + return layer; +} + +static cairo_surface_t * +render_page_to_surface (PopplerPage *page, + int width, + int height, + double scale, + gboolean antialias, + gboolean white_background) +{ + cairo_surface_t *surface; + cairo_t *cr; + + surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height); + cr = cairo_create (surface); + + cairo_save (cr); + cairo_translate (cr, 0.0, 0.0); + + if (scale != 1.0) + cairo_scale (cr, scale, scale); + + if (! antialias) + { + cairo_font_options_t *options = cairo_font_options_create (); + + cairo_get_font_options (cr, options); + cairo_font_options_set_antialias (options, CAIRO_ANTIALIAS_NONE); + cairo_set_font_options (cr, options); + cairo_font_options_destroy (options); + + cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE); + } + + poppler_page_render (page, cr); + cairo_restore (cr); + + if (white_background) + { + cairo_set_operator (cr, CAIRO_OPERATOR_DEST_OVER); + cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); + cairo_paint (cr); + } + + cairo_destroy (cr); + + return surface; +} + +#if 0 + +/* This is currently unused, but we'll have it here in case the military + wants it. */ + +static GdkPixbuf * +render_page_to_pixbuf (PopplerPage *page, + int width, + int height, + double scale) +{ + GdkPixbuf *pixbuf; + cairo_surface_t *surface; + + surface = render_page_to_surface (page, width, height, scale); + pixbuf = gdk_pixbuf_get_from_surface (surface, 0, 0, + cairo_image_surface_get_width (surface), + cairo_image_surface_get_height (surface)); + cairo_surface_destroy (surface); + + return pixbuf; +} + +#endif + +static gint32 +load_image (PopplerDocument *doc, + const gchar *filename, + GimpRunMode run_mode, + GimpPageSelectorTarget target, + gdouble resolution, + gboolean antialias, + gboolean white_background, + gboolean reverse_order, + PdfSelectedPages *pages) +{ + gint32 image_ID = 0; + gint32 *images = NULL; + gint i; + gdouble scale; + gdouble doc_progress = 0; + gint base_index = 0; + gint sign = 1; + + if (reverse_order && pages->n_pages > 0) + { + base_index = pages->n_pages - 1; + sign = -1; + } + + if (target == GIMP_PAGE_SELECTOR_TARGET_IMAGES) + images = g_new0 (gint32, pages->n_pages); + + gimp_progress_init_printf (_("Opening '%s'"), + gimp_filename_to_utf8 (filename)); + + scale = resolution / gimp_unit_get_factor (GIMP_UNIT_POINT); + + /* read the file */ + + for (i = 0; i < pages->n_pages; i++) + { + PopplerPage *page; + gchar *page_label; + gdouble page_width; + gdouble page_height; + + cairo_surface_t *surface; + gint width; + gint height; + gint page_index; + + page_index = base_index + sign * i; + + page = poppler_document_get_page (doc, pages->pages[page_index]); + + poppler_page_get_size (page, &page_width, &page_height); + width = page_width * scale; + height = page_height * scale; + + g_object_get (G_OBJECT (page), "label", &page_label, NULL); + + if (! image_ID) + { + gchar *name; + + image_ID = gimp_image_new (width, height, GIMP_RGB); + gimp_image_undo_disable (image_ID); + + if (target == GIMP_PAGE_SELECTOR_TARGET_IMAGES) + name = g_strdup_printf (_("%s-%s"), filename, page_label); + else + name = g_strdup_printf (_("%s-pages"), filename); + + gimp_image_set_filename (image_ID, name); + g_free (name); + + gimp_image_set_resolution (image_ID, resolution, resolution); + } + + surface = render_page_to_surface (page, width, height, scale, + antialias, white_background); + + layer_from_surface (image_ID, page_label, 0, surface, + doc_progress, 1.0 / pages->n_pages); + + g_free (page_label); + cairo_surface_destroy (surface); + + doc_progress = (double) (i + 1) / pages->n_pages; + gimp_progress_update (doc_progress); + + if (target == GIMP_PAGE_SELECTOR_TARGET_IMAGES) + { + images[i] = image_ID; + + gimp_image_undo_enable (image_ID); + gimp_image_clean_all (image_ID); + + image_ID = 0; + } + } + gimp_progress_update (1.0); + + if (image_ID) + { + gimp_image_undo_enable (image_ID); + gimp_image_clean_all (image_ID); + } + + if (target == GIMP_PAGE_SELECTOR_TARGET_IMAGES) + { + if (run_mode != GIMP_RUN_NONINTERACTIVE) + { + /* Display images in reverse order. The last will be + * displayed by GIMP itself + */ + for (i = pages->n_pages - 1; i > 0; i--) + gimp_display_new (images[i]); + } + + image_ID = images[0]; + + g_free (images); + } + + return image_ID; +} + +static cairo_surface_t * +get_thumb_surface (PopplerDocument *doc, + gint page_num, + gint preferred_size, + gboolean white_background) +{ + PopplerPage *page; + cairo_surface_t *surface; + + page = poppler_document_get_page (doc, page_num); + + if (! page) + return NULL; + + surface = poppler_page_get_thumbnail (page); + + if (! surface) + { + gdouble width; + gdouble height; + gdouble scale; + + poppler_page_get_size (page, &width, &height); + + scale = (gdouble) preferred_size / MAX (width, height); + + width *= scale; + height *= scale; + + surface = render_page_to_surface (page, width, height, scale, TRUE, white_background); + } + + g_object_unref (page); + + return surface; +} + +static GdkPixbuf * +get_thumb_pixbuf (PopplerDocument *doc, + gint page_num, + gint preferred_size, + gboolean white_background) +{ + cairo_surface_t *surface; + GdkPixbuf *pixbuf; + + surface = get_thumb_surface (doc, page_num, preferred_size, white_background); + pixbuf = gdk_pixbuf_get_from_surface (surface, 0, 0, + cairo_image_surface_get_width (surface), + cairo_image_surface_get_height (surface)); + cairo_surface_destroy (surface); + + return pixbuf; +} + +typedef struct +{ + PopplerDocument *document; + GimpPageSelector *selector; + gboolean white_background; + + GMutex mutex; + GCond render_thumb; + gboolean stop_thumbnailing; + gboolean render_thumbnails; +} ThreadData; + +typedef struct +{ + GimpPageSelector *selector; + gint page_no; + GdkPixbuf *pixbuf; +} IdleData; + +static gboolean +idle_set_thumbnail (gpointer data) +{ + IdleData *idle_data = data; + + gimp_page_selector_set_page_thumbnail (idle_data->selector, + idle_data->page_no, + idle_data->pixbuf); + g_object_unref (idle_data->pixbuf); + g_free (idle_data); + + return FALSE; +} + +static gpointer +thumbnail_thread (gpointer data) +{ + ThreadData *thread_data = data; + gboolean first_loop = TRUE; + gint n_pages; + gint i; + + n_pages = poppler_document_get_n_pages (thread_data->document); + + while (TRUE) + { + gboolean white_background; + gboolean stop_thumbnailing; + gboolean render_thumbnails; + + g_mutex_lock (&thread_data->mutex); + if (first_loop) + first_loop = FALSE; + else + g_cond_wait (&thread_data->render_thumb, &thread_data->mutex); + + stop_thumbnailing = thread_data->stop_thumbnailing; + g_mutex_unlock (&thread_data->mutex); + + if (stop_thumbnailing) + break; + + g_mutex_lock (&thread_data->mutex); + render_thumbnails = thread_data->render_thumbnails; + white_background = thread_data->white_background; + thread_data->render_thumbnails = FALSE; + g_mutex_unlock (&thread_data->mutex); + + /* This handles "spurious wakeup", i.e. cases when g_cond_wait() returned + * even though there was no call asking us to re-render the thumbnails. + * See docs of g_cond_wait(). + */ + if (! render_thumbnails) + continue; + + for (i = 0; i < n_pages; i++) + { + IdleData *idle_data = g_new0 (IdleData, 1); + gboolean white_background2; + + idle_data->selector = thread_data->selector; + idle_data->page_no = i; + + /* FIXME get preferred size from somewhere? */ + idle_data->pixbuf = get_thumb_pixbuf (thread_data->document, i, + THUMBNAIL_SIZE, + white_background); + + g_idle_add (idle_set_thumbnail, idle_data); + + g_mutex_lock (&thread_data->mutex); + white_background2 = thread_data->white_background; + stop_thumbnailing = thread_data->stop_thumbnailing; + g_mutex_unlock (&thread_data->mutex); + + if (stop_thumbnailing || white_background2 != white_background) + break; + } + + if (stop_thumbnailing) + break; + } + + return NULL; +} + +static void +white_background_toggled (GtkToggleButton *widget, + ThreadData *thread_data) +{ + g_mutex_lock (&thread_data->mutex); + thread_data->white_background = gtk_toggle_button_get_active (widget); + thread_data->render_thumbnails = TRUE; + g_cond_signal (&thread_data->render_thumb); + g_mutex_unlock (&thread_data->mutex); +} + +static GimpPDBStatusType +load_dialog (PopplerDocument *doc, + PdfSelectedPages *pages) +{ + GtkWidget *dialog; + GtkWidget *vbox; + GtkWidget *title; + GtkWidget *selector; + GtkWidget *resolution; + GtkWidget *antialias; + GtkWidget *white_bg; + GtkWidget *hbox; + GtkWidget *reverse_order; + GtkWidget *separator; + + ThreadData thread_data; + GThread *thread; + + gint i; + gint n_pages; + + gdouble width; + gdouble height; + + gboolean run; + + dialog = gimp_dialog_new (_("Import from PDF"), PLUG_IN_ROLE, + NULL, 0, + gimp_standard_help_func, LOAD_PROC, + + _("_Cancel"), GTK_RESPONSE_CANCEL, + _("_Import"), GTK_RESPONSE_OK, + + NULL); + + gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), + GTK_RESPONSE_OK, + GTK_RESPONSE_CANCEL, + -1); + + gimp_window_set_transient (GTK_WINDOW (dialog)); + + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); + gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); + gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), + vbox, TRUE, TRUE, 0); + gtk_widget_show (vbox); + + /* Title */ + title = gimp_prop_label_new (G_OBJECT (doc), "title"); + gtk_label_set_ellipsize (GTK_LABEL (title), PANGO_ELLIPSIZE_END); + gtk_box_pack_start (GTK_BOX (vbox), title, FALSE, FALSE, 0); + gtk_widget_show (title); + + /* Page Selector */ + selector = gimp_page_selector_new (); + gtk_widget_set_size_request (selector, 380, 360); + gtk_box_pack_start (GTK_BOX (vbox), selector, TRUE, TRUE, 0); + gtk_widget_show (selector); + + n_pages = poppler_document_get_n_pages (doc); + + if (n_pages <= 0) + { + g_message (_("Error getting number of pages from the given PDF file.")); + return GIMP_PDB_EXECUTION_ERROR; + } + + gimp_page_selector_set_n_pages (GIMP_PAGE_SELECTOR (selector), n_pages); + gimp_page_selector_set_target (GIMP_PAGE_SELECTOR (selector), + loadvals.target); + + for (i = 0; i < n_pages; i++) + { + PopplerPage *page; + gchar *label; + + page = poppler_document_get_page (doc, i); + g_object_get (G_OBJECT (page), "label", &label, NULL); + + gimp_page_selector_set_page_label (GIMP_PAGE_SELECTOR (selector), i, + label); + + if (i == 0) + poppler_page_get_size (page, &width, &height); + + g_object_unref (page); + g_free (label); + } + /* Since selecting none will be equivalent to selecting all, this is + * only useful as a feedback for the default behavior of selecting all + * pages. */ + gimp_page_selector_select_all (GIMP_PAGE_SELECTOR (selector)); + + g_signal_connect_swapped (selector, "activate", + G_CALLBACK (gtk_window_activate_default), + dialog); + + thread_data.document = doc; + thread_data.selector = GIMP_PAGE_SELECTOR (selector); + thread_data.render_thumbnails = TRUE; + thread_data.stop_thumbnailing = FALSE; + thread_data.white_background = loadvals.white_background; + g_mutex_init (&thread_data.mutex); + g_cond_init (&thread_data.render_thumb); + + thread = g_thread_new ("thumbnailer", thumbnail_thread, &thread_data); + + /* "Load in reverse order" toggle button */ + reverse_order = gtk_check_button_new_with_mnemonic (_("Load in reverse order")); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (reverse_order), loadvals.reverse_order); + gtk_box_pack_start (GTK_BOX (vbox), reverse_order, FALSE, FALSE, 0); + + g_signal_connect (reverse_order, "toggled", + G_CALLBACK (gimp_toggle_button_update), &loadvals.reverse_order); + gtk_widget_show (reverse_order); + + /* Separator */ + separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL); + gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0); + gtk_widget_show (separator); + + /* Resolution */ + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + resolution = gimp_resolution_entry_new (_("_Width (pixels):"), width, + _("_Height (pixels):"), height, + GIMP_UNIT_POINT, + _("_Resolution:"), + loadvals.resolution, GIMP_UNIT_INCH); + + gtk_box_pack_start (GTK_BOX (hbox), resolution, FALSE, FALSE, 0); + gtk_widget_show (resolution); + + g_signal_connect (resolution, "x-changed", + G_CALLBACK (gimp_resolution_entry_update_x_in_dpi), + &loadvals.resolution); + + /* Antialiasing*/ + antialias = gtk_check_button_new_with_mnemonic (_("Use _Anti-aliasing")); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (antialias), loadvals.antialias); + gtk_box_pack_start (GTK_BOX (vbox), antialias, FALSE, FALSE, 0); + + g_signal_connect (antialias, "toggled", + G_CALLBACK (gimp_toggle_button_update), &loadvals.antialias); + gtk_widget_show (antialias); + + /* White Background */ + white_bg = gtk_check_button_new_with_mnemonic (_("_Fill transparent areas with white")); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (white_bg), loadvals.white_background); + gtk_box_pack_start (GTK_BOX (vbox), white_bg, FALSE, FALSE, 0); + + g_signal_connect (white_bg, "toggled", + G_CALLBACK (gimp_toggle_button_update), &loadvals.white_background); + g_signal_connect (white_bg, "toggled", + G_CALLBACK (white_background_toggled), &thread_data); + gtk_widget_show (white_bg); + + /* Setup done; display the dialog */ + gtk_widget_show (dialog); + + /* run the dialog */ + run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); + + loadvals.target = + gimp_page_selector_get_target (GIMP_PAGE_SELECTOR (selector)); + + pages->pages = + gimp_page_selector_get_selected_pages (GIMP_PAGE_SELECTOR (selector), + &pages->n_pages); + + /* select all if none selected */ + if (pages->n_pages == 0) + { + gimp_page_selector_select_all (GIMP_PAGE_SELECTOR (selector)); + + pages->pages = + gimp_page_selector_get_selected_pages (GIMP_PAGE_SELECTOR (selector), + &pages->n_pages); + } + + /* cleanup */ + g_mutex_lock (&thread_data.mutex); + thread_data.stop_thumbnailing = TRUE; + g_cond_signal (&thread_data.render_thumb); + g_mutex_unlock (&thread_data.mutex); + g_thread_join (thread); + + g_mutex_clear (&thread_data.mutex); + g_cond_clear (&thread_data.render_thumb); + + return run ? GIMP_PDB_SUCCESS : GIMP_PDB_CANCEL; +} + + +/** + ** code for GimpResolutionEntry widget, formerly in libgimpwidgets + **/ + +static guint gimp_resolution_entry_signals[LAST_SIGNAL] = { 0 }; + +static GtkTableClass *parent_class = NULL; + + +GType +gimp_resolution_entry_get_type (void) +{ + static GType gre_type = 0; + + if (! gre_type) + { + const GTypeInfo gre_info = + { + sizeof (GimpResolutionEntryClass), + (GBaseInitFunc) NULL, + (GBaseFinalizeFunc) NULL, + (GClassInitFunc) gimp_resolution_entry_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (GimpResolutionEntry), + 0, /* n_preallocs */ + (GInstanceInitFunc) gimp_resolution_entry_init, + }; + + gre_type = g_type_register_static (GTK_TYPE_TABLE, + "GimpResolutionEntry", + &gre_info, 0); + } + + return gre_type; +} + +static void +gimp_resolution_entry_class_init (GimpResolutionEntryClass *klass) +{ + parent_class = g_type_class_peek_parent (klass); + + gimp_resolution_entry_signals[HEIGHT_CHANGED] = + g_signal_new ("height-changed", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (GimpResolutionEntryClass, value_changed), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + gimp_resolution_entry_signals[WIDTH_CHANGED] = + g_signal_new ("width-changed", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (GimpResolutionEntryClass, value_changed), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + gimp_resolution_entry_signals[X_CHANGED] = + g_signal_new ("x-changed", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (GimpResolutionEntryClass, value_changed), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + gimp_resolution_entry_signals[Y_CHANGED] = + g_signal_new ("y-changed", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (GimpResolutionEntryClass, refval_changed), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + gimp_resolution_entry_signals[UNIT_CHANGED] = + g_signal_new ("unit-changed", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (GimpResolutionEntryClass, unit_changed), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + klass->value_changed = NULL; + klass->refval_changed = NULL; + klass->unit_changed = NULL; +} + +static void +gimp_resolution_entry_init (GimpResolutionEntry *gre) +{ + gre->unitmenu = NULL; + gre->unit = GIMP_UNIT_INCH; + + gtk_table_set_col_spacings (GTK_TABLE (gre), 4); + gtk_table_set_row_spacings (GTK_TABLE (gre), 2); +} + +static void +gimp_resolution_entry_field_init (GimpResolutionEntry *gre, + GimpResolutionEntryField *gref, + GimpResolutionEntryField *corresponding, + guint changed_signal, + gdouble initial_val, + GimpUnit initial_unit, + gboolean size, + gint spinbutton_width) +{ + gint digits; + + g_return_if_fail (GIMP_IS_RESOLUTION_ENTRY (gre)); + + gref->gre = gre; + gref->corresponding = corresponding; + gref->changed_signal = gimp_resolution_entry_signals[changed_signal]; + + if (size) + { + gref->value = initial_val / + gimp_unit_get_factor (initial_unit) * + corresponding->value * + gimp_unit_get_factor (gre->unit); + + gref->phy_size = initial_val / + gimp_unit_get_factor (initial_unit); + } + else + { + gref->value = initial_val; + } + + gref->min_value = GIMP_MIN_RESOLUTION; + gref->max_value = GIMP_MAX_RESOLUTION; + gref->adjustment = NULL; + + gref->stop_recursion = 0; + + gref->size = size; + + if (size) + { + gref->label = g_object_new (GTK_TYPE_LABEL, + "xalign", 0.0, + "yalign", 0.5, + NULL); + gimp_label_set_attributes (GTK_LABEL (gref->label), + PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, + -1); + + gimp_resolution_entry_format_label (gre, gref->label, gref->phy_size); + } + + digits = size ? 0 : MIN (gimp_unit_get_digits (initial_unit), 5) + 1; + + gref->adjustment = (GtkAdjustment *) + gtk_adjustment_new (gref->value, + gref->min_value, + gref->max_value, + 1.0, 10.0, 0.0); + gref->spinbutton = gimp_spin_button_new (gref->adjustment, + 1.0, digits); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (gref->spinbutton), TRUE); + + if (spinbutton_width > 0) + { + if (spinbutton_width < 17) + gtk_entry_set_width_chars (GTK_ENTRY (gref->spinbutton), + spinbutton_width); + else + gtk_widget_set_size_request (gref->spinbutton, + spinbutton_width, -1); + } +} + +/** + * gimp_resolution_entry_new: + * @width_label: Optional label for the width control. + * @width: Width of the item, specified in terms of @size_unit. + * @height_label: Optional label for the height control. + * @height: Height of the item, specified in terms of @size_unit. + * @size_unit: Unit used to specify the width and height. + * @res_label: Optional label for the resolution entry. + * @initial_res: The initial resolution. + * @initial_unit: The initial unit. + * + * Creates a new #GimpResolutionEntry widget. + * + * The #GimpResolutionEntry is derived from #GtkTable and will have + * an empty border of one cell width on each side plus an empty column left + * of the #GimpUnitMenu to allow the caller to add labels or other widgets. + * + * A #GimpChainButton is displayed if independent is set to %TRUE. + * + * Returns: A pointer to the new #GimpResolutionEntry widget. + **/ +GtkWidget * +gimp_resolution_entry_new (const gchar *width_label, + gdouble width, + const gchar *height_label, + gdouble height, + GimpUnit size_unit, + const gchar *res_label, + gdouble initial_res, + GimpUnit initial_unit) +{ + GimpResolutionEntry *gre; + GtkTreeModel *model; + + gre = g_object_new (GIMP_TYPE_RESOLUTION_ENTRY, NULL); + + gre->unit = initial_unit; + + gtk_table_resize (GTK_TABLE (gre), 4, 4); + + gimp_resolution_entry_field_init (gre, &gre->x, + &gre->width, + X_CHANGED, + initial_res, initial_unit, + FALSE, 0); + + gtk_table_attach_defaults (GTK_TABLE (gre), gre->x.spinbutton, + 1, 2, + 3, 4); + + g_signal_connect (gre->x.adjustment, "value-changed", + G_CALLBACK (gimp_resolution_entry_value_callback), + &gre->x); + + gtk_widget_show (gre->x.spinbutton); + + gre->unitmenu = gimp_unit_combo_box_new (); + model = gtk_combo_box_get_model (GTK_COMBO_BOX (gre->unitmenu)); + gimp_unit_store_set_has_pixels (GIMP_UNIT_STORE (model), FALSE); + gimp_unit_store_set_has_percent (GIMP_UNIT_STORE (model), FALSE); + g_object_set (model, + "short-format", _("pixels/%a"), + "long-format", _("pixels/%a"), + NULL); + gimp_unit_combo_box_set_active (GIMP_UNIT_COMBO_BOX (gre->unitmenu), + initial_unit); + + gtk_table_attach (GTK_TABLE (gre), gre->unitmenu, + 3, 4, 3, 4, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + g_signal_connect (gre->unitmenu, "changed", + G_CALLBACK (gimp_resolution_entry_unit_callback), + gre); + gtk_widget_show (gre->unitmenu); + + gimp_resolution_entry_field_init (gre, &gre->width, + &gre->x, + WIDTH_CHANGED, + width, size_unit, + TRUE, 0); + + gtk_table_attach_defaults (GTK_TABLE (gre), gre->width.spinbutton, + 1, 2, + 1, 2); + + gtk_table_attach_defaults (GTK_TABLE (gre), gre->width.label, + 3, 4, + 1, 2); + + g_signal_connect (gre->width.adjustment, "value-changed", + G_CALLBACK (gimp_resolution_entry_value_callback), + &gre->width); + + gtk_widget_show (gre->width.spinbutton); + gtk_widget_show (gre->width.label); + + gimp_resolution_entry_field_init (gre, &gre->height, &gre->x, + HEIGHT_CHANGED, + height, size_unit, + TRUE, 0); + + gtk_table_attach_defaults (GTK_TABLE (gre), gre->height.spinbutton, + 1, 2, 2, 3); + + gtk_table_attach_defaults (GTK_TABLE (gre), gre->height.label, + 3, 4, 2, 3); + + g_signal_connect (gre->height.adjustment, "value-changed", + G_CALLBACK (gimp_resolution_entry_value_callback), + &gre->height); + + gtk_widget_show (gre->height.spinbutton); + gtk_widget_show (gre->height.label); + + if (width_label) + gimp_resolution_entry_attach_label (gre, width_label, 1, 0, 0.0); + + if (height_label) + gimp_resolution_entry_attach_label (gre, height_label, 2, 0, 0.0); + + if (res_label) + gimp_resolution_entry_attach_label (gre, res_label, 3, 0, 0.0); + + return GTK_WIDGET (gre); +} + +/** + * gimp_resolution_entry_attach_label: + * @gre: The #GimpResolutionEntry you want to add a label to. + * @text: The text of the label. + * @row: The row where the label will be attached. + * @column: The column where the label will be attached. + * @alignment: The horizontal alignment of the label. + * + * Attaches a #GtkLabel to the #GimpResolutionEntry (which is a #GtkTable). + * + * Returns: A pointer to the new #GtkLabel widget. + **/ +GtkWidget * +gimp_resolution_entry_attach_label (GimpResolutionEntry *gre, + const gchar *text, + gint row, + gint column, + gfloat alignment) +{ + GtkWidget *label; + + g_return_val_if_fail (GIMP_IS_RESOLUTION_ENTRY (gre), NULL); + g_return_val_if_fail (text != NULL, NULL); + + label = gtk_label_new_with_mnemonic (text); + + if (column == 0) + { + GList *children; + GList *list; + + children = gtk_container_get_children (GTK_CONTAINER (gre)); + + for (list = children; list; list = g_list_next (list)) + { + GtkWidget *child = list->data; + gint left_attach; + gint top_attach; + + gtk_container_child_get (GTK_CONTAINER (gre), child, + "left-attach", &left_attach, + "top-attach", &top_attach, + NULL); + + if (left_attach == 1 && top_attach == row) + { + gtk_label_set_mnemonic_widget (GTK_LABEL (label), child); + break; + } + } + + g_list_free (children); + } + + gtk_label_set_xalign (GTK_LABEL (label), alignment); + + gtk_table_attach (GTK_TABLE (gre), label, column, column+1, row, row+1, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + return label; +} + +/** + * gimp_resolution_entry_get_x_in_dpi; + * @gre: The #GimpResolutionEntry you want to know the resolution of. + * + * Returns the X resolution of the #GimpResolutionEntry in pixels per inch. + **/ +gdouble +gimp_resolution_entry_get_x_in_dpi (GimpResolutionEntry *gre) +{ + g_return_val_if_fail (GIMP_IS_RESOLUTION_ENTRY (gre), 0); + + /* dots_in_one_unit * units_in_one_inch -> dpi */ + return gre->x.value * gimp_unit_get_factor (gre->unit); +} + +/** + * gimp_resolution_entry_get_y_in_dpi; + * @gre: The #GimpResolutionEntry you want to know the resolution of. + * + * Returns the Y resolution of the #GimpResolutionEntry in pixels per inch. + **/ +gdouble +gimp_resolution_entry_get_y_in_dpi (GimpResolutionEntry *gre) +{ + g_return_val_if_fail (GIMP_IS_RESOLUTION_ENTRY (gre), 0); + + return gre->y.value * gimp_unit_get_factor (gre->unit); +} + + +static void +gimp_resolution_entry_update_value (GimpResolutionEntryField *gref, + gdouble value) +{ + if (gref->stop_recursion > 0) + return; + + gref->value = value; + + gref->stop_recursion++; + + if (gref->size) + gimp_resolution_entry_update_value (gref->corresponding, + gref->value / + gref->phy_size / + gimp_unit_get_factor (gref->gre->unit)); + else + { + gdouble factor = gimp_unit_get_factor (gref->gre->unit); + + gimp_resolution_entry_update_value (&gref->gre->width, + gref->value * + gref->gre->width.phy_size * + factor); + + gimp_resolution_entry_update_value (&gref->gre->height, + gref->value * + gref->gre->height.phy_size * + factor); + } + + gtk_adjustment_set_value (gref->adjustment, value); + + gref->stop_recursion--; + + g_signal_emit (gref->gre, gref->changed_signal, 0); +} + +static void +gimp_resolution_entry_value_callback (GtkWidget *widget, + gpointer data) +{ + GimpResolutionEntryField *gref = (GimpResolutionEntryField *) data; + gdouble new_value; + + new_value = gtk_adjustment_get_value (GTK_ADJUSTMENT (widget)); + + if (gref->value != new_value) + gimp_resolution_entry_update_value (gref, new_value); +} + +static void +gimp_resolution_entry_update_unit (GimpResolutionEntry *gre, + GimpUnit unit) +{ + GimpUnit old_unit; + gint digits; + gdouble factor; + + old_unit = gre->unit; + gre->unit = unit; + + digits = (gimp_unit_get_digits (GIMP_UNIT_INCH) - + gimp_unit_get_digits (unit)); + + gtk_spin_button_set_digits (GTK_SPIN_BUTTON (gre->x.spinbutton), + MAX (3 + digits, 3)); + + factor = gimp_unit_get_factor (old_unit) / gimp_unit_get_factor (unit); + + gre->x.min_value *= factor; + gre->x.max_value *= factor; + gre->x.value *= factor; + + gtk_adjustment_set_value (GTK_ADJUSTMENT (gre->x.adjustment), + gre->x.value); + + gimp_resolution_entry_format_label (gre, + gre->width.label, gre->width.phy_size); + gimp_resolution_entry_format_label (gre, + gre->height.label, gre->height.phy_size); + + g_signal_emit (gre, gimp_resolution_entry_signals[UNIT_CHANGED], 0); +} + +static void +gimp_resolution_entry_unit_callback (GtkWidget *widget, + GimpResolutionEntry *gre) +{ + GimpUnit new_unit; + + new_unit = gimp_unit_combo_box_get_active (GIMP_UNIT_COMBO_BOX (widget)); + + if (gre->unit != new_unit) + gimp_resolution_entry_update_unit (gre, new_unit); +} + +/** + * gimp_resolution_entry_update_x_in_dpi: + * @gre: the #GimpResolutionEntry + * @data: a pointer to a gdouble + * + * Convenience function to set a double to the X resolution, suitable + * for use as a signal callback. + */ +void +gimp_resolution_entry_update_x_in_dpi (GimpResolutionEntry *gre, + gpointer data) +{ + gdouble *val; + + g_return_if_fail (gre != NULL); + g_return_if_fail (data != NULL); + g_return_if_fail (GIMP_IS_RESOLUTION_ENTRY (gre)); + + val = (gdouble *) data; + + *val = gimp_resolution_entry_get_x_in_dpi (gre); +} + +/** + * gimp_resolution_entry_update_y_in_dpi: + * @gre: the #GimpResolutionEntry + * @data: a pointer to a gdouble + * + * Convenience function to set a double to the Y resolution, suitable + * for use as a signal callback. + */ +void +gimp_resolution_entry_update_y_in_dpi (GimpResolutionEntry *gre, + gpointer data) +{ + gdouble *val; + + g_return_if_fail (gre != NULL); + g_return_if_fail (data != NULL); + g_return_if_fail (GIMP_IS_RESOLUTION_ENTRY (gre)); + + val = (gdouble *) data; + + *val = gimp_resolution_entry_get_y_in_dpi (gre); +} + +static void +gimp_resolution_entry_format_label (GimpResolutionEntry *gre, + GtkWidget *label, + gdouble size) +{ + gchar *format = g_strdup_printf ("%%.%df %%s", + gimp_unit_get_digits (gre->unit)); + gchar *text = g_strdup_printf (format, + size * gimp_unit_get_factor (gre->unit), + gimp_unit_get_plural (gre->unit)); + g_free (format); + + gtk_label_set_text (GTK_LABEL (label), text); + g_free (text); +} |