/* 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 .
*/
#include "config.h"
#include
#include
#include
#undef GTK_DISABLE_SINGLE_INCLUDES
#include
#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,
100.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 stop_thumbnailing;
gboolean white_background;
GMutex mutex;
GCond render_thumb;
} 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;
g_mutex_lock (&thread_data->mutex);
if (! first_loop)
g_cond_wait (&thread_data->render_thumb, &thread_data->mutex);
white_background = thread_data->white_background;
stop_thumbnailing = thread_data->stop_thumbnailing;
g_mutex_unlock (&thread_data->mutex);
if (stop_thumbnailing)
break;
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);
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.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);
}