AlderconeStudio/PIKApp
0
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases 1 Wiki Activity

Updated with upstream update

Browse Source
This commit is contained in:
Cassowary
2023-10-30 15:55:30 -07:00
parent 098531073c
commit 3bbdd873ef
584 changed files with 91827 additions and 70362 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
plug-ins/common/align-layers.c
View File

@ -85,7 +85,7 @@ struct _AlignLayersClass
#define ALIGN_LAYERS_TYPE (align_layers_get_type ())
#define ALIGN_LAYERS (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ALIGN_LAYERS_TYPE, AlignLayers))
#define ALIGN_LAYERS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ALIGN_LAYERS_TYPE, AlignLayers))
GType align_layers_get_type (void) G_GNUC_CONST;
@ -98,7 +98,7 @@ static PikaValueArray * align_layers_run (PikaProcedure
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
@ -266,18 +266,14 @@ align_layers_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaValueArray *return_vals = NULL;
PikaPDBStatusType status = PIKA_PDB_EXECUTION_ERROR;
GError *error = NULL;
GList *layers;
gint layer_num;
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
PikaValueArray *return_vals = NULL;
PikaPDBStatusType status = PIKA_PDB_EXECUTION_ERROR;
GError *error = NULL;
GList *layers;
gint layer_num;
switch ( run_mode )
{
@ -312,11 +308,7 @@ align_layers_run (PikaProcedure *procedure,
pika_displays_flush ();
}
pika_procedure_config_end_run (config, status);
g_object_unref (config);
return_vals = pika_procedure_new_return_values (procedure, status,
error);
return_vals = pika_procedure_new_return_values (procedure, status, error);
return return_vals;
}

6
plug-ins/common/animation-optimize.c
View File

@ -75,7 +75,7 @@ struct _OptimizeClass
#define OPTIMIZE_TYPE (optimize_get_type ())
#define OPTIMIZE (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), OPTIMIZE_TYPE, Optimize))
#define OPTIMIZE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), OPTIMIZE_TYPE, Optimize))
GType optimize_get_type (void) G_GNUC_CONST;
@ -88,7 +88,7 @@ static PikaValueArray * optimize_run (PikaProcedure *procedu
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * do_optimizations (PikaRunMode run_mode,
@ -311,7 +311,7 @@ optimize_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;

37
plug-ins/common/animation-play.c
View File

@ -99,7 +99,7 @@ static PikaValueArray * play_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static void initialize (PikaPlay *play);
@ -340,6 +340,11 @@ play_create_procedure (PikaPlugIn *plug_in,
"Adam D. Moss <adam@gimp.org>",
"Adam D. Moss <adam@gimp.org>",
"1997, 1998...");
PIKA_PROC_AUX_ARG_BYTES (procedure, "settings-data",
"Settings data",
"TODO: eventually we must implement proper args for every settings",
PIKA_PARAM_READWRITE);
}
return procedure;
@ -351,12 +356,26 @@ play_run (PikaProcedure *procedure,
PikaImage *_image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
GBytes *settings_bytes = NULL;
GMenu *section;
PikaPlay *play;
if (run_mode != PIKA_RUN_INTERACTIVE)
{
GError *error = NULL;
g_set_error (&error, PIKA_PLUG_IN_ERROR, 0,
_("Procedure '%s' only works in interactive mode."),
pika_procedure_get_name (procedure));
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CALLING_ERROR,
error);
}
play = PIKA_PLAY (pika_procedure_get_plug_in (procedure));
#if GLIB_CHECK_VERSION(2,74,0)
play->app = gtk_application_new (NULL, G_APPLICATION_DEFAULT_FLAGS);
@ -392,7 +411,15 @@ play_run (PikaProcedure *procedure,
image = _image;
pika_get_data (PLUG_IN_PROC, &settings);
/* Temporary code replacing legacy pika_[gs]et_data() using an AUX argument.
* This doesn't actually fix the "Reset to initial values|factory defaults"
* features, but at least makes per-run value storage work.
* TODO: eventually we want proper separate arguments as a complete fix.
*/
g_object_get (config, "settings-data", &settings_bytes, NULL);
if (settings_bytes != NULL && g_bytes_get_size (settings_bytes) == sizeof (AnimationSettings))
settings = *((AnimationSettings *) g_bytes_get_data (settings_bytes, NULL));
g_bytes_unref (settings_bytes);
g_signal_connect (play->app, "activate", G_CALLBACK (on_app_activate), play);
@ -400,7 +427,9 @@ play_run (PikaProcedure *procedure,
g_clear_object (&play->app);
pika_set_data (PLUG_IN_PROC, &settings, sizeof (settings));
settings_bytes = g_bytes_new (&settings, sizeof (AnimationSettings));
g_object_set (config, "settings-data", settings_bytes, NULL);
g_bytes_unref (settings_bytes);
if (run_mode != PIKA_RUN_NONINTERACTIVE)
pika_displays_flush ();

41
plug-ins/common/blinds.c
View File

@ -62,7 +62,7 @@ struct _BlindsClass
#define BLINDS_TYPE (blinds_get_type ())
#define BLINDS (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), BLINDS_TYPE, Blinds))
#define BLINDS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), BLINDS_TYPE, Blinds))
GType blinds_get_type (void) G_GNUC_CONST;
@ -75,7 +75,7 @@ static PikaValueArray * blinds_run (PikaProcedure *procedure
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static gboolean blinds_dialog (PikaProcedure *procedure,
@ -186,11 +186,10 @@ blinds_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaDrawable *drawable;
PikaDrawable *drawable;
gegl_init (NULL, NULL);
@ -211,26 +210,10 @@ blinds_run (PikaProcedure *procedure,
drawable = drawables[0];
}
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
if (! blinds_dialog (procedure, G_OBJECT (config), drawable))
{
pika_procedure_config_end_run (config, PIKA_PDB_CANCEL);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
break;
default:
break;
}
if (run_mode == PIKA_RUN_INTERACTIVE && ! blinds_dialog (procedure, G_OBJECT (config), drawable))
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
if (pika_drawable_is_rgb (drawable) ||
pika_drawable_is_gray (drawable))
@ -244,17 +227,11 @@ blinds_run (PikaProcedure *procedure,
}
else
{
pika_procedure_config_end_run (config, PIKA_PDB_EXECUTION_ERROR);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
NULL);
}
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL);
}
@ -298,7 +275,7 @@ blinds_dialog (PikaProcedure *procedure,
"orientation", PIKA_INT_STORE (store));
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"bg_label", _("Background"));
"bg_label", _("Background"), FALSE, FALSE);
pika_procedure_dialog_fill_frame (PIKA_PROCEDURE_DIALOG (dialog),
"bg-frame", "bg_label", FALSE,

50
plug-ins/common/border-average.c
View File

@ -45,7 +45,7 @@ struct _BorderAverageClass
#define BORDER_AVERAGE_TYPE (border_average_get_type ())
#define BORDER_AVERAGE (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), BORDER_AVERAGE_TYPE, BorderAverage))
#define BORDER_AVERAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), BORDER_AVERAGE_TYPE, BorderAverage))
GType border_average_get_type (void) G_GNUC_CONST;
@ -59,7 +59,7 @@ static PikaValueArray * border_average_run (PikaProcedure
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
@ -107,7 +107,7 @@ border_average_query_procedures (PikaPlugIn *plug_in)
static PikaProcedure *
border_average_create_procedure (PikaPlugIn *plug_in,
const gchar *name)
const gchar *name)
{
PikaProcedure *procedure = NULL;
@ -166,15 +166,14 @@ border_average_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaDrawable *drawable;
PikaValueArray *return_vals = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaRGB result_color = { 0.0, };
GeglBuffer *buffer;
PikaDrawable *drawable;
PikaValueArray *return_vals = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaRGB result_color = { 0.0, };
GeglBuffer *buffer;
gegl_init (NULL, NULL);
@ -195,27 +194,11 @@ border_average_run (PikaProcedure *procedure,
drawable = drawables[0];
}
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
buffer = pika_drawable_get_buffer (drawable);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
if (! borderaverage_dialog (procedure, G_OBJECT (config),
image, drawable))
status = PIKA_PDB_EXECUTION_ERROR;
break;
case PIKA_RUN_NONINTERACTIVE:
if (pika_value_array_length (args) != 2)
status = PIKA_PDB_CALLING_ERROR;
break;
default:
break;
}
if (run_mode == PIKA_RUN_INTERACTIVE &&
! borderaverage_dialog (procedure, G_OBJECT (config), image, drawable))
return pika_procedure_new_return_values (procedure, PIKA_PDB_CANCEL, NULL);
if (status == PIKA_PDB_SUCCESS)
{
@ -238,9 +221,6 @@ border_average_run (PikaProcedure *procedure,
return_vals = pika_procedure_new_return_values (procedure, status, NULL);
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
if (status == PIKA_PDB_SUCCESS)
PIKA_VALUES_SET_RGB (return_vals, 1, &result_color);
@ -414,7 +394,8 @@ borderaverage_dialog (PikaProcedure *procedure,
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"border-size-label",
_("Border Size"));
_("Border Size"),
FALSE, FALSE);
/* Get the image resolution */
pika_image_get_resolution (image, &xres, &yres);
@ -440,7 +421,8 @@ borderaverage_dialog (PikaProcedure *procedure,
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"bucket-size-label",
_("Number of Colors"));
_("Number of Colors"),
FALSE, FALSE);
store = pika_int_store_new ("1", 0, "2", 1, "4", 2, "8", 3,
"16", 4, "32", 5, "64", 6, "128", 7,

34
plug-ins/common/busy-dialog.c
View File

@ -57,7 +57,7 @@ struct _BusyDialogClass
#define BUSY_DIALOG_TYPE (busy_dialog_get_type ())
#define BUSY_DIALOG (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), BUSY_DIALOG_TYPE, BusyDialog))
#define BUSY_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), BUSY_DIALOG_TYPE, BusyDialog))
GType busy_dialog_get_type (void) G_GNUC_CONST;
@ -66,7 +66,7 @@ static GList * busy_dialog_query_procedures (PikaPlugIn
static PikaProcedure * busy_dialog_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * busy_dialog_run (PikaProcedure *procedure,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static PikaPDBStatusType busy_dialog (gint read_fd,
@ -177,30 +177,30 @@ busy_dialog_create_procedure (PikaPlugIn *plug_in,
static PikaValueArray *
busy_dialog_run (PikaProcedure *procedure,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaRunMode run_mode;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaRunMode run_mode = PIKA_RUN_INTERACTIVE;
gint read_fd;
gint write_fd;
const gchar *message;
gboolean cancelable;
run_mode = PIKA_VALUES_GET_ENUM (args, 0);
g_object_get (config,
"run-mode", &run_mode,
"read-fd", &read_fd,
"write-fd", &write_fd,
"message", &message,
"cancelable", &cancelable,
NULL);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
case PIKA_RUN_NONINTERACTIVE:
case PIKA_RUN_WITH_LAST_VALS:
if (pika_value_array_length (args) != 5)
{
status = PIKA_PDB_CALLING_ERROR;
}
else
{
status = busy_dialog (PIKA_VALUES_GET_INT (args, 1),
PIKA_VALUES_GET_INT (args, 2),
PIKA_VALUES_GET_STRING (args, 3),
PIKA_VALUES_GET_BOOLEAN (args, 4));
}
status = busy_dialog (read_fd, write_fd, message, cancelable);
break;
default:

41
plug-ins/common/checkerboard.c
View File

@ -46,7 +46,7 @@ struct _CheckerboardClass
#define CHECKERBOARD_TYPE (checkerboard_get_type ())
#define CHECKERBOARD (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CHECKERBOARD_TYPE, Checkerboard))
#define CHECKERBOARD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CHECKERBOARD_TYPE, Checkerboard))
GType checkerboard_get_type (void) G_GNUC_CONST;
@ -59,7 +59,7 @@ static PikaValueArray * checkerboard_run (PikaProcedure *pro
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static void do_checkerboard_pattern (GObject *config,
@ -161,11 +161,10 @@ checkerboard_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaDrawable *drawable;
PikaDrawable *drawable;
gegl_init (NULL, NULL);
@ -186,27 +185,11 @@ checkerboard_run (PikaProcedure *procedure,
drawable = drawables[0];
}
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
if (! checkerboard_dialog (procedure, G_OBJECT (config), image,
drawable))
{
pika_procedure_config_end_run (config, PIKA_PDB_CANCEL);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
break;
default:
break;
}
if (run_mode == PIKA_RUN_INTERACTIVE &&
! checkerboard_dialog (procedure, G_OBJECT (config), image, drawable))
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
if (pika_drawable_is_rgb (drawable) ||
pika_drawable_is_gray (drawable))
@ -218,17 +201,11 @@ checkerboard_run (PikaProcedure *procedure,
}
else
{
pika_procedure_config_end_run (config, PIKA_PDB_EXECUTION_ERROR);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
NULL);
}
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL);
}

789
plug-ins/common/cml-explorer.c
View File

File diff suppressed because it is too large Load Diff

89
plug-ins/common/colormap-remap.c
View File

@ -77,7 +77,7 @@ static PikaValueArray * remap_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static gboolean real_remap (PikaImage *image,
@ -194,10 +194,10 @@ remap_create_procedure (PikaPlugIn *plug_in,
pika_procedure_set_documentation (procedure,
_("Rearrange the colormap"),
"This procedure takes an indexed "
"image and lets you alter the "
"positions of colors in the colormap "
"without visually changing the image.",
_("This procedure takes an indexed "
"image and lets you alter the "
"positions of colors in the colormap "
"without visually changing the image."),
name);
pika_procedure_set_attribution (procedure,
"Mukund Sivaraman <muks@mukund.org>",
@ -205,8 +205,8 @@ remap_create_procedure (PikaPlugIn *plug_in,
"June 2006");
PIKA_PROC_ARG_BYTES (procedure, "map",
"Map",
"Remap array for the colormap",
_("Map"),
_("Remap array for the colormap"),
G_PARAM_READWRITE);
}
else if (! strcmp (name, PLUG_IN_PROC_SWAP))
@ -226,11 +226,11 @@ remap_create_procedure (PikaPlugIn *plug_in,
pika_procedure_set_documentation (procedure,
_("Swap two colors in the colormap"),
"This procedure takes an indexed "
"image and lets you swap the "
"positions of two colors in the "
"colormap without visually changing "
"the image.",
_("This procedure takes an indexed "
"image and lets you swap the "
"positions of two colors in the "
"colormap without visually changing "
"the image."),
name);
pika_procedure_set_attribution (procedure,
"Mukund Sivaraman <muks@mukund.org>",
@ -238,14 +238,14 @@ remap_create_procedure (PikaPlugIn *plug_in,
"June 2006");
PIKA_PROC_ARG_INT (procedure, "index1",
"Index 1",
"First index in the colormap",
_("Index 1"),
_("First index in the colormap"),
0, 255, 0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_INT (procedure, "index2",
"Index 2",
"Second (other) index in the colormap",
_("Index 2"),
_("Second (other) index in the colormap"),
0, 255, 0,
G_PARAM_READWRITE);
}
@ -259,7 +259,7 @@ remap_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
GMenu *section;
@ -309,8 +309,11 @@ remap_run (PikaProcedure *procedure,
g_free (pika_image_get_colormap (image, NULL, &remap->n_cols));
col_args_bytes = PIKA_VALUES_GET_BYTES (args, 0);
col_args = g_bytes_get_data (col_args_bytes, NULL);
g_object_get (config,
"map", &col_args_bytes,
NULL);
col_args = g_bytes_get_data (col_args_bytes, NULL);
switch (run_mode)
{
@ -336,7 +339,6 @@ remap_run (PikaProcedure *procedure,
break;
case PIKA_RUN_WITH_LAST_VALS:
pika_get_data (PLUG_IN_PROC_REMAP, remap->map);
break;
}
@ -345,19 +347,21 @@ remap_run (PikaProcedure *procedure,
PIKA_PDB_EXECUTION_ERROR,
NULL);
if (run_mode == PIKA_RUN_INTERACTIVE)
pika_set_data (PLUG_IN_PROC_REMAP, remap->map, sizeof (remap->map));
if (run_mode != PIKA_RUN_NONINTERACTIVE)
pika_displays_flush ();
}
else if (strcmp (pika_procedure_get_name (procedure),
PLUG_IN_PROC_SWAP) == 0)
{
gint index1 = PIKA_VALUES_GET_INT (args, 0);
gint index2 = PIKA_VALUES_GET_INT (args, 1);
guchar tmp;
gint n_cols;
gint index1;
gint index2;
g_object_get (config,
"index1", &index1,
"index2", &index2,
NULL);
if (run_mode != PIKA_RUN_NONINTERACTIVE)
return pika_procedure_new_return_values (procedure,
@ -581,23 +585,26 @@ remap_sort (GtkTreeSortable *store,
GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, 0);
}
static void remap_sort_hue_action (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
static void
remap_sort_hue_action (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
remap_sort (GTK_TREE_SORTABLE (store), COLOR_H, GTK_SORT_ASCENDING);
}
static void remap_sort_sat_action (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
static void
remap_sort_sat_action (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
remap_sort (GTK_TREE_SORTABLE (store), COLOR_S, GTK_SORT_ASCENDING);
}
static void remap_sort_val_action (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
static void
remap_sort_val_action (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
remap_sort (GTK_TREE_SORTABLE (store), COLOR_V, GTK_SORT_ASCENDING);
}
@ -646,9 +653,9 @@ remap_button_press (GtkWidget *widget,
}
static void
remap_response (GtkWidget *dialog,
gint response_id,
PikaRemap *remap)
remap_response (GtkWidget *dialog,
gint response_id,
PikaRemap *remap)
{
switch (response_id)
{
@ -694,10 +701,10 @@ remap_dialog (PikaImage *image,
NULL);
pika_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
RESPONSE_RESET,
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
RESPONSE_RESET,
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
pika_window_set_transient (GTK_WINDOW (dialog));

425
plug-ins/common/compose.c
View File

@ -130,7 +130,7 @@ struct _ComposeClass
#define COMPOSE_TYPE (compose_get_type ())
#define COMPOSE (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COMPOSE_TYPE, Compose))
#define COMPOSE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COMPOSE_TYPE, Compose))
GType compose_get_type (void) G_GNUC_CONST;
@ -143,56 +143,58 @@ static PikaValueArray * compose_run (PikaProcedure *procedur
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static void cpn_affine_transform (GeglBuffer *buffer,
gdouble min,
gdouble max);
static void cpn_affine_transform (GeglBuffer *buffer,
gdouble min,
gdouble max);
static void fill_buffer_from_components (GeglBuffer *temp[MAX_COMPOSE_IMAGES],
GeglBuffer *dst,
gint num_cpn,
ComposeInput *inputs,
gdouble mask_vals[MAX_COMPOSE_IMAGES]);
static void fill_buffer_from_components (GeglBuffer *temp[MAX_COMPOSE_IMAGES],
GeglBuffer *dst,
gint num_cpn,
ComposeInput *inputs,
gdouble mask_vals[MAX_COMPOSE_IMAGES]);
static void perform_composition (COMPOSE_DSC curr_compose_dsc,
GeglBuffer *buffer_src[MAX_COMPOSE_IMAGES],
GeglBuffer *buffer_dst,
ComposeInput *inputs,
gint num_images);
static void perform_composition (COMPOSE_DSC curr_compose_dsc,
GeglBuffer *buffer_src[MAX_COMPOSE_IMAGES],
GeglBuffer *buffer_dst,
ComposeInput *inputs,
gint num_images);
static PikaImage * compose (const gchar *compose_type,
ComposeInput *inputs,
gboolean compose_by_drawable);
static PikaImage * compose (const gchar *compose_type,
ComposeInput *inputs,
gboolean compose_by_drawable,
PikaProcedureConfig *config);
static PikaImage * create_new_image (GFile *file,
guint width,
guint height,
PikaImageType gdtype,
PikaPrecision precision,
PikaLayer **layer,
GeglBuffer **buffer);
static PikaImage * create_new_image (GFile *file,
guint width,
guint height,
PikaImageType gdtype,
PikaPrecision precision,
PikaLayer **layer,
GeglBuffer **buffer);
static gboolean compose_dialog (const gchar *compose_type,
PikaDrawable *drawable);
static gboolean compose_dialog (PikaProcedure *procedure,
PikaProcedureConfig *config,
const gchar *compose_type,
PikaDrawable *drawable);
static gboolean check_gray (PikaImage *image,
PikaItem *drawable,
gpointer data);
static gboolean check_gray (PikaImage *image,
PikaItem *drawable,
gpointer data);
static void combo_callback (PikaIntComboBox *cbox,
gpointer data);
static void combo_callback (PikaIntComboBox *cbox,
gpointer data);
static void scale_callback (PikaLabelSpin *scale,
ComposeInput *input);
static void scale_callback (PikaLabelSpin *scale,
ComposeInput *input);
static void check_response (GtkWidget *dialog,
gint response,
gpointer data);
static void check_response (GtkWidget *dialog,
gint response,
gpointer data);
static void type_combo_callback (PikaIntComboBox *combo,
gpointer data);
static void type_combo_callback (PikaProcedureConfig *config);
G_DEFINE_TYPE (Compose, compose, PIKA_TYPE_PLUG_IN)
@ -408,8 +410,8 @@ compose_create_procedure (PikaPlugIn *plug_in,
pika_procedure_set_documentation (procedure,
_("Create an image using multiple "
"gray images as color channels"),
"This function creates a new image from "
"multiple gray images",
_("This function creates a new image from "
"multiple gray images"),
name);
pika_procedure_set_attribution (procedure,
"Peter Kirchgessner",
@ -417,32 +419,44 @@ compose_create_procedure (PikaPlugIn *plug_in,
"1997");
PIKA_PROC_ARG_IMAGE (procedure, "image-2",
"Image 2",
"Second input image",
_("Image 2"),
_("Second input image"),
TRUE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_IMAGE (procedure, "image-3",
"Image 3",
"Third input image",
_("Image 3"),
_("Third input image"),
TRUE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_IMAGE (procedure, "image-4",
"Image 4",
"Fourth input image",
_("Image 4"),
_("Fourth input image"),
TRUE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_STRING (procedure, "compose-type",
"Compose type",
PIKA_PROC_ARG_CHOICE (procedure, "compose-type",
_("Color _model"),
type_desc->str,
"RGB",
pika_choice_new_with_values ("rgb", 0, _("RGB"), NULL,
"rgba", 1, _("RGBA"), NULL,
"hsv", 2, _("HSV"), NULL,
"hsl", 3, _("HSL"), NULL,
"cmyk", 4, _("CMYK"), NULL,
"lab", 5, _("LAB"), NULL,
"lch", 6, _("LCH"), NULL,
"ycbcr470", 7, _("YCbCr ITU R470"), NULL,
"ycbcr709", 8, _("YCbCr ITU R709"), NULL,
"ycbcr470f", 9, _("YCbCr ITU R470 256"), NULL,
"ycbcr709f", 10, _("YCbCr ITU R709 256"), NULL,
NULL),
"rgb",
G_PARAM_READWRITE);
PIKA_PROC_VAL_IMAGE (procedure, "new-image",
"New image",
"Output image",
_("New image"),
_("Output image"),
FALSE,
G_PARAM_READWRITE);
}
@ -457,10 +471,10 @@ compose_create_procedure (PikaPlugIn *plug_in,
PIKA_PROCEDURE_SENSITIVE_DRAWABLE);
pika_procedure_set_documentation (procedure,
"Compose an image from multiple "
"drawables of gray images",
"This function creates a new image from "
"multiple drawables of gray images",
_("Compose an image from multiple "
"drawables of gray images"),
_("This function creates a new image from "
"multiple drawables of gray images"),
name);
pika_procedure_set_attribution (procedure,
"Peter Kirchgessner",
@ -468,32 +482,44 @@ compose_create_procedure (PikaPlugIn *plug_in,
"1998");
PIKA_PROC_ARG_DRAWABLE (procedure, "drawable-2",
"Drawable 2",
"Second input drawable",
_("Drawable 2"),
_("Second input drawable"),
TRUE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DRAWABLE (procedure, "drawable-3",
"Drawable 3",
"Third input drawable",
_("Drawable 3"),
_("Third input drawable"),
TRUE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DRAWABLE (procedure, "drawable-4",
"Drawable 4",
"Fourth input drawable",
_("Drawable 4"),
_("Fourth input drawable"),
TRUE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_STRING (procedure, "compose-type",
"Compose type",
PIKA_PROC_ARG_CHOICE (procedure, "compose-type",
_("Color _model"),
type_desc->str,
"RGB",
pika_choice_new_with_values ("rgb", 0, _("RGB"), NULL,
"rgba", 1, _("RGBA"), NULL,
"hsv", 2, _("HSV"), NULL,
"hsl", 3, _("HSL"), NULL,
"cmyk", 4, _("CMYK"), NULL,
"lab", 5, _("LAB"), NULL,
"lch", 6, _("LCH"), NULL,
"ycbcr470", 7, _("YCbCr ITU R470"), NULL,
"ycbcr709", 8, _("YCbCr ITU R709"), NULL,
"ycbcr470f", 9, _("YCbCr ITU R470 256"), NULL,
"ycbcr709f", 10, _("YCbCr ITU R709 256"), NULL,
NULL),
"rgb",
G_PARAM_READWRITE);
PIKA_PROC_VAL_IMAGE (procedure, "new-image",
"New image",
"Output image",
_("New image"),
_("Output image"),
FALSE,
G_PARAM_READWRITE);
}
@ -515,11 +541,11 @@ compose_create_procedure (PikaPlugIn *plug_in,
pika_procedure_set_documentation (procedure,
_("Recompose an image that was "
"previously decomposed"),
"This function recombines the grayscale "
"layers produced by Decompose "
"into a single RGB or RGBA layer, and "
"replaces the originally decomposed "
"layer with the result.",
_("This function recombines the grayscale "
"layers produced by Decompose "
"into a single RGB or RGBA layer, and "
"replaces the originally decomposed "
"layer with the result."),
name);
pika_procedure_set_attribution (procedure,
"Bill Skaggs",
@ -538,13 +564,14 @@ compose_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaDrawable *drawable = NULL;
const gchar *name = pika_procedure_get_name (procedure);
gint compose_by_drawable;
gint compose_idx;
gint i;
gegl_init (NULL, NULL);
@ -662,8 +689,6 @@ compose_run (PikaProcedure *procedure,
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
pika_get_data (name, &composevals);
compose_by_drawable = TRUE;
/* Get a drawable-ID of the image */
@ -689,7 +714,8 @@ compose_run (PikaProcedure *procedure,
g_free (layers);
}
if (! compose_dialog (composevals.compose_type, drawable))
if (! compose_dialog (procedure, config, composevals.compose_type,
drawable))
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
@ -699,21 +725,23 @@ compose_run (PikaProcedure *procedure,
if (compose_by_drawable)
{
composevals.inputs[0].comp.object = drawable;
composevals.inputs[1].comp.object = PIKA_VALUES_GET_DRAWABLE (args, 0);
composevals.inputs[2].comp.object = PIKA_VALUES_GET_DRAWABLE (args, 1);
composevals.inputs[3].comp.object = PIKA_VALUES_GET_DRAWABLE (args, 2);
g_object_get (config,
"drawable-2", &composevals.inputs[1].comp.object,
"drawable-3", &composevals.inputs[2].comp.object,
"drawable-4", &composevals.inputs[3].comp.object,
NULL);
}
else
{
composevals.inputs[0].comp.object = image;
composevals.inputs[1].comp.object = PIKA_VALUES_GET_IMAGE (args, 0);
composevals.inputs[2].comp.object = PIKA_VALUES_GET_IMAGE (args, 1);
composevals.inputs[3].comp.object = PIKA_VALUES_GET_IMAGE (args, 2);
}
g_strlcpy (composevals.compose_type,
PIKA_VALUES_GET_STRING (args, 3),
sizeof (composevals.compose_type));
g_object_get (config,
"image-2", &composevals.inputs[1].comp.object,
"image-3", &composevals.inputs[2].comp.object,
"image-4", &composevals.inputs[3].comp.object,
NULL);
}
for (i = 0; i < MAX_COMPOSE_IMAGES; i++)
{
@ -730,8 +758,6 @@ compose_run (PikaProcedure *procedure,
break;
case PIKA_RUN_WITH_LAST_VALS:
pika_get_data (name, &composevals);
compose_by_drawable = TRUE;
break;
@ -740,17 +766,47 @@ compose_run (PikaProcedure *procedure,
}
}
compose_idx = pika_procedure_config_get_choice_id (config, "compose-type");
if (compose_idx >= 0 && compose_idx < G_N_ELEMENTS (compose_dsc))
{
g_strlcpy (composevals.compose_type,
compose_dsc[compose_idx].compose_type,
sizeof (composevals.compose_type));
}
pika_progress_init (_("Composing"));
image = compose (composevals.compose_type,
composevals.inputs,
compose_by_drawable);
compose_by_drawable,
config);
if (! image)
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
NULL);
/* Save drawables/images in PikaProcedureConfig */
if (run_mode == PIKA_RUN_NONINTERACTIVE)
{
if (compose_by_drawable)
{
g_object_set (config,
"drawable-2", composevals.inputs[1].comp.object,
"drawable-3", composevals.inputs[2].comp.object,
"drawable-4", composevals.inputs[3].comp.object,
NULL);
}
else
{
g_object_set (config,
"image-2", composevals.inputs[1].comp.object,
"image-3", composevals.inputs[2].comp.object,
"image-4", composevals.inputs[3].comp.object,
NULL);
}
}
if (composevals.do_recompose)
{
pika_displays_flush ();
@ -764,9 +820,6 @@ compose_run (PikaProcedure *procedure,
pika_display_new (image);
}
if (run_mode == PIKA_RUN_INTERACTIVE)
pika_set_data (name, &composevals, sizeof (ComposeVals));
return_vals = pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,
NULL);
@ -930,9 +983,10 @@ perform_composition (COMPOSE_DSC curr_compose_dsc,
/* Compose an image from several gray-images */
static PikaImage *
compose (const gchar *compose_type,
ComposeInput *inputs,
gboolean compose_by_drawable)
compose (const gchar *compose_type,
ComposeInput *inputs,
gboolean compose_by_drawable,
PikaProcedureConfig *config)
{
gint width, height;
gint num_images, compose_idx;
@ -1143,33 +1197,26 @@ create_new_image (GFile *file,
static gboolean
compose_dialog (const gchar *compose_type,
PikaDrawable *drawable)
compose_dialog (PikaProcedure *procedure,
PikaProcedureConfig *config,
const gchar *compose_type,
PikaDrawable *drawable)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *combo;
GtkWidget *grid;
GtkSizeGroup *size_group;
PikaLayer **layer_list;
gint compose_idx;
gint nlayers;
gint j;
gboolean run;
/* Check default compose type */
composeint.compose_idx = 0;
for (j = 0; j < G_N_ELEMENTS (compose_dsc); j++)
{
if (g_ascii_strcasecmp (compose_type, compose_dsc[j].compose_type) == 0)
{
composeint.compose_idx = j;
break;
}
}
compose_idx = pika_procedure_config_get_choice_id (config, "compose-type");
/* Save original image width/height */
composeint.width = pika_drawable_get_width (drawable);
@ -1180,19 +1227,14 @@ compose_dialog (const gchar *compose_type,
layer_list = pika_image_get_layers (pika_item_get_image (PIKA_ITEM (drawable)),
&nlayers);
dialog = pika_dialog_new (_("Compose"), PLUG_IN_ROLE,
NULL, 0,
pika_standard_help_func, COMPOSE_PROC,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_OK"), GTK_RESPONSE_OK,
NULL);
dialog = pika_procedure_dialog_new (procedure,
PIKA_PROCEDURE_CONFIG (config),
_("Compose"));
pika_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
g_signal_connect (dialog, "response",
G_CALLBACK (check_response),
@ -1200,53 +1242,20 @@ compose_dialog (const gchar *compose_type,
pika_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
main_vbox, TRUE, TRUE, 0);
gtk_widget_show (main_vbox);
/* Compose type combo */
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"compose-label", _("Compose Channels"),
FALSE, FALSE);
frame = pika_frame_new (_("Compose Channels"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
pika_procedure_dialog_fill_frame (PIKA_PROCEDURE_DIALOG (dialog),
"compose-frame", "compose-label", FALSE,
"compose-type");
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_widget_show (hbox);
size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
label = gtk_label_new_with_mnemonic (_("Color _model:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
gtk_size_group_add_widget (size_group, label);
g_object_unref (size_group);
combo = g_object_new (PIKA_TYPE_INT_COMBO_BOX, NULL);
for (j = 0; j < G_N_ELEMENTS (compose_dsc); j++)
{
gchar *label = g_strdup (gettext (compose_dsc[j].compose_type));
gchar *l;
for (l = label; *l; l++)
if (*l == '-' || *l == '_')
*l = ' ';
pika_int_combo_box_append (PIKA_INT_COMBO_BOX (combo),
PIKA_INT_STORE_LABEL, label,
PIKA_INT_STORE_VALUE, j,
-1);
g_free (label);
}
gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0);
gtk_widget_show (combo);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
main_vbox = pika_procedure_dialog_fill_box (PIKA_PROCEDURE_DIALOG (dialog),
"compose-vbox", "compose-frame",
NULL);
pika_procedure_dialog_fill (PIKA_PROCEDURE_DIALOG (dialog),
"compose-vbox", NULL);
/* Channel representation grid */
@ -1264,6 +1273,8 @@ compose_dialog (const gchar *compose_type,
gtk_box_pack_start (GTK_BOX (vbox), grid, FALSE, FALSE, 0);
gtk_widget_show (grid);
size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
for (j = 0; j < MAX_COMPOSE_IMAGES; j++)
{
GtkWidget *image;
@ -1275,7 +1286,6 @@ compose_dialog (const gchar *compose_type,
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_grid_attach (GTK_GRID (grid), hbox, 0, j, 1, 1);
// GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (hbox);
gtk_size_group_add_widget (size_group, hbox);
@ -1289,8 +1299,8 @@ compose_dialog (const gchar *compose_type,
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
if (composeint.compose_idx >= 0 &&
nlayers >= compose_dsc[composeint.compose_idx].num_images &&
if (compose_idx >= 0 &&
nlayers >= compose_dsc[compose_idx].num_images &&
j < nlayers)
{
composeint.selected[j].comp.object = layer_list[j];
@ -1313,7 +1323,6 @@ compose_dialog (const gchar *compose_type,
PIKA_INT_STORE_ICON_NAME, PIKA_ICON_CHANNEL_GRAY,
-1);
gtk_grid_attach (GTK_GRID (grid), combo, 1, j, 1, 1);
// GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (combo);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
@ -1341,14 +1350,14 @@ compose_dialog (const gchar *compose_type,
g_free (layer_list);
/* Calls the combo callback and sets icons, labels and sensitivity */
pika_int_combo_box_connect (PIKA_INT_COMBO_BOX (combo),
composeint.compose_idx,
G_CALLBACK (type_combo_callback),
NULL, NULL);
g_signal_connect (config, "notify::compose-type",
G_CALLBACK (type_combo_callback),
NULL);
type_combo_callback (config);
gtk_widget_show (dialog);
run = (pika_dialog_run (PIKA_DIALOG (dialog)) == GTK_RESPONSE_OK);
run = pika_procedure_dialog_run (PIKA_PROCEDURE_DIALOG (dialog));
gtk_widget_destroy (dialog);
@ -1367,7 +1376,7 @@ compose_dialog (const gchar *compose_type,
}
strcpy (composevals.compose_type,
compose_dsc[composeint.compose_idx].compose_type);
compose_dsc[compose_idx].compose_type);
}
return run;
@ -1468,46 +1477,46 @@ scale_callback (PikaLabelSpin *scale,
}
static void
type_combo_callback (PikaIntComboBox *combo,
gpointer data)
type_combo_callback (PikaProcedureConfig *config)
{
if (pika_int_combo_box_get_active (combo, &composeint.compose_idx))
gboolean combo4;
gboolean scale4;
gint compose_idx;
gint j;
if (config)
compose_idx = pika_procedure_config_get_choice_id (config, "compose-type");
else
return;
for (j = 0; j < MAX_COMPOSE_IMAGES; j++)
{
gboolean combo4;
gboolean scale4;
gint compose_idx;
gint j;
GtkWidget *label = composeint.channel_label[j];
GtkWidget *image = composeint.channel_icon[j];
const gchar *text = compose_dsc[compose_idx].components[j].name;
const gchar *icon = compose_dsc[compose_idx].components[j].icon;
compose_idx = composeint.compose_idx;
gtk_label_set_text_with_mnemonic (GTK_LABEL (label),
text ? gettext (text) : "");
for (j = 0; j < MAX_COMPOSE_IMAGES; j++)
if (icon)
{
GtkWidget *label = composeint.channel_label[j];
GtkWidget *image = composeint.channel_icon[j];
const gchar *text = compose_dsc[compose_idx].components[j].name;
const gchar *icon = compose_dsc[compose_idx].components[j].icon;
gtk_label_set_text_with_mnemonic (GTK_LABEL (label),
text ? gettext (text) : "");
if (icon)
{
gtk_image_set_from_icon_name (GTK_IMAGE (image),
icon, GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image);
}
else
{
gtk_image_clear (GTK_IMAGE (image));
gtk_widget_hide (image);
}
gtk_image_set_from_icon_name (GTK_IMAGE (image),
icon, GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image);
}
else
{
gtk_image_clear (GTK_IMAGE (image));
gtk_widget_hide (image);
}
/* Set sensitivity of last menu */
combo4 = (compose_dsc[compose_idx].num_images == 4);
gtk_widget_set_sensitive (composeint.channel_menu[3], combo4);
scale4 = combo4 && !composeint.selected[3].is_object;
gtk_widget_set_sensitive (composeint.scales[3], scale4);
}
/* Set sensitivity of last menu */
combo4 = (compose_dsc[compose_idx].num_images == 4);
gtk_widget_set_sensitive (composeint.channel_menu[3], combo4);
scale4 = combo4 && !composeint.selected[3].is_object;
gtk_widget_set_sensitive (composeint.scales[3], scale4);
}

66
plug-ins/common/contrast-retinex.c
View File

@ -79,7 +79,7 @@ struct _RetinexClass
#define RETINEX_TYPE (retinex_get_type ())
#define RETINEX (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RETINEX_TYPE, Retinex))
#define RETINEX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RETINEX_TYPE, Retinex))
GType retinex_get_type (void) G_GNUC_CONST;
@ -92,7 +92,7 @@ static PikaValueArray * retinex_run (PikaProcedure *procedur
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static gboolean retinex_dialog (PikaProcedure *procedure,
@ -234,25 +234,18 @@ retinex_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaDrawable *drawable;
gint x, y, width, height;
PikaDrawable *drawable;
gint x, y, width, height;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
if (n_drawables != 1)
{
GError *error = NULL;
pika_procedure_config_end_run (config, PIKA_PDB_EXECUTION_ERROR);
g_object_unref (config);
g_set_error (&error, PIKA_PLUG_IN_ERROR, 0,
_("Procedure '%s' only works with one drawable."),
PLUG_IN_PROC);
@ -269,32 +262,14 @@ retinex_run (PikaProcedure *procedure,
if (! pika_drawable_mask_intersect (drawable, &x, &y, &width, &height) ||
width < MIN_GAUSSIAN_SCALE ||
height < MIN_GAUSSIAN_SCALE)
{
pika_procedure_config_end_run (config, PIKA_PDB_EXECUTION_ERROR);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
NULL);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
NULL);
}
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
if (! retinex_dialog (procedure, G_OBJECT (config), drawable))
{
pika_procedure_config_end_run (config, PIKA_PDB_CANCEL);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
break;
default:
break;
}
if (run_mode == PIKA_RUN_INTERACTIVE && ! retinex_dialog (procedure, G_OBJECT (config), drawable))
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
if (pika_drawable_is_rgb (drawable))
{
@ -307,17 +282,11 @@ retinex_run (PikaProcedure *procedure,
}
else
{
pika_procedure_config_end_run (config, PIKA_PDB_EXECUTION_ERROR);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
NULL);
}
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL);
}
@ -409,11 +378,11 @@ retinex (GObject *config,
PikaDrawable *drawable,
PikaPreview *preview)
{
GeglBuffer *src_buffer;
GeglBuffer *src_buffer = NULL;
GeglBuffer *dest_buffer;
const Babl *format;
guchar *src = NULL;
guchar *psrc = NULL;
const Babl *format = NULL;
guchar *src = NULL;
guchar *psrc = NULL;
gint x, y, width, height;
gint size, bytes;
@ -476,7 +445,8 @@ retinex (GObject *config,
format, psrc,
GEGL_AUTO_ROWSTRIDE);
g_object_unref (src_buffer);
if (src_buffer)
g_object_unref (src_buffer);
g_object_unref (dest_buffer);
pika_progress_update (1.0);

6
plug-ins/common/crop-zealous.c
View File

@ -44,7 +44,7 @@ struct _CropClass
};
#define CROP_TYPE (crop_get_type ())
#define CROP (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CROP_TYPE, Crop))
#define CROP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CROP_TYPE, Crop))
GType crop_get_type (void) G_GNUC_CONST;
@ -57,7 +57,7 @@ static PikaValueArray * crop_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static inline gboolean colors_equal (const gfloat *col1,
@ -134,7 +134,7 @@ crop_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaDrawable *drawable;

1246
plug-ins/common/curve-bend.c
View File

File diff suppressed because it is too large Load Diff

53
plug-ins/common/decompose.c
View File

@ -91,7 +91,7 @@ struct _DecomposeClass
#define DECOMPOSE_TYPE (decompose_get_type ())
#define DECOMPOSE (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DECOMPOSE_TYPE, Decompose))
#define DECOMPOSE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DECOMPOSE_TYPE, Decompose))
GType decompose_get_type (void) G_GNUC_CONST;
@ -104,7 +104,7 @@ static PikaValueArray * decompose_run (PikaProcedure *proced
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static gint decompose (PikaImage *image,
@ -355,20 +355,19 @@ decompose_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaValueArray *return_vals;
PikaDrawable *drawable;
gint num_images;
PikaImage *image_extract[MAX_EXTRACT_IMAGES];
PikaLayer *layer_extract[MAX_EXTRACT_IMAGES];
gint num_layers;
GString *data;
gchar *decompose_type;
gchar *tmp;
gint j;
PikaValueArray *return_vals;
PikaDrawable *drawable;
gint num_images;
PikaImage *image_extract[MAX_EXTRACT_IMAGES];
PikaLayer *layer_extract[MAX_EXTRACT_IMAGES];
gint num_layers;
GString *data;
gchar *decompose_type;
gchar *tmp;
gint j;
gegl_init (NULL, NULL);
@ -389,9 +388,6 @@ decompose_run (PikaProcedure *procedure,
drawable = drawables[0];
}
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
g_object_get (config,
"decompose-type", &decompose_type,
NULL);
@ -405,15 +401,8 @@ decompose_run (PikaProcedure *procedure,
g_free (tmp);
if (run_mode == PIKA_RUN_INTERACTIVE)
{
if (! decompose_dialog (procedure, G_OBJECT (config)))
{
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
}
if (run_mode == PIKA_RUN_INTERACTIVE && ! decompose_dialog (procedure, G_OBJECT (config)))
return pika_procedure_new_return_values (procedure, PIKA_PDB_CANCEL, NULL);
pika_progress_init (_("Decomposing"));
@ -425,14 +414,7 @@ decompose_run (PikaProcedure *procedure,
layer_extract);
if (num_images <= 0)
{
pika_procedure_config_end_run (config, PIKA_PDB_EXECUTION_ERROR);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
NULL);
}
return pika_procedure_new_return_values (procedure, PIKA_PDB_EXECUTION_ERROR, NULL);
/* create decompose-data parasite */
data = g_string_new ("");
@ -473,9 +455,6 @@ decompose_run (PikaProcedure *procedure,
pika_display_new (image_extract[j]);
}
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
pika_progress_end ();
return return_vals;

991
plug-ins/common/depth-merge.c
View File

File diff suppressed because it is too large Load Diff

38
plug-ins/common/despeckle.c
View File

@ -85,7 +85,7 @@ struct _DespeckleClass
#define DESPECKLE_TYPE (despeckle_get_type ())
#define DESPECKLE (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DESPECKLE_TYPE, Despeckle))
#define DESPECKLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DESPECKLE_TYPE, Despeckle))
GType despeckle_get_type (void) G_GNUC_CONST;
@ -98,7 +98,7 @@ static PikaValueArray * despeckle_run (PikaProcedure *proced
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static void despeckle (PikaDrawable *drawable,
@ -220,11 +220,10 @@ despeckle_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaDrawable *drawable;
PikaDrawable *drawable;
gegl_init (NULL, NULL);
@ -245,35 +244,14 @@ despeckle_run (PikaProcedure *procedure,
drawable = drawables[0];
}
if (! pika_drawable_is_rgb (drawable) &&
! pika_drawable_is_gray (drawable))
{
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
NULL);
}
if (! pika_drawable_is_rgb (drawable) && ! pika_drawable_is_gray (drawable))
return pika_procedure_new_return_values (procedure, PIKA_PDB_EXECUTION_ERROR, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
if (run_mode == PIKA_RUN_INTERACTIVE)
{
if (! despeckle_dialog (procedure, G_OBJECT (config), drawable))
{
pika_procedure_config_end_run (config, PIKA_PDB_CANCEL);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
}
if (run_mode == PIKA_RUN_INTERACTIVE && ! despeckle_dialog (procedure, G_OBJECT (config), drawable))
return pika_procedure_new_return_values (procedure, PIKA_PDB_CANCEL, NULL);
despeckle (drawable, G_OBJECT (config));
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL);
}

61
plug-ins/common/destripe.c
View File

@ -57,7 +57,7 @@ struct _DestripeClass
#define DESTRIPE_TYPE (destripe_get_type ())
#define DESTRIPE (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DESTRIPE_TYPE, Destripe))
#define DESTRIPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DESTRIPE_TYPE, Destripe))
GType destripe_get_type (void) G_GNUC_CONST;
@ -70,7 +70,7 @@ static PikaValueArray * destripe_run (PikaProcedure *procedu
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static void destripe (GObject *config,
@ -164,24 +164,17 @@ destripe_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaDrawable *drawable;
PikaDrawable *drawable;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
if (n_drawables != 1)
{
GError *error = NULL;
pika_procedure_config_end_run (config, PIKA_PDB_EXECUTION_ERROR);
g_object_unref (config);
g_set_error (&error, PIKA_PLUG_IN_ERROR, 0,
_("Procedure '%s' only works with one drawable."),
PLUG_IN_PROC);
@ -195,44 +188,20 @@ destripe_run (PikaProcedure *procedure,
drawable = drawables[0];
}
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
if (! destripe_dialog (procedure, G_OBJECT (config), drawable))
{
pika_procedure_config_end_run (config, PIKA_PDB_CANCEL);
g_object_unref (config);
if (run_mode == PIKA_RUN_INTERACTIVE && ! destripe_dialog (procedure, G_OBJECT (config), drawable))
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
break;
default:
break;
};
if (pika_drawable_is_rgb (drawable) ||
pika_drawable_is_gray (drawable))
{
destripe (G_OBJECT (config), drawable, NULL);
if (run_mode != PIKA_RUN_NONINTERACTIVE)
pika_displays_flush ();
}
if (pika_drawable_is_rgb (drawable)|| pika_drawable_is_gray (drawable))
destripe (G_OBJECT (config), drawable, NULL);
else
{
pika_procedure_config_end_run (config, PIKA_PDB_EXECUTION_ERROR);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
NULL);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
NULL);
}
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
if (run_mode != PIKA_RUN_NONINTERACTIVE)
pika_displays_flush ();
return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL);
}

23
plug-ins/common/file-aa.c
View File

@ -60,7 +60,7 @@ struct _AsciiClass
#define ASCII_TYPE (ascii_get_type ())
#define ASCII (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ASCII_TYPE, Ascii))
#define ASCII(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ASCII_TYPE, Ascii))
GType ascii_get_type (void) G_GNUC_CONST;
@ -74,7 +74,8 @@ static PikaValueArray * ascii_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static gboolean save_aa (GFile *file,
@ -128,7 +129,7 @@ ascii_create_procedure (PikaPlugIn *plug_in,
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
ascii_save, NULL, NULL);
FALSE, ascii_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "*");
@ -172,19 +173,16 @@ ascii_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, image, run_mode, args);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
@ -231,9 +229,6 @@ ascii_save (PikaProcedure *procedure,
}
}
pika_procedure_config_end_run (config, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
pika_image_delete (image);

338
plug-ins/common/file-cel.c
View File

@ -56,41 +56,46 @@ struct _CelClass
#define CEL_TYPE (cel_get_type ())
#define CEL (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CEL_TYPE, Cel))
#define CEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CEL_TYPE, Cel))
GType cel_get_type (void) G_GNUC_CONST;
static GList * cel_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * cel_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * cel_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * cel_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * cel_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * cel_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * cel_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * cel_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static gint load_palette (GFile *file,
FILE *fp,
guchar palette[],
GError **error);
static PikaImage * load_image (GFile *file,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
static void palette_dialog (const gchar *title);
static gboolean need_palette (GFile *file,
GError **error);
static gint load_palette (GFile *file,
guchar palette[],
GError **error);
static PikaImage * load_image (GFile *file,
GFile *palette_file,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
static gboolean palette_dialog (const gchar *title,
PikaProcedure *procedure,
PikaProcedureConfig *config);
static gboolean need_palette (GFile *file,
GError **error);
G_DEFINE_TYPE (Cel, cel, PIKA_TYPE_PLUG_IN)
@ -99,10 +104,6 @@ PIKA_MAIN (CEL_TYPE)
DEFINE_STD_SET_I18N
static gchar *palette_file = NULL;
static gsize data_length = 0;
static void
cel_class_init (CelClass *klass)
{
@ -158,18 +159,16 @@ cel_create_procedure (PikaPlugIn *plug_in,
pika_file_procedure_set_magics (PIKA_FILE_PROCEDURE (procedure),
"0,string,KiSS\\040");
PIKA_PROC_ARG_STRING (procedure, "palette-filename",
"Palette filename",
"Filename to load palette from",
NULL,
G_PARAM_READWRITE |
PIKA_PARAM_NO_VALIDATE);
PIKA_PROC_ARG_FILE (procedure, "palette-file",
_("_Palette file"),
_("KCF file to load palette from"),
G_PARAM_READWRITE);
}
else if (! strcmp (name, SAVE_PROC))
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
cel_save, NULL, NULL);
FALSE, cel_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "RGB*, INDEXED*");
@ -190,73 +189,80 @@ cel_create_procedure (PikaPlugIn *plug_in,
pika_file_procedure_set_extensions (PIKA_FILE_PROCEDURE (procedure),
"cel");
PIKA_PROC_ARG_STRING (procedure, "palette-filename",
"Palette filename",
"Filename to save palette to",
NULL,
G_PARAM_READWRITE |
PIKA_PARAM_NO_VALIDATE);
PIKA_PROC_ARG_FILE (procedure, "palette-file",
"Palette file",
"File to save palette to",
G_PARAM_READWRITE);
}
return procedure;
}
static PikaValueArray *
cel_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
cel_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *image = NULL;
gboolean needs_palette = FALSE;
GFile *palette_file = NULL;
GError *error = NULL;
gegl_init (NULL, NULL);
if (run_mode != PIKA_RUN_NONINTERACTIVE)
needs_palette = need_palette (file, &error);
if (error != NULL)
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
error);
g_object_get (config, "palette-file", &palette_file, NULL);
switch (run_mode)
{
data_length = pika_get_data_size (SAVE_PROC);
if (data_length > 0)
case PIKA_RUN_INTERACTIVE:
if (needs_palette)
{
palette_file = g_malloc (data_length);
pika_get_data (SAVE_PROC, palette_file);
}
else
{
palette_file = g_strdup ("*.kcf");
data_length = strlen (palette_file) + 1;
/* Let user choose KCF palette (cancel ignores) */
if (! palette_dialog (_("Load KISS Palette"), procedure, config))
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
g_clear_object (&palette_file);
g_object_get (config, "palette-file", &palette_file, NULL);
}
break;
case PIKA_RUN_WITH_LAST_VALS:
if (! needs_palette)
/* It is possible to have a palette file from a previous call. Just ignore
* it if it's unneeded, yet keep it stored.
*/
g_clear_object (&palette_file);
break;
case PIKA_RUN_NONINTERACTIVE:
/* Note: we don't forbid setting a palette file when unneeded as a way to
* override the embedded palette in scripts.
*/
break;
}
if (run_mode == PIKA_RUN_NONINTERACTIVE)
if (needs_palette && palette_file == NULL)
{
palette_file = (gchar *) PIKA_VALUES_GET_STRING (args, 0);
if (palette_file)
data_length = strlen (palette_file) + 1;
else
data_length = 0;
}
else if (run_mode == PIKA_RUN_INTERACTIVE)
{
/* Let user choose KCF palette (cancel ignores) */
needs_palette = need_palette (file, &error);
g_set_error (&error, G_FILE_ERROR, 0,
_("This KISS CEL image requires a palette file."));
if (! error)
{
if (needs_palette)
palette_dialog (_("Load KISS Palette"));
pika_set_data (SAVE_PROC, palette_file, data_length);
}
}
if (! error)
{
image = load_image (file, &error);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CALLING_ERROR,
error);
}
image = load_image (file, palette_file, &error);
g_clear_object (&palette_file);
if (! image)
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
@ -278,12 +284,13 @@ cel_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
GError *error = NULL;
gegl_init (NULL, NULL);
@ -318,17 +325,8 @@ cel_save (PikaProcedure *procedure,
error);
}
if (save_image (file, image, drawables[0], &error))
{
if (data_length)
{
pika_set_data (SAVE_PROC, palette_file, data_length);
}
}
else
{
status = PIKA_PDB_EXECUTION_ERROR;
}
if (! save_image (file, image, drawables[0], &error))
status = PIKA_PDB_EXECUTION_ERROR;
if (export == PIKA_EXPORT_EXPORT)
{
@ -376,6 +374,7 @@ need_palette (GFile *file,
static PikaImage *
load_image (GFile *file,
GFile *palette_file,
GError **error)
{
FILE *fp; /* Read file pointer */
@ -384,7 +383,7 @@ load_image (GFile *file,
bpp; /* Bits per pixel */
gint height, width, /* Dimensions of image */
offx, offy, /* Layer offsets */
colors; /* Number of colors */
colors; /* Number of colors */
PikaImage *image; /* Image */
PikaLayer *layer; /* Layer */
@ -630,29 +629,9 @@ load_image (GFile *file,
/* Use palette from file or otherwise default grey palette */
guchar palette[256 * 3];
/* Open the file for reading if user picked one */
if (palette_file == NULL)
if (palette_file != NULL)
{
fp = NULL;
}
else
{
fp = g_fopen (palette_file, "r");
if (fp == NULL)
{
g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
_("Could not open '%s' for reading: %s"),
pika_filename_to_utf8 (palette_file),
g_strerror (errno));
return NULL;
}
}
if (fp != NULL)
{
colors = load_palette (g_file_new_for_path (palette_file), fp, palette, error);
fclose (fp);
colors = load_palette (palette_file, palette, error);
if (colors < 0 || *error)
return NULL;
}
@ -677,42 +656,43 @@ load_image (GFile *file,
}
static gint
load_palette (GFile *file,
FILE *fp,
guchar palette[],
GError **error)
load_palette (GFile *file,
guchar palette[],
GError **error)
{
guchar header[32]; /* File header */
guchar buffer[2];
guchar file_mark, bpp;
gint i, colors = 0;
size_t n_read;
GFileInputStream *input;
guchar header[32]; /* File header */
guchar buffer[2];
guchar file_mark, bpp;
gint i, colors = 0;
gssize n_read;
n_read = fread (header, 4, 1, fp);
input = g_file_read (file, NULL, error);
if (input == NULL)
return -1;
n_read = g_input_stream_read (G_INPUT_STREAM (input), header, 4, NULL, error);
if (n_read < 1)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s': EOF or error while reading palette header"),
pika_file_get_utf8_name (file));
g_object_unref (input);
return -1;
}
if (!strncmp ((const gchar *) header, "KiSS", 4))
{
n_read = fread (header+4, 28, 1, fp);
n_read = g_input_stream_read (G_INPUT_STREAM (input), header + 4, 28, NULL, error);
if (n_read < 1)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s': EOF or error while reading palette header"),
pika_file_get_utf8_name (file));
g_object_unref (input);
return -1;
}
file_mark = header[4];
if (file_mark != 0x10)
{
g_object_unref (input);
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s': is not a KCF palette file"),
pika_file_get_utf8_name (file));
@ -722,6 +702,7 @@ load_palette (GFile *file,
bpp = header[5];
if (bpp != 12 && bpp != 24)
{
g_object_unref (input);
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s': illegal bpp value in palette: %hhu"),
pika_file_get_utf8_name (file), bpp);
@ -731,6 +712,7 @@ load_palette (GFile *file,
colors = header[8] + header[9] * 256;
if (colors != 16 && colors != 256)
{
g_object_unref (input);
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s': illegal number of colors: %u"),
pika_file_get_utf8_name (file), colors);
@ -742,16 +724,22 @@ load_palette (GFile *file,
case 12:
for (i = 0; i < colors; ++i)
{
n_read = fread (buffer, 1, 2, fp);
n_read = g_input_stream_read (G_INPUT_STREAM (input), buffer, 2, NULL, error);
if (n_read < 2)
if (n_read == 1)
{
g_object_unref (input);
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s': EOF or error while reading "
"palette data"),
pika_file_get_utf8_name (file));
return -1;
}
else if (n_read < 1)
{
g_object_unref (input);
return -1;
}
palette[i*3]= buffer[0] & 0xf0;
palette[i*3+1]= (buffer[1] & 0x0f) * 16;
@ -759,10 +747,16 @@ load_palette (GFile *file,
}
break;
case 24:
n_read = fread (palette, colors, 3, fp);
n_read = g_input_stream_read (G_INPUT_STREAM (input), palette, 3 * colors, NULL, error);
if (n_read < 3)
if (n_read < 1)
{
g_object_unref (input);
return -1;
}
else if (n_read < 3 * colors)
{
g_object_unref (input);
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s': EOF or error while reading palette data"),
pika_file_get_utf8_name (file));
@ -776,13 +770,24 @@ load_palette (GFile *file,
else
{
colors = 16;
fseek (fp, 0, SEEK_SET);
if (! g_seekable_seek (G_SEEKABLE (input), 0, G_SEEK_SET, NULL, error))
{
g_object_unref (input);
return -1;
}
for (i= 0; i < colors; ++i)
{
n_read = fread (buffer, 1, 2, fp);
n_read = g_input_stream_read (G_INPUT_STREAM (input), buffer, 2, NULL, error);
if (n_read < 2)
if (n_read < 1)
{
g_object_unref (input);
return -1;
}
else if (n_read == 1)
{
g_object_unref (input);
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("'%s': EOF or error while reading palette data"),
pika_file_get_utf8_name (file));
@ -992,38 +997,25 @@ save_image (GFile *file,
return FALSE;
}
static void
palette_dialog (const gchar *title)
static gboolean
palette_dialog (const gchar *title,
PikaProcedure *procedure,
PikaProcedureConfig *config)
{
GtkWidget *dialog;
gboolean run;
pika_ui_init (PLUG_IN_BINARY);
dialog = gtk_file_chooser_dialog_new (title, NULL,
GTK_FILE_CHOOSER_ACTION_OPEN,
dialog = pika_procedure_dialog_new (PIKA_PROCEDURE (procedure),
PIKA_PROCEDURE_CONFIG (config),
title);
pika_procedure_dialog_set_ok_label (PIKA_PROCEDURE_DIALOG (dialog), _("_Open"));
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Open"), GTK_RESPONSE_OK,
NULL);
pika_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog), palette_file);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_widget_show (dialog);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
{
g_free (palette_file);
palette_file = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
data_length = strlen (palette_file) + 1;
}
pika_procedure_dialog_fill (PIKA_PROCEDURE_DIALOG (dialog), NULL);
run = pika_procedure_dialog_run (PIKA_PROCEDURE_DIALOG (dialog));
gtk_widget_destroy (dialog);
return run;
}

108
plug-ins/common/file-compressor.c
View File

@ -149,60 +149,63 @@ struct _CompressorClass
#define COMPRESSOR_TYPE (compressor_get_type ())
#define COMPRESSOR (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COMPRESSOR_TYPE, Compressor))
#define COMPRESSOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COMPRESSOR_TYPE, Compressor))
GType compressor_get_type (void) G_GNUC_CONST;
static GList * compressor_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * compressor_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * compressor_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * compressor_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * compressor_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * compressor_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
static PikaValueArray * compressor_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * compressor_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (const CompressorEntry *compressor,
GFile *file,
gint32 run_mode,
PikaPDBStatusType *status,
GError **error);
static PikaPDBStatusType save_image (const CompressorEntry *compressor,
GFile *file,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
gint32 run_mode,
GError **error);
static PikaImage * load_image (const CompressorEntry *compressor,
GFile *file,
gint32 run_mode,
PikaPDBStatusType *status,
GError **error);
static PikaPDBStatusType save_image (const CompressorEntry *compressor,
GFile *file,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
gint32 run_mode,
GError **error);
static gboolean valid_file (GFile *file);
static const gchar * find_extension (const CompressorEntry *compressor,
const gchar *filename);
static gboolean valid_file (GFile *file);
static const gchar * find_extension (const CompressorEntry *compressor,
const gchar *filename);
static gboolean gzip_load (GFile *infile,
GFile *outfile);
static gboolean gzip_save (GFile *infile,
GFile *outfile);
static gboolean gzip_load (GFile *infile,
GFile *outfile);
static gboolean gzip_save (GFile *infile,
GFile *outfile);
static gboolean bzip2_load (GFile *infile,
GFile *outfile);
static gboolean bzip2_save (GFile *infile,
GFile *outfile);
static gboolean bzip2_load (GFile *infile,
GFile *outfile);
static gboolean bzip2_save (GFile *infile,
GFile *outfile);
static gboolean xz_load (GFile *infile,
GFile *outfile);
static gboolean xz_save (GFile *infile,
GFile *outfile);
static goffset get_file_info (GFile *file);
static gboolean xz_load (GFile *infile,
GFile *outfile);
static gboolean xz_save (GFile *infile,
GFile *outfile);
static goffset get_file_info (GFile *file);
G_DEFINE_TYPE (Compressor, compressor, PIKA_TYPE_PLUG_IN)
@ -334,7 +337,7 @@ compressor_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
compressor_save,
FALSE, compressor_save,
(gpointer) compressor, NULL);
pika_procedure_set_image_types (procedure, "RGB*, GRAY*, INDEXED*");
@ -368,11 +371,13 @@ compressor_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
compressor_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
compressor_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
const CompressorEntry *compressor = run_data;
PikaValueArray *return_vals;
@ -404,7 +409,8 @@ compressor_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
const CompressorEntry *compressor = run_data;

27
plug-ins/common/file-csource.c
View File

@ -51,7 +51,7 @@ struct _CsourceClass
#define CSOURCE_TYPE (csource_get_type ())
#define CSOURCE (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CSOURCE_TYPE, Csource))
#define CSOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CSOURCE_TYPE, Csource))
GType csource_get_type (void) G_GNUC_CONST;
@ -65,7 +65,8 @@ static PikaValueArray * csource_save (PikaProcedure *procedur
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static gboolean save_image (GFile *file,
@ -115,7 +116,7 @@ csource_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
csource_save, NULL, NULL);
FALSE, csource_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "*");
@ -208,15 +209,15 @@ csource_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
gchar *prefixed_name;
gchar *comment;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
gchar *prefixed_name;
gchar *comment;
GError *error = NULL;
gegl_init (NULL, NULL);
@ -225,9 +226,6 @@ csource_save (PikaProcedure *procedure,
PIKA_PDB_CALLING_ERROR,
NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_export (config, image, run_mode, args, NULL);
pika_ui_init (PLUG_IN_BINARY);
export = pika_export_image (&image, &n_drawables, &drawables, "C Source",
@ -283,9 +281,6 @@ csource_save (PikaProcedure *procedure,
}
}
pika_procedure_config_end_export (config, image, file, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
pika_image_delete (image);

38
plug-ins/common/file-desktop-link.c
View File

@ -55,23 +55,25 @@ struct _DesktopClass
#define DESKTOP_TYPE (desktop_get_type ())
#define DESKTOP (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DESKTOP_TYPE, Desktop))
#define DESKTOP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DESKTOP_TYPE, Desktop))
GType desktop_get_type (void) G_GNUC_CONST;
static GList * desktop_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * desktop_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * desktop_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * desktop_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * desktop_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * desktop_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
PikaRunMode run_mode,
GError **error);
static PikaImage * load_image (GFile *file,
PikaRunMode run_mode,
GError **error);
G_DEFINE_TYPE (Desktop, desktop, PIKA_TYPE_PLUG_IN)
@ -136,11 +138,13 @@ desktop_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
desktop_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
desktop_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_values;
PikaImage *image;

104
plug-ins/common/file-dicom.c
View File

@ -81,53 +81,56 @@ struct _DicomClass
#define DICOM_TYPE (dicom_get_type ())
#define DICOM (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DICOM_TYPE, Dicom))
#define DICOM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DICOM_TYPE, Dicom))
GType dicom_get_type (void) G_GNUC_CONST;
static GList * dicom_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * dicom_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * dicom_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * dicom_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * dicom_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * dicom_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * dicom_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * dicom_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
static void dicom_loader (guint8 *pix_buf,
DicomInfo *info,
GeglBuffer *buffer);
static void guess_and_set_endian2 (guint16 *buf16,
gint length);
static void toggle_endian2 (guint16 *buf16,
gint length);
static void add_tag_pointer (GByteArray *group_stream,
gint group,
gint element,
const gchar *value_rep,
const guint8 *data,
gint length);
static GSList * dicom_add_tags (FILE *dicom,
GByteArray *group_stream,
GSList *elements);
static gboolean write_group_to_file (FILE *dicom,
gint group,
GByteArray *group_stream);
static PikaImage * load_image (GFile *file,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
static void dicom_loader (guint8 *pix_buf,
DicomInfo *info,
GeglBuffer *buffer);
static void guess_and_set_endian2 (guint16 *buf16,
gint length);
static void toggle_endian2 (guint16 *buf16,
gint length);
static void add_tag_pointer (GByteArray *group_stream,
gint group,
gint element,
const gchar *value_rep,
const guint8 *data,
gint length);
static GSList * dicom_add_tags (FILE *dicom,
GByteArray *group_stream,
GSList *elements);
static gboolean write_group_to_file (FILE *dicom,
gint group,
GByteArray *group_stream);
G_DEFINE_TYPE (Dicom, dicom, PIKA_TYPE_PLUG_IN)
@ -201,7 +204,7 @@ dicom_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
dicom_save, NULL, NULL);
FALSE, dicom_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "RGB, GRAY");
@ -236,11 +239,13 @@ dicom_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
dicom_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
dicom_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *image;
@ -271,7 +276,8 @@ dicom_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaPDBStatusType status = PIKA_PDB_SUCCESS;

83
plug-ins/common/file-farbfeld.c
View File

@ -54,37 +54,40 @@ struct _FarbfeldClass
#define FARBFELD_TYPE (farbfeld_get_type ())
#define FARBFELD (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FARBFELD_TYPE, Farbfeld))
#define FARBFELD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FARBFELD_TYPE, Farbfeld))
GType farbfeld_get_type (void) G_GNUC_CONST;
static GList * farbfeld_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * farbfeld_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * farbfeld_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * farbfeld_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * farbfeld_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * farbfeld_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * farbfeld_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * farbfeld_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
GObject *config,
PikaRunMode run_mode,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
static PikaImage * load_image (GFile *file,
GObject *config,
PikaRunMode run_mode,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
G_DEFINE_TYPE (Farbfeld, farbfeld, PIKA_TYPE_PLUG_IN)
@ -154,7 +157,7 @@ farbfeld_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
farbfeld_save, NULL, NULL);
FALSE, farbfeld_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "*");
@ -179,22 +182,20 @@ farbfeld_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
farbfeld_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
farbfeld_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaValueArray *return_vals;
PikaImage *image;
GError *error = NULL;
PikaValueArray *return_vals;
PikaImage *image;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
image = load_image (file, G_OBJECT (config), run_mode, &error);
if (! image)
@ -202,9 +203,6 @@ farbfeld_load (PikaProcedure *procedure,
PIKA_PDB_EXECUTION_ERROR,
error);
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
return_vals = pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,
NULL);
@ -221,7 +219,8 @@ farbfeld_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaPDBStatusType status = PIKA_PDB_SUCCESS;

64
plug-ins/common/file-gbr.c
View File

@ -63,7 +63,7 @@ struct _GbrClass
#define GBR_TYPE (gbr_get_type ())
#define GBR (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GBR_TYPE, Gbr))
#define GBR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GBR_TYPE, Gbr))
GType gbr_get_type (void) G_GNUC_CONST;
@ -77,7 +77,8 @@ static PikaValueArray * gbr_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static gboolean save_dialog (PikaProcedure *procedure,
@ -122,7 +123,7 @@ gbr_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
gbr_save, NULL, NULL);
FALSE, gbr_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "*");
@ -174,17 +175,14 @@ gbr_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
gchar *description;
GError *error = NULL;
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, image, run_mode, args);
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
gchar *description;
GError *error = NULL;
g_object_get (config,
"description", &description,
@ -229,16 +227,6 @@ gbr_save (PikaProcedure *procedure,
break;
}
if (n_drawables != 1)
{
g_set_error (&error, G_FILE_ERROR, 0,
_("GBR format does not support multiple layers."));
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CALLING_ERROR,
error);
}
if (run_mode == PIKA_RUN_INTERACTIVE)
{
if (! save_dialog (procedure, G_OBJECT (config), image))
@ -247,25 +235,30 @@ gbr_save (PikaProcedure *procedure,
if (status == PIKA_PDB_SUCCESS)
{
PikaValueArray *save_retvals;
gint spacing;
PikaProcedure *procedure;
PikaValueArray *save_retvals;
PikaObjectArray *drawables_array;
gint spacing;
g_object_get (config,
"description", &description,
"spacing", &spacing,
NULL);
save_retvals =
pika_pdb_run_procedure (pika_get_pdb (),
"file-gbr-save-internal",
PIKA_TYPE_RUN_MODE, PIKA_RUN_NONINTERACTIVE,
PIKA_TYPE_IMAGE, image,
PIKA_TYPE_DRAWABLE, drawables[0],
G_TYPE_FILE, file,
G_TYPE_INT, spacing,
G_TYPE_STRING, description,
G_TYPE_NONE);
drawables_array = pika_object_array_new (PIKA_TYPE_DRAWABLE, (GObject **) drawables,
n_drawables, FALSE);
procedure = pika_pdb_lookup_procedure (pika_get_pdb (),
"file-gbr-save-internal");
save_retvals = pika_procedure_run (procedure,
"image", image,
"num-drawables", n_drawables,
"drawables", drawables_array,
"file", file,
"spacing", spacing,
"name", description,
NULL);
pika_object_array_free (drawables_array);
g_free (description);
if (PIKA_VALUES_GET_ENUM (save_retvals, 0) != PIKA_PDB_SUCCESS)
@ -281,9 +274,6 @@ gbr_save (PikaProcedure *procedure,
pika_value_array_unref (save_retvals);
}
pika_procedure_config_end_run (config, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
pika_image_delete (image);

70
plug-ins/common/file-gegl.c
View File

@ -74,36 +74,39 @@ struct _GoatClass
#define GOAT_TYPE (goat_get_type ())
#define GOAT (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOAT_TYPE, Goat))
#define GOAT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOAT_TYPE, Goat))
GType goat_get_type (void) G_GNUC_CONST;
static GList * goat_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * goat_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * goat_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * goat_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * goat_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * goat_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * goat_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * goat_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
const gchar *gegl_op,
GError **error);
static gboolean save_image (GFile *file,
const gchar *gegl_op,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
static PikaImage * load_image (GFile *file,
const gchar *gegl_op,
GError **error);
static gboolean save_image (GFile *file,
const gchar *gegl_op,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
G_DEFINE_TYPE (Goat, goat, PIKA_TYPE_PLUG_IN)
@ -218,7 +221,7 @@ goat_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
goat_save,
FALSE, goat_save,
(gpointer) format, NULL);
pika_procedure_set_image_types (procedure, "*");
@ -241,11 +244,13 @@ goat_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
goat_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
goat_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
const FileFormat *format = run_data;
PikaValueArray *return_vals;
@ -277,7 +282,8 @@ goat_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
const FileFormat *format = run_data;

90
plug-ins/common/file-gif-load.c
View File

@ -98,28 +98,30 @@ struct _GifClass
#define GIF_TYPE (gif_get_type ())
#define GIF (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIF_TYPE, Gif))
#define GIF(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIF_TYPE, Gif))
GType gif_get_type (void) G_GNUC_CONST;
static GList * gif_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * gif_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * gif_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * gif_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * gif_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * gif_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * gif_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * gif_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
gboolean thumbnail,
GError **error);
static PikaImage * load_image (GFile *file,
gboolean thumbnail,
GError **error);
G_DEFINE_TYPE (Gif, gif, PIKA_TYPE_PLUG_IN)
@ -177,8 +179,7 @@ gif_create_procedure (PikaPlugIn *plug_in,
pika_procedure_set_documentation (procedure,
"Loads files of Compuserve GIF "
"file format",
"FIXME: write help for gif_load",
"file format", NULL,
name);
pika_procedure_set_attribution (procedure,
"Spencer Kimball, Peter Mattis, "
@ -220,11 +221,13 @@ gif_create_procedure (PikaPlugIn *plug_in,
static PikaValueArray *
gif_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
gif_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *image;
@ -261,17 +264,18 @@ gif_load (PikaProcedure *procedure,
PIKA_PDB_SUCCESS,
NULL);
*flags = PIKA_METADATA_LOAD_ALL;
PIKA_VALUES_SET_IMAGE (return_vals, 1, image);
return return_vals;
}
static PikaValueArray *
gif_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
const PikaValueArray *args,
gpointer run_data)
gif_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *image;
@ -461,11 +465,6 @@ load_image (GFile *file,
}
}
if (GifScreen.AspectRatio != 0 && GifScreen.AspectRatio != 49)
{
g_message (_("Non-square pixels. Image might look squashed."));
}
highest_used_index = GifScreen.BitPixel;
while (TRUE)
@ -554,8 +553,29 @@ load_image (GFile *file,
}
if (!status)
break;
if (GifScreen.AspectRatio != 0 && GifScreen.AspectRatio != 49)
{
break;
/* Byte overflow is allowed per the GIF specification */
guint8 par = GifScreen.AspectRatio + 15;
if (par > 0)
{
gdouble image_xres;
gdouble image_yres;
gfloat ratio = par / 64.0;
g_message (_("Non-square pixels. Image might look squashed if "
"Dot for Dot mode is enabled."));
pika_image_get_resolution (image, &image_xres, &image_yres);
if (ratio < 1)
image_xres = image_yres * (1 / ratio);
else
image_yres = image_xres * ratio;
pika_image_set_resolution (image, image_xres, image_yres);
}
}
if (comment_parasite != NULL)

36
plug-ins/common/file-gif-save.c
View File

@ -67,7 +67,7 @@ struct _GifClass
#define GIF_TYPE (gif_get_type ())
#define GIF (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIF_TYPE, Gif))
#define GIF(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIF_TYPE, Gif))
GType gif_get_type (void) G_GNUC_CONST;
@ -81,7 +81,8 @@ static PikaValueArray * gif_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static gboolean save_image (GFile *file,
@ -142,7 +143,7 @@ gif_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
gif_save, NULL, NULL);
FALSE, gif_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "INDEXED*, GRAY*");
@ -259,21 +260,18 @@ gif_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
PikaImage *orig_image;
PikaImage *sanitized_image = NULL;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
PikaImage *orig_image;
PikaImage *sanitized_image = NULL;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_export (config, image, run_mode, args, NULL);
orig_image = image;
if (run_mode == PIKA_RUN_INTERACTIVE ||
@ -363,9 +361,6 @@ gif_save (PikaProcedure *procedure,
pika_image_delete (sanitized_image);
}
pika_procedure_config_end_export (config, image, file, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
pika_image_delete (image);
@ -1263,7 +1258,8 @@ save_dialog (PikaImage *image,
widget = pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"milliseconds",
_("milliseconds"));
_("milliseconds"),
FALSE, FALSE);
gtk_label_set_xalign (GTK_LABEL (widget), 0.1);
gtk_grid_attach (GTK_GRID (grid), widget, 1, 1, 1, 1);
gtk_widget_set_visible (widget, TRUE);
@ -1301,9 +1297,11 @@ save_dialog (PikaImage *image,
/* Used to create vbox to store hintbox in */
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"spacer", " ");
"spacer", " ",
FALSE, FALSE);
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"no-ani-title", _("Animated GIF"));
"no-ani-title", _("Animated GIF"),
FALSE, FALSE);
vbox = pika_procedure_dialog_fill_box (PIKA_PROCEDURE_DIALOG (dialog),
"no-animation-vbox", "spacer",

925
plug-ins/common/file-gih.c
View File

File diff suppressed because it is too large Load Diff

32
plug-ins/common/file-glob.c
View File

@ -46,8 +46,8 @@ struct _GlobClass
};
#define GLOB_TYPE (glob_get_type ())
#define GLOB (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GLOB_TYPE, Glob))
#define GLOB_TYPE (glob_get_type ())
#define GLOB(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GLOB_TYPE, Glob))
GType glob_get_type (void) G_GNUC_CONST;
@ -56,7 +56,7 @@ static PikaProcedure * glob_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * glob_run (PikaProcedure *procedure,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static gboolean glob_match (const gchar *pattern,
@ -145,29 +145,33 @@ glob_create_procedure (PikaPlugIn *plug_in,
static PikaValueArray *
glob_run (PikaProcedure *procedure,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
const gchar *pattern;
gchar *pattern;
gboolean filename_encoding;
gchar **matches;
pattern = PIKA_VALUES_GET_STRING (args, 0);
filename_encoding = PIKA_VALUES_GET_BOOLEAN (args, 1);
g_object_get (config,
"pattern", &pattern,
"filename-encoding", &filename_encoding,
NULL);
if (! glob_match (pattern, filename_encoding, &matches))
{
return pika_procedure_new_return_values (procedure,
return_vals = pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
NULL);
}
return_vals = pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,
NULL);
PIKA_VALUES_TAKE_STRV (return_vals, 1, matches);
else
{
return_vals = pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,
NULL);
PIKA_VALUES_TAKE_STRV (return_vals, 1, matches);
}
g_free (pattern);
return return_vals;
}

10
plug-ins/common/file-header.c
View File

@ -49,7 +49,7 @@ struct _HeaderClass
#define HEADER_TYPE (header_get_type ())
#define HEADER (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), HEADER_TYPE, Header))
#define HEADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), HEADER_TYPE, Header))
GType header_get_type (void) G_GNUC_CONST;
@ -63,7 +63,8 @@ static PikaValueArray * header_save (PikaProcedure *procedure
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static gboolean save_image (GFile *file,
@ -114,7 +115,7 @@ header_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
header_save, NULL, NULL);
FALSE, header_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "INDEXED, RGB");
@ -148,7 +149,8 @@ header_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaPDBStatusType status = PIKA_PDB_SUCCESS;

124
plug-ins/common/file-heif.c
View File

@ -65,43 +65,47 @@ struct _PikaHeifClass
#define PIKA_HEIF_TYPE (pika_heif_get_type ())
#define PIKA_HEIF (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PIKA_HEIF_TYPE, PikaHeif))
#define PIKA_HEIF(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PIKA_HEIF_TYPE, PikaHeif))
GType pika_heif_get_type (void) G_GNUC_CONST;
static GList * heif_init_procedures (PikaPlugIn *plug_in);
static PikaProcedure * heif_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * heif_init_procedures (PikaPlugIn *plug_in);
static PikaProcedure * heif_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * heif_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * heif_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * heif_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * heif_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
#if LIBHEIF_HAVE_VERSION(1,8,0)
static PikaValueArray * heif_av1_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * heif_av1_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
#endif
static PikaImage * load_image (GFile *file,
gboolean interactive,
PikaPDBStatusType *status,
GError **error);
static PikaImage * load_image (GFile *file,
gboolean interactive,
PikaPDBStatusType *status,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
@ -110,11 +114,11 @@ static gboolean save_image (GFile *fil
enum heif_compression_format compression,
PikaMetadata *metadata);
static gboolean load_dialog (struct heif_context *heif,
uint32_t *selected_image);
static gboolean save_dialog (PikaProcedure *procedure,
GObject *config,
PikaImage *image);
static gboolean load_dialog (struct heif_context *heif,
uint32_t *selected_image);
static gboolean save_dialog (PikaProcedure *procedure,
GObject *config,
PikaImage *image);
G_DEFINE_TYPE (PikaHeif, pika_heif, PIKA_TYPE_PLUG_IN)
@ -223,7 +227,7 @@ heif_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
heif_save, NULL, NULL);
FALSE, heif_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "RGB*");
@ -332,7 +336,7 @@ heif_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
heif_av1_save, NULL, NULL);
FALSE, heif_av1_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "RGB*");
@ -413,11 +417,13 @@ heif_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
heif_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
heif_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
@ -461,20 +467,17 @@ heif_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata_unused,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
PikaMetadata *metadata;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
PikaMetadata *metadata;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, image, run_mode, args);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
@ -537,9 +540,6 @@ heif_save (PikaProcedure *procedure,
}
}
pika_procedure_config_end_run (config, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
pika_image_delete (image);
@ -557,20 +557,17 @@ heif_av1_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata_unused,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
PikaMetadata *metadata;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
PikaMetadata *metadata;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, image, run_mode, args);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
@ -633,9 +630,6 @@ heif_av1_save (PikaProcedure *procedure,
}
}
pika_procedure_config_end_run (config, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
pika_image_delete (image);

38
plug-ins/common/file-html-table.c
View File

@ -80,7 +80,7 @@ struct _HtmlClass
#define HTML_TYPE (html_get_type ())
#define HTML (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), HTML_TYPE, Html))
#define HTML(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), HTML_TYPE, Html))
GType html_get_type (void) G_GNUC_CONST;
@ -94,7 +94,8 @@ static PikaValueArray * html_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static gboolean save_image (GFile *file,
@ -150,7 +151,7 @@ html_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
html_save, NULL, NULL);
FALSE, html_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "*");
@ -264,13 +265,13 @@ html_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
GeglBuffer *buffer;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
GeglBuffer *buffer;
GError *error = NULL;
gegl_init (NULL, NULL);
@ -279,9 +280,6 @@ html_save (PikaProcedure *procedure,
PIKA_PDB_CALLING_ERROR,
NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, image, run_mode, args);
if (! save_dialog (image, procedure, G_OBJECT (config)))
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
@ -307,9 +305,6 @@ html_save (PikaProcedure *procedure,
g_object_unref (buffer);
pika_procedure_config_end_run (config, status);
g_object_unref (config);
return pika_procedure_new_return_values (procedure, status, error);
}
@ -617,7 +612,8 @@ save_dialog (PikaImage *image,
"warning-label",
_("You are about to create a huge\n"
"HTML file which will most likely\n"
"crash your browser."));
"crash your browser."),
FALSE, FALSE);
hbox = pika_procedure_dialog_fill_box (PIKA_PROCEDURE_DIALOG (dialog),
"warning-hbox", "warning-label",
NULL);
@ -632,7 +628,8 @@ save_dialog (PikaImage *image,
gtk_widget_set_margin_end (eek, 24);
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"warning-frame-label", _("Warning"));
"warning-frame-label", _("Warning"),
FALSE, FALSE);
frame = pika_procedure_dialog_fill_frame (PIKA_PROCEDURE_DIALOG (dialog),
"warning-frame",
"warning-frame-label",
@ -645,7 +642,8 @@ save_dialog (PikaImage *image,
/* HTML Page Options */
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"page-label", _("HTML Page Options"));
"page-label", _("HTML Page Options"),
FALSE, FALSE);
frame = pika_procedure_dialog_fill_frame (PIKA_PROCEDURE_DIALOG (dialog),
"page-frame",
"page-label",
@ -655,7 +653,8 @@ save_dialog (PikaImage *image,
/* HTML Table Creation Options */
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"creation-label",
_("Table Creation Options"));
_("Table Creation Options"),
FALSE, FALSE);
pika_procedure_dialog_fill_box (PIKA_PROCEDURE_DIALOG (dialog),
"creation-vbox", "span-tags",
@ -674,7 +673,8 @@ save_dialog (PikaImage *image,
gtk_widget_set_margin_bottom (frame, 8);
/* HTML Table Options */
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"table-label", _("Table Options"));
"table-label", _("Table Options"),
FALSE, FALSE);
pika_procedure_dialog_fill_box (PIKA_PROCEDURE_DIALOG (dialog),
"table-vbox", "border", "cell-width",

98
plug-ins/common/file-iff.c
View File

@ -57,46 +57,48 @@ struct _IffClass
#define IFF_TYPE (iff_get_type ())
#define IFF (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), IFF_TYPE, Iff))
#define IFF(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), IFF_TYPE, Iff))
GType iff_get_type (void) G_GNUC_CONST;
static GList * iff_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * iff_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * iff_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * iff_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * iff_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * iff_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
GObject *config,
PikaRunMode run_mode,
GError **error);
static PikaImage * load_image (GFile *file,
GObject *config,
PikaRunMode run_mode,
GError **error);
static void deleave_indexed_row (IFF_UByte *bitplanes,
guchar *pixel_row,
gint width,
gint nPlanes);
static void deleave_indexed_row (IFF_UByte *bitplanes,
guchar *pixel_row,
gint width,
gint nPlanes);
static void deleave_rgb_row (IFF_UByte *bitplanes,
guchar *pixel_row,
gint width,
gint nPlanes,
gint pixel_size);
static void deleave_rgb_row (IFF_UByte *bitplanes,
guchar *pixel_row,
gint width,
gint nPlanes,
gint pixel_size);
static void deleave_ham_row (const guchar *pika_cmap,
IFF_UByte *bitplanes,
guchar *pixel_row,
gint width,
gint nPlanes);
static void deleave_ham_row (const guchar *pika_cmap,
IFF_UByte *bitplanes,
guchar *pixel_row,
gint width,
gint nPlanes);
static void pbm_row (IFF_UByte *bitplanes,
guchar *pixel_row,
gint width);
static void pbm_row (IFF_UByte *bitplanes,
guchar *pixel_row,
gint width);
G_DEFINE_TYPE (Iff, iff, PIKA_TYPE_PLUG_IN)
@ -165,36 +167,26 @@ iff_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
iff_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
iff_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaValueArray *return_vals;
PikaImage *image;
GError *error = NULL;
PikaValueArray *return_vals;
PikaImage *image;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
image = load_image (file, G_OBJECT (config), run_mode, &error);
if (! image)
{
pika_procedure_config_end_run (config, PIKA_PDB_EXECUTION_ERROR);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
error);
}
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
error);
return_vals = pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,

108
plug-ins/common/file-jp2-load.c
View File

@ -117,31 +117,33 @@ struct _Jp2Class
GType jp2_get_type (void) G_GNUC_CONST;
static GList * jp2_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * jp2_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * jp2_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * jp2_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * jp2_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * jp2_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (PikaProcedure *procedure,
GObject *config,
GFile *file,
OPJ_CODEC_FORMAT format,
OPJ_COLOR_SPACE color_space,
gboolean interactive,
gboolean *profile_loaded,
GError **error);
static PikaImage * load_image (PikaProcedure *procedure,
GObject *config,
GFile *file,
OPJ_CODEC_FORMAT format,
OPJ_COLOR_SPACE color_space,
gboolean interactive,
gboolean *profile_loaded,
GError **error);
static OPJ_COLOR_SPACE open_dialog (PikaProcedure *procedure,
GObject *config,
GFile *file,
OPJ_CODEC_FORMAT format,
gint num_components,
GError **error);
static OPJ_COLOR_SPACE open_dialog (PikaProcedure *procedure,
GObject *config,
GFile *file,
OPJ_CODEC_FORMAT format,
gint num_components,
GError **error);
G_DEFINE_TYPE (Jp2, jp2, PIKA_TYPE_PLUG_IN)
@ -259,27 +261,24 @@ jp2_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
jp2_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
jp2_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaValueArray *return_vals;
PikaImage *image = NULL;
OPJ_COLOR_SPACE color_space = OPJ_CLRSPC_UNKNOWN;
gboolean interactive;
PikaMetadata *metadata;
gboolean profile_loaded = FALSE;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
GError *error = NULL;
PikaValueArray *return_vals;
PikaImage *image = NULL;
OPJ_COLOR_SPACE color_space = OPJ_CLRSPC_UNKNOWN;
gboolean interactive;
gboolean profile_loaded = FALSE;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, image, run_mode, args);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
@ -290,11 +289,17 @@ jp2_load (PikaProcedure *procedure,
default:
if (! strcmp (pika_procedure_get_name (procedure), LOAD_J2K_PROC))
{
gint color_space_argument = 0;
g_object_get (config,
"colorspace", &color_space_argument,
NULL);
/* Order is not the same as OpenJPEG enum on purpose,
* since it's better to not rely on a given order or
* on enum values.
*/
switch (PIKA_VALUES_GET_INT (args, 0))
switch (color_space_argument)
{
case 1:
color_space = OPJ_CLRSPC_GRAY;
@ -336,30 +341,11 @@ jp2_load (PikaProcedure *procedure,
{
status = error ? PIKA_PDB_EXECUTION_ERROR : PIKA_PDB_CANCEL;
pika_procedure_config_end_run (config, status);
g_object_unref (config);
return pika_procedure_new_return_values (procedure, status, error);
}
metadata = pika_image_metadata_load_prepare (image, "image/jp2",
file, NULL);
if (metadata)
{
PikaMetadataLoadFlags flags = PIKA_METADATA_LOAD_ALL;
if (profile_loaded)
flags &= ~PIKA_METADATA_LOAD_COLORSPACE;
pika_image_metadata_load_finish (image, "image/jp2",
metadata, flags);
g_object_unref (metadata);
}
pika_procedure_config_end_run (config, status);
g_object_unref (config);
if (profile_loaded)
*flags &= ~PIKA_METADATA_LOAD_COLORSPACE;
return_vals = pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,

129
plug-ins/common/file-jpegxl.c
View File

@ -55,46 +55,49 @@ struct _JpegXLClass
#define JPEGXL_TYPE (jpegxl_get_type ())
#define JPEGXL (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), JPEGXL_TYPE, JpegXL))
#define JPEGXL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), JPEGXL_TYPE, JpegXL))
GType jpegxl_get_type (void) G_GNUC_CONST;
static GList *jpegxl_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure *jpegxl_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList *jpegxl_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure *jpegxl_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray *jpegxl_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray *jpegxl_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray *jpegxl_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray *jpegxl_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static void create_cmyk_layer (PikaImage *image,
PikaLayer *layer,
const Babl *space,
const Babl *type,
gpointer picture_buffer,
gpointer key_buffer,
gint bit_depth,
gboolean has_alpha);
static void extract_cmyk (GeglBuffer *buffer,
gpointer *cmy_data,
gpointer *key_data,
gpointer *alpha_data,
const Babl *type,
const Babl *space,
gint width,
gint height,
gint bit_depth,
gboolean has_alpha);
static void create_cmyk_layer (PikaImage *image,
PikaLayer *layer,
const Babl *space,
const Babl *type,
gpointer picture_buffer,
gpointer key_buffer,
gint bit_depth,
gboolean has_alpha);
static void extract_cmyk (GeglBuffer *buffer,
gpointer *cmy_data,
gpointer *key_data,
gpointer *alpha_data,
const Babl *type,
const Babl *space,
gint width,
gint height,
gint bit_depth,
gboolean has_alpha);
G_DEFINE_TYPE (JpegXL, jpegxl, PIKA_TYPE_PLUG_IN)
@ -163,7 +166,7 @@ jpegxl_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
jpegxl_save, NULL, NULL);
FALSE, jpegxl_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "RGB*, GRAY*");
@ -1141,37 +1144,27 @@ load_image (GFile *file,
}
static PikaValueArray *
jpegxl_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
jpegxl_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *image;
GError *error = NULL;
GError *error = NULL;
gegl_init (NULL, NULL);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
case PIKA_RUN_WITH_LAST_VALS:
pika_ui_init (PLUG_IN_BINARY);
break;
default:
break;
}
image = load_image (file, run_mode, &error);
if (! image)
{
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
error);
}
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
error);
return_vals = pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,
NULL);
@ -2039,7 +2032,8 @@ save_dialog (PikaImage *image,
/* Profile label */
profile_label = pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"profile-label", _("CMYK profile required for export"));
"profile-label", _("CMYK profile required for export"),
FALSE, FALSE);
gtk_label_set_xalign (GTK_LABEL (profile_label), 0.0);
gtk_label_set_ellipsize (GTK_LABEL (profile_label), PANGO_ELLIPSIZE_END);
pika_label_set_attributes (GTK_LABEL (profile_label),
@ -2114,19 +2108,16 @@ jpegxl_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaProcedureConfig *config;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, image, run_mode, args);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
@ -2185,10 +2176,6 @@ jpegxl_save (PikaProcedure *procedure,
}
}
pika_procedure_config_end_run (config, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
g_free (drawables);

30
plug-ins/common/file-mng.c
View File

@ -153,7 +153,7 @@ struct _MngClass
#define MNG_TYPE (mng_get_type ())
#define MNG (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MNG_TYPE, Mng))
#define MNG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MNG_TYPE, Mng))
GType mng_get_type (void) G_GNUC_CONST;
@ -167,7 +167,8 @@ static PikaValueArray * mng_save (PikaProcedure *procedur
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static mng_ptr MNG_DECL myalloc (mng_size_t size);
@ -251,7 +252,7 @@ mng_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
mng_save, NULL, NULL);
FALSE, mng_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "*");
@ -365,19 +366,16 @@ mng_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_IGNORE;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_IGNORE;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_export (config, image, run_mode, args, NULL);
if (run_mode == PIKA_RUN_INTERACTIVE ||
run_mode == PIKA_RUN_WITH_LAST_VALS)
{
@ -411,9 +409,6 @@ mng_save (PikaProcedure *procedure,
}
}
pika_procedure_config_end_export (config, image, file, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
pika_image_delete (image);
@ -1597,7 +1592,8 @@ mng_save_dialog (PikaImage *image,
"bkgd", "gama", "phys", "time",
NULL);
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"options-label", _("MNG Options"));
"options-label", _("MNG Options"),
FALSE, FALSE);
pika_procedure_dialog_fill_frame (PIKA_PROCEDURE_DIALOG (dialog),
"options-frame", "options-label",
FALSE, "options-vbox");
@ -1643,7 +1639,7 @@ mng_save_dialog (PikaImage *image,
/* MNG Animation Options */
label = pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"milliseconds-label",
_("milliseconds"));
_("milliseconds"), FALSE, FALSE);
gtk_widget_set_margin_start (label, 6);
hbox = pika_procedure_dialog_fill_box (PIKA_PROCEDURE_DIALOG (dialog),
"animation-box", "default-delay",
@ -1656,7 +1652,7 @@ mng_save_dialog (PikaImage *image,
"animation-box", NULL);
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"mng-animation-label",
_("Animated MNG Options"));
_("Animated MNG Options"), FALSE, FALSE);
frame = pika_procedure_dialog_fill_frame (PIKA_PROCEDURE_DIALOG (dialog),
"mng-animation-frame",
"mng-animation-label", FALSE,

57
plug-ins/common/file-pat.c
View File

@ -46,7 +46,7 @@ struct _PatClass
#define PAT_TYPE (pat_get_type ())
#define PAT (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PAT_TYPE, Pat))
#define PAT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PAT_TYPE, Pat))
GType pat_get_type (void) G_GNUC_CONST;
@ -60,7 +60,8 @@ static PikaValueArray * pat_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static gboolean save_dialog (PikaImage *image,
@ -105,7 +106,7 @@ pat_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
pat_save, NULL, NULL);
FALSE, pat_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "*");
@ -149,17 +150,14 @@ pat_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
gchar *description;
GError *error = NULL;
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, image, run_mode, args);
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
gchar *description;
GError *error = NULL;
g_object_get (config,
"description", &description,
@ -211,28 +209,25 @@ pat_save (PikaProcedure *procedure,
if (status == PIKA_PDB_SUCCESS)
{
PikaValueArray *save_retvals;
PikaValueArray *args;
PikaProcedure *procedure;
PikaValueArray *save_retvals;
PikaObjectArray *drawables_array;
drawables_array = pika_object_array_new (PIKA_TYPE_DRAWABLE, (GObject **) drawables, n_drawables, FALSE);
g_object_get (config,
"description", &description,
NULL);
args = pika_value_array_new_from_types (NULL,
PIKA_TYPE_RUN_MODE, PIKA_RUN_NONINTERACTIVE,
PIKA_TYPE_IMAGE, image,
G_TYPE_INT, n_drawables,
PIKA_TYPE_OBJECT_ARRAY, NULL,
G_TYPE_FILE, file,
G_TYPE_STRING, description,
G_TYPE_NONE);
pika_value_set_object_array (pika_value_array_index (args, 3),
PIKA_TYPE_ITEM, (GObject **) drawables, n_drawables);
save_retvals = pika_pdb_run_procedure_array (pika_get_pdb (),
"file-pat-save-internal",
args);
pika_value_array_unref (args);
procedure = pika_pdb_lookup_procedure (pika_get_pdb (),
"file-pat-save-internal");
save_retvals = pika_procedure_run (procedure,
"image", image,
"num-drawables", n_drawables,
"drawables", drawables_array,
"file", file,
"name", description,
NULL);
if (PIKA_VALUES_GET_ENUM (save_retvals, 0) != PIKA_PDB_SUCCESS)
{
@ -245,11 +240,9 @@ pat_save (PikaProcedure *procedure,
}
pika_value_array_unref (save_retvals);
pika_object_array_free (drawables_array);
}
pika_procedure_config_end_run (config, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
pika_image_delete (image);

272
plug-ins/common/file-pcx.c
View File

@ -54,109 +54,114 @@ struct _PcxClass
#define PCX_TYPE (pcx_get_type ())
#define PCX (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PCX_TYPE, Pcx))
#define PCX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PCX_TYPE, Pcx))
GType pcx_get_type (void) G_GNUC_CONST;
static GList * pcx_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * pcx_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * pcx_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * pcx_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * pcx_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * dcx_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * pcx_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * pcx_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * dcx_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * pcx_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_single (PikaProcedure *procedure,
GFile *file,
GObject *config,
gint run_mode,
GError **error);
static PikaImage * load_multi (PikaProcedure *procedure,
GFile *file,
GObject *config,
gint run_mode,
GError **error);
static PikaImage * load_single (PikaProcedure *procedure,
GFile *file,
GObject *config,
gint run_mode,
GError **error);
static PikaImage * load_multi (PikaProcedure *procedure,
GFile *file,
GObject *config,
gint run_mode,
GError **error);
static PikaImage * load_image (PikaProcedure *procedure,
FILE *fd,
const gchar *filename,
GObject *config,
gint run_mode,
gint image_num,
GError **error);
static gboolean pcx_load_dialog (PikaProcedure *procedure,
GObject *config);
static PikaImage * load_image (PikaProcedure *procedure,
FILE *fd,
const gchar *filename,
GObject *config,
gint run_mode,
gint image_num,
GError **error);
static gboolean pcx_load_dialog (PikaProcedure *procedure,
GObject *config);
static void load_1 (FILE *fp,
gint width,
gint height,
guchar *buf,
guint16 bytes);
static void load_4 (FILE *fp,
gint width,
gint height,
guchar *buf,
guint16 bytes);
static void load_sub_8 (FILE *fp,
gint width,
gint height,
gint bpp,
gint plane,
guchar *buf,
guint16 bytes);
static void load_8 (FILE *fp,
gint width,
gint height,
guchar *buf,
guint16 bytes);
static void load_24 (FILE *fp,
gint width,
gint height,
guchar *buf,
guint16 bytes,
guint8 planes);
static void readline (FILE *fp,
guchar *buf,
gint bytes);
static void load_1 (FILE *fp,
gint width,
gint height,
guchar *buf,
guint16 bytes);
static void load_4 (FILE *fp,
gint width,
gint height,
guchar *buf,
guint16 bytes);
static void load_sub_8 (FILE *fp,
gint width,
gint height,
gint bpp,
gint plane,
guchar *buf,
guint16 bytes);
static void load_8 (FILE *fp,
gint width,
gint height,
guchar *buf,
guint16 bytes);
static void load_24 (FILE *fp,
gint width,
gint height,
guchar *buf,
guint16 bytes,
guint8 planes);
static void readline (FILE *fp,
guchar *buf,
gint bytes);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
static void save_less_than_8 (FILE *fp,
gint width,
gint height,
const gint bpp,
const guchar *buf,
gboolean padding);
static void save_8 (FILE *fp,
gint width,
gint height,
const guchar *buf,
gboolean padding);
static void save_24 (FILE *fp,
gint width,
gint height,
const guchar *buf,
gboolean padding);
static void writeline (FILE *fp,
const guchar *buf,
gint bytes);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
static void save_less_than_8 (FILE *fp,
gint width,
gint height,
const gint bpp,
const guchar *buf,
gboolean padding);
static void save_8 (FILE *fp,
gint width,
gint height,
const guchar *buf,
gboolean padding);
static void save_24 (FILE *fp,
gint width,
gint height,
const guchar *buf,
gboolean padding);
static void writeline (FILE *fp,
const guchar *buf,
gint bytes);
G_DEFINE_TYPE (Pcx, pcx, PIKA_TYPE_PLUG_IN)
@ -264,7 +269,7 @@ pcx_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
pcx_save, NULL, NULL);
FALSE, pcx_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "INDEXED, RGB, GRAY");
@ -289,36 +294,26 @@ pcx_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
pcx_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
pcx_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaValueArray *return_vals;
PikaImage *image;
GError *error = NULL;
PikaValueArray *return_vals;
PikaImage *image;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
image = load_single (procedure, file, G_OBJECT (config), run_mode, &error);
if (! image)
{
pika_procedure_config_end_run (config, PIKA_PDB_CANCEL);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
error);
}
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
error);
return_vals = pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,
@ -330,36 +325,26 @@ pcx_load (PikaProcedure *procedure,
}
static PikaValueArray *
dcx_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
dcx_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaValueArray *return_vals;
PikaImage *image;
GError *error = NULL;
PikaValueArray *return_vals;
PikaImage *image;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
image = load_multi (procedure, file, G_OBJECT (config), run_mode, &error);
if (! image)
{
pika_procedure_config_end_run (config, PIKA_PDB_CANCEL);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
error);
}
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
error);
return_vals = pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,
@ -377,7 +362,8 @@ pcx_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaPDBStatusType status = PIKA_PDB_SUCCESS;

273
plug-ins/common/file-pdf-load.c
View File

@ -217,61 +217,63 @@ struct _PdfClass
#define PDF_TYPE (pdf_get_type ())
#define PDF (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDF_TYPE, Pdf))
#define PDF(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDF_TYPE, Pdf))
GType pdf_get_type (void) G_GNUC_CONST;
static GList * pdf_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * pdf_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * pdf_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * pdf_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * pdf_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * pdf_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * pdf_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * pdf_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (PopplerDocument *doc,
GFile *file,
PikaRunMode run_mode,
static PikaImage * load_image (PopplerDocument *doc,
GFile *file,
PikaRunMode run_mode,
PikaPageSelectorTarget target,
gdouble resolution,
gboolean antialias,
gboolean white_background,
gboolean reverse_order,
PdfSelectedPages *pages);
gdouble resolution,
gboolean antialias,
gboolean white_background,
gboolean reverse_order,
PdfSelectedPages *pages);
static PikaPDBStatusType load_dialog (PopplerDocument *doc,
PdfSelectedPages *pages,
PikaProcedure *procedure,
PikaProcedureConfig *config);
static PikaPDBStatusType load_dialog (PopplerDocument *doc,
PdfSelectedPages *pages,
PikaProcedure *procedure,
PikaProcedureConfig *config);
static PopplerDocument * open_document (GFile *file,
const gchar *PDF_password,
PikaRunMode run_mode,
GError **error);
static PopplerDocument * open_document (GFile *file,
const gchar *PDF_password,
PikaRunMode run_mode,
GError **error);
static cairo_surface_t * get_thumb_surface (PopplerDocument *doc,
gint page,
gint preferred_size,
gboolean white_background);
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 GdkPixbuf * get_thumb_pixbuf (PopplerDocument *doc,
gint page,
gint preferred_size,
gboolean white_background);
static PikaLayer * layer_from_surface (PikaImage *image,
const gchar *layer_name,
gint position,
cairo_surface_t *surface,
gdouble progress_start,
gdouble progress_scale);
static PikaLayer * layer_from_surface (PikaImage *image,
const gchar *layer_name,
gint position,
cairo_surface_t *surface,
gdouble progress_start,
gdouble progress_scale);
G_DEFINE_TYPE (Pdf, pdf, PIKA_TYPE_PLUG_IN)
@ -435,127 +437,104 @@ pdf_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
pdf_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
pdf_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaProcedureConfig *config;
PikaImage *image = NULL;
PopplerDocument *doc = NULL;
PdfSelectedPages pages = { 0, NULL };
GError *error = NULL;
gchar *password;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
if (run_mode == PIKA_RUN_INTERACTIVE)
pika_ui_init (PLUG_IN_BINARY);
switch (run_mode)
g_object_get (config,
"password", &password,
NULL);
doc = open_document (file,
password,
run_mode, &error);
g_free (password);
if (doc == NULL)
{
case PIKA_RUN_INTERACTIVE:
{
gchar *password;
pika_ui_init (PLUG_IN_BINARY);
g_object_get (config,
"password", &password,
NULL);
doc = open_document (file,
password,
run_mode, &error);
g_free (password);
if (! doc)
{
status = PIKA_PDB_EXECUTION_ERROR;
break;
}
status = load_dialog (doc, &pages, procedure, config);
}
break;
case PIKA_RUN_WITH_LAST_VALS:
/* FIXME: implement last vals mode */
status = PIKA_PDB_EXECUTION_ERROR;
break;
}
else if (run_mode == PIKA_RUN_INTERACTIVE)
{
status = load_dialog (doc, &pages, procedure, config);
}
else if (run_mode == PIKA_RUN_NONINTERACTIVE)
{
PopplerPage *test_page = poppler_document_get_page (doc, 0);
case PIKA_RUN_NONINTERACTIVE:
doc = open_document (file,
PIKA_VALUES_GET_STRING (args, 0),
run_mode, &error);
if (doc)
if (test_page)
{
PopplerPage *test_page = poppler_document_get_page (doc, 0);
gint i;
gint doc_n_pages;
if (test_page)
g_object_get (config, "n-pages", &pages.n_pages, NULL);
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.
*/
if (pages.n_pages <= 0)
{
gint i;
gint doc_n_pages;
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
{
const gint32 *p;
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 = PIKA_VALUES_GET_INT (args, 2);
if (pages.n_pages <= 0)
g_object_get (config, "pages", &p, NULL);
pages.pages = g_new (gint, pages.n_pages);
for (i = 0; i < pages.n_pages; i++)
{
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
{
const gint32 *p = PIKA_VALUES_GET_INT32_ARRAY (args, 3);
pages.pages = g_new (gint, pages.n_pages);
for (i = 0; i < pages.n_pages; i++)
if (p[i] >= doc_n_pages)
{
if (p[i] >= doc_n_pages)
{
status = PIKA_PDB_EXECUTION_ERROR;
g_set_error (&error, PIKA_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),
pika_file_get_utf8_name (file),
p[i],
doc_n_pages);
break;
}
else
{
pages.pages[i] = p[i];
}
status = PIKA_PDB_EXECUTION_ERROR;
g_set_error (&error, PIKA_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),
pika_file_get_utf8_name (file),
p[i],
doc_n_pages);
break;
}
else
{
pages.pages[i] = p[i];
}
}
g_object_unref (test_page);
}
g_object_unref (test_page);
}
else
{
status = PIKA_PDB_EXECUTION_ERROR;
g_object_unref (doc);
}
break;
}
if (status == PIKA_PDB_SUCCESS)
@ -590,8 +569,6 @@ pdf_load (PikaProcedure *procedure,
if (doc)
g_object_unref (doc);
pika_procedure_config_end_run (config, status);
g_object_unref (config);
g_free (pages.pages);
return_vals = pika_procedure_new_return_values (procedure, status, error);
@ -602,11 +579,11 @@ pdf_load (PikaProcedure *procedure,
}
static PikaValueArray *
pdf_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
const PikaValueArray *args,
gpointer run_data)
pdf_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
gdouble width = 0;

153
plug-ins/common/file-pdf-save.c
View File

@ -179,7 +179,7 @@ struct _PdfClass
#define PDF_TYPE (pdf_get_type ())
#define PDF (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDF_TYPE, Pdf))
#define PDF(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PDF_TYPE, Pdf))
GType pdf_get_type (void) G_GNUC_CONST;
@ -193,10 +193,11 @@ static PikaValueArray * pdf_save (PikaProcedure *procedur
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * pdf_save_multi (PikaProcedure *procedure,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static PikaPDBStatusType pdf_save_image (PikaProcedure *procedure,
@ -311,7 +312,7 @@ pdf_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
pdf_save, NULL, NULL);
TRUE, pdf_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "*");
@ -476,46 +477,21 @@ pdf_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
gboolean had_saved_list = FALSE;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
gegl_init (NULL, NULL);
/* Initializing all the settings */
multi_page.image_count = 0;
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_export (config, image, run_mode,
args, "application/pdf");
file_name = g_file_get_path (file);
switch (run_mode)
{
case PIKA_RUN_NONINTERACTIVE:
init_image_list_defaults (image);
break;
case PIKA_RUN_INTERACTIVE:
/* Possibly retrieve data */
had_saved_list = pika_get_data (DATA_IMAGE_LIST, &multi_page);
if (had_saved_list && (file_name == NULL || strlen (file_name) == 0))
{
file_name = multi_page.file_name;
}
init_image_list_defaults (image);
break;
case PIKA_RUN_WITH_LAST_VALS:
init_image_list_defaults (image);
break;
}
init_image_list_defaults (image);
validate_image_list ();
@ -530,73 +506,40 @@ pdf_save (PikaProcedure *procedure,
(run_mode != PIKA_RUN_NONINTERACTIVE),
&error);
pika_procedure_config_end_export (config, image, file, status);
g_object_unref (config);
return pika_procedure_new_return_values (procedure, status, error);
}
static PikaValueArray *
pdf_save_multi (PikaProcedure *procedure,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaRunMode run_mode;
gchar *uri;
const gint32 *image_ids;
PikaImage *image = NULL;
GFile *file;
gboolean had_saved_list = FALSE;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaRunMode run_mode;
gchar *uri;
const gint32 *image_ids = NULL;
PikaImage *image = NULL;
GFile *file;
gegl_init (NULL, NULL);
run_mode = PIKA_VALUES_GET_ENUM (args, 0);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
g_object_get (config,
"uri", &uri,
"count", &multi_page.image_count,
"images", &image_ids,
"run-mode", &run_mode,
"uri", &uri,
"count", &multi_page.image_count,
"images", &image_ids,
NULL);
file = g_file_new_for_uri (uri);
g_free (uri);
file_name = g_file_get_path (file);
switch (run_mode)
{
gint i;
case PIKA_RUN_NONINTERACTIVE:
if (image_ids)
for (i = 0; i < multi_page.image_count; i++)
multi_page.images[i] = pika_image_get_by_id (image_ids[i]);
break;
case PIKA_RUN_INTERACTIVE:
/* Possibly retrieve data */
had_saved_list = pika_get_data (DATA_IMAGE_LIST, &multi_page);
if (had_saved_list && (file_name == NULL || strlen (file_name) == 0))
{
file_name = multi_page.file_name;
}
if (! had_saved_list)
init_image_list_defaults (image);
break;
case PIKA_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
had_saved_list = pika_get_data (DATA_IMAGE_LIST, &multi_page);
if (had_saved_list)
file_name = multi_page.file_name;
break;
}
if (image_ids)
for (gint i = 0; i < multi_page.image_count; i++)
multi_page.images[i] = pika_image_get_by_id (image_ids[i]);
else
init_image_list_defaults (image);
validate_image_list ();
@ -612,9 +555,6 @@ pdf_save_multi (PikaProcedure *procedure,
(run_mode != PIKA_RUN_NONINTERACTIVE),
&error);
pika_procedure_config_end_run (config, status);
g_object_unref (config);
return pika_procedure_new_return_values (procedure, status, error);
}
@ -656,7 +596,7 @@ get_missing_fonts (GList *layers)
}
else if (pika_item_is_text_layer (PIKA_ITEM (layer)))
{
gchar *font_family;
PikaFont *pika_font;
PangoFontDescription *font_description;
PangoFontDescription *font_description2;
PangoFontMap *fontmap;
@ -666,8 +606,8 @@ get_missing_fonts (GList *layers)
fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
context = pango_font_map_create_context (fontmap);
font_family = pika_text_layer_get_font (PIKA_TEXT_LAYER (layer));
font_description = pango_font_description_from_string (font_family);
pika_font = pika_text_layer_get_font (PIKA_TEXT_LAYER (layer));
font_description = pika_font_get_pango_font_description (pika_font);
font = pango_font_map_load_font (fontmap, context, font_description);
font_description2 = pango_font_describe (font);
@ -684,7 +624,6 @@ get_missing_fonts (GList *layers)
g_object_unref (font);
pango_font_description_free (font_description);
pango_font_description_free (font_description2);
g_free (font_family);
g_object_unref (context);
g_object_unref (fontmap);
}
@ -892,12 +831,6 @@ pdf_save_image (PikaProcedure *procedure,
fclose (fp);
if (! single_image)
{
g_strlcpy (multi_page.file_name, file_name, MAX_FILE_NAME_LENGTH);
pika_set_data (DATA_IMAGE_LIST, &multi_page, sizeof (multi_page));
}
return PIKA_PDB_SUCCESS;
}
@ -1017,8 +950,8 @@ gui_single (PikaProcedure *procedure,
* the warning more obvious.
*/
widget = pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (window),
"missing-fonts-label",
text);
"missing-fonts-label",
text, FALSE, FALSE);
gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE);
pika_procedure_dialog_fill_frame (PIKA_PROCEDURE_DIALOG (window),
"convert-text-layers-frame",
@ -1614,7 +1547,6 @@ drawText (PikaLayer *layer,
PikaImageType type = pika_drawable_type (PIKA_DRAWABLE (layer));
gchar *text = pika_text_layer_get_text (PIKA_TEXT_LAYER (layer));
gchar *markup = pika_text_layer_get_markup (PIKA_TEXT_LAYER (layer));
gchar *font_family;
gchar *language;
cairo_font_options_t *options;
gint x;
@ -1629,6 +1561,7 @@ drawText (PikaLayer *layer,
PikaTextDirection dir;
PangoLayout *layout;
PangoContext *context;
PikaFont *font;
PangoFontDescription *font_description;
gdouble indent;
gdouble line_spacing;
@ -1691,6 +1624,15 @@ drawText (PikaLayer *layer,
*/
fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
/* Font */
font = pika_text_layer_get_font (PIKA_TEXT_LAYER (layer));
font_description = pika_font_get_pango_font_description (font);
/* This function breaks rendering with some fonts if it's called before
* pika_font_get_pango_font_description(). I'm still unsure why yet it
* probably means there is a bug somewhere we must fix. Until then, let's make
* sure we keep this order. XXX
*/
pango_cairo_font_map_set_resolution (PANGO_CAIRO_FONT_MAP (fontmap), y_res);
context = pango_font_map_create_context (fontmap);
@ -1702,7 +1644,7 @@ drawText (PikaLayer *layer,
language = pika_text_layer_get_language (PIKA_TEXT_LAYER (layer));
if (language)
pango_context_set_language (context,
pango_language_from_string(language));
pango_language_from_string (language));
/* Text Direction */
dir = pika_text_layer_get_base_direction (PIKA_TEXT_LAYER (layer));
@ -1752,14 +1694,6 @@ drawText (PikaLayer *layer,
layout = pango_layout_new (context);
pango_layout_set_wrap (layout, PANGO_WRAP_WORD_CHAR);
/* Font */
font_family = pika_text_layer_get_font (PIKA_TEXT_LAYER (layer));
/* We need to find a way to convert PIKA's returned font name to a
* normal Pango name... Hopefully PIKA 2.8 with Pango will fix it.
*/
font_description = pango_font_description_from_string (font_family);
/* Font Size */
size = pika_text_layer_get_font_size (PIKA_TEXT_LAYER (layer), &unit);
size = pika_units_to_pixels (size, unit, y_res);
@ -1840,7 +1774,6 @@ drawText (PikaLayer *layer,
pango_cairo_show_layout (cr, layout);
g_free (text);
g_free (font_family);
g_free (language);
g_object_unref (layout);

94
plug-ins/common/file-pix.c
View File

@ -86,43 +86,46 @@ struct _PixClass
#define PIX_TYPE (pix_get_type ())
#define PIX (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PIX_TYPE, Pix))
#define PIX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PIX_TYPE, Pix))
GType pix_get_type (void) G_GNUC_CONST;
static GList * pix_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * pix_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * pix_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * pix_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * pix_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * pix_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * pix_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * pix_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
GError **error);
static PikaImage * load_image (GFile *file,
GError **error);
static PikaImage * load_esm_image (GInputStream *input,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
static gboolean get_short (GInputStream *input,
guint16 *value,
GError **error);
static gboolean put_short (GOutputStream *output,
guint16 value,
GError **error);
static gboolean get_short (GInputStream *input,
guint16 *value,
GError **error);
static gboolean put_short (GOutputStream *output,
guint16 value,
GError **error);
G_DEFINE_TYPE (Pix, pix, PIKA_TYPE_PLUG_IN)
@ -196,7 +199,7 @@ pix_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
pix_save, NULL, NULL);
FALSE, pix_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "*");
@ -224,11 +227,13 @@ pix_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
pix_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
pix_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *image;
@ -259,7 +264,8 @@ pix_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
@ -567,7 +573,6 @@ load_esm_image (GInputStream *input,
GError **error)
{
PikaImage *image = NULL;
PikaValueArray *return_vals = NULL;
GFile *temp_file = NULL;
FILE *fp;
goffset file_size;
@ -593,7 +598,9 @@ load_esm_image (GInputStream *input,
}
else
{
guchar buffer[file_size - 21];
PikaProcedure *procedure;
PikaValueArray *return_vals;
guchar buffer[file_size - 21];
if (! g_input_stream_read_all (input, buffer, sizeof (buffer),
NULL, NULL, error))
@ -608,12 +615,11 @@ load_esm_image (GInputStream *input,
fwrite (buffer, sizeof (guchar), file_size, fp);
fclose (fp);
return_vals =
pika_pdb_run_procedure (pika_get_pdb (),
"file-jpeg-load",
PIKA_TYPE_RUN_MODE, PIKA_RUN_NONINTERACTIVE,
G_TYPE_FILE, temp_file,
G_TYPE_NONE);
procedure = pika_pdb_lookup_procedure (pika_get_pdb (), "file-jpeg-load");
return_vals = pika_procedure_run (procedure,
"run-mode", PIKA_RUN_NONINTERACTIVE,
"file", temp_file,
NULL);
if (return_vals)
{

226
plug-ins/common/file-png.c
View File

@ -80,61 +80,64 @@ struct _PngClass
};
#define PNG_TYPE (png_get_type ())
#define PNG (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PNG_TYPE, Png))
#define PNG_TYPE (png_get_type ())
#define PNG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PNG_TYPE, Png))
GType png_get_type (void) G_GNUC_CONST;
static GList * png_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * png_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * png_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * png_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * png_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * png_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * png_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * png_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
gboolean interactive,
gboolean *resolution_loaded,
gboolean *profile_loaded,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
PikaImage *orig_image,
GObject *config,
gint *bits_per_sample,
gboolean interactive,
GError **error);
static PikaImage * load_image (GFile *file,
gboolean report_progress,
gboolean *resolution_loaded,
gboolean *profile_loaded,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
PikaImage *orig_image,
GObject *config,
gint *bits_per_sample,
gboolean report_progress,
GError **error);
static int respin_cmap (png_structp pp,
png_infop info,
guchar *remap,
PikaImage *image,
PikaDrawable *drawable);
static int respin_cmap (png_structp pp,
png_infop info,
guchar *remap,
PikaImage *image,
PikaDrawable *drawable);
static gboolean save_dialog (PikaImage *image,
PikaProcedure *procedure,
GObject *config,
gboolean alpha);
static gboolean save_dialog (PikaImage *image,
PikaProcedure *procedure,
GObject *config,
gboolean alpha);
static gboolean offsets_dialog (gint offset_x,
gint offset_y);
static gboolean offsets_dialog (gint offset_x,
gint offset_y);
static gboolean ia_has_transparent_pixels (GeglBuffer *buffer);
static gboolean ia_has_transparent_pixels (GeglBuffer *buffer);
static gint find_unused_ia_color (GeglBuffer *buffer,
gint *colors);
static gint find_unused_ia_color (GeglBuffer *buffer,
gint *colors);
G_DEFINE_TYPE (Png, png, PIKA_TYPE_PLUG_IN)
@ -207,7 +210,7 @@ png_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
png_save, NULL, NULL);
TRUE, png_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "*");
@ -283,12 +286,20 @@ png_create_procedure (PikaPlugIn *plug_in,
FALSE,
G_PARAM_READWRITE);
PIKA_PROC_AUX_ARG_INT (procedure, "format",
_("_Pixel format"),
_("PNG export format"),
PNG_FORMAT_AUTO, PNG_FORMAT_GRAYA16,
PNG_FORMAT_AUTO,
G_PARAM_READWRITE);
PIKA_PROC_AUX_ARG_CHOICE (procedure, "format",
_("_Pixel format"),
_("PNG export format"),
pika_choice_new_with_values ("auto", PNG_FORMAT_AUTO, _("Automatic"), NULL,
"rgb8", PNG_FORMAT_RGB8, _("8 bpc RGB"), NULL,
"gray8", PNG_FORMAT_GRAY8, _("8 bpc GRAY"), NULL,
"rgba8", PNG_FORMAT_RGBA8, _("8 bpc RGBA"), NULL,
"graya8", PNG_FORMAT_GRAYA8, _("8 bpc GRAYA"), NULL,
"rgb16", PNG_FORMAT_RGB16, _("16 bpc RGB"), NULL,
"gray16", PNG_FORMAT_GRAY16, _("16 bpc GRAY"), NULL,
"rgba16", PNG_FORMAT_RGBA16, _("16 bpc RGBA"), NULL,
"graya16", PNG_FORMAT_GRAYA16, _("16 bpc GRAYA"), NULL,
NULL),
"auto", G_PARAM_READWRITE);
pika_save_procedure_set_support_exif (PIKA_SAVE_PROCEDURE (procedure), TRUE);
pika_save_procedure_set_support_iptc (PIKA_SAVE_PROCEDURE (procedure), TRUE);
@ -304,36 +315,31 @@ png_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
png_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
png_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
gboolean interactive;
gboolean report_progress = FALSE;
gboolean resolution_loaded = FALSE;
gboolean profile_loaded = FALSE;
PikaImage *image;
PikaMetadata *metadata;
GError *error = NULL;
gegl_init (NULL, NULL);
switch (run_mode)
if (run_mode != PIKA_RUN_NONINTERACTIVE)
{
case PIKA_RUN_INTERACTIVE:
case PIKA_RUN_WITH_LAST_VALS:
pika_ui_init (PLUG_IN_BINARY);
interactive = TRUE;
break;
default:
interactive = FALSE;
break;
report_progress = TRUE;
}
image = load_image (file,
interactive,
report_progress,
&resolution_loaded,
&profile_loaded,
&error);
@ -343,24 +349,11 @@ png_load (PikaProcedure *procedure,
PIKA_PDB_EXECUTION_ERROR,
error);
metadata = pika_image_metadata_load_prepare (image, "image/png",
file, NULL);
if (resolution_loaded)
*flags &= ~PIKA_METADATA_LOAD_RESOLUTION;
if (metadata)
{
PikaMetadataLoadFlags flags = PIKA_METADATA_LOAD_ALL;
if (resolution_loaded)
flags &= ~PIKA_METADATA_LOAD_RESOLUTION;
if (profile_loaded)
flags &= ~PIKA_METADATA_LOAD_COLORSPACE;
pika_image_metadata_load_finish (image, "image/png",
metadata, flags);
g_object_unref (metadata);
}
if (profile_loaded)
*flags &= ~PIKA_METADATA_LOAD_COLORSPACE;
return_vals = pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,
@ -378,23 +371,18 @@ png_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
PikaMetadata *metadata;
PikaImage *orig_image;
gboolean alpha;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
PikaImage *orig_image;
gboolean alpha;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
metadata = pika_procedure_config_begin_export (config, image, run_mode,
args, "image/png");
orig_image = image;
switch (run_mode)
@ -465,9 +453,6 @@ png_save (PikaProcedure *procedure,
}
}
pika_procedure_config_end_export (config, image, file, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
pika_image_delete (image);
@ -589,7 +574,7 @@ Build_sRGBGamma (cmsContext ContextID)
*/
static PikaImage *
load_image (GFile *file,
gboolean interactive,
gboolean report_progress,
gboolean *resolution_loaded,
gboolean *profile_loaded,
GError **error)
@ -665,7 +650,7 @@ load_image (GFile *file,
* Open the file and initialize the PNG read "engine"...
*/
if (interactive)
if (report_progress)
pika_progress_init_printf (_("Opening '%s'"),
pika_file_get_utf8_name (file));
@ -973,7 +958,7 @@ load_image (GFile *file,
if (offset_x != 0 ||
offset_y != 0)
{
if (! interactive)
if (! report_progress)
{
pika_layer_set_offsets (layer, offset_x, offset_y);
}
@ -1108,7 +1093,7 @@ load_image (GFile *file,
pixel,
GEGL_AUTO_ROWSTRIDE);
if (interactive)
if (report_progress)
pika_progress_update (((gdouble) pass +
(gdouble) end / (gdouble) height) /
(gdouble) num_passes);
@ -1291,7 +1276,7 @@ save_image (GFile *file,
PikaImage *orig_image,
GObject *config,
gint *bits_per_sample,
gboolean interactive,
gboolean report_progress,
GError **error)
{
gint i, k; /* Looping vars */
@ -1360,10 +1345,11 @@ save_image (GFile *file,
"save-transparent", &save_transp_pixels,
"optimize-palette", &optimize_palette,
"compression", &compression_level,
"format", &export_format,
"save-color-profile", &save_profile,
NULL);
export_format = pika_procedure_config_get_choice_id (PIKA_PROCEDURE_CONFIG (config), "format");
out_linear = FALSE;
space = pika_drawable_get_format (drawable);
@ -1494,7 +1480,7 @@ save_image (GFile *file,
* Open the file and initialize the PNG write "engine"...
*/
if (interactive)
if (report_progress)
pika_progress_init_printf (_("Exporting '%s'"),
pika_file_get_utf8_name (file));
@ -1701,7 +1687,7 @@ save_image (GFile *file,
break;
case PNG_FORMAT_AUTO:
g_return_val_if_reached (FALSE);
}
}
}
if (! file_format)
@ -2044,14 +2030,14 @@ save_image (GFile *file,
png_write_rows (pp, pixels, num);
if (interactive)
if (report_progress)
pika_progress_update (((double) pass + (double) end /
(double) height) /
(double) num_passes);
}
}
if (interactive)
if (report_progress)
pika_progress_update (1.0);
png_write_end (pp, info);
@ -2283,10 +2269,9 @@ save_dialog (PikaImage *image,
GObject *config,
gboolean alpha)
{
GtkWidget *dialog;
GtkListStore *store;
gboolean run;
gboolean indexed;
GtkWidget *dialog;
gboolean run;
gboolean indexed;
indexed = (pika_image_get_base_type (image) == PIKA_INDEXED);
@ -2297,19 +2282,6 @@ save_dialog (PikaImage *image,
pika_procedure_dialog_get_widget (PIKA_PROCEDURE_DIALOG (dialog),
"compression", PIKA_TYPE_SPIN_SCALE);
store = pika_int_store_new (_("Automatic"), PNG_FORMAT_AUTO,
_("8 bpc RGB"), PNG_FORMAT_RGB8,
_("8 bpc GRAY"), PNG_FORMAT_GRAY8,
_("8 bpc RGBA"), PNG_FORMAT_RGBA8,
_("8 bpc GRAYA"), PNG_FORMAT_GRAYA8,
_("16 bpc RGB"), PNG_FORMAT_RGB16,
_("16 bpc GRAY"), PNG_FORMAT_GRAY16,
_("16 bpc RGBA"), PNG_FORMAT_RGBA16,
_("16 bpc GRAYA"), PNG_FORMAT_GRAYA16,
NULL);
pika_procedure_dialog_get_int_combo (PIKA_PROCEDURE_DIALOG (dialog),
"format", PIKA_INT_STORE (store));
pika_procedure_dialog_set_sensitive (PIKA_PROCEDURE_DIALOG (dialog),
"save-transparent",
alpha, NULL, NULL, FALSE);

215
plug-ins/common/file-pnm.c
View File

@ -140,101 +140,104 @@ struct _PnmClass
#define PNM_TYPE (pnm_get_type ())
#define PNM (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PNM_TYPE, Pnm))
#define PNM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PNM_TYPE, Pnm))
GType pnm_get_type (void) G_GNUC_CONST;
static GList * pnm_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * pnm_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * pnm_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * pnm_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * pnm_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * pnm_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * pnm_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * pnm_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
GError **error);
static gint save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
FileType file_type,
GObject *config,
GError **error);
static PikaImage * load_image (GFile *file,
GError **error);
static gint save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
FileType file_type,
GObject *config,
GError **error);
static gboolean save_dialog (PikaProcedure *procedure,
GObject *config,
PikaImage *image);
static gboolean save_dialog (PikaProcedure *procedure,
GObject *config,
PikaImage *image);
static void process_pam_header (PNMScanner *scan,
PNMInfo *info);
static void process_pam_header (PNMScanner *scan,
PNMInfo *info);
static void pnm_load_ascii (PNMScanner *scan,
PNMInfo *info,
GeglBuffer *buffer);
static void pnm_load_raw (PNMScanner *scan,
PNMInfo *info,
GeglBuffer *buffer);
static void pnm_load_rawpbm (PNMScanner *scan,
PNMInfo *info,
GeglBuffer *buffer);
static void pnm_load_rawpfm (PNMScanner *scan,
PNMInfo *info,
GeglBuffer *buffer);
static void pnm_load_ascii (PNMScanner *scan,
PNMInfo *info,
GeglBuffer *buffer);
static void pnm_load_raw (PNMScanner *scan,
PNMInfo *info,
GeglBuffer *buffer);
static void pnm_load_rawpbm (PNMScanner *scan,
PNMInfo *info,
GeglBuffer *buffer);
static void pnm_load_rawpfm (PNMScanner *scan,
PNMInfo *info,
GeglBuffer *buffer);
static void create_pam_header (const gchar **header_string,
PNMRowInfo *rowinfo,
PNMSaverowFunc *saverow,
PikaImageType drawable_type,
GeglBuffer *buffer,
const Babl **format,
gint *rowbufsize,
gint *np,
gchar *comment);
static void create_pam_header (const gchar **header_string,
PNMRowInfo *rowinfo,
PNMSaverowFunc *saverow,
PikaImageType drawable_type,
GeglBuffer *buffer,
const Babl **format,
gint *rowbufsize,
gint *np,
gchar *comment);
static gboolean pnmsaverow_ascii (PNMRowInfo *ri,
guchar *data,
GError **error);
static gboolean pnmsaverow_raw (PNMRowInfo *ri,
guchar *data,
GError **error);
static gboolean pnmsaverow_raw_pbm (PNMRowInfo *ri,
guchar *data,
GError **error);
static gboolean pnmsaverow_ascii_pbm (PNMRowInfo *ri,
guchar *data,
GError **error);
static gboolean pnmsaverow_ascii_indexed (PNMRowInfo *ri,
guchar *data,
GError **error);
static gboolean pnmsaverow_raw_indexed (PNMRowInfo *ri,
guchar *data,
GError **error);
static gboolean pnmsaverow_ascii (PNMRowInfo *ri,
guchar *data,
GError **error);
static gboolean pnmsaverow_raw (PNMRowInfo *ri,
guchar *data,
GError **error);
static gboolean pnmsaverow_raw_pbm (PNMRowInfo *ri,
guchar *data,
GError **error);
static gboolean pnmsaverow_ascii_pbm (PNMRowInfo *ri,
guchar *data,
GError **error);
static gboolean pnmsaverow_ascii_indexed (PNMRowInfo *ri,
guchar *data,
GError **error);
static gboolean pnmsaverow_raw_indexed (PNMRowInfo *ri,
guchar *data,
GError **error);
static PNMScanner * pnmscanner_create (GInputStream *input);
static void pnmscanner_destroy (PNMScanner *s);
static void pnmscanner_createbuffer (PNMScanner *s,
gint bufsize);
static void pnmscanner_getchar (PNMScanner *s);
static void pnmscanner_eatwhitespace (PNMScanner *s);
static void pnmscanner_eatinnerspace (PNMScanner *s);
static void pnmscanner_gettoken (PNMScanner *s,
gchar *buf,
gint bufsize);
static void pnmscanner_getsmalltoken (PNMScanner *s,
gchar *buf);
static void pnmscanner_getheaderline (PNMScanner *s,
gchar *buf,
gint bufsize);
static PNMScanner * pnmscanner_create (GInputStream *input);
static void pnmscanner_destroy (PNMScanner *s);
static void pnmscanner_createbuffer (PNMScanner *s,
gint bufsize);
static void pnmscanner_getchar (PNMScanner *s);
static void pnmscanner_eatwhitespace (PNMScanner *s);
static void pnmscanner_eatinnerspace (PNMScanner *s);
static void pnmscanner_gettoken (PNMScanner *s,
gchar *buf,
gint bufsize);
static void pnmscanner_getsmalltoken (PNMScanner *s,
gchar *buf);
static void pnmscanner_getheaderline (PNMScanner *s,
gchar *buf,
gint bufsize);
#define pnmscanner_eof(s) ((s)->eof)
#define pnmscanner_input(s) ((s)->input)
@ -343,7 +346,7 @@ pnm_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
pnm_save,
FALSE, pnm_save,
GINT_TO_POINTER (FILE_TYPE_PNM),
NULL);
@ -380,7 +383,7 @@ pnm_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
pnm_save,
FALSE, pnm_save,
GINT_TO_POINTER (FILE_TYPE_PBM),
NULL);
@ -416,7 +419,7 @@ pnm_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
pnm_save,
FALSE, pnm_save,
GINT_TO_POINTER (FILE_TYPE_PGM),
NULL);
@ -452,7 +455,7 @@ pnm_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
pnm_save,
FALSE, pnm_save,
GINT_TO_POINTER (FILE_TYPE_PPM),
NULL);
@ -488,7 +491,7 @@ pnm_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
pnm_save,
FALSE, pnm_save,
GINT_TO_POINTER (FILE_TYPE_PAM),
NULL);
@ -517,7 +520,7 @@ pnm_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
pnm_save,
FALSE, pnm_save,
GINT_TO_POINTER (FILE_TYPE_PFM),
NULL);
@ -547,11 +550,13 @@ pnm_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
pnm_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
pnm_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *image;
@ -582,21 +587,18 @@ pnm_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
FileType file_type = GPOINTER_TO_INT (run_data);
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
const gchar *format_name = NULL;
GError *error = NULL;
FileType file_type = GPOINTER_TO_INT (run_data);
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
const gchar *format_name = NULL;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_export (config, image, run_mode, args, NULL);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
@ -687,9 +689,6 @@ pnm_save (PikaProcedure *procedure,
}
}
pika_procedure_config_end_export (config, image, file, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
pika_image_delete (image);

144
plug-ins/common/file-ps.c
View File

@ -127,41 +127,44 @@ struct _PostScriptClass
#define PS_TYPE (ps_get_type ())
#define PS (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PS_TYPE, PostScript))
#define PS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PS_TYPE, PostScript))
GType ps_get_type (void) G_GNUC_CONST;
static GList * ps_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * ps_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * ps_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * ps_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * ps_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * ps_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * ps_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * ps_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * ps_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * ps_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
GObject *config,
GError **error);
static gboolean save_image (GFile *file,
GObject *config,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
static PikaImage * load_image (GFile *file,
GObject *config,
GError **error);
static gboolean save_image (GFile *file,
GObject *config,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
static void ps_set_save_size (GObject *config,
PikaImage *image);
@ -446,7 +449,7 @@ ps_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
ps_save, NULL, NULL);
FALSE, ps_save, NULL, NULL);
if (! strcmp (name, SAVE_PS_PROC))
{
@ -571,23 +574,20 @@ ps_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
ps_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
ps_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaValueArray *return_vals;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaImage *image = NULL;
GError *error = NULL;
PikaValueArray *return_vals;
PikaImage *image = NULL;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, image, run_mode, args);
l_run_mode = run_mode;
switch (run_mode)
@ -607,9 +607,6 @@ ps_load (PikaProcedure *procedure,
image = load_image (file, G_OBJECT (config), &error);
pika_procedure_config_end_run (config, status);
g_object_unref (config);
if (! image)
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
@ -625,23 +622,18 @@ ps_load (PikaProcedure *procedure,
}
static PikaValueArray *
ps_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
const PikaValueArray *args,
gpointer run_data)
ps_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaValueArray *return_vals;
PikaImage *image = NULL;
GError *error = NULL;
PikaValueArray *return_vals;
PikaImage *image = NULL;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, image,
PIKA_RUN_NONINTERACTIVE, args);
/* We should look for an embedded preview but for now we
* just load the document at a small resolution and the
* first page only.
@ -650,9 +642,6 @@ ps_load_thumb (PikaProcedure *procedure,
image = load_image (file, NULL, &error);
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
if (! image)
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
@ -676,21 +665,18 @@ ps_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
PikaImage *orig_image;
gboolean eps_flag = FALSE;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
PikaImage *orig_image;
gboolean eps_flag = FALSE;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, image, run_mode, args);
eps_flag = strcmp (pika_procedure_get_name (procedure), SAVE_PS_PROC);
g_object_set (config,
"eps-flag", eps_flag ? 1 : 0,
@ -767,9 +753,6 @@ ps_save (PikaProcedure *procedure,
status = PIKA_PDB_EXECUTION_ERROR;
}
pika_procedure_config_end_run (config, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
pika_image_delete (image);
@ -3730,7 +3713,8 @@ load_dialog (GFile *file,
config);
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"rendering-title", _("Rendering"));
"rendering-title", _("Rendering"),
FALSE, FALSE);
pika_procedure_dialog_fill_frame (PIKA_PROCEDURE_DIALOG (dialog),
"rendering-frame", "rendering-title",
@ -3891,7 +3875,8 @@ save_dialog (PikaProcedure *procedure,
"#keep_aspect_ratio"),
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"image-title", _("Image Size"));
"image-title", _("Image Size"),
FALSE, FALSE);
pika_procedure_dialog_fill_box (PIKA_PROCEDURE_DIALOG (dialog), "image-box",
"width", "height", "x-offset", "y-offset",
@ -3926,7 +3911,8 @@ save_dialog (PikaProcedure *procedure,
/* Output */
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"output-title", _("Output"));
"output-title", _("Output"),
FALSE, FALSE);
pika_procedure_dialog_set_sensitive (PIKA_PROCEDURE_DIALOG (dialog),
"preview",

288
plug-ins/common/file-psp.c
View File

@ -460,7 +460,7 @@ typedef enum {
PSP_XDATA_GRID, /* Image grid information (since PSP7) */
PSP_XDATA_GUIDE, /* Image guide information (since PSP7) */
PSP_XDATA_EXIF, /* Image Exif information (since PSP8) */
PSP_XDATA_IPTC, /* Image IPTC information (since PSP10) */
PSP_XDATA_IPTC, /* Image IPTC information (since PSP8) */
} PSPExtendedDataID;
/* Creator field types.
@ -576,39 +576,42 @@ struct _PspClass
#define PSP_TYPE (psp_get_type ())
#define PSP (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PSP_TYPE, Psp))
#define PSP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PSP_TYPE, Psp))
GType psp_get_type (void) G_GNUC_CONST;
static GList * psp_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * psp_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * psp_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * psp_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * psp_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * psp_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * psp_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * psp_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GObject *config,
GError **error);
static gboolean save_dialog (PikaProcedure *procedure,
GObject *config,
PikaImage *image);
static PikaImage * load_image (GFile *file,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GObject *config,
GError **error);
static gboolean save_dialog (PikaProcedure *procedure,
GObject *config,
PikaImage *image);
G_DEFINE_TYPE (Psp, psp, PIKA_TYPE_PLUG_IN)
@ -687,7 +690,7 @@ psp_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
psp_save, NULL, NULL);
FALSE, psp_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "*");
@ -724,11 +727,13 @@ psp_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
psp_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
psp_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *image;
@ -759,19 +764,16 @@ psp_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, image, run_mode, args);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
@ -810,9 +812,6 @@ psp_save (PikaProcedure *procedure,
}
}
pika_procedure_config_end_run (config, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
pika_image_delete (image);
@ -2362,6 +2361,193 @@ compression_name (gint compression)
return NULL;
}
static gint
read_selection_block (FILE *f,
PikaImage *image,
guint total_len,
PSPimage *ia,
GError **error)
{
gsize current_location;
gsize file_size;
guint32 chunk_size;
guint32 rect[4];
current_location = ftell (f);
fseek (f, 0, SEEK_END);
file_size = ftell (f);
fseek (f, current_location, SEEK_SET);
if (fread (&chunk_size, 4, 1, f) < 1)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Error reading selection chunk"));
return -1;
}
chunk_size = GUINT32_FROM_LE (chunk_size);
current_location = ftell (f);
if (chunk_size > (file_size - current_location))
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Invalid selection chunk size"));
return -1;
}
if (fread (&rect, 16, 1, f) < 1)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Error reading selection chunk"));
return -1;
}
swab_rect (rect);
pika_image_select_rectangle (image, PIKA_CHANNEL_OP_ADD,
rect[0], rect[1],
rect[2] - rect[0],
rect[3] - rect[1]);
/* The file format specifies multiple selections, but
* as of PSP 8 they only allow one. Skipping the remaining
* information in the block. */
total_len -= sizeof (guint32) + sizeof (rect);
if (try_fseek (f, total_len, SEEK_SET, error) < 0)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Error reading end of selection chunk"));
return -1;
}
return 0;
}
static gint
read_extended_block (FILE *f,
PikaImage *image,
guint total_len,
PSPimage *ia,
GError **error)
{
guchar header[4];
guint16 field_type;
guint32 field_length;
while (total_len > 0)
{
if (fread (header, 4, 1, f) < 1 ||
fread (&field_type, 2, 1, f) < 1 ||
fread (&field_length, 4, 1, f) < 1)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Error reading extended block chunk header"));
return -1;
}
if (memcmp (header, "~FL\0", 4) != 0)
{
g_print ("Header: %s\n", header);
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Invalid extended block chunk header"));
return -1;
}
total_len -= sizeof (header) + sizeof (field_type) + sizeof (field_length);
field_type = GUINT16_FROM_LE (field_type);
field_length = GUINT32_FROM_LE (field_length);
if (field_length > total_len)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Invalid extended block chunk size"));
return -1;
}
switch (field_type)
{
case PSP_XDATA_GRID:
{
PikaRGB color;
guchar rgb[4];
guint32 h_spacing;
guint32 v_spacing;
guint16 unit; /* Unused */
if (field_length != 14 ||
fread (rgb, 4, 1, f) < 1 ||
fread (&h_spacing, 4, 1, f) < 1 ||
fread (&v_spacing, 4, 1, f) < 1 ||
fread (&unit, 2, 1, f) < 1)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Error reading extended chunk grid data"));
return -1;
}
h_spacing = GUINT32_FROM_LE (h_spacing);
v_spacing = GUINT32_FROM_LE (v_spacing);
pika_image_grid_set_spacing (image, h_spacing, v_spacing);
pika_rgba_set_uchar (&color, rgb[0], rgb[1], rgb[2], 255);
pika_image_grid_set_foreground_color (image, &color);
pika_image_grid_set_background_color (image, &color);
}
break;
case PSP_XDATA_GUIDE:
{
guchar rgb[4]; /* Unused */
guint32 offset;
guint16 orientation;
if (field_length != 10 ||
fread (rgb, 4, 1, f) < 1 ||
fread (&offset, 4, 1, f) < 1 ||
fread (&orientation, 2, 1, f) < 1)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Error reading extended chunk guide data"));
return -1;
}
offset = GUINT32_FROM_LE (offset);
orientation = GUINT16_FROM_LE (orientation);
if (orientation == keHorizontalGuide)
{
pika_image_add_hguide (image, offset);
}
else if (orientation == keVerticalGuide)
{
pika_image_add_vguide (image, offset);
}
else
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Invalid guide orientation"));
return -1;
}
}
break;
/* Not yet implemented */
case PSP_XDATA_TRNS_INDEX:
case PSP_XDATA_EXIF:
case PSP_XDATA_IPTC:
default:
if (try_fseek (f, field_length, SEEK_CUR, error) < 0)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Error reading extended block chunk"));
return -1;
}
break;
}
total_len -= field_length;
}
return 0;
}
static gint
read_colorprofile_block (FILE *f,
PikaImage *image,
@ -2553,7 +2739,10 @@ load_image (GFile *file,
break;
case PSP_SELECTION_BLOCK:
break; /* Not yet implemented */
if (read_selection_block (f, image, block_total_len, &ia,
error) == -1)
goto error;
break;
case PSP_ALPHA_BANK_BLOCK:
break; /* Not yet implemented */
@ -2562,7 +2751,10 @@ load_image (GFile *file,
break; /* No use for it */
case PSP_EXTENDED_DATA_BLOCK:
break; /* Not yet implemented */
if (read_extended_block (f, image, block_total_len, &ia,
error) == -1)
goto error;
break;
case PSP_TUBE_BLOCK:
if (read_tube_block (f, image, block_total_len, &ia, error) == -1)

83
plug-ins/common/file-qoi.c
View File

@ -56,37 +56,40 @@ struct _QoiClass
#define QOI_TYPE (qoi_get_type ())
#define QOI (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), QOI_TYPE, Qoi))
#define QOI(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), QOI_TYPE, Qoi))
GType qoi_get_type (void) G_GNUC_CONST;
static GList * qoi_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * qoi_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * qoi_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * qoi_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * qoi_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * qoi_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * qoi_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * qoi_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
GObject *config,
PikaRunMode run_mode,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
static PikaImage * load_image (GFile *file,
GObject *config,
PikaRunMode run_mode,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
G_DEFINE_TYPE (Qoi, qoi, PIKA_TYPE_PLUG_IN)
@ -157,7 +160,7 @@ qoi_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
qoi_save, NULL, NULL);
FALSE, qoi_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "*");
@ -183,22 +186,20 @@ qoi_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
qoi_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
qoi_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaValueArray *return_vals;
PikaImage *image;
GError *error = NULL;
PikaValueArray *return_vals;
PikaImage *image;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
image = load_image (file, G_OBJECT (config), run_mode, &error);
if (! image)
@ -206,9 +207,6 @@ qoi_load (PikaProcedure *procedure,
PIKA_PDB_EXECUTION_ERROR,
error);
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
return_vals = pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,
NULL);
@ -225,7 +223,8 @@ qoi_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaPDBStatusType status = PIKA_PDB_SUCCESS;

278
plug-ins/common/file-raw-data.c
View File

@ -156,130 +156,133 @@ struct _RawClass
#define RAW_TYPE (raw_get_type ())
#define RAW (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RAW_TYPE, Raw))
#define RAW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RAW_TYPE, Raw))
GType raw_get_type (void) G_GNUC_CONST;
static GList * raw_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * raw_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * raw_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * raw_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * raw_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * raw_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * raw_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * raw_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
/* prototypes for the new load functions */
static gboolean raw_load_standard (RawPikaData *data,
gint width,
gint height,
gint bpp,
gint offset,
RawType type,
gboolean is_big_endian,
gboolean is_signed,
gboolean is_float);
static gboolean raw_load_planar (RawPikaData *data,
gint width,
gint height,
gint bpp,
gint offset,
RawType type,
gboolean is_big_endian,
gboolean is_signed,
gboolean is_float);
static gboolean raw_load_gray (RawPikaData *data,
gint width,
gint height,
gint offset,
gint bpp,
gint bitspp);
static gboolean raw_load_rgb565 (RawPikaData *data,
gint width,
gint height,
gint offset,
RawType type,
RawEndianness endianness);
static gboolean raw_load_palette (RawPikaData *data,
gint palette_offset,
RawPaletteType palette_type,
GFile *palette_file);
static gboolean raw_load_standard (RawPikaData *data,
gint width,
gint height,
gint bpp,
gint offset,
RawType type,
gboolean is_big_endian,
gboolean is_signed,
gboolean is_float);
static gboolean raw_load_planar (RawPikaData *data,
gint width,
gint height,
gint bpp,
gint offset,
RawType type,
gboolean is_big_endian,
gboolean is_signed,
gboolean is_float);
static gboolean raw_load_gray (RawPikaData *data,
gint width,
gint height,
gint offset,
gint bpp,
gint bitspp);
static gboolean raw_load_rgb565 (RawPikaData *data,
gint width,
gint height,
gint offset,
RawType type,
RawEndianness endianness);
static gboolean raw_load_palette (RawPikaData *data,
gint palette_offset,
RawPaletteType palette_type,
GFile *palette_file);
/* support functions */
static goffset get_file_info (GFile *file);
static void raw_read_row (FILE *fp,
guchar *buf,
gint32 offset,
gint32 size);
static int mmap_read (gint fd,
gpointer buf,
gint32 len,
gint32 pos,
gint rowstride);
static void rgb_565_to_888 (guint16 *in,
guchar *out,
gint32 num_pixels,
RawType type,
RawEndianness endianness);
static goffset get_file_info (GFile *file);
static void raw_read_row (FILE *fp,
guchar *buf,
gint32 offset,
gint32 size);
static int mmap_read (gint fd,
gpointer buf,
gint32 len,
gint32 pos,
gint rowstride);
static void rgb_565_to_888 (guint16 *in,
guchar *out,
gint32 num_pixels,
RawType type,
RawEndianness endianness);
static PikaImage * load_image (GFile *file,
PikaProcedureConfig *config,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
PikaProcedureConfig *config,
GError **error);
static PikaImage * load_image (GFile *file,
PikaProcedureConfig *config,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
PikaProcedureConfig *config,
GError **error);
static void get_bpp (PikaProcedureConfig *config,
gint *bpp,
gint *bitspp);
static gboolean detect_sample_spacing (PikaProcedureConfig *config,
GFile *file,
GError **error);
static void get_load_config_values (PikaProcedureConfig *config,
gint32 *file_offset,
gint32 *image_width,
gint32 *image_height,
RawType *image_type,
RawEncoding *encoding,
RawEndianness *endianness,
RawPlanarConfiguration *planar_configuration,
gint32 *palette_offset,
RawPaletteType *palette_type,
GFile **palette_file);
static void get_bpp (PikaProcedureConfig *config,
gint *bpp,
gint *bitspp);
static gboolean detect_sample_spacing (PikaProcedureConfig *config,
GFile *file,
GError **error);
static void get_load_config_values (PikaProcedureConfig *config,
gint32 *file_offset,
gint32 *image_width,
gint32 *image_height,
RawType *image_type,
RawEncoding *encoding,
RawEndianness *endianness,
RawPlanarConfiguration *planar_configuration,
gint32 *palette_offset,
RawPaletteType *palette_type,
GFile **palette_file);
/* gui functions */
static void halfp2singles (uint32_t *xp,
const uint16_t *hp,
int numel);
static void halfp2singles (uint32_t *xp,
const uint16_t *hp,
int numel);
static void preview_update (PikaPreviewArea *preview,
gboolean preview_cmap_update);
static void preview_update_size (PikaPreviewArea *preview);
static void load_config_notify (PikaProcedureConfig *config,
GParamSpec *pspec,
PikaPreviewArea *preview);
static void preview_allocate (PikaPreviewArea *preview,
GtkAllocation *allocation,
gpointer user_data);
static gboolean load_dialog (GFile *file,
PikaProcedure *procedure,
GObject *config,
gboolean is_hgt);
static gboolean save_dialog (PikaImage *image,
PikaProcedure *procedure,
gboolean has_alpha,
GObject *config);
static void preview_update (PikaPreviewArea *preview,
gboolean preview_cmap_update);
static void preview_update_size (PikaPreviewArea *preview);
static void load_config_notify (PikaProcedureConfig *config,
GParamSpec *pspec,
PikaPreviewArea *preview);
static void preview_allocate (PikaPreviewArea *preview,
GtkAllocation *allocation,
gpointer user_data);
static gboolean load_dialog (GFile *file,
PikaProcedure *procedure,
GObject *config,
gboolean is_hgt);
static gboolean save_dialog (PikaImage *image,
PikaProcedure *procedure,
gboolean has_alpha,
GObject *config);
G_DEFINE_TYPE (Raw, raw, PIKA_TYPE_PLUG_IN)
@ -395,7 +398,7 @@ raw_create_procedure (PikaPlugIn *plug_in,
G_PARAM_READWRITE);
PIKA_PROC_ARG_INT (procedure, "palette-type",
_("Palette's la_yout"),
_("The layout for the palette's color channels"
_("The layout for the palette's color channels "
"{ RAW_PALETTE_RGB (0), RAW_PALETTE_BGR (1) }"),
RAW_PALETTE_RGB, RAW_PALETTE_BGR, RAW_PALETTE_RGB,
G_PARAM_READWRITE);
@ -407,8 +410,8 @@ raw_create_procedure (PikaPlugIn *plug_in,
else if (! strcmp (name, LOAD_HGT_PROC))
{
procedure = pika_load_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
raw_load, NULL, NULL);
PIKA_PDB_PROC_TYPE_PLUGIN,
raw_load, NULL, NULL);
pika_procedure_set_menu_label (procedure,
_("Digital Elevation Model data"));
@ -445,7 +448,7 @@ raw_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
raw_save, NULL, NULL);
FALSE, raw_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "INDEXED, GRAY, RGB, RGBA");
@ -471,7 +474,7 @@ raw_create_procedure (PikaPlugIn *plug_in,
PIKA_PROC_ARG_INT (procedure, "palette-type",
_("Palette's layout"),
_("The layout for the palette's color channels"
_("The layout for the palette's color channels "
"{ RAW_PALETTE_RGB (0), RAW_PALETTE_BGR (1) }"),
RAW_PALETTE_RGB, RAW_PALETTE_BGR, RAW_PALETTE_RGB,
G_PARAM_READWRITE);
@ -484,24 +487,22 @@ raw_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
raw_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
raw_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaProcedureConfig *config;
gboolean is_hgt;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaImage *image = NULL;
GError *error = NULL;
PikaValueArray *return_vals;
gboolean is_hgt;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaImage *image = NULL;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, image, run_mode, args);
is_hgt = (! strcmp (pika_procedure_get_name (procedure), LOAD_HGT_PROC));
if (run_mode == PIKA_RUN_INTERACTIVE)
@ -590,9 +591,6 @@ raw_load (PikaProcedure *procedure,
error->message);
}
pika_procedure_config_end_run (config, status);
g_object_unref (config);
if (! image)
return pika_procedure_new_return_values (procedure, status, error);
@ -612,10 +610,10 @@ raw_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
RawPlanarConfiguration planar_conf;
@ -623,9 +621,6 @@ raw_save (PikaProcedure *procedure,
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_export (config, image, run_mode, args, NULL);
g_object_get (config,
"planar-configuration", &planar_conf,
NULL);
@ -680,9 +675,6 @@ raw_save (PikaProcedure *procedure,
}
}
pika_procedure_config_end_export (config, image, file, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
pika_image_delete (image);
@ -1738,9 +1730,9 @@ load_image (GFile *file,
ltype = PIKA_RGBA_IMAGE;
itype = PIKA_RGB;
if (encoding == RAW_ENCODING_FLOAT)
precision = PIKA_PRECISION_U32_NON_LINEAR;
else
precision = PIKA_PRECISION_FLOAT_NON_LINEAR;
else
precision = PIKA_PRECISION_U32_NON_LINEAR;
break;
case RAW_GRAY_1BPP:

233
plug-ins/common/file-sunras.c
View File

@ -106,125 +106,128 @@ struct _SunrasClass
#define SUNRAS_TYPE (sunras_get_type ())
#define SUNRAS (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SUNRAS_TYPE, Sunras))
#define SUNRAS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SUNRAS_TYPE, Sunras))
GType sunras_get_type (void) G_GNUC_CONST;
static GList * sunras_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * sunras_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * sunras_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * sunras_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * sunras_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * sunras_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * sunras_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * sunras_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GObject *config,
GError **error);
static PikaImage * load_image (GFile *file,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GObject *config,
GError **error);
static void set_color_table (PikaImage *image,
L_SUNFILEHEADER *sunhdr,
const guchar *suncolmap);
static PikaImage * create_new_image (GFile *file,
guint width,
guint height,
PikaImageBaseType type,
PikaLayer **layer,
GeglBuffer **buffer);
static void set_color_table (PikaImage *image,
L_SUNFILEHEADER *sunhdr,
const guchar *suncolmap);
static PikaImage * create_new_image (GFile *file,
guint width,
guint height,
PikaImageBaseType type,
PikaLayer **layer,
GeglBuffer **buffer);
static PikaImage * load_sun_d1 (GFile *file,
FILE *ifp,
L_SUNFILEHEADER *sunhdr,
guchar *suncolmap);
static PikaImage * load_sun_d8 (GFile *file,
FILE *ifp,
L_SUNFILEHEADER *sunhdr,
guchar *suncolmap);
static PikaImage * load_sun_d24 (GFile *file,
FILE *ifp,
L_SUNFILEHEADER *sunhdr,
guchar *suncolmap);
static PikaImage * load_sun_d32 (GFile *file,
FILE *ifp,
L_SUNFILEHEADER *sunhdr,
guchar *suncolmap);
static PikaImage * load_sun_d1 (GFile *file,
FILE *ifp,
L_SUNFILEHEADER *sunhdr,
guchar *suncolmap);
static PikaImage * load_sun_d8 (GFile *file,
FILE *ifp,
L_SUNFILEHEADER *sunhdr,
guchar *suncolmap);
static PikaImage * load_sun_d24 (GFile *file,
FILE *ifp,
L_SUNFILEHEADER *sunhdr,
guchar *suncolmap);
static PikaImage * load_sun_d32 (GFile *file,
FILE *ifp,
L_SUNFILEHEADER *sunhdr,
guchar *suncolmap);
static L_CARD32 read_card32 (FILE *ifp,
int *err);
static L_CARD32 read_card32 (FILE *ifp,
int *err);
static void write_card32 (FILE *ofp,
L_CARD32 c);
static void write_card32 (FILE *ofp,
L_CARD32 c);
static void byte2bit (guchar *byteline,
int width,
guchar *bitline,
gboolean invert);
static void byte2bit (guchar *byteline,
int width,
guchar *bitline,
gboolean invert);
static void rle_startread (FILE *ifp);
static int rle_fread (char *ptr,
int sz,
int nelem,
FILE *ifp);
static int rle_fgetc (FILE *ifp);
static void rle_startread (FILE *ifp);
static int rle_fread (char *ptr,
int sz,
int nelem,
FILE *ifp);
static int rle_fgetc (FILE *ifp);
#define rle_getc(fp) ((rlebuf.n > 0) ? (rlebuf.n)--,rlebuf.val : rle_fgetc (fp))
static void rle_startwrite (FILE *ofp);
static int rle_fwrite (char *ptr,
int sz,
int nelem,
FILE *ofp);
static int rle_fputc (int val,
FILE *ofp);
static int rle_putrun (int n,
int val,
FILE *ofp);
static void rle_endwrite (FILE *ofp);
static void rle_startwrite (FILE *ofp);
static int rle_fwrite (char *ptr,
int sz,
int nelem,
FILE *ofp);
static int rle_fputc (int val,
FILE *ofp);
static int rle_putrun (int n,
int val,
FILE *ofp);
static void rle_endwrite (FILE *ofp);
#define rle_putc rle_fputc
static void read_sun_header (FILE *ifp,
L_SUNFILEHEADER *sunhdr);
static void write_sun_header (FILE *ofp,
L_SUNFILEHEADER *sunhdr);
static void read_sun_cols (FILE *ifp,
L_SUNFILEHEADER *sunhdr,
guchar *colormap);
static void write_sun_cols (FILE *ofp,
L_SUNFILEHEADER *sunhdr,
guchar *colormap);
static void read_sun_header (FILE *ifp,
L_SUNFILEHEADER *sunhdr);
static void write_sun_header (FILE *ofp,
L_SUNFILEHEADER *sunhdr);
static void read_sun_cols (FILE *ifp,
L_SUNFILEHEADER *sunhdr,
guchar *colormap);
static void write_sun_cols (FILE *ofp,
L_SUNFILEHEADER *sunhdr,
guchar *colormap);
static gint save_index (FILE *ofp,
PikaImage *image,
PikaDrawable *drawable,
gboolean grey,
gint rle);
static gint save_rgb (FILE *ofp,
PikaImage *image,
PikaDrawable *drawable,
gint rle);
static gint save_index (FILE *ofp,
PikaImage *image,
PikaDrawable *drawable,
gboolean grey,
gint rle);
static gint save_rgb (FILE *ofp,
PikaImage *image,
PikaDrawable *drawable,
gint rle);
static gboolean save_dialog (PikaImage *image,
PikaProcedure *procedure,
GObject *config);
static gboolean save_dialog (PikaImage *image,
PikaProcedure *procedure,
GObject *config);
/* Portability kludge */
static int my_fwrite (void *ptr,
int size,
int nmemb,
FILE *stream);
static int my_fwrite (void *ptr,
int size,
int nmemb,
FILE *stream);
G_DEFINE_TYPE (Sunras, sunras, PIKA_TYPE_PLUG_IN)
@ -297,7 +300,7 @@ sunras_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
sunras_save, NULL, NULL);
FALSE, sunras_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "RGB, GRAY, INDEXED");
@ -333,11 +336,13 @@ sunras_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
sunras_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
sunras_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *image;
@ -368,19 +373,16 @@ sunras_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, image, run_mode, args);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
@ -430,9 +432,6 @@ sunras_save (PikaProcedure *procedure,
}
}
pika_procedure_config_end_run (config, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
pika_image_delete (image);

552
plug-ins/common/file-svg.c
View File

@ -53,8 +53,6 @@ typedef struct
gdouble resolution;
gint width;
gint height;
gboolean import;
gboolean merge;
} SvgLoadVals;
@ -73,40 +71,49 @@ struct _SvgClass
#define SVG_TYPE (svg_get_type ())
#define SVG (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SVG_TYPE, Svg))
#define SVG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SVG_TYPE, Svg))
GType svg_get_type (void) G_GNUC_CONST;
static GList * svg_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * svg_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * svg_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * svg_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * svg_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * svg_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * svg_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * svg_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
RsvgHandleFlags rsvg_flags,
GError **error);
static GdkPixbuf * load_rsvg_pixbuf (GFile *file,
SvgLoadVals *vals,
RsvgHandleFlags rsvg_flags,
gboolean *allow_retry,
GError **error);
static gboolean load_rsvg_size (GFile *file,
SvgLoadVals *vals,
RsvgHandleFlags rsvg_flags,
GError **error);
static PikaPDBStatusType load_dialog (GFile *file,
RsvgHandleFlags *rsvg_flags,
GError **error);
static PikaImage * load_image (GFile *file,
gint width,
gint height,
gdouble resolution,
RsvgHandleFlags rsvg_flags,
GError **error);
static GdkPixbuf * load_rsvg_pixbuf (GFile *file,
gint width,
gint height,
gdouble resolution,
RsvgHandleFlags rsvg_flags,
gboolean *allow_retry,
GError **error);
static gboolean load_rsvg_size (GFile *file,
SvgLoadVals *vals,
RsvgHandleFlags rsvg_flags,
GError **error);
static PikaPDBStatusType load_dialog (GFile *file,
PikaProcedure *procedure,
PikaProcedureConfig *config,
RsvgHandleFlags *rsvg_flags,
GError **error);
@ -116,16 +123,6 @@ PIKA_MAIN (SVG_TYPE)
DEFINE_STD_SET_I18N
static SvgLoadVals load_vals =
{
SVG_DEFAULT_RESOLUTION,
0,
0,
FALSE,
FALSE
};
static void
svg_class_init (SvgClass *klass)
{
@ -187,13 +184,13 @@ svg_create_procedure (PikaPlugIn *plug_in,
LOAD_THUMB_PROC);
PIKA_PROC_ARG_DOUBLE (procedure, "resolution",
"Resolution",
"Resolu_tion",
"Resolution to use for rendering the SVG",
PIKA_MIN_RESOLUTION, PIKA_MAX_RESOLUTION, 90,
PIKA_MIN_RESOLUTION, PIKA_MAX_RESOLUTION, 300,
PIKA_PARAM_READWRITE);
PIKA_PROC_ARG_INT (procedure, "width",
"Width",
"_Width",
"Width (in pixels) to load the SVG in. "
"(0 for original width, a negative width to "
"specify a maximum width)",
@ -201,19 +198,21 @@ svg_create_procedure (PikaPlugIn *plug_in,
PIKA_PARAM_READWRITE);
PIKA_PROC_ARG_INT (procedure, "height",
"Height",
"_Height",
"Height (in pixels) to load the SVG in. "
"(0 for original height, a negative height to "
"specify a maximum height)",
-PIKA_MAX_IMAGE_SIZE, PIKA_MAX_IMAGE_SIZE, 0,
PIKA_PARAM_READWRITE);
PIKA_PROC_ARG_INT (procedure, "paths",
"Paths",
"(0) don't import paths, (1) paths individually, "
"(2) paths merged",
0, 2, 0,
PIKA_PARAM_READWRITE);
PIKA_PROC_ARG_CHOICE (procedure, "paths",
_("_Paths"),
_("Whether and how to import paths so that they can be used with the path tool"),
pika_choice_new_with_values ("no-import", 0, _("Don't import paths"), NULL,
"import", 0, _("Import paths individually"), NULL,
"import-merged", 0, _("Merge imported paths"), NULL,
NULL),
"no-import", G_PARAM_READWRITE);
}
else if (! strcmp (name, LOAD_THUMB_PROC))
{
@ -236,62 +235,58 @@ svg_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
svg_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
svg_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *image;
GError *error = NULL;
RsvgHandleFlags rsvg_flags = RSVG_HANDLE_FLAGS_NONE;
PikaPDBStatusType status;
gchar *import_paths;
gint width;
gint height;
gdouble resolution;
gegl_init (NULL, NULL);
switch (run_mode)
if (run_mode == PIKA_RUN_INTERACTIVE)
{
case PIKA_RUN_NONINTERACTIVE:
load_vals.resolution = PIKA_VALUES_GET_DOUBLE (args, 0);
load_vals.width = PIKA_VALUES_GET_INT (args, 1);
load_vals.height = PIKA_VALUES_GET_INT (args, 2);
load_vals.import = PIKA_VALUES_GET_INT (args, 3) != FALSE;
load_vals.merge = PIKA_VALUES_GET_INT (args, 3) == 2;
break;
case PIKA_RUN_INTERACTIVE:
pika_get_data (LOAD_PROC, &load_vals);
status = load_dialog (file, &rsvg_flags, &error);
status = load_dialog (file, procedure, config, &rsvg_flags, &error);
if (status != PIKA_PDB_SUCCESS)
return pika_procedure_new_return_values (procedure, status, error);
break;
case PIKA_RUN_WITH_LAST_VALS:
pika_get_data (LOAD_PROC, &load_vals);
break;
}
image = load_image (file, rsvg_flags, &error);
g_object_get (config,
"width", &width,
"height", &height,
"resolution", &resolution,
NULL);
image = load_image (file, width, height, resolution, rsvg_flags, &error);
if (! image)
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
error);
if (load_vals.import)
g_object_get (config, "paths", &import_paths, NULL);
if (g_strcmp0 (import_paths, "no-import") != 0)
{
PikaVectors **vectors;
gint num_vectors;
pika_vectors_import_from_file (image, file,
load_vals.merge, TRUE,
&num_vectors, &vectors);
g_strcmp0 (import_paths, "import-merged") == 0,
TRUE, &num_vectors, &vectors);
if (num_vectors > 0)
g_free (vectors);
}
if (run_mode != PIKA_RUN_NONINTERACTIVE)
pika_set_data (LOAD_PROC, &load_vals, sizeof (load_vals));
g_free (import_paths);
return_vals = pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,
@ -303,31 +298,50 @@ svg_load (PikaProcedure *procedure,
}
static PikaValueArray *
svg_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
const PikaValueArray *args,
gpointer run_data)
svg_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
gint width = 0;
gint height = 0;
PikaImage *image;
GError *error = NULL;
gint width = 0;
gint height = 0;
gint thumb_width = 0;
gint thumb_height = 0;
GError *error = NULL;
SvgLoadVals vals =
{
SVG_DEFAULT_RESOLUTION,
SVG_PREVIEW_SIZE,
SVG_PREVIEW_SIZE,
};
gegl_init (NULL, NULL);
if (load_rsvg_size (file, &load_vals, RSVG_HANDLE_FLAGS_NONE, NULL))
if (load_rsvg_size (file, &vals, RSVG_HANDLE_FLAGS_NONE, NULL))
{
width = load_vals.width;
height = load_vals.height;
width = vals.width;
height = vals.height;
if (width > height)
{
thumb_width = size;
thumb_height = size * height / width;
}
else
{
thumb_width = size * width / height;
thumb_height = size;
}
}
else
{
thumb_width = size;
thumb_height = size;
}
load_vals.resolution = SVG_DEFAULT_RESOLUTION;
load_vals.width = - size;
load_vals.height = - size;
image = load_image (file, RSVG_HANDLE_FLAGS_NONE, &error);
image = load_image (file, thumb_width, thumb_height, SVG_DEFAULT_RESOLUTION, RSVG_HANDLE_FLAGS_NONE, &error);
if (! image)
return pika_procedure_new_return_values (procedure,
@ -349,17 +363,18 @@ svg_load_thumb (PikaProcedure *procedure,
static PikaImage *
load_image (GFile *file,
gint width,
gint height,
gdouble resolution,
RsvgHandleFlags rsvg_flags,
GError **load_error)
{
PikaImage *image;
PikaLayer *layer;
GdkPixbuf *pixbuf;
gint width;
gint height;
GError *error = NULL;
PikaImage *image;
PikaLayer *layer;
GdkPixbuf *pixbuf;
GError *error = NULL;
pixbuf = load_rsvg_pixbuf (file, &load_vals, rsvg_flags, NULL, &error);
pixbuf = load_rsvg_pixbuf (file, width, height, resolution, rsvg_flags, NULL, &error);
if (! pixbuf)
{
@ -382,8 +397,7 @@ load_image (GFile *file,
image = pika_image_new (width, height, PIKA_RGB);
pika_image_undo_disable (image);
pika_image_set_resolution (image,
load_vals.resolution, load_vals.resolution);
pika_image_set_resolution (image, resolution, resolution);
layer = pika_layer_new_from_pixbuf (image, _("Rendered SVG"), pixbuf,
100,
@ -461,7 +475,9 @@ load_set_size_callback (gint *width,
/* This function renders a pixbuf from an SVG file according to vals. */
static GdkPixbuf *
load_rsvg_pixbuf (GFile *file,
SvgLoadVals *vals,
gint width,
gint height,
gdouble resolution,
RsvgHandleFlags rsvg_flags,
gboolean *allow_retry,
GError **error)
@ -475,6 +491,8 @@ load_rsvg_pixbuf (GFile *file,
RsvgRectangle viewport = { 0, };
guchar *src;
gint y;
#else
SvgLoadVals vals;
#endif
handle = rsvg_handle_new_from_gfile_sync (file, rsvg_flags, NULL, error);
@ -489,10 +507,9 @@ load_rsvg_pixbuf (GFile *file,
return NULL;
}
rsvg_handle_set_dpi (handle, vals->resolution);
rsvg_handle_set_dpi (handle, resolution);
#if LIBRSVG_CHECK_VERSION(2, 46, 0)
pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
vals->width, vals->height);
pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, width, height);
surf = cairo_image_surface_create_for_data (gdk_pixbuf_get_pixels (pixbuf),
CAIRO_FORMAT_ARGB32,
gdk_pixbuf_get_width (pixbuf),
@ -500,8 +517,8 @@ load_rsvg_pixbuf (GFile *file,
gdk_pixbuf_get_rowstride (pixbuf));
cr = cairo_create (surf);
viewport.width = vals->width;
viewport.height = vals->height;
viewport.width = width;
viewport.height = height;
rsvg_handle_render_document (handle, cr, &viewport, NULL);
@ -511,10 +528,10 @@ load_rsvg_pixbuf (GFile *file,
/* un-premultiply the data */
src = gdk_pixbuf_get_pixels (pixbuf);
for (y = 0; y < vals->height; y++)
for (y = 0; y < height; y++)
{
guchar *s = src;
gint w = vals->width;
gint w = width;
while (w--)
{
@ -525,6 +542,9 @@ load_rsvg_pixbuf (GFile *file,
src += gdk_pixbuf_get_rowstride (pixbuf);
}
#else
vals.resolution = resolution;
vals.width = width;
vals.height = height;
rsvg_handle_set_size_callback (handle, load_set_size_callback, vals, NULL);
pixbuf = rsvg_handle_get_pixbuf (handle);
#endif
@ -656,39 +676,6 @@ load_dialog_ratio_callback (GtkAdjustment *adj,
load_dialog_set_ratio (x, y);
}
static void
load_dialog_resolution_callback (PikaSizeEntry *res,
GFile *file)
{
SvgLoadVals vals = { 0.0, 0, 0 };
RsvgHandleFlags rsvg_flags;
rsvg_flags = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (file), "rsvg-flags"));
load_vals.resolution = vals.resolution = pika_size_entry_get_refval (res, 0);
if (! load_rsvg_size (file, &vals, rsvg_flags, NULL))
return;
g_signal_handlers_block_by_func (size, load_dialog_size_callback, NULL);
pika_size_entry_set_resolution (size, 0, load_vals.resolution, FALSE);
pika_size_entry_set_resolution (size, 1, load_vals.resolution, FALSE);
g_signal_handlers_unblock_by_func (size, load_dialog_size_callback, NULL);
if (pika_size_entry_get_unit (size) != PIKA_UNIT_PIXEL)
{
ratio_x = pika_size_entry_get_refval (size, 0) / vals.width;
ratio_y = pika_size_entry_get_refval (size, 1) / vals.height;
}
svg_width = vals.width;
svg_height = vals.height;
load_dialog_set_ratio (ratio_x, ratio_y);
}
static void
load_dialog_set_ratio (gdouble x,
gdouble y)
@ -714,24 +701,19 @@ load_dialog_set_ratio (gdouble x,
}
static PikaPDBStatusType
load_dialog (GFile *file,
RsvgHandleFlags *rsvg_flags,
GError **load_error)
load_dialog (GFile *file,
PikaProcedure *procedure,
PikaProcedureConfig *config,
RsvgHandleFlags *rsvg_flags,
GError **load_error)
{
GtkWidget *dialog;
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *main_hbox;
GtkWidget *vbox;
GtkWidget *image;
GdkPixbuf *preview;
GtkWidget *grid;
GtkWidget *grid2;
GtkWidget *res;
GtkWidget *label;
GtkWidget *spinbutton;
GtkWidget *toggle;
GtkWidget *toggle2;
GtkAdjustment *adj;
gboolean run;
GError *error = NULL;
gchar *text;
@ -743,7 +725,8 @@ load_dialog (GFile *file,
SVG_PREVIEW_SIZE,
};
preview = load_rsvg_pixbuf (file, &vals, *rsvg_flags, &allow_retry, &error);
preview = load_rsvg_pixbuf (file, SVG_PREVIEW_SIZE, SVG_PREVIEW_SIZE, SVG_DEFAULT_RESOLUTION,
*rsvg_flags, &allow_retry, &error);
pika_ui_init (PLUG_IN_BINARY);
@ -768,11 +751,11 @@ load_dialog (GFile *file,
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
pika_window_set_transient (GTK_WINDOW (dialog));
hbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
main_hbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
main_hbox, TRUE, TRUE, 0);
gtk_widget_show (main_hbox);
/* Unfortunately the error returned by librsvg is unclear. While
* libxml explicitly returns a "parser error : internal error:
@ -791,7 +774,7 @@ load_dialog (GFile *file,
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (label), PANGO_WRAP_WORD);
gtk_label_set_max_width_chars (GTK_LABEL (label), 80);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (main_hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
label = gtk_label_new (NULL);
@ -800,12 +783,12 @@ load_dialog (GFile *file,
gtk_label_set_markup (GTK_LABEL (label), text);
g_free (text);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (main_hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
label = gtk_label_new (_("Retry without limits preventing to parse huge data?"));
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (main_hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
gtk_widget_show (dialog);
@ -817,7 +800,8 @@ load_dialog (GFile *file,
{
*rsvg_flags = RSVG_HANDLE_FLAG_UNLIMITED;
g_clear_error (&error);
preview = load_rsvg_pixbuf (file, &vals, *rsvg_flags, NULL, &error);
preview = load_rsvg_pixbuf (file, SVG_PREVIEW_SIZE, SVG_PREVIEW_SIZE, SVG_DEFAULT_RESOLUTION,
*rsvg_flags, NULL, &error);
}
}
@ -835,34 +819,21 @@ load_dialog (GFile *file,
}
/* Scalable Vector Graphics is SVG, should perhaps not be translated */
dialog = pika_dialog_new (_("Render Scalable Vector Graphics"),
PLUG_IN_ROLE,
NULL, 0,
pika_standard_help_func, LOAD_PROC,
dialog = pika_procedure_dialog_new (PIKA_PROCEDURE (procedure),
PIKA_PROCEDURE_CONFIG (config),
_("Render Scalable Vector Graphics"));
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_OK"), GTK_RESPONSE_OK,
NULL);
pika_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
pika_window_set_transient (GTK_WINDOW (dialog));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
pika_procedure_dialog_fill_box (PIKA_PROCEDURE_DIALOG (dialog),
"vbox-arguments",
"width", "height", "resolution", "paths",
NULL);
main_hbox = pika_procedure_dialog_fill_box (PIKA_PROCEDURE_DIALOG (dialog), "main-hbox",
"vbox-arguments", NULL);
gtk_orientable_set_orientation (GTK_ORIENTABLE (main_hbox), GTK_ORIENTATION_HORIZONTAL);
/* The SVG preview */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (main_hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
frame = gtk_frame_new (NULL);
@ -880,202 +851,17 @@ load_dialog (GFile *file,
gtk_widget_show (size_label);
/* query the initial size after the size label is created */
vals.resolution = load_vals.resolution;
g_object_get (config, "resolution", &vals.resolution, NULL);
load_rsvg_size (file, &vals, *rsvg_flags, NULL);
g_object_set (config,
"width", vals.width,
"height", vals.height,
NULL);
svg_width = vals.width;
svg_height = vals.height;
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
gtk_box_pack_start (GTK_BOX (hbox), grid, TRUE, TRUE, 0);
gtk_widget_show (grid);
/* Width and Height */
label = gtk_label_new (_("Width:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
// GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
label = gtk_label_new (_("Height:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
// GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_grid_attach (GTK_GRID (grid), hbox, 1, 0, 1, 1);
// GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (hbox);
adj = gtk_adjustment_new (1, 1, 1, 1, 10, 0);
spinbutton = pika_spin_button_new (adj, 1.0, 2);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_grid_attach (GTK_GRID (grid), hbox, 1, 1, 1, 1);
// GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (hbox);
size = PIKA_SIZE_ENTRY (pika_size_entry_new (1, PIKA_UNIT_PIXEL, "%a",
TRUE, FALSE, FALSE, 10,
PIKA_SIZE_ENTRY_UPDATE_SIZE));
pika_size_entry_add_field (size, GTK_SPIN_BUTTON (spinbutton), NULL);
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (size), FALSE, FALSE, 0);
gtk_widget_show (GTK_WIDGET (size));
pika_size_entry_set_refval_boundaries (size, 0,
PIKA_MIN_IMAGE_SIZE,
PIKA_MAX_IMAGE_SIZE);
pika_size_entry_set_refval_boundaries (size, 1,
PIKA_MIN_IMAGE_SIZE,
PIKA_MAX_IMAGE_SIZE);
pika_size_entry_set_refval (size, 0, svg_width);
pika_size_entry_set_refval (size, 1, svg_height);
pika_size_entry_set_resolution (size, 0, load_vals.resolution, FALSE);
pika_size_entry_set_resolution (size, 1, load_vals.resolution, FALSE);
g_signal_connect (size, "value-changed",
G_CALLBACK (load_dialog_size_callback),
NULL);
/* Scale ratio */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_grid_attach (GTK_GRID (grid), hbox, 1, 2, 1, 2);
// GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (hbox);
grid2 = gtk_grid_new ();
gtk_box_pack_start (GTK_BOX (hbox), grid2, FALSE, FALSE, 0);
xadj = gtk_adjustment_new (ratio_x,
(gdouble) PIKA_MIN_IMAGE_SIZE / (gdouble) svg_width,
(gdouble) PIKA_MAX_IMAGE_SIZE / (gdouble) svg_width,
0.01, 0.1, 0);
spinbutton = pika_spin_button_new (xadj, 0.01, 4);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10);
gtk_grid_attach (GTK_GRID (grid2), spinbutton, 0, 0, 1, 1);
gtk_widget_show (spinbutton);
g_signal_connect (xadj, "value-changed",
G_CALLBACK (load_dialog_ratio_callback),
NULL);
label = gtk_label_new_with_mnemonic (_("_X ratio:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1);
// GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
yadj = gtk_adjustment_new (ratio_y,
(gdouble) PIKA_MIN_IMAGE_SIZE / (gdouble) svg_height,
(gdouble) PIKA_MAX_IMAGE_SIZE / (gdouble) svg_height,
0.01, 0.1, 0);
spinbutton = pika_spin_button_new (yadj, 0.01, 4);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10);
gtk_grid_attach (GTK_GRID (grid2), spinbutton, 0, 1, 1, 1);
gtk_widget_show (spinbutton);
g_signal_connect (yadj, "value-changed",
G_CALLBACK (load_dialog_ratio_callback),
NULL);
label = gtk_label_new_with_mnemonic (_("_Y ratio:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1);
// GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
/* the constrain ratio chainbutton */
constrain = pika_chain_button_new (PIKA_CHAIN_RIGHT);
pika_chain_button_set_active (PIKA_CHAIN_BUTTON (constrain), TRUE);
gtk_grid_attach (GTK_GRID (grid2), constrain, 1, 0, 1, 2);
gtk_widget_show (constrain);
pika_help_set_help_data (pika_chain_button_get_button (PIKA_CHAIN_BUTTON (constrain)),
_("Constrain aspect ratio"), NULL);
gtk_widget_show (grid2);
/* Resolution */
label = gtk_label_new (_("Resolution:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_grid_attach (GTK_GRID (grid), label, 0, 4, 1, 1);
// GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
res = pika_size_entry_new (1, PIKA_UNIT_INCH, _("pixels/%a"),
FALSE, FALSE, FALSE, 10,
PIKA_SIZE_ENTRY_UPDATE_RESOLUTION);
gtk_grid_attach (GTK_GRID (grid), res, 1, 4, 1, 1);
// GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (res);
/* don't let the resolution become too small, librsvg tends to
crash with very small resolutions */
pika_size_entry_set_refval_boundaries (PIKA_SIZE_ENTRY (res), 0,
5.0, PIKA_MAX_RESOLUTION);
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (res), 0, load_vals.resolution);
g_object_set_data (G_OBJECT (file), "rsvg-flags", GINT_TO_POINTER (rsvg_flags));
g_signal_connect (res, "value-changed",
G_CALLBACK (load_dialog_resolution_callback),
file);
/* Path Import */
toggle = gtk_check_button_new_with_mnemonic (_("Import _paths"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), load_vals.import);
gtk_grid_attach (GTK_GRID (grid), toggle, 0, 5, 2, 1);
// GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (toggle);
pika_help_set_help_data (toggle,
_("Import path elements of the SVG so they "
"can be used with the PIKA path tool"),
NULL);
g_signal_connect (toggle, "toggled",
G_CALLBACK (pika_toggle_button_update),
&load_vals.import);
toggle2 = gtk_check_button_new_with_mnemonic (_("Merge imported paths"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle2), load_vals.merge);
gtk_grid_attach (GTK_GRID (grid), toggle2, 0, 6, 2, 1);
// GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (toggle2);
g_signal_connect (toggle2, "toggled",
G_CALLBACK (pika_toggle_button_update),
&load_vals.merge);
g_object_bind_property (toggle, "active",
toggle2, "sensitive",
G_BINDING_SYNC_CREATE);
gtk_widget_show (dialog);
run = (pika_dialog_run (PIKA_DIALOG (dialog)) == GTK_RESPONSE_OK);
if (run)
{
load_vals.width = ROUND (pika_size_entry_get_refval (size, 0));
load_vals.height = ROUND (pika_size_entry_get_refval (size, 1));
}
/* Complete the dialog. */
pika_procedure_dialog_fill (PIKA_PROCEDURE_DIALOG (dialog), "main-hbox", NULL);
run = pika_procedure_dialog_run (PIKA_PROCEDURE_DIALOG (dialog));
gtk_widget_destroy (dialog);

93
plug-ins/common/file-tga.c
View File

@ -170,43 +170,46 @@ struct _TgaClass
#define TGA_TYPE (tga_get_type ())
#define TGA (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TGA_TYPE, Tga))
#define TGA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TGA_TYPE, Tga))
GType tga_get_type (void) G_GNUC_CONST;
static GList * tga_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * tga_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * tga_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * tga_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * tga_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * tga_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * tga_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * tga_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GObject *config,
GError **error);
static PikaImage * load_image (GFile *file,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GObject *config,
GError **error);
static gboolean save_dialog (PikaImage *image,
PikaProcedure *procedure,
GObject *config);
static gboolean save_dialog (PikaImage *image,
PikaProcedure *procedure,
GObject *config);
static PikaImage * ReadImage (FILE *fp,
tga_info *info,
GFile *file);
static PikaImage * ReadImage (FILE *fp,
tga_info *info,
GFile *file);
G_DEFINE_TYPE (Tga, tga, PIKA_TYPE_PLUG_IN)
@ -283,7 +286,7 @@ tga_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
tga_save, NULL, NULL);
FALSE, tga_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "*");
@ -322,11 +325,13 @@ tga_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
tga_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
tga_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *image;
@ -357,19 +362,16 @@ tga_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, image, run_mode, args);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
@ -417,9 +419,6 @@ tga_save (PikaProcedure *procedure,
}
}
pika_procedure_config_end_run (config, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
pika_image_delete (image);

46
plug-ins/common/file-wbmp.c
View File

@ -48,28 +48,30 @@ struct _WbmpClass
};
#define WBMP_TYPE (wbmp_get_type ())
#define WBMP (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), WBMP_TYPE, Wbmp))
#define WBMP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), WBMP_TYPE, Wbmp))
GType wbmp_get_type (void) G_GNUC_CONST;
static GList * wbmp_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * wbmp_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * wbmp_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * wbmp_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * wbmp_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * wbmp_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
PikaImage * load_image (GFile *file,
GError **error);
PikaImage * load_image (GFile *file,
GError **error);
static PikaImage * read_image (FILE *fd,
GFile *file,
gint width,
gint height,
GError **error);
static PikaImage * read_image (FILE *fd,
GFile *file,
gint width,
gint height,
GError **error);
G_DEFINE_TYPE (Wbmp, wbmp, PIKA_TYPE_PLUG_IN)
@ -134,11 +136,13 @@ wbmp_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
wbmp_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
wbmp_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *image;

480
plug-ins/common/file-wmf.c
View File

@ -41,7 +41,7 @@
#define PLUG_IN_BINARY "file-wmf"
#define PLUG_IN_ROLE "pika-file-wmf"
#define WMF_DEFAULT_RESOLUTION 90.0
#define WMF_DEFAULT_RESOLUTION 300.0
#define WMF_DEFAULT_SIZE 500
#define WMF_PREVIEW_SIZE 128
@ -69,37 +69,47 @@ struct _WmfClass
#define WMF_TYPE (wmf_get_type ())
#define WMF (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), WMF_TYPE, Wmf))
#define WMF(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), WMF_TYPE, Wmf))
GType wmf_get_type (void) G_GNUC_CONST;
static GList * wmf_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * wmf_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * wmf_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * wmf_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * wmf_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * wmf_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * wmf_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * wmf_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
GError **error);
static gboolean load_wmf_size (GFile *file,
WmfLoadVals *vals);
static gboolean load_dialog (GFile *file);
static guchar * wmf_get_pixbuf (GFile *file,
gint *width,
gint *height);
static guchar * wmf_load_file (GFile *file,
guint *width,
guint *height,
GError **error);
static PikaImage * load_image (GFile *file,
gint requested_width,
gint requested_height,
gdouble resolution,
GError **error);
static gboolean load_wmf_size (GFile *file,
WmfLoadVals *vals);
static gboolean load_dialog (GFile *file,
PikaProcedure *procedure,
PikaProcedureConfig *config);
static guchar * wmf_get_pixbuf (GFile *file,
gint *width,
gint *height);
static guchar * wmf_load_file (GFile *file,
gint requested_width,
gint requested_height,
gdouble resolution,
guint *width,
guint *height,
GError **error);
G_DEFINE_TYPE (Wmf, wmf, PIKA_TYPE_PLUG_IN)
@ -108,14 +118,6 @@ PIKA_MAIN (WMF_TYPE)
DEFINE_STD_SET_I18N
static WmfLoadVals load_vals =
{
WMF_DEFAULT_RESOLUTION,
0,
0,
};
static void
wmf_class_init (WmfClass *klass)
{
@ -216,40 +218,34 @@ wmf_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
wmf_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
wmf_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *image;
GError *error = NULL;
gdouble resolution;
gint width;
gint height;
gegl_init (NULL, NULL);
switch (run_mode)
{
case PIKA_RUN_NONINTERACTIVE:
load_vals.resolution = PIKA_VALUES_GET_DOUBLE (args, 0);
load_vals.width = PIKA_VALUES_GET_INT (args, 1);
load_vals.height = PIKA_VALUES_GET_INT (args, 2);
break;
if (run_mode == PIKA_RUN_INTERACTIVE && ! load_dialog (file, procedure, config))
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
case PIKA_RUN_INTERACTIVE:
pika_get_data (LOAD_PROC, &load_vals);
if (! load_dialog (file))
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
break;
case PIKA_RUN_WITH_LAST_VALS:
pika_get_data (LOAD_PROC, &load_vals);
break;
}
image = load_image (file, &error);
g_object_get (config,
"resolution", &resolution,
"width", &width,
"height", &height,
NULL);
image = load_image (file, width, height, resolution, &error);
if (! image)
return pika_procedure_new_return_values (procedure,
@ -266,17 +262,18 @@ wmf_load (PikaProcedure *procedure,
}
static PikaValueArray *
wmf_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
const PikaValueArray *args,
gpointer run_data)
wmf_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *image;
gint width;
gint height;
GError *error = NULL;
gint width = 0;
gint height = 0;
GError *error = NULL;
WmfLoadVals load_vals = { WMF_DEFAULT_RESOLUTION, 0, 0, };
gegl_init (NULL, NULL);
@ -289,8 +286,8 @@ wmf_load_thumb (PikaProcedure *procedure,
if ((gdouble) load_vals.width > (gdouble) load_vals.height)
{
load_vals.height *= (size / (gdouble) load_vals.width);
load_vals.width = size;
load_vals.height *= size / (gdouble) load_vals.width;
}
else
{
@ -305,7 +302,7 @@ wmf_load_thumb (PikaProcedure *procedure,
NULL);
}
image = load_image (file, &error);
image = load_image (file, load_vals.width, load_vals.height, load_vals.resolution, &error);
if (! image)
return pika_procedure_new_return_values (procedure,
@ -418,74 +415,6 @@ load_wmf_size (GFile *file,
/* User interface */
static PikaSizeEntry *size = NULL;
static GtkAdjustment *xadj = NULL;
static GtkAdjustment *yadj = NULL;
static GtkWidget *constrain = NULL;
static gdouble ratio_x = 1.0;
static gdouble ratio_y = 1.0;
static gint wmf_width = 0;
static gint wmf_height = 0;
static void load_dialog_set_ratio (gdouble x,
gdouble y);
static void
load_dialog_size_callback (GtkWidget *widget,
gpointer data)
{
if (pika_chain_button_get_active (PIKA_CHAIN_BUTTON (constrain)))
{
gdouble x = pika_size_entry_get_refval (size, 0) / (gdouble) wmf_width;
gdouble y = pika_size_entry_get_refval (size, 1) / (gdouble) wmf_height;
if (x != ratio_x)
{
load_dialog_set_ratio (x, x);
}
else if (y != ratio_y)
{
load_dialog_set_ratio (y, y);
}
}
}
static void
load_dialog_ratio_callback (GtkAdjustment *adj,
gpointer data)
{
gdouble x = gtk_adjustment_get_value (xadj);
gdouble y = gtk_adjustment_get_value (yadj);
if (pika_chain_button_get_active (PIKA_CHAIN_BUTTON (constrain)))
{
if (x != ratio_x)
y = x;
else
x = y;
}
load_dialog_set_ratio (x, y);
}
static void
load_dialog_resolution_callback (PikaSizeEntry *res,
GFile *file)
{
WmfLoadVals vals = { 0.0, 0, 0 };
load_vals.resolution = vals.resolution = pika_size_entry_get_refval (res, 0);
if (! load_wmf_size (file, &vals))
return;
wmf_width = vals.width;
wmf_height = vals.height;
load_dialog_set_ratio (ratio_x, ratio_y);
}
static void
wmf_preview_callback (GtkWidget *widget,
GtkAllocation *allocation,
@ -497,79 +426,45 @@ wmf_preview_callback (GtkWidget *widget,
pixels, allocation->width * 4);
}
static void
load_dialog_set_ratio (gdouble x,
gdouble y)
{
ratio_x = x;
ratio_y = y;
g_signal_handlers_block_by_func (size, load_dialog_size_callback, NULL);
pika_size_entry_set_refval (size, 0, wmf_width * x);
pika_size_entry_set_refval (size, 1, wmf_height * y);
g_signal_handlers_unblock_by_func (size, load_dialog_size_callback, NULL);
g_signal_handlers_block_by_func (xadj, load_dialog_ratio_callback, NULL);
g_signal_handlers_block_by_func (yadj, load_dialog_ratio_callback, NULL);
gtk_adjustment_set_value (xadj, x);
gtk_adjustment_set_value (yadj, y);
g_signal_handlers_unblock_by_func (xadj, load_dialog_ratio_callback, NULL);
g_signal_handlers_unblock_by_func (yadj, load_dialog_ratio_callback, NULL);
}
static gboolean
load_dialog (GFile *file)
load_dialog (GFile *file,
PikaProcedure *procedure,
PikaProcedureConfig *config)
{
GtkWidget *dialog;
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *main_hbox;
GtkWidget *vbox;
GtkWidget *frame;
GtkWidget *image;
GtkWidget *grid;
GtkWidget *grid2;
GtkWidget *res;
GtkWidget *label;
GtkWidget *spinbutton;
GtkAdjustment *adj;
guchar *pixels;
gboolean run = FALSE;
WmfLoadVals vals = { WMF_DEFAULT_RESOLUTION,
- WMF_PREVIEW_SIZE, - WMF_PREVIEW_SIZE };
WmfLoadVals vals;
pika_ui_init (PLUG_IN_BINARY);
dialog = pika_dialog_new (_("Render Windows Metafile"), PLUG_IN_ROLE,
NULL, 0,
pika_standard_help_func, LOAD_PROC,
dialog = pika_procedure_dialog_new (PIKA_PROCEDURE (procedure),
PIKA_PROCEDURE_CONFIG (config),
_("Render Windows Metafile"));
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_OK"), GTK_RESPONSE_OK,
NULL);
pika_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
pika_window_set_transient (GTK_WINDOW (dialog));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
/* TODO: we'll want to have a special widget (or even procedure argument type)
* for dimensions (showing units, possibility to link dimensions and so on).
* TODO 2: in the old version, there used to be X and Y ratio fields which
* could be constrained/linked (or not) and would sync back and forth with the
* width/height fields. Are these needed? If so, should we try to automatize
* such UI when editing dimensions?
*/
pika_procedure_dialog_fill_box (PIKA_PROCEDURE_DIALOG (dialog),
"vbox-arguments",
"width", "height", "resolution",
NULL);
main_hbox = pika_procedure_dialog_fill_box (PIKA_PROCEDURE_DIALOG (dialog), "main-hbox",
"vbox-arguments", NULL);
gtk_orientable_set_orientation (GTK_ORIENTABLE (main_hbox), GTK_ORIENTATION_HORIZONTAL);
/* The WMF preview */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (main_hbox), vbox, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (main_hbox), vbox, 0);
gtk_widget_show (vbox);
frame = gtk_frame_new (NULL);
@ -577,6 +472,8 @@ load_dialog (GFile *file)
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vals.width = - WMF_PREVIEW_SIZE;
vals.height = - WMF_PREVIEW_SIZE;
pixels = wmf_get_pixbuf (file, &vals.width, &vals.height);
image = pika_preview_area_new ();
gtk_widget_set_size_request (image, vals.width, vals.height);
@ -593,163 +490,18 @@ load_dialog (GFile *file)
gtk_widget_show (size_label);
/* query the initial size after the size label is created */
vals.resolution = load_vals.resolution;
g_object_get (config, "resolution", &vals.resolution, NULL);
load_wmf_size (file, &vals);
g_object_set (config,
"width", vals.width,
"height", vals.height,
NULL);
wmf_width = vals.width;
wmf_height = vals.height;
/* Complete the dialog. */
pika_procedure_dialog_fill (PIKA_PROCEDURE_DIALOG (dialog), "main-hbox", NULL);
run = pika_procedure_dialog_run (PIKA_PROCEDURE_DIALOG (dialog));
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
gtk_box_pack_start (GTK_BOX (hbox), grid, TRUE, TRUE, 0);
gtk_widget_show (grid);
/* Width and Height */
label = gtk_label_new (_("Width:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
gtk_widget_show (label);
label = gtk_label_new (_("Height:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
gtk_widget_show (label);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_grid_attach (GTK_GRID (grid), hbox, 1, 0, 1, 1);
gtk_widget_show (hbox);
adj = gtk_adjustment_new (1, 1, 1, 1, 10, 0);
spinbutton = pika_spin_button_new (adj, 1.0, 2);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_grid_attach (GTK_GRID (grid), hbox, 1, 1, 1, 1);
gtk_widget_show (hbox);
size = PIKA_SIZE_ENTRY (pika_size_entry_new (1, PIKA_UNIT_PIXEL, "%a",
TRUE, FALSE, FALSE, 10,
PIKA_SIZE_ENTRY_UPDATE_SIZE));
pika_size_entry_add_field (size, GTK_SPIN_BUTTON (spinbutton), NULL);
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (size), FALSE, FALSE, 0);
gtk_widget_show (GTK_WIDGET (size));
pika_size_entry_set_refval_boundaries (size, 0,
PIKA_MIN_IMAGE_SIZE,
PIKA_MAX_IMAGE_SIZE);
pika_size_entry_set_refval_boundaries (size, 1,
PIKA_MIN_IMAGE_SIZE,
PIKA_MAX_IMAGE_SIZE);
pika_size_entry_set_refval (size, 0, wmf_width);
pika_size_entry_set_refval (size, 1, wmf_height);
pika_size_entry_set_resolution (size, 0, load_vals.resolution, FALSE);
pika_size_entry_set_resolution (size, 1, load_vals.resolution, FALSE);
g_signal_connect (size, "value-changed",
G_CALLBACK (load_dialog_size_callback),
NULL);
/* Scale ratio */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_grid_attach (GTK_GRID (grid), hbox, 1, 2, 1, 2);
gtk_widget_show (hbox);
grid2 = gtk_grid_new ();
gtk_box_pack_start (GTK_BOX (hbox), grid2, FALSE, FALSE, 0);
xadj = gtk_adjustment_new (ratio_x,
(gdouble) PIKA_MIN_IMAGE_SIZE / (gdouble) wmf_width,
(gdouble) PIKA_MAX_IMAGE_SIZE / (gdouble) wmf_width,
0.01, 0.1, 0);
spinbutton = pika_spin_button_new (xadj, 0.01, 4);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10);
gtk_grid_attach (GTK_GRID (grid2), spinbutton, 0, 0, 1, 1);
gtk_widget_show (spinbutton);
g_signal_connect (xadj, "value-changed",
G_CALLBACK (load_dialog_ratio_callback),
NULL);
label = gtk_label_new_with_mnemonic (_("_X ratio:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1);
gtk_widget_show (label);
yadj = gtk_adjustment_new (ratio_y,
(gdouble) PIKA_MIN_IMAGE_SIZE / (gdouble) wmf_height,
(gdouble) PIKA_MAX_IMAGE_SIZE / (gdouble) wmf_height,
0.01, 0.1, 0);
spinbutton = pika_spin_button_new (yadj, 0.01, 4);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10);
gtk_grid_attach (GTK_GRID (grid2), spinbutton, 0, 1, 1, 1);
gtk_widget_show (spinbutton);
g_signal_connect (yadj, "value-changed",
G_CALLBACK (load_dialog_ratio_callback),
NULL);
label = gtk_label_new_with_mnemonic (_("_Y ratio:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1);
gtk_widget_show (label);
/* the constrain ratio chainbutton */
constrain = pika_chain_button_new (PIKA_CHAIN_RIGHT);
pika_chain_button_set_active (PIKA_CHAIN_BUTTON (constrain), TRUE);
gtk_grid_attach (GTK_GRID (grid2), constrain, 1, 0, 1, 2);
gtk_widget_show (constrain);
pika_help_set_help_data (pika_chain_button_get_button (PIKA_CHAIN_BUTTON (constrain)),
_("Constrain aspect ratio"), NULL);
gtk_widget_show (grid2);
/* Resolution */
label = gtk_label_new (_("Resolution:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_grid_attach (GTK_GRID (grid), label, 0, 4, 1, 1);
gtk_widget_show (label);
res = pika_size_entry_new (1, PIKA_UNIT_INCH, _("pixels/%a"),
FALSE, FALSE, FALSE, 10,
PIKA_SIZE_ENTRY_UPDATE_RESOLUTION);
gtk_grid_attach (GTK_GRID (grid), res, 1, 4, 1, 1);
gtk_widget_show (res);
/* don't let the resolution become too small ? does libwmf tend to
crash with very small resolutions */
pika_size_entry_set_refval_boundaries (PIKA_SIZE_ENTRY (res), 0,
5.0, PIKA_MAX_RESOLUTION);
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (res), 0, load_vals.resolution);
g_signal_connect (res, "value-changed",
G_CALLBACK (load_dialog_resolution_callback),
file);
gtk_widget_show (dialog);
if (pika_dialog_run (PIKA_DIALOG (dialog)) == GTK_RESPONSE_OK)
{
load_vals.width = ROUND (pika_size_entry_get_refval (size, 0));
load_vals.height = ROUND (pika_size_entry_get_refval (size, 1));
run = TRUE;
}
gtk_widget_destroy (GTK_WIDGET (dialog));
gtk_widget_destroy (dialog);
return run;
}
@ -915,6 +667,9 @@ wmf_get_pixbuf (GFile *file,
static guchar *
wmf_load_file (GFile *file,
gint requested_width,
gint requested_height,
gdouble resolution,
guint *width,
guint *height,
GError **error)
@ -970,14 +725,14 @@ wmf_load_file (GFile *file,
err = wmf_display_size (API,
width, height,
load_vals.resolution, load_vals.resolution);
resolution, resolution);
if (err != wmf_E_None || *width <= 0 || *height <= 0)
goto _wmf_error;
if (load_vals.width > 0 && load_vals.height > 0)
if (requested_width > 0 && requested_height > 0)
{
*width = load_vals.width;
*height = load_vals.height;
*width = requested_width;
*height = requested_height;
}
ddata->bbox = bbox;
@ -1018,8 +773,11 @@ wmf_load_file (GFile *file,
* 'load_image()' - Load a WMF image into a new image window.
*/
static PikaImage *
load_image (GFile *file,
GError **error)
load_image (GFile *file,
gint requested_width,
gint requested_height,
gdouble resolution,
GError **error)
{
PikaImage *image;
PikaLayer *layer;
@ -1030,14 +788,14 @@ load_image (GFile *file,
pika_progress_init_printf (_("Opening '%s'"),
pika_file_get_utf8_name (file));
pixels = wmf_load_file (file, &width, &height, error);
pixels = wmf_load_file (file, requested_width, requested_height, resolution,
&width, &height, error);
if (! pixels)
return NULL;
image = pika_image_new (width, height, PIKA_RGB);
pika_image_set_resolution (image,
load_vals.resolution, load_vals.resolution);
pika_image_set_resolution (image, resolution, resolution);
layer = pika_layer_new (image,
_("Rendered WMF"),

93
plug-ins/common/file-xbm.c
View File

@ -74,45 +74,48 @@ struct _XbmClass
#define XBM_TYPE (xbm_get_type ())
#define XBM (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), XBM_TYPE, Xbm))
#define XBM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), XBM_TYPE, Xbm))
GType xbm_get_type (void) G_GNUC_CONST;
static GList * xbm_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * xbm_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * xbm_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * xbm_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * xbm_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * xbm_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * xbm_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * xbm_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
GError **error);
static gboolean save_image (GFile *file,
const gchar *prefix,
gboolean save_mask,
PikaImage *image,
PikaDrawable *drawable,
GObject *config,
GError **error);
static gboolean save_dialog (PikaImage *image,
PikaDrawable *drawable,
PikaProcedure *procedure,
GObject *config);
static PikaImage * load_image (GFile *file,
GError **error);
static gboolean save_image (GFile *file,
const gchar *prefix,
gboolean save_mask,
PikaImage *image,
PikaDrawable *drawable,
GObject *config,
GError **error);
static gboolean save_dialog (PikaImage *image,
PikaDrawable *drawable,
PikaProcedure *procedure,
GObject *config);
static gboolean print (GOutputStream *output,
GError **error,
const gchar *format,
static gboolean print (GOutputStream *output,
GError **error,
const gchar *format,
...) G_GNUC_PRINTF (3, 4);
@ -184,7 +187,7 @@ xbm_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
xbm_save, NULL, NULL);
FALSE, xbm_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "INDEXED");
@ -274,11 +277,13 @@ xbm_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
xbm_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
xbm_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
@ -340,10 +345,10 @@ xbm_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
gchar *mask_basename = NULL;
@ -351,9 +356,6 @@ xbm_save (PikaProcedure *procedure,
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_export (config, image, run_mode, args, NULL);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
@ -490,9 +492,6 @@ xbm_save (PikaProcedure *procedure,
g_object_unref (mask_file);
}
pika_procedure_config_end_export (config, image, file, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
pika_image_delete (image);

244
plug-ins/common/file-xmc.c
View File

@ -149,106 +149,108 @@ struct _XmcClass
#define XMC_TYPE (xmc_get_type ())
#define XMC (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), XMC_TYPE, Xmc))
#define XMC(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), XMC_TYPE, Xmc))
GType xmc_get_type (void) G_GNUC_CONST;
GType xmc_get_type (void) G_GNUC_CONST;
static GList * xmc_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * xmc_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * xmc_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * xmc_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * xmc_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * xmc_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * xmc_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * xmc_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * xmc_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * xmc_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
GError **error);
static PikaImage * load_image (GFile *file,
GError **error);
static PikaImage * load_thumbnail (GFile *file,
gint32 thumb_size,
gint32 *width,
gint32 *height,
gint32 *num_layers,
GError **error);
static PikaImage * load_thumbnail (GFile *file,
gint32 thumb_size,
gint32 *width,
gint32 *height,
gint32 *num_layers,
GError **error);
static guint32 read32 (FILE *f,
GError **error);
static guint32 read32 (FILE *f,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
PikaImage *orig_image,
GObject *config,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
PikaImage *orig_image,
GObject *config,
GError **error);
static gboolean save_dialog (PikaProcedure *procedure,
GObject *config,
PikaImage *image,
GeglRectangle *hotspot_range);
static gboolean save_dialog (PikaProcedure *procedure,
GObject *config,
PikaImage *image,
GeglRectangle *hotspot_range);
static void load_default_hotspot (PikaImage *image,
GeglRectangle *hotspot_range,
GObject *config);
static void load_default_hotspot (PikaImage *image,
GeglRectangle *hotspot_range,
GObject *config);
static inline guint32 separate_alpha (guint32 pixel);
static inline guint32 separate_alpha (guint32 pixel);
static inline guint32 premultiply_alpha (guint32 pixel);
static inline guint32 premultiply_alpha (guint32 pixel);
static XcursorComments *set_cursor_comments (GObject *config);
static XcursorComments *set_cursor_comments (GObject *config);
static gboolean set_hotspot_to_parasite (PikaImage *image,
gint hot_spot_x,
gint hot_spot_y);
static gboolean set_hotspot_to_parasite (PikaImage *image,
gint hot_spot_x,
gint hot_spot_y);
static gboolean get_hotspot_from_parasite (PikaImage *image,
gint *hot_spot_x,
gint *hot_spot_y);
static gboolean get_hotspot_from_parasite (PikaImage *image,
gint *hot_spot_x,
gint *hot_spot_y);
static void set_size_and_delay (GObject *config,
const gchar *framename,
guint32 *sizep,
guint32 *delayp,
GRegex *re,
gboolean *size_warnp);
static void set_size_and_delay (GObject *config,
const gchar *framename,
guint32 *sizep,
guint32 *delayp,
GRegex *re,
gboolean *size_warnp);
static gchar * make_framename (guint32 size,
guint32 delay,
guint indent,
GError **errorp);
static gchar * make_framename (guint32 size,
guint32 delay,
guint indent,
GError **errorp);
static void get_cropped_region (GeglRectangle *retrun_rgn,
GeglBuffer *buffer);
static void get_cropped_region (GeglRectangle *retrun_rgn,
GeglBuffer *buffer);
static inline gboolean pix_is_opaque (guint32 pix);
static inline gboolean pix_is_opaque (guint32 pix);
static GeglRectangle * get_intersection_of_frames (PikaImage *image);
static GeglRectangle * get_intersection_of_frames (PikaImage *image);
static gboolean pix_in_region (gint32 x,
gint32 y,
GeglRectangle *xmcrp);
static gboolean pix_in_region (gint32 x,
gint32 y,
GeglRectangle *xmcrp);
static void find_hotspots_and_dimensions
(XcursorImages *xcIs,
gint32 *xhot,
gint32 *yhot,
gint32 *width,
gint32 *height);
static void find_hotspots_and_dimensions (XcursorImages *xcIs,
gint32 *xhot,
gint32 *yhot,
gint32 *width,
gint32 *height);
G_DEFINE_TYPE (Xmc, xmc, PIKA_TYPE_PLUG_IN)
@ -341,7 +343,7 @@ xmc_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
xmc_save, NULL, NULL);
FALSE, xmc_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "RGBA");
@ -438,11 +440,13 @@ xmc_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
xmc_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
xmc_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *image;
@ -467,11 +471,11 @@ xmc_load (PikaProcedure *procedure,
}
static PikaValueArray *
xmc_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
const PikaValueArray *args,
gpointer run_data)
xmc_load_thumb (PikaProcedure *procedure,
GFile *file,
gint size,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
gint width;
@ -513,17 +517,17 @@ xmc_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
PikaImage *orig_image;
GeglRectangle *hotspot_range;
gint hot_spot_x;
gint hot_spot_y;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
PikaImage *orig_image;
GeglRectangle *hotspot_range;
gint hot_spot_x;
gint hot_spot_y;
GError *error = NULL;
gegl_init (NULL, NULL);
@ -543,9 +547,6 @@ xmc_save (PikaProcedure *procedure,
error);
}
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_export (config, image, run_mode, args, NULL);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
@ -616,9 +617,6 @@ xmc_save (PikaProcedure *procedure,
g_free (hotspot_range);
pika_procedure_config_end_export (config, image, file, status);
g_object_unref (config);
return pika_procedure_new_return_values (procedure, status, error);
}
@ -853,9 +851,9 @@ load_image (GFile *file,
static PikaImage *
load_thumbnail (GFile *file,
gint32 thumb_size,
gint32 *thumb_width,
gint32 *thumb_height,
gint32 *thumb_num_layers,
gint32 *img_width,
gint32 *img_height,
gint32 *num_layers,
GError **error)
{
/* Return only one frame for thumbnail.
@ -881,13 +879,13 @@ load_thumbnail (GFile *file,
gint height;
gint i;
g_return_val_if_fail (thumb_width, NULL);
g_return_val_if_fail (thumb_height, NULL);
g_return_val_if_fail (thumb_num_layers, NULL);
g_return_val_if_fail (img_width, NULL);
g_return_val_if_fail (img_height, NULL);
g_return_val_if_fail (num_layers, NULL);
*thumb_width = 0;
*thumb_height = 0;
*thumb_num_layers = 0;
*img_width = 0;
*img_height = 0;
*num_layers = 0;
fp = g_fopen (g_file_peek_path (file), "rb");
@ -939,15 +937,15 @@ load_thumbnail (GFile *file,
/* this content is image */
size = READ32 (fp, error)
positions[*thumb_num_layers] = READ32 (fp, error)
positions[*num_layers] = READ32 (fp, error)
/* is this image is more preferred than selected before? */
diff = MAX (thumb_size, size) - MIN (thumb_size, size);
if (diff < min_diff)
{/* the image size is closer than current selected image */
min_diff = diff;
sel_num = *thumb_num_layers;
sel_num = *num_layers;
}
++*thumb_num_layers;
++*num_layers;
}
}
@ -963,8 +961,8 @@ load_thumbnail (GFile *file,
/* get width and height of entire image */
/* Let's make XcursorImages */
xcIs = XcursorImagesCreate (*thumb_num_layers);
xcIs->nimage = *thumb_num_layers;
xcIs = XcursorImagesCreate (*num_layers);
xcIs->nimage = *num_layers;
for (i = 0; i < xcIs->nimage; ++i)
{
/* make XcursorImage with no pixel buffer */
@ -986,13 +984,13 @@ load_thumbnail (GFile *file,
thumb_size - min_diff, thumb_size + min_diff);
/* get entire image dimensions */
find_hotspots_and_dimensions (xcIs, NULL, NULL, thumb_width, thumb_height);
find_hotspots_and_dimensions (xcIs, NULL, NULL, img_width, img_height);
DM_XMC ("width=%i\theight=%i\tnum-layers=%i\n",
*thumb_width, *thumb_height, xcIs->nimage);
*img_width, *img_height, xcIs->nimage);
/* dimension check */
if (*thumb_width > MAX_LOAD_DIMENSION)
if (*img_width > MAX_LOAD_DIMENSION)
{
g_set_error (error, 0, 0,
_("'%s' is too wide for an X cursor."),
@ -1001,7 +999,7 @@ load_thumbnail (GFile *file,
return NULL;
}
if (*thumb_height > MAX_LOAD_DIMENSION)
if (*img_height > MAX_LOAD_DIMENSION)
{
g_set_error (error, 0, 0,
_("'%s' is too high for an X cursor."),

95
plug-ins/common/file-xpm.c
View File

@ -100,42 +100,45 @@ struct _XpmClass
#define XPM_TYPE (xpm_get_type ())
#define XPM (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), XPM_TYPE, Xpm))
#define XPM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), XPM_TYPE, Xpm))
GType xpm_get_type (void) G_GNUC_CONST;
static GList * xpm_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * xpm_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * xpm_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * xpm_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * xpm_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * xpm_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * xpm_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * xpm_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
GError **error);
static guchar * parse_colors (XpmImage *xpm_image);
static void parse_image (PikaImage *image,
XpmImage *xpm_image,
guchar *cmap);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GObject *config,
GError **error);
static gboolean save_dialog (PikaImage *image,
PikaProcedure *procedure,
GObject *config);
static PikaImage * load_image (GFile *file,
GError **error);
static guchar * parse_colors (XpmImage *xpm_image);
static void parse_image (PikaImage *image,
XpmImage *xpm_image,
guchar *cmap);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GObject *config,
GError **error);
static gboolean save_dialog (PikaImage *image,
PikaProcedure *procedure,
GObject *config);
G_DEFINE_TYPE (Xpm, xpm, PIKA_TYPE_PLUG_IN)
@ -228,7 +231,7 @@ xpm_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
xpm_save, NULL, NULL);
FALSE, xpm_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "*");
@ -270,11 +273,13 @@ xpm_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
xpm_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
xpm_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *image;
@ -305,19 +310,16 @@ xpm_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
GError *error = NULL;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, image, run_mode, args);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
@ -366,9 +368,6 @@ xpm_save (PikaProcedure *procedure,
}
}
pika_procedure_config_end_run (config, status);
g_object_unref (config);
if (export == PIKA_EXPORT_EXPORT)
{
pika_image_delete (image);

244
plug-ins/common/file-xwd.c
View File

@ -155,130 +155,133 @@ struct _XwdClass
#define XWD_TYPE (xwd_get_type ())
#define XWD (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), XWD_TYPE, Xwd))
#define XWD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), XWD_TYPE, Xwd))
GType xwd_get_type (void) G_GNUC_CONST;
static GList * xwd_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * xwd_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static GList * xwd_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * xwd_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * xwd_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * xwd_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
gpointer run_data);
static PikaValueArray * xwd_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data);
static PikaValueArray * xwd_save (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data);
static PikaImage * load_image (GFile *file,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
static PikaImage * create_new_image (GFile *file,
guint width,
guint height,
PikaImageBaseType type,
PikaImageType gdtype,
PikaLayer **layer,
GeglBuffer **buffer);
static PikaImage * load_image (GFile *file,
GError **error);
static gboolean save_image (GFile *file,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
static PikaImage * create_new_image (GFile *file,
guint width,
guint height,
PikaImageBaseType type,
PikaImageType gdtype,
PikaLayer **layer,
GeglBuffer **buffer);
static int set_pixelmap (gint ncols,
L_XWDCOLOR *xwdcol,
PIXEL_MAP *pixelmap);
static gboolean get_pixelmap (L_CARD32 pixelval,
PIXEL_MAP *pixelmap,
guchar *red,
guchar *green,
guchar *glue);
static int set_pixelmap (gint ncols,
L_XWDCOLOR *xwdcol,
PIXEL_MAP *pixelmap);
static gboolean get_pixelmap (L_CARD32 pixelval,
PIXEL_MAP *pixelmap,
guchar *red,
guchar *green,
guchar *glue);
static void set_bw_color_table (PikaImage *image);
static void set_color_table (PikaImage *image,
L_XWDFILEHEADER *xwdhdr,
L_XWDCOLOR *xwdcolmap);
static void set_bw_color_table (PikaImage *image);
static void set_color_table (PikaImage *image,
L_XWDFILEHEADER *xwdhdr,
L_XWDCOLOR *xwdcolmap);
static PikaImage * load_xwd_f2_d1_b1 (GFile *file,
FILE *ifp,
L_XWDFILEHEADER *xwdhdr,
L_XWDCOLOR *xwdcolmap,
GError **error);
static PikaImage * load_xwd_f2_d8_b8 (GFile *file,
FILE *ifp,
L_XWDFILEHEADER *xwdhdr,
L_XWDCOLOR *xwdcolmap,
GError **error);
static PikaImage * load_xwd_f2_d16_b16 (GFile *file,
FILE *ifp,
L_XWDFILEHEADER *xwdhdr,
L_XWDCOLOR *xwdcolmap,
GError **error);
static PikaImage * load_xwd_f2_d24_b32 (GFile *file,
FILE *ifp,
L_XWDFILEHEADER *xwdhdr,
L_XWDCOLOR *xwdcolmap,
GError **error);
static PikaImage * load_xwd_f2_d32_b32 (GFile *file,
FILE *ifp,
L_XWDFILEHEADER *xwdhdr,
L_XWDCOLOR *xwdcolmap,
GError **error);
static PikaImage * load_xwd_f1_d24_b1 (GFile *file,
FILE *ifp,
L_XWDFILEHEADER *xwdhdr,
L_XWDCOLOR *xwdcolmap,
GError **error);
static PikaImage * load_xwd_f2_d1_b1 (GFile *file,
FILE *ifp,
L_XWDFILEHEADER *xwdhdr,
L_XWDCOLOR *xwdcolmap,
GError **error);
static PikaImage * load_xwd_f2_d8_b8 (GFile *file,
FILE *ifp,
L_XWDFILEHEADER *xwdhdr,
L_XWDCOLOR *xwdcolmap,
GError **error);
static PikaImage * load_xwd_f2_d16_b16 (GFile *file,
FILE *ifp,
L_XWDFILEHEADER *xwdhdr,
L_XWDCOLOR *xwdcolmap,
GError **error);
static PikaImage * load_xwd_f2_d24_b32 (GFile *file,
FILE *ifp,
L_XWDFILEHEADER *xwdhdr,
L_XWDCOLOR *xwdcolmap,
GError **error);
static PikaImage * load_xwd_f2_d32_b32 (GFile *file,
FILE *ifp,
L_XWDFILEHEADER *xwdhdr,
L_XWDCOLOR *xwdcolmap,
GError **error);
static PikaImage * load_xwd_f1_d24_b1 (GFile *file,
FILE *ifp,
L_XWDFILEHEADER *xwdhdr,
L_XWDCOLOR *xwdcolmap,
GError **error);
static L_CARD32 read_card32 (FILE *ifp,
gint *err);
static L_CARD16 read_card16 (FILE *ifp,
gint *err);
static L_CARD8 read_card8 (FILE *ifp,
gint *err);
static L_CARD32 read_card32 (FILE *ifp,
gint *err);
static L_CARD16 read_card16 (FILE *ifp,
gint *err);
static L_CARD8 read_card8 (FILE *ifp,
gint *err);
static gboolean write_card32 (GOutputStream *output,
L_CARD32 c,
GError **error);
static gboolean write_card16 (GOutputStream *output,
L_CARD32 c,
GError **error);
static gboolean write_card8 (GOutputStream *output,
L_CARD32 c,
GError **error);
static gboolean write_card32 (GOutputStream *output,
L_CARD32 c,
GError **error);
static gboolean write_card16 (GOutputStream *output,
L_CARD32 c,
GError **error);
static gboolean write_card8 (GOutputStream *output,
L_CARD32 c,
GError **error);
static void read_xwd_header (FILE *ifp,
L_XWDFILEHEADER *xwdhdr);
static void read_xwd_header (FILE *ifp,
L_XWDFILEHEADER *xwdhdr);
static gboolean write_xwd_header (GOutputStream *output,
L_XWDFILEHEADER *xwdhdr,
GError **error);
static gboolean write_xwd_header (GOutputStream *output,
L_XWDFILEHEADER *xwdhdr,
GError **error);
static void read_xwd_cols (FILE *ifp,
L_XWDFILEHEADER *xwdhdr,
L_XWDCOLOR *xwdcolmap,
GError **error);
static void read_xwd_cols (FILE *ifp,
L_XWDFILEHEADER *xwdhdr,
L_XWDCOLOR *xwdcolmap,
GError **error);
static gboolean write_xwd_cols (GOutputStream *output,
L_XWDFILEHEADER *xwdhdr,
L_XWDCOLOR *colormap,
GError **error);
static gboolean write_xwd_cols (GOutputStream *output,
L_XWDFILEHEADER *xwdhdr,
L_XWDCOLOR *colormap,
GError **error);
static gint save_index (GOutputStream *output,
PikaImage *image,
PikaDrawable *drawable,
gboolean gray,
GError **error);
static gint save_rgb (GOutputStream *output,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
static gint save_index (GOutputStream *output,
PikaImage *image,
PikaDrawable *drawable,
gboolean gray,
GError **error);
static gint save_rgb (GOutputStream *output,
PikaImage *image,
PikaDrawable *drawable,
GError **error);
G_DEFINE_TYPE (Xwd, xwd, PIKA_TYPE_PLUG_IN)
@ -351,7 +354,7 @@ xwd_create_procedure (PikaPlugIn *plug_in,
{
procedure = pika_save_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
xwd_save, NULL, NULL);
FALSE, xwd_save, NULL, NULL);
pika_procedure_set_image_types (procedure, "RGB, GRAY, INDEXED");
@ -380,11 +383,13 @@ xwd_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
xwd_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
const PikaValueArray *args,
gpointer run_data)
xwd_load (PikaProcedure *procedure,
PikaRunMode run_mode,
GFile *file,
PikaMetadata *metadata,
PikaMetadataLoadFlags *flags,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *image;
@ -415,12 +420,13 @@ xwd_save (PikaProcedure *procedure,
gint n_drawables,
PikaDrawable **drawables,
GFile *file,
const PikaValueArray *args,
PikaMetadata *metadata,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
GError *error = NULL;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaExportReturn export = PIKA_EXPORT_CANCEL;
GError *error = NULL;
gegl_init (NULL, NULL);

1005
plug-ins/common/film.c
View File

File diff suppressed because it is too large Load Diff

18
plug-ins/common/gradient-map.c
View File

@ -59,7 +59,7 @@ struct _MapClass
#define MAP_TYPE (map_get_type ())
#define MAP (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAP_TYPE, Map))
#define MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAP_TYPE, Map))
GType map_get_type (void) G_GNUC_CONST;
@ -72,7 +72,7 @@ static PikaValueArray * map_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static void map (GeglBuffer *buffer,
@ -197,13 +197,13 @@ map_create_procedure (PikaPlugIn *plug_in,
}
static PikaValueArray *
map_run (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
gpointer run_data)
map_run (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
PikaProcedureConfig *config,
gpointer run_data)
{
MapMode mode = GPOINTER_TO_INT (run_data);
GeglBuffer *shadow_buffer;

440
plug-ins/common/grid.c
View File

@ -57,29 +57,19 @@
#define COLOR_BUTTON_WIDTH 55
typedef struct
{
gint hwidth;
gint hspace;
gint hoffset;
PikaRGB hcolor;
gint vwidth;
gint vspace;
gint voffset;
PikaRGB vcolor;
gint iwidth;
gint ispace;
gint ioffset;
PikaRGB icolor;
} Config;
typedef struct _Grid Grid;
typedef struct _GridClass GridClass;
struct _Grid
{
PikaPlugIn parent_instance;
PikaPlugIn parent_instance;
PikaDrawable *drawable;
PikaProcedureConfig *config;
GtkWidget *hcolor_button;
GtkWidget *vcolor_button;
GtkWidget *icolor_button;
GtkWidget *color_chain;
};
struct _GridClass
@ -89,7 +79,7 @@ struct _GridClass
#define GRID_TYPE (grid_get_type ())
#define GRID (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GRID_TYPE, Grid))
#define GRID(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GRID_TYPE, Grid))
GType grid_get_type (void) G_GNUC_CONST;
@ -102,17 +92,20 @@ static PikaValueArray * grid_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static guchar best_cmap_match (const guchar *cmap,
gint ncolors,
const PikaRGB *color);
static void grid (PikaImage *image,
static void render_grid (PikaImage *image,
PikaDrawable *drawable,
PikaProcedureConfig *config,
PikaPreview *preview);
static gint dialog (PikaImage *image,
PikaDrawable *drawable);
PikaDrawable *drawable,
PikaProcedure *procedure,
PikaProcedureConfig *config);
G_DEFINE_TYPE (Grid, grid, PIKA_TYPE_PLUG_IN)
@ -124,15 +117,6 @@ DEFINE_STD_SET_I18N
static gint sx1, sy1, sx2, sy2;
static GtkWidget *main_dialog = NULL;
static GtkWidget *hcolor_button = NULL;
static GtkWidget *vcolor_button = NULL;
static Config grid_cfg =
{
1, 16, 8, { 0.0, 0.0, 0.0, 1.0 }, /* horizontal */
1, 16, 8, { 0.0, 0.0, 0.0, 1.0 }, /* vertical */
0, 2, 6, { 0.0, 0.0, 0.0, 1.0 }, /* intersection */
};
static void
@ -208,6 +192,11 @@ grid_create_procedure (PikaPlugIn *plug_in,
0, PIKA_MAX_IMAGE_SIZE, 8,
G_PARAM_READWRITE);
/* TODO: for "hcolor", "icolor" and "vcolor", the original code would use
* the foreground color as default. It would be interesting if
* PIKA_PROC_ARG_RGB() had a way to specify the foreground or background
* colors as default (instead of a hardcoded color).
*/
PIKA_PROC_ARG_RGB (procedure, "hcolor",
"H color",
"Horizontal color",
@ -272,7 +261,7 @@ grid_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaDrawable *drawable;
@ -296,51 +285,18 @@ grid_run (PikaProcedure *procedure,
drawable = drawables[0];
}
if (run_mode == PIKA_RUN_NONINTERACTIVE)
{
grid_cfg.hwidth = PIKA_VALUES_GET_INT (args, 0);
grid_cfg.hspace = PIKA_VALUES_GET_INT (args, 1);
grid_cfg.hoffset = PIKA_VALUES_GET_INT (args, 2);
PIKA_VALUES_GET_RGB (args, 3, &grid_cfg.hcolor);
grid_cfg.vwidth = PIKA_VALUES_GET_INT (args, 4);
grid_cfg.vspace = PIKA_VALUES_GET_INT (args, 5);
grid_cfg.voffset = PIKA_VALUES_GET_INT (args, 6);
PIKA_VALUES_GET_RGB (args, 7, &grid_cfg.vcolor);
grid_cfg.iwidth = PIKA_VALUES_GET_INT (args, 8);
grid_cfg.ispace = PIKA_VALUES_GET_INT (args, 9);
grid_cfg.ioffset = PIKA_VALUES_GET_INT (args, 10);
PIKA_VALUES_GET_RGB (args, 11, &grid_cfg.icolor);
}
else
{
pika_context_get_foreground (&grid_cfg.hcolor);
grid_cfg.vcolor = grid_cfg.icolor = grid_cfg.hcolor;
pika_get_data (PLUG_IN_PROC, &grid_cfg);
}
if (run_mode == PIKA_RUN_INTERACTIVE)
{
if (! dialog (image, drawable))
{
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
}
if (run_mode == PIKA_RUN_INTERACTIVE && ! dialog (image, drawable, procedure, config))
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
pika_progress_init (_("Drawing grid"));
grid (image, drawable, NULL);
render_grid (image, drawable, config, NULL);
if (run_mode != PIKA_RUN_NONINTERACTIVE)
pika_displays_flush ();
if (run_mode == PIKA_RUN_INTERACTIVE)
pika_set_data (PLUG_IN_PROC, &grid_cfg, sizeof (grid_cfg));
return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL);
}
@ -413,9 +369,10 @@ pix_composite (guchar *p1,
}
static void
grid (PikaImage *image,
PikaDrawable *drawable,
PikaPreview *preview)
render_grid (PikaImage *image,
PikaDrawable *drawable,
PikaProcedureConfig *config,
PikaPreview *preview)
{
GeglBuffer *src_buffer = NULL;
GeglBuffer *dest_buffer = NULL;
@ -434,11 +391,39 @@ grid (PikaImage *image,
guchar *cmap;
gint ncolors;
pika_rgba_get_uchar (&grid_cfg.hcolor,
gint hwidth;
gint hspace;
gint hoffset;
PikaRGB *hcolor_rgb;
gint vwidth;
gint vspace;
gint voffset;
PikaRGB *vcolor_rgb;
gint iwidth;
gint ispace;
gint ioffset;
PikaRGB *icolor_rgb;
g_object_get (config,
"hwidth", &hwidth,
"hspace", &hspace,
"hoffset", &hoffset,
"hcolor", &hcolor_rgb,
"vwidth", &vwidth,
"vspace", &vspace,
"voffset", &voffset,
"vcolor", &vcolor_rgb,
"iwidth", &iwidth,
"ispace", &ispace,
"ioffset", &ioffset,
"icolor", &icolor_rgb,
NULL);
pika_rgba_get_uchar (hcolor_rgb,
hcolor, hcolor + 1, hcolor + 2, hcolor + 3);
pika_rgba_get_uchar (&grid_cfg.vcolor,
pika_rgba_get_uchar (vcolor_rgb,
vcolor, vcolor + 1, vcolor + 2, vcolor + 3);
pika_rgba_get_uchar (&grid_cfg.icolor,
pika_rgba_get_uchar (icolor_rgb,
icolor, icolor + 1, icolor + 2, icolor + 3);
alpha = pika_drawable_has_alpha (drawable);
@ -455,9 +440,9 @@ grid (PikaImage *image,
break;
case PIKA_GRAY:
hcolor[0] = pika_rgb_luminance_uchar (&grid_cfg.hcolor);
vcolor[0] = pika_rgb_luminance_uchar (&grid_cfg.vcolor);
icolor[0] = pika_rgb_luminance_uchar (&grid_cfg.icolor);
hcolor[0] = pika_rgb_luminance_uchar (hcolor_rgb);
vcolor[0] = pika_rgb_luminance_uchar (vcolor_rgb);
icolor[0] = pika_rgb_luminance_uchar (icolor_rgb);
blend = TRUE;
if (alpha)
@ -469,9 +454,9 @@ grid (PikaImage *image,
case PIKA_INDEXED:
cmap = pika_image_get_colormap (image, NULL, &ncolors);
hcolor[0] = best_cmap_match (cmap, ncolors, &grid_cfg.hcolor);
vcolor[0] = best_cmap_match (cmap, ncolors, &grid_cfg.vcolor);
icolor[0] = best_cmap_match (cmap, ncolors, &grid_cfg.icolor);
hcolor[0] = best_cmap_match (cmap, ncolors, hcolor_rgb);
vcolor[0] = best_cmap_match (cmap, ncolors, vcolor_rgb);
icolor[0] = best_cmap_match (cmap, ncolors, icolor_rgb);
g_free (cmap);
blend = FALSE;
@ -520,12 +505,11 @@ grid (PikaImage *image,
format, dest,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
y_offset = y - grid_cfg.hoffset;
y_offset = y - hoffset;
while (y_offset < 0)
y_offset += grid_cfg.hspace;
y_offset += hspace;
if ((y_offset +
(grid_cfg.hwidth / 2)) % grid_cfg.hspace < grid_cfg.hwidth)
if ((y_offset + (hwidth / 2)) % hspace < hwidth)
{
for (x = sx1; x < sx2; x++)
{
@ -536,53 +520,50 @@ grid (PikaImage *image,
for (x = sx1; x < sx2; x++)
{
x_offset = grid_cfg.vspace + x - grid_cfg.voffset;
x_offset = vspace + x - voffset;
while (x_offset < 0)
x_offset += grid_cfg.vspace;
x_offset += vspace;
if ((x_offset +
(grid_cfg.vwidth / 2)) % grid_cfg.vspace < grid_cfg.vwidth)
if ((x_offset + (vwidth / 2)) % vspace < vwidth)
{
pix_composite (&dest[(x-sx1) * bytes],
vcolor, bytes, blend, alpha);
}
if ((x_offset +
(grid_cfg.iwidth / 2)) % grid_cfg.vspace < grid_cfg.iwidth
if ((x_offset + (iwidth / 2)) % vspace < iwidth
&&
((y_offset % grid_cfg.hspace >= grid_cfg.ispace
((y_offset % hspace >= ispace
&&
y_offset % grid_cfg.hspace < grid_cfg.ioffset)
y_offset % hspace < ioffset)
||
(grid_cfg.hspace -
(y_offset % grid_cfg.hspace) >= grid_cfg.ispace
(hspace -
(y_offset % hspace) >= ispace
&&
grid_cfg.hspace -
(y_offset % grid_cfg.hspace) < grid_cfg.ioffset)))
hspace -
(y_offset % hspace) < ioffset)))
{
pix_composite (&dest[(x-sx1) * bytes],
icolor, bytes, blend, alpha);
}
}
if ((y_offset +
(grid_cfg.iwidth / 2)) % grid_cfg.hspace < grid_cfg.iwidth)
if ((y_offset + (iwidth / 2)) % hspace < iwidth)
{
for (x = sx1; x < sx2; x++)
{
x_offset = grid_cfg.vspace + x - grid_cfg.voffset;
x_offset = vspace + x - voffset;
while (x_offset < 0)
x_offset += grid_cfg.vspace;
x_offset += vspace;
if ((x_offset % grid_cfg.vspace >= grid_cfg.ispace
if ((x_offset % vspace >= ispace
&&
x_offset % grid_cfg.vspace < grid_cfg.ioffset)
x_offset % vspace < ioffset)
||
(grid_cfg.vspace -
(x_offset % grid_cfg.vspace) >= grid_cfg.ispace
(vspace -
(x_offset % vspace) >= ispace
&&
grid_cfg.vspace -
(x_offset % grid_cfg.vspace) < grid_cfg.ioffset))
vspace -
(x_offset % vspace) < ioffset))
{
pix_composite (&dest[(x-sx1) * bytes],
icolor, bytes, blend, alpha);
@ -636,46 +617,57 @@ grid (PikaImage *image,
static void
update_values (void)
update_values (Grid *grid)
{
GtkWidget *entry;
PikaRGB color;
entry = g_object_get_data (G_OBJECT (main_dialog), "width");
grid_cfg.hwidth =
RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (entry), 0));
grid_cfg.vwidth =
RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (entry), 1));
grid_cfg.iwidth =
RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (entry), 2));
g_object_set (grid->config,
"hwidth",
(gint) RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (entry), 0)),
"vwidth",
(gint) RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (entry), 1)),
"iwidth",
(gint) RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (entry), 2)),
NULL);
entry = g_object_get_data (G_OBJECT (main_dialog), "space");
grid_cfg.hspace =
RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (entry), 0));
grid_cfg.vspace =
RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (entry), 1));
grid_cfg.ispace =
RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (entry), 2));
g_object_set (grid->config,
"hspace",
(gint) RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (entry), 0)),
"vspace",
(gint) RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (entry), 1)),
"ispace",
(gint) RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (entry), 2)),
NULL);
entry = g_object_get_data (G_OBJECT (main_dialog), "offset");
g_object_set (grid->config,
"hoffset",
(gint) RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (entry), 0)),
"voffset",
(gint) RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (entry), 1)),
"ioffset",
(gint) RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (entry), 2)),
NULL);
grid_cfg.hoffset =
RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (entry), 0));
grid_cfg.voffset =
RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (entry), 1));
grid_cfg.ioffset =
RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (entry), 2));
pika_color_button_get_color (PIKA_COLOR_BUTTON (grid->hcolor_button), &color);
g_object_set (grid->config, "hcolor", &color, NULL);
pika_color_button_get_color (PIKA_COLOR_BUTTON (grid->vcolor_button), &color);
g_object_set (grid->config, "vcolor", &color, NULL);
pika_color_button_get_color (PIKA_COLOR_BUTTON (grid->icolor_button), &color);
g_object_set (grid->config, "icolor", &color, NULL);
}
static void
update_preview (PikaPreview *preview,
PikaDrawable *drawable)
update_preview (PikaPreview *preview,
Grid *grid)
{
update_values ();
update_values (grid);
grid (pika_item_get_image (PIKA_ITEM (drawable)),
drawable, preview);
render_grid (pika_item_get_image (PIKA_ITEM (grid->drawable)),
grid->drawable, grid->config, preview);
}
static void
@ -714,32 +706,37 @@ static void
color_callback (GtkWidget *widget,
gpointer data)
{
if (pika_chain_button_get_active (PIKA_CHAIN_BUTTON (data)))
Grid *grid = GRID (data);
GtkWidget *chain_button = grid->color_chain;
if (pika_chain_button_get_active (PIKA_CHAIN_BUTTON (chain_button)))
{
PikaRGB color;
PikaRGB color;
pika_color_button_get_color (PIKA_COLOR_BUTTON (widget), &color);
if (widget == vcolor_button)
pika_color_button_set_color (PIKA_COLOR_BUTTON (hcolor_button), &color);
else if (widget == hcolor_button)
pika_color_button_set_color (PIKA_COLOR_BUTTON (vcolor_button), &color);
if (widget == grid->vcolor_button)
pika_color_button_set_color (PIKA_COLOR_BUTTON (grid->hcolor_button), &color);
else if (widget == grid->hcolor_button)
pika_color_button_set_color (PIKA_COLOR_BUTTON (grid->vcolor_button), &color);
}
}
static gint
dialog (PikaImage *image,
PikaDrawable *drawable)
dialog (PikaImage *image,
PikaDrawable *drawable,
PikaProcedure *procedure,
PikaProcedureConfig *config)
{
PikaColorConfig *config;
Grid *grid;
PikaColorConfig *color_config;
GtkWidget *dlg;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkSizeGroup *group;
GtkWidget *label;
GtkWidget *preview;
GtkWidget *button;
GtkWidget *width;
GtkWidget *space;
GtkWidget *offset;
@ -751,8 +748,36 @@ dialog (PikaImage *image,
gdouble yres;
gboolean run;
gint hwidth;
gint hspace;
gint hoffset;
PikaRGB *hcolor;
gint vwidth;
gint vspace;
gint voffset;
PikaRGB *vcolor;
gint iwidth;
gint ispace;
gint ioffset;
PikaRGB *icolor;
g_return_val_if_fail (main_dialog == NULL, FALSE);
g_object_get (config,
"hwidth", &hwidth,
"hspace", &hspace,
"hoffset", &hoffset,
"hcolor", &hcolor,
"vwidth", &vwidth,
"vspace", &vspace,
"voffset", &voffset,
"vcolor", &vcolor,
"iwidth", &iwidth,
"ispace", &ispace,
"ioffset", &ioffset,
"icolor", &icolor,
NULL);
pika_ui_init (PLUG_IN_BINARY);
d_width = pika_drawable_get_width (drawable);
@ -788,9 +813,12 @@ dialog (PikaImage *image,
gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0);
gtk_widget_show (preview);
grid = GRID (pika_procedure_get_plug_in (procedure));
grid->drawable = drawable;
grid->config = config;
g_signal_connect (preview, "invalidated",
G_CALLBACK (update_preview),
drawable);
grid);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
@ -806,7 +834,6 @@ dialog (PikaImage *image,
SPIN_BUTTON_WIDTH, /* spinbutton_usize */
PIKA_SIZE_ENTRY_UPDATE_SIZE); /* update_policy */
gtk_box_pack_start (GTK_BOX (vbox), width, FALSE, FALSE, 0);
gtk_widget_show (width);
@ -833,9 +860,9 @@ dialog (PikaImage *image,
gtk_grid_set_column_spacing (GTK_GRID (width), 6);
/* initialize the values */
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (width), 0, grid_cfg.hwidth);
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (width), 1, grid_cfg.vwidth);
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (width), 2, grid_cfg.iwidth);
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (width), 0, hwidth);
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (width), 1, vwidth);
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (width), 2, iwidth);
/* attach labels */
pika_size_entry_attach_label (PIKA_SIZE_ENTRY (width), _("Horizontal\nLines"),
@ -854,7 +881,7 @@ dialog (PikaImage *image,
/* put a chain_button under the size_entries */
chain_button = pika_chain_button_new (PIKA_CHAIN_BOTTOM);
if (grid_cfg.hwidth == grid_cfg.vwidth)
if (hwidth == vwidth)
pika_chain_button_set_active (PIKA_CHAIN_BUTTON (chain_button), TRUE);
gtk_grid_attach (GTK_GRID (width), chain_button, 1, 2, 2, 1);
gtk_widget_show (chain_button);
@ -904,9 +931,9 @@ dialog (PikaImage *image,
gtk_grid_set_column_spacing (GTK_GRID (space), 6);
/* initialize the values */
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (space), 0, grid_cfg.hspace);
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (space), 1, grid_cfg.vspace);
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (space), 2, grid_cfg.ispace);
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (space), 0, hspace);
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (space), 1, vspace);
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (space), 2, ispace);
/* attach labels */
label = pika_size_entry_attach_label (PIKA_SIZE_ENTRY (space), _("Spacing:"),
@ -915,7 +942,7 @@ dialog (PikaImage *image,
/* put a chain_button under the spacing_entries */
chain_button = pika_chain_button_new (PIKA_CHAIN_BOTTOM);
if (grid_cfg.hspace == grid_cfg.vspace)
if (hspace == vspace)
pika_chain_button_set_active (PIKA_CHAIN_BUTTON (chain_button), TRUE);
gtk_grid_attach (GTK_GRID (space), chain_button, 1, 2, 2, 1);
gtk_widget_show (chain_button);
@ -969,9 +996,9 @@ dialog (PikaImage *image,
gtk_grid_set_column_spacing (GTK_GRID (offset), 6);
/* initialize the values */
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (offset), 0, grid_cfg.hoffset);
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (offset), 1, grid_cfg.voffset);
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (offset), 2, grid_cfg.ioffset);
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (offset), 0, hoffset);
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (offset), 1, voffset);
pika_size_entry_set_refval (PIKA_SIZE_ENTRY (offset), 2, ioffset);
/* attach labels */
label = pika_size_entry_attach_label (PIKA_SIZE_ENTRY (offset), _("Offset:"),
@ -980,7 +1007,7 @@ dialog (PikaImage *image,
/* put a chain_button under the offset_entries */
chain_button = pika_chain_button_new (PIKA_CHAIN_BOTTOM);
if (grid_cfg.hoffset == grid_cfg.voffset)
if (hoffset == voffset)
pika_chain_button_set_active (PIKA_CHAIN_BUTTON (chain_button), TRUE);
gtk_grid_attach (GTK_GRID (offset), chain_button, 1, 2, 2, 1);
gtk_widget_show (chain_button);
@ -1000,72 +1027,72 @@ dialog (PikaImage *image,
preview);
/* put a chain_button under the color_buttons */
chain_button = pika_chain_button_new (PIKA_CHAIN_BOTTOM);
if (pika_rgba_distance (&grid_cfg.hcolor, &grid_cfg.vcolor) < 0.0001)
pika_chain_button_set_active (PIKA_CHAIN_BUTTON (chain_button), TRUE);
gtk_grid_attach (GTK_GRID (offset), chain_button, 1, 4, 2, 1);
gtk_widget_show (chain_button);
grid->color_chain = pika_chain_button_new (PIKA_CHAIN_BOTTOM);
if (pika_rgba_distance (hcolor, vcolor) < 0.0001)
pika_chain_button_set_active (PIKA_CHAIN_BUTTON (grid->color_chain), TRUE);
gtk_grid_attach (GTK_GRID (offset), grid->color_chain, 1, 4, 2, 1);
gtk_widget_show (grid->color_chain);
/* attach color selectors */
hcolor_button = pika_color_button_new (_("Horizontal Color"),
COLOR_BUTTON_WIDTH, 16,
&grid_cfg.hcolor,
PIKA_COLOR_AREA_SMALL_CHECKS);
pika_color_button_set_update (PIKA_COLOR_BUTTON (hcolor_button), TRUE);
gtk_grid_attach (GTK_GRID (offset), hcolor_button, 1, 3, 1, 1);
gtk_widget_show (hcolor_button);
grid->hcolor_button = pika_color_button_new (_("Horizontal Color"),
COLOR_BUTTON_WIDTH, 16,
hcolor,
PIKA_COLOR_AREA_SMALL_CHECKS);
pika_color_button_set_update (PIKA_COLOR_BUTTON (grid->hcolor_button), TRUE);
gtk_grid_attach (GTK_GRID (offset), grid->hcolor_button, 1, 3, 1, 1);
gtk_widget_show (grid->hcolor_button);
config = pika_get_color_configuration ();
pika_color_button_set_color_config (PIKA_COLOR_BUTTON (hcolor_button),
config);
color_config = pika_get_color_configuration ();
pika_color_button_set_color_config (PIKA_COLOR_BUTTON (grid->hcolor_button),
color_config);
g_signal_connect (hcolor_button, "color-changed",
g_signal_connect (grid->hcolor_button, "color-changed",
G_CALLBACK (pika_color_button_get_color),
&grid_cfg.hcolor);
g_signal_connect (hcolor_button, "color-changed",
hcolor);
g_signal_connect (grid->hcolor_button, "color-changed",
G_CALLBACK (color_callback),
chain_button);
g_signal_connect_swapped (hcolor_button, "color-changed",
grid);
g_signal_connect_swapped (grid->hcolor_button, "color-changed",
G_CALLBACK (pika_preview_invalidate),
preview);
vcolor_button = pika_color_button_new (_("Vertical Color"),
COLOR_BUTTON_WIDTH, 16,
&grid_cfg.vcolor,
PIKA_COLOR_AREA_SMALL_CHECKS);
pika_color_button_set_update (PIKA_COLOR_BUTTON (vcolor_button), TRUE);
gtk_grid_attach (GTK_GRID (offset), vcolor_button, 2, 3, 1, 1);
gtk_widget_show (vcolor_button);
grid->vcolor_button = pika_color_button_new (_("Vertical Color"),
COLOR_BUTTON_WIDTH, 16,
vcolor,
PIKA_COLOR_AREA_SMALL_CHECKS);
pika_color_button_set_update (PIKA_COLOR_BUTTON (grid->vcolor_button), TRUE);
gtk_grid_attach (GTK_GRID (offset), grid->vcolor_button, 2, 3, 1, 1);
gtk_widget_show (grid->vcolor_button);
pika_color_button_set_color_config (PIKA_COLOR_BUTTON (vcolor_button),
config);
pika_color_button_set_color_config (PIKA_COLOR_BUTTON (grid->vcolor_button),
color_config);
g_signal_connect (vcolor_button, "color-changed",
g_signal_connect (grid->vcolor_button, "color-changed",
G_CALLBACK (pika_color_button_get_color),
&grid_cfg.vcolor);
g_signal_connect (vcolor_button, "color-changed",
vcolor);
g_signal_connect (grid->vcolor_button, "color-changed",
G_CALLBACK (color_callback),
chain_button);
g_signal_connect_swapped (vcolor_button, "color-changed",
grid);
g_signal_connect_swapped (grid->vcolor_button, "color-changed",
G_CALLBACK (pika_preview_invalidate),
preview);
button = pika_color_button_new (_("Intersection Color"),
COLOR_BUTTON_WIDTH, 16,
&grid_cfg.icolor,
PIKA_COLOR_AREA_SMALL_CHECKS);
pika_color_button_set_update (PIKA_COLOR_BUTTON (button), TRUE);
gtk_grid_attach (GTK_GRID (offset), button, 3, 3, 1, 1);
gtk_widget_show (button);
grid->icolor_button = pika_color_button_new (_("Intersection Color"),
COLOR_BUTTON_WIDTH, 16,
icolor,
PIKA_COLOR_AREA_SMALL_CHECKS);
pika_color_button_set_update (PIKA_COLOR_BUTTON (grid->icolor_button), TRUE);
gtk_grid_attach (GTK_GRID (offset), grid->icolor_button, 3, 3, 1, 1);
gtk_widget_show (grid->icolor_button);
pika_color_button_set_color_config (PIKA_COLOR_BUTTON (button),
config);
g_object_unref (config);
pika_color_button_set_color_config (PIKA_COLOR_BUTTON (grid->icolor_button),
color_config);
g_object_unref (color_config);
g_signal_connect (button, "color-changed",
g_signal_connect (grid->icolor_button, "color-changed",
G_CALLBACK (pika_color_button_get_color),
&grid_cfg.icolor);
g_signal_connect_swapped (button, "color-changed",
icolor);
g_signal_connect_swapped (grid->icolor_button, "color-changed",
G_CALLBACK (pika_preview_invalidate),
preview);
@ -1078,10 +1105,9 @@ dialog (PikaImage *image,
run = (pika_dialog_run (PIKA_DIALOG (dlg)) == GTK_RESPONSE_OK);
if (run)
update_values ();
update_values (grid);
gtk_widget_destroy (dlg);
return run;
}

6
plug-ins/common/guillotine.c
View File

@ -50,7 +50,7 @@ struct _GuillotineClass
#define GUILLOTINE_TYPE (guillotine_get_type ())
#define GUILLOTINE (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GUILLOTINE_TYPE, Guillotine))
#define GUILLOTINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GUILLOTINE_TYPE, Guillotine))
GType guillotine_get_type (void) G_GNUC_CONST;
@ -63,7 +63,7 @@ static PikaValueArray * guillotine_run (PikaProcedure *proce
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static GList * guillotine (PikaImage *image,
gboolean interactive);
@ -151,7 +151,7 @@ guillotine_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals = NULL;

49
plug-ins/common/hot.c
View File

@ -145,7 +145,7 @@ struct _HotClass
#define HOT_TYPE (hot_get_type ())
#define HOT (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), HOT_TYPE, Hot))
#define HOT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), HOT_TYPE, Hot))
GType hot_get_type (void) G_GNUC_CONST;
@ -158,7 +158,7 @@ static PikaValueArray * hot_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static gboolean pluginCore (PikaImage *image,
@ -295,11 +295,10 @@ hot_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaDrawable *drawable;
PikaDrawable *drawable;
gegl_init (NULL, NULL);
@ -320,41 +319,15 @@ hot_run (PikaProcedure *procedure,
drawable = drawables[0];
}
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
if (! plugin_dialog (procedure, G_OBJECT (config)))
{
pika_procedure_config_end_run (config, PIKA_PDB_CANCEL);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
break;
case PIKA_RUN_NONINTERACTIVE:
case PIKA_RUN_WITH_LAST_VALS:
break;
}
if (run_mode == PIKA_RUN_INTERACTIVE && ! plugin_dialog (procedure, G_OBJECT (config)))
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
if (! pluginCore (image, drawable, G_OBJECT (config)))
{
pika_procedure_config_end_run (config, PIKA_PDB_CANCEL);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
NULL);
}
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
NULL);
if (run_mode != PIKA_RUN_NONINTERACTIVE)
pika_displays_flush ();

45
plug-ins/common/jigsaw.c
View File

@ -188,7 +188,7 @@ struct _JigsawClass
#define JIGSAW_TYPE (jigsaw_get_type ())
#define JIGSAW (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), JIGSAW_TYPE, Jigsaw))
#define JIGSAW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), JIGSAW_TYPE, Jigsaw))
GType jigsaw_get_type (void) G_GNUC_CONST;
@ -201,7 +201,7 @@ static PikaValueArray * jigsaw_run (PikaProcedure *procedure
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static void jigsaw (GObject *config,
@ -451,24 +451,17 @@ jigsaw_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaDrawable *drawable;
PikaDrawable *drawable;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
if (n_drawables != 1)
{
GError *error = NULL;
pika_procedure_config_end_run (config, PIKA_PDB_EXECUTION_ERROR);
g_object_unref (config);
g_set_error (&error, PIKA_PLUG_IN_ERROR, 0,
_("Procedure '%s' only works with one drawable."),
PLUG_IN_PROC);
@ -482,23 +475,10 @@ jigsaw_run (PikaProcedure *procedure,
drawable = drawables[0];
}
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
if (! jigsaw_dialog (procedure, G_OBJECT (config), drawable))
{
pika_procedure_config_end_run (config, PIKA_PDB_CANCEL);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
break;
default:
break;
};
if (run_mode == PIKA_RUN_INTERACTIVE && ! jigsaw_dialog (procedure, G_OBJECT (config), drawable))
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
pika_progress_init (_("Assembling jigsaw"));
@ -507,9 +487,6 @@ jigsaw_run (PikaProcedure *procedure,
if (run_mode != PIKA_RUN_NONINTERACTIVE)
pika_displays_flush ();
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL);
}
@ -2515,7 +2492,8 @@ jigsaw_dialog (PikaProcedure *procedure,
gtk_widget_set_margin_bottom (scale, 12);
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"num-tiles-label", _("Number of Tiles"));
"num-tiles-label", _("Number of Tiles"),
FALSE, FALSE);
pika_procedure_dialog_fill_box (PIKA_PROCEDURE_DIALOG (dialog),
"num-tiles-vbox", "x", "y", NULL);
pika_procedure_dialog_fill_frame (PIKA_PROCEDURE_DIALOG (dialog),
@ -2532,7 +2510,8 @@ jigsaw_dialog (PikaProcedure *procedure,
gtk_widget_set_margin_bottom (scale, 12);
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"bevel-label", _("Bevel Edges"));
"bevel-label", _("Bevel Edges"),
FALSE, FALSE);
pika_procedure_dialog_fill_box (PIKA_PROCEDURE_DIALOG (dialog),
"bevel-vbox", "blend-lines", "blend-amount",
NULL);

56
plug-ins/common/mail.c
View File

@ -71,7 +71,7 @@ struct _MailClass
#define MAIL_TYPE (mail_get_type ())
#define MAIL (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAIL_TYPE, Mail))
#define MAIL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAIL_TYPE, Mail))
GType mail_get_type (void) G_GNUC_CONST;
@ -84,7 +84,7 @@ static PikaValueArray * mail_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static PikaPDBStatusType send_image (GObject *config,
@ -251,48 +251,31 @@ mail_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
PikaPDBStatusType status = PIKA_PDB_SUCCESS;
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
switch (run_mode)
if (run_mode == PIKA_RUN_INTERACTIVE)
{
case PIKA_RUN_INTERACTIVE:
{
gchar *filename = g_file_get_path (pika_image_get_file (image));
gchar *filename = g_file_get_path (pika_image_get_file (image));
if (filename)
{
gchar *basename = g_filename_display_basename (filename);
gchar buffername[BUFFER_SIZE];
if (filename)
{
gchar *basename = g_filename_display_basename (filename);
gchar buffername[BUFFER_SIZE];
g_strlcpy (buffername, basename, BUFFER_SIZE);
g_strlcpy (buffername, basename, BUFFER_SIZE);
g_object_set (config,
"filename", buffername,
NULL);
g_free (basename);
g_free (filename);
}
}
g_object_set (config,
"filename", buffername,
NULL);
g_free (basename);
g_free (filename);
}
if (! send_dialog (procedure, G_OBJECT (config)))
{
pika_procedure_config_end_run (config, PIKA_PDB_CANCEL);
g_object_unref (config);
return pika_procedure_new_return_values (procedure, PIKA_PDB_CANCEL,
NULL);
}
break;
default:
break;
return pika_procedure_new_return_values (procedure, PIKA_PDB_CANCEL, NULL);
}
status = send_image (G_OBJECT (config),
@ -300,9 +283,6 @@ mail_run (PikaProcedure *procedure,
n_drawables, drawables,
run_mode);
pika_procedure_config_end_run (config, status);
g_object_unref (config);
return pika_procedure_new_return_values (procedure, status, NULL);
}

2
plug-ins/common/meson.build
View File

@ -21,7 +21,7 @@ common_plugins_list = [
{ 'name': 'destripe', },
{ 'name': 'file-cel', },
{ 'name': 'file-compressor',
'deps': [ gegl, gdk_pixbuf, cairo, gio, liblzma, bz2, zlib, ],
'deps': [ gegl, gdk_pixbuf, cairo, gio, liblzma, pango, bz2, zlib, ],
},
{ 'name': 'file-csource', },
{ 'name': 'file-desktop-link',

39
plug-ins/common/nl-filter.c
View File

@ -73,7 +73,7 @@ struct _NlfilterClass
#define NLFILTER_TYPE (nlfilter_get_type ())
#define NLFILTER (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NLFILTER_TYPE, Nlfilter))
#define NLFILTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NLFILTER_TYPE, Nlfilter))
GType nlfilter_get_type (void) G_GNUC_CONST;
@ -86,7 +86,7 @@ static PikaValueArray * nlfilter_run (PikaProcedure *procedu
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static void nlfilter (GObject *config,
@ -202,24 +202,17 @@ nlfilter_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaDrawable *drawable;
PikaDrawable *drawable;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
if (n_drawables != 1)
{
GError *error = NULL;
pika_procedure_config_end_run (config, PIKA_PDB_EXECUTION_ERROR);
g_object_unref (config);
g_set_error (&error, PIKA_PLUG_IN_ERROR, 0,
_("Procedure '%s' only works with one drawable."),
pika_procedure_get_name (procedure));
@ -233,32 +226,16 @@ nlfilter_run (PikaProcedure *procedure,
drawable = drawables[0];
}
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
if (! nlfilter_dialog (procedure, G_OBJECT (config), drawable))
{
pika_procedure_config_end_run (config, PIKA_PDB_CANCEL);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
break;
default:
break;
};
if (run_mode == PIKA_RUN_INTERACTIVE && ! nlfilter_dialog (procedure, G_OBJECT (config), drawable))
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
nlfilter (G_OBJECT (config), drawable, NULL);
if (run_mode != PIKA_RUN_NONINTERACTIVE)
pika_displays_flush ();
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL);
}

16
plug-ins/common/plugin-browser.c
View File

@ -101,7 +101,7 @@ struct _BrowserClass
*/
#define BROWSER_TYPE (browser_get_type ())
#define BROWSER (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), BROWSER_TYPE, Browser))
#define BROWSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), BROWSER_TYPE, Browser))
GType browser_get_type (void) G_GNUC_CONST;
@ -110,7 +110,7 @@ static PikaProcedure * browser_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * browser_run (PikaProcedure *procedure,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static GtkWidget * browser_dialog_new (void);
@ -199,7 +199,7 @@ browser_create_procedure (PikaPlugIn *plug_in,
static PikaValueArray *
browser_run (PikaProcedure *procedure,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
browser_dialog_new ();
@ -361,6 +361,7 @@ browser_search (PikaBrowser *pika_browser,
gint search_type,
PluginBrowser *browser)
{
PikaProcedure *procedure;
PikaValueArray *return_vals;
const gchar **procedure_strs;
gint num_plugins = 0;
@ -371,10 +372,11 @@ browser_search (PikaBrowser *pika_browser,
pika_browser_show_message (PIKA_BROWSER (browser->browser),
_("Searching by name"));
return_vals = pika_pdb_run_procedure (pika_get_pdb (),
"pika-plug-ins-query",
G_TYPE_STRING, search_text,
G_TYPE_NONE);
procedure = pika_pdb_lookup_procedure (pika_get_pdb (),
"pika-plug-ins-query");
return_vals = pika_procedure_run (procedure,
"search-string", search_text,
NULL);
if (PIKA_VALUES_GET_ENUM (return_vals, 0) == PIKA_PDB_SUCCESS)
{

23
plug-ins/common/procedure-browser.c
View File

@ -75,7 +75,7 @@ struct _BrowserClass
*/
#define BROWSER_TYPE (browser_get_type ())
#define BROWSER (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), BROWSER_TYPE, Browser))
#define BROWSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), BROWSER_TYPE, Browser))
GType browser_get_type (void) G_GNUC_CONST;
@ -84,7 +84,7 @@ static PikaProcedure * browser_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * browser_run (PikaProcedure *procedure,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
@ -152,11 +152,12 @@ browser_create_procedure (PikaPlugIn *plug_in,
static PikaValueArray *
browser_run (PikaProcedure *procedure,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaRunMode run_mode = PIKA_VALUES_GET_ENUM (args, 0);
PikaRunMode run_mode;
g_object_get (config, "run-mode", &run_mode, NULL);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
@ -180,11 +181,17 @@ browser_run (PikaProcedure *procedure,
case PIKA_RUN_WITH_LAST_VALS:
case PIKA_RUN_NONINTERACTIVE:
g_printerr (PLUG_IN_PROC " allows only interactive invocation");
{
GError *error = NULL;
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CALLING_ERROR,
NULL);
g_set_error (&error, PIKA_PLUG_IN_ERROR, 0,
_("Procedure %s allows only interactive invocation."),
pika_procedure_get_name (procedure));
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CALLING_ERROR,
error);
}
break;
default:

44
plug-ins/common/qbist.c
View File

@ -99,7 +99,7 @@ struct _QbistClass
#define QBIST_TYPE (qbist_get_type ())
#define QBIST (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), QBIST_TYPE, Qbist))
#define QBIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), QBIST_TYPE, Qbist))
GType qbist_get_type (void) G_GNUC_CONST;
@ -112,7 +112,7 @@ static PikaValueArray * qbist_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static gboolean dialog_run (void);
@ -228,20 +228,19 @@ qbist_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
gint sel_x1, sel_y1, sel_width, sel_height;
gint img_height, img_width;
GeglBuffer *buffer;
GeglBufferIterator *iter;
PikaDrawable *drawable;
PikaParasite *pattern_parasite;
gconstpointer pattern_data;
guint32 pattern_data_length;
gint total_pixels;
gint done_pixels;
gint sel_x1, sel_y1, sel_width, sel_height;
gint img_height, img_width;
GeglBuffer *buffer;
GeglBufferIterator *iter;
PikaDrawable *drawable;
PikaParasite *pattern_parasite;
gconstpointer pattern_data;
guint32 pattern_data_length;
gint total_pixels;
gint done_pixels;
gegl_init (NULL, NULL);
@ -262,9 +261,6 @@ qbist_run (PikaProcedure *procedure,
drawable = drawables[0];
}
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, image, run_mode, args);
img_width = pika_drawable_get_width (drawable);
img_height = pika_drawable_get_height (drawable);
@ -308,13 +304,9 @@ qbist_run (PikaProcedure *procedure,
}
if (! dialog_run ())
{
pika_procedure_config_end_run (config, PIKA_PDB_CANCEL);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
pattern_parasite = pika_parasite_new ("pattern", 0,
sizeof (qbist_info.info),
@ -328,7 +320,6 @@ qbist_run (PikaProcedure *procedure,
break;
case PIKA_RUN_NONINTERACTIVE:
pika_procedure_config_end_run (config, PIKA_PDB_CALLING_ERROR);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CALLING_ERROR,
NULL);
@ -404,9 +395,6 @@ qbist_run (PikaProcedure *procedure,
g_rand_free (gr);
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL);
}

684
plug-ins/common/sample-colorize.c
View File

File diff suppressed because it is too large Load Diff

199
plug-ins/common/smooth-palette.c
View File

@ -49,7 +49,7 @@ struct _PaletteClass
#define PALETTE_TYPE (palette_get_type ())
#define PALETTE (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PALETTE_TYPE, Palette))
#define PALETTE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PALETTE_TYPE, Palette))
GType palette_get_type (void) G_GNUC_CONST;
@ -62,12 +62,15 @@ static PikaValueArray * palette_run (PikaProcedure *procedur
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static gboolean dialog (PikaDrawable *drawable);
static gboolean dialog (PikaProcedure *procedure,
PikaProcedureConfig *config,
PikaDrawable *drawable);
static PikaImage * smooth_palette (PikaDrawable *drawable,
static PikaImage * smooth_palette (PikaProcedureConfig *config,
PikaDrawable *drawable,
PikaLayer **layer);
@ -76,23 +79,7 @@ G_DEFINE_TYPE (Palette, palette, PIKA_TYPE_PLUG_IN)
PIKA_MAIN (PALETTE_TYPE)
DEFINE_STD_SET_I18N
static struct
{
gint width;
gint height;
gint ntries;
gint try_size;
gboolean show_image;
} config =
{
256,
64,
50,
10000,
TRUE
};
#define TRY_SIZE 10000
static void
palette_class_init (PaletteClass *klass)
@ -145,38 +132,38 @@ palette_create_procedure (PikaPlugIn *plug_in,
"1997");
PIKA_PROC_ARG_INT (procedure, "width",
"Widtg",
"Widtg",
_("_Width"),
_("Width"),
2, PIKA_MAX_IMAGE_SIZE, 256,
G_PARAM_READWRITE);
PIKA_PROC_ARG_INT (procedure, "height",
"Height",
"Height",
_("_Height"),
_("Height"),
2, PIKA_MAX_IMAGE_SIZE, 64,
G_PARAM_READWRITE);
PIKA_PROC_ARG_INT (procedure, "n-tries",
"N tries",
"Search septh",
_("Search _depth"),
_("Search depth"),
1, 1024, 50,
G_PARAM_READWRITE);
PIKA_PROC_ARG_BOOLEAN (procedure, "show-image",
"Show image",
"Show image",
_("Show image"),
_("Show image"),
TRUE,
G_PARAM_READWRITE);
PIKA_PROC_VAL_IMAGE (procedure, "new-image",
"New image",
"Output image",
_("New image"),
_("Output image"),
FALSE,
G_PARAM_READWRITE);
PIKA_PROC_VAL_LAYER (procedure, "new-layer",
"New layer",
"Output layer",
_("New layer"),
_("Output layer"),
FALSE,
G_PARAM_READWRITE);
}
@ -190,13 +177,13 @@ palette_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaImage *new_image;
PikaLayer *new_layer;
PikaDrawable *drawable;
PikaImage *new_image;
PikaLayer *new_layer;
PikaDrawable *drawable;
gboolean show_image;
gegl_init (NULL, NULL);
@ -217,41 +204,21 @@ palette_run (PikaProcedure *procedure,
drawable = drawables[0];
}
switch (run_mode)
if (run_mode == PIKA_RUN_INTERACTIVE && ! dialog (procedure, config, drawable))
{
case PIKA_RUN_INTERACTIVE:
pika_get_data (PLUG_IN_PROC, &config);
if (! dialog (drawable))
{
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
break;
case PIKA_RUN_NONINTERACTIVE:
config.width = PIKA_VALUES_GET_INT (args, 0);
config.height = PIKA_VALUES_GET_INT (args, 1);
config.ntries = PIKA_VALUES_GET_INT (args, 2);
config.show_image = PIKA_VALUES_GET_BOOLEAN (args, 3);
break;
case PIKA_RUN_WITH_LAST_VALS:
pika_get_data (PLUG_IN_PROC, &config);
break;
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
if (pika_drawable_is_rgb (drawable))
{
pika_progress_init (_("Deriving smooth palette"));
new_image = smooth_palette (drawable, &new_layer);
new_image = smooth_palette (config, drawable, &new_layer);
if (run_mode == PIKA_RUN_INTERACTIVE)
pika_set_data (PLUG_IN_PROC, &config, sizeof (config));
if (config.show_image)
g_object_get (config, "show-image", &show_image, NULL);
if (show_image)
pika_display_new (new_image);
}
else
@ -261,14 +228,7 @@ palette_run (PikaProcedure *procedure,
NULL);
}
return_vals = pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,
NULL);
PIKA_VALUES_SET_IMAGE (return_vals, 1, new_image);
PIKA_VALUES_SET_LAYER (return_vals, 2, new_layer);
return return_vals;
return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL);
}
static gfloat
@ -307,14 +267,18 @@ pix_swap (gfloat *pal,
}
static PikaImage *
smooth_palette (PikaDrawable *drawable,
PikaLayer **layer)
smooth_palette (PikaProcedureConfig *config,
PikaDrawable *drawable,
PikaLayer **layer)
{
PikaImage *new_image;
gint psize, i, j;
guint bpp;
gint sel_x1, sel_y1;
gint width, height;
gint config_width;
gint config_height;
gint config_n_tries;
GeglBuffer *buffer;
GeglSampler *sampler;
gfloat *pal;
@ -322,15 +286,21 @@ smooth_palette (PikaDrawable *drawable,
const Babl *format = babl_format ("RGB float");
new_image = pika_image_new_with_precision (config.width,
config.height,
g_object_get (config,
"width", &config_width,
"height", &config_height,
"n-tries", &config_n_tries,
NULL);
new_image = pika_image_new_with_precision (config_width,
config_height,
PIKA_RGB,
PIKA_PRECISION_FLOAT_LINEAR);
pika_image_undo_disable (new_image);
*layer = pika_layer_new (new_image, _("Background"),
config.width, config.height,
config_width, config_height,
pika_drawable_type (drawable),
100,
pika_image_get_default_new_layer_mode (new_image));
@ -343,7 +313,7 @@ smooth_palette (PikaDrawable *drawable,
gr = g_rand_new ();
psize = config.width;
psize = config_width;
buffer = pika_drawable_get_buffer (drawable);
@ -379,12 +349,12 @@ smooth_palette (PikaDrawable *drawable,
pal_best = g_memdup2 (pal, bpp * psize);
original = g_memdup2 (pal, bpp * psize);
for (try = 0; try < config.ntries; try++)
for (try = 0; try < config_n_tries; try++)
{
gdouble len;
if (!(try%5))
pika_progress_update (try / (double) config.ntries);
if (! (try % 5))
pika_progress_update (try / (double) config_n_tries);
memcpy (pal, original, bpp * psize);
/* scramble */
@ -397,7 +367,7 @@ smooth_palette (PikaDrawable *drawable,
len += pix_diff (pal, bpp, i, i-1);
/* improve */
for (i = 0; i < config.try_size; i++)
for (i = 0; i < TRY_SIZE; i++)
{
gint i0 = 1 + g_rand_int_range (gr, 0, psize-2);
gint i1 = 1 + g_rand_int_range (gr, 0, psize-2);
@ -471,16 +441,16 @@ smooth_palette (PikaDrawable *drawable,
buffer = pika_drawable_get_buffer (PIKA_DRAWABLE (*layer));
for (j = 0; j < config.height; j++)
for (j = 0; j < config_height; j++)
{
GeglRectangle row = {0, j, config.width, 1};
GeglRectangle row = {0, j, config_width, 1};
gegl_buffer_set (buffer, &row, 0, format, pal, GEGL_AUTO_ROWSTRIDE);
}
gegl_buffer_flush (buffer);
pika_drawable_update (PIKA_DRAWABLE (*layer), 0, 0,
config.width, config.height);
config_width, config_height);
pika_image_undo_enable (new_image);
g_object_unref (buffer);
@ -491,32 +461,34 @@ smooth_palette (PikaDrawable *drawable,
}
static gboolean
dialog (PikaDrawable *drawable)
dialog (PikaProcedure *procedure,
PikaProcedureConfig *config,
PikaDrawable *drawable)
{
GtkWidget *dlg;
GtkWidget *spinbutton;
GtkAdjustment *adj;
GtkWidget *sizeentry;
PikaImage *image;
PikaUnit unit;
gdouble xres, yres;
gint width;
gint height;
gboolean run;
g_object_get (config,
"width", &width,
"height", &height,
NULL);
pika_ui_init (PLUG_IN_BINARY);
dlg = pika_dialog_new (_("Smooth Palette"), PLUG_IN_ROLE,
NULL, 0,
pika_standard_help_func, PLUG_IN_PROC,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_OK"), GTK_RESPONSE_OK,
NULL);
dlg = pika_procedure_dialog_new (procedure,
PIKA_PROCEDURE_CONFIG (config),
_("Smooth Palette"));
pika_dialog_set_alternative_button_order (GTK_DIALOG (dlg),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
pika_window_set_transient (GTK_WINDOW (dlg));
@ -529,12 +501,12 @@ dialog (PikaDrawable *drawable)
FALSE, FALSE,
_("_Width:"),
config.width, xres,
width, xres,
2, PIKA_MAX_IMAGE_SIZE,
2, PIKA_MAX_IMAGE_SIZE,
_("_Height:"),
config.height, yres,
height, yres,
1, PIKA_MAX_IMAGE_SIZE,
1, PIKA_MAX_IMAGE_SIZE);
gtk_container_set_border_width (GTK_CONTAINER (sizeentry), 12);
@ -542,16 +514,8 @@ dialog (PikaDrawable *drawable)
sizeentry, FALSE, FALSE, 0);
gtk_widget_show (sizeentry);
adj = gtk_adjustment_new (config.ntries, 1, 1024, 1, 10, 0);
spinbutton = pika_spin_button_new (adj, 1, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
pika_grid_attach_aligned (GTK_GRID (sizeentry), 0, 2,
_("_Search depth:"), 0.0, 0.5,
spinbutton, 1);
g_signal_connect (adj, "value-changed",
G_CALLBACK (pika_int_adjustment_update),
&config.ntries);
/* We don't want to have the "Show Image" option in the GUI */
pika_procedure_dialog_fill (PIKA_PROCEDURE_DIALOG (dlg), "n-tries", NULL);
gtk_widget_show (dlg);
@ -559,10 +523,13 @@ dialog (PikaDrawable *drawable)
if (run)
{
config.width = pika_size_entry_get_refval (PIKA_SIZE_ENTRY (sizeentry),
0);
config.height = pika_size_entry_get_refval (PIKA_SIZE_ENTRY (sizeentry),
1);
width = pika_size_entry_get_refval (PIKA_SIZE_ENTRY (sizeentry), 0);
height = pika_size_entry_get_refval (PIKA_SIZE_ENTRY (sizeentry), 1);
g_object_set (config,
"width", width,
"height", height,
NULL);
}
gtk_widget_destroy (dlg);

51
plug-ins/common/sparkle.c
View File

@ -65,7 +65,7 @@ struct _SparkleClass
#define SPARKLE_TYPE (sparkle_get_type ())
#define SPARKLE (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SPARKLE_TYPE, Sparkle))
#define SPARKLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SPARKLE_TYPE, Sparkle))
GType sparkle_get_type (void) G_GNUC_CONST;
@ -78,7 +78,7 @@ static PikaValueArray * sparkle_run (PikaProcedure *procedur
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static gboolean sparkle_dialog (PikaProcedure *procedure,
@ -284,25 +284,18 @@ sparkle_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaDrawable *drawable;
gint x, y, w, h;
PikaDrawable *drawable;
gint x, y, w, h;
gegl_init (NULL, NULL);
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
if (n_drawables != 1)
{
GError *error = NULL;
pika_procedure_config_end_run (config, PIKA_PDB_EXECUTION_ERROR);
g_object_unref (config);
g_set_error (&error, PIKA_PLUG_IN_ERROR, 0,
_("Procedure '%s' only works with one drawable."),
PLUG_IN_PROC);
@ -320,32 +313,15 @@ sparkle_run (PikaProcedure *procedure,
{
g_message (_("Region selected for filter is empty"));
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,
NULL);
}
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
if (! sparkle_dialog (procedure, G_OBJECT (config), drawable))
{
pika_procedure_config_end_run (config, PIKA_PDB_CANCEL);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
break;
default:
break;
}
if (run_mode == PIKA_RUN_INTERACTIVE && ! sparkle_dialog (procedure, G_OBJECT (config), drawable))
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
if (pika_drawable_is_rgb (drawable) ||
pika_drawable_is_gray (drawable))
@ -359,17 +335,11 @@ sparkle_run (PikaProcedure *procedure,
}
else
{
pika_procedure_config_end_run (config, PIKA_PDB_EXECUTION_ERROR);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
NULL);
}
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL);
}
@ -444,7 +414,8 @@ sparkle_dialog (PikaProcedure *procedure,
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
"sparkle-bool-label",
_("Additional Options"));
_("Additional Options"),
FALSE, FALSE);
pika_procedure_dialog_fill_frame (PIKA_PROCEDURE_DIALOG (dialog),
"sparkle-bool-frame", "sparkle-bool-label",
FALSE, "sparkle-bool-vbox");

41
plug-ins/common/sphere-designer.c
View File

@ -272,7 +272,7 @@ struct _DesignerClass
#define DESIGNER_TYPE (designer_get_type ())
#define DESIGNER (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DESIGNER_TYPE, Designer))
#define DESIGNER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DESIGNER_TYPE, Designer))
GType designer_get_type (void) G_GNUC_CONST;
@ -285,7 +285,7 @@ static PikaValueArray * designer_run (PikaProcedure *procedu
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static inline void vset (PikaVector4 *v,
@ -423,6 +423,11 @@ designer_create_procedure (PikaPlugIn *plug_in,
"Vidar Madsen",
"Vidar Madsen",
"1999");
PIKA_PROC_AUX_ARG_BYTES (procedure, "settings-data",
"Settings data",
"TODO: eventually we must implement proper args for every settings",
PIKA_PARAM_READWRITE);
}
return procedure;
@ -3163,9 +3168,10 @@ designer_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
GBytes *settings_bytes = NULL;
PikaDrawable *drawable;
gint x, y, w, h;
@ -3197,24 +3203,27 @@ designer_run (PikaProcedure *procedure,
NULL);
}
s.com.numtexture = 0;
/* Temporary code replacing legacy pika_[gs]et_data() using an AUX argument.
* This doesn't actually fix the "Reset to initial values|factory defaults"
* features, but at least makes per-run value storage work.
* TODO: eventually we want proper separate arguments as a complete fix.
*/
g_object_get (config, "settings-data", &settings_bytes, NULL);
if (settings_bytes != NULL && g_bytes_get_size (settings_bytes) == sizeof (sphere))
s = *((sphere *) g_bytes_get_data (settings_bytes, NULL));
g_bytes_unref (settings_bytes);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
s.com.numtexture = 0;
pika_get_data (PLUG_IN_PROC, &s);
if (! sphere_main (drawable))
{
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
break;
case PIKA_RUN_WITH_LAST_VALS:
s.com.numtexture = 0;
pika_get_data (PLUG_IN_PROC, &s);
if (s.com.numtexture == 0)
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
@ -3227,7 +3236,9 @@ designer_run (PikaProcedure *procedure,
NULL);
}
pika_set_data (PLUG_IN_PROC, &s, sizeof (s));
settings_bytes = g_bytes_new (&s, sizeof (sphere));
g_object_set (config, "settings-data", settings_bytes, NULL);
g_bytes_unref (settings_bytes);
realrender (drawable);
pika_displays_flush ();

193
plug-ins/common/tile-small.c
View File

@ -98,7 +98,7 @@ struct _TileClass
#define TILE_TYPE (tile_get_type ())
#define TILE (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TILE_TYPE, Tile))
#define TILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TILE_TYPE, Tile))
GType tile_get_type (void) G_GNUC_CONST;
@ -111,43 +111,49 @@ static PikaValueArray * tile_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static gboolean tileit_dialog (PikaDrawable *drawable);
static gboolean tileit_dialog (PikaProcedure *procedure,
PikaProcedureConfig *config,
PikaDrawable *drawable);
static void tileit_scale_update (PikaLabelSpin *entry,
gint *value);
static void tileit_scale_update (PikaLabelSpin *entry,
gint *value);
static void tileit_config_update (PikaLabelSpin *entry,
PikaProcedureConfig *config);
static void tileit_exp_update (GtkWidget *widget,
gpointer value);
static void tileit_exp_update_f (GtkWidget *widget,
gpointer value);
static void tileit_exp_update (GtkWidget *widget,
gpointer value);
static void tileit_exp_update_f (GtkWidget *widget,
gpointer value);
static void tileit_reset (GtkWidget *widget,
gpointer value);
static void tileit_radio_update (GtkWidget *widget,
gpointer data);
static void tileit_hvtoggle_update (GtkWidget *widget,
gpointer data);
static void tileit_reset (GtkWidget *widget,
gpointer value);
static void tileit_radio_update (GtkWidget *widget,
gpointer data);
static void tileit_hvtoggle_update (GtkWidget *widget,
gpointer data);
static void do_tiles (PikaDrawable *drawable);
static gint tiles_xy (gint width,
gint height,
gint x,
gint y,
gint *nx,
gint *ny);
static void do_tiles (PikaProcedureConfig *config,
PikaDrawable *drawable);
static gint tiles_xy (PikaProcedureConfig *config,
gint width,
gint height,
gint x,
gint y,
gint *nx,
gint *ny);
static void all_update (void);
static void alt_update (void);
static void explicit_update (gboolean);
static void dialog_update_preview (void);
static void cache_preview (PikaDrawable *drawable);
static gboolean tileit_preview_draw (GtkWidget *widget,
cairo_t *cr);
static gboolean tileit_preview_events (GtkWidget *widget,
GdkEvent *event);
static void cache_preview (PikaDrawable *drawable);
static gboolean tileit_preview_draw (GtkWidget *widget,
cairo_t *cr);
static gboolean tileit_preview_events (GtkWidget *widget,
GdkEvent *event);
G_DEFINE_TYPE (Tile, tile, PIKA_TYPE_PLUG_IN)
@ -276,8 +282,8 @@ tile_create_procedure (PikaPlugIn *plug_in,
"1997");
PIKA_PROC_ARG_INT (procedure, "num-tiles",
"Num tiles",
"Number of tiles to make",
_("_n²"),
_("Number of tiles to make"),
2, MAX_SEGS, 2,
G_PARAM_READWRITE);
}
@ -291,7 +297,7 @@ tile_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaDrawable *drawable;
@ -352,9 +358,7 @@ tile_run (PikaProcedure *procedure,
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
pika_get_data (PLUG_IN_PROC, &itvals);
if (! tileit_dialog (drawable))
if (! tileit_dialog (procedure, config, drawable))
{
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
@ -363,11 +367,7 @@ tile_run (PikaProcedure *procedure,
break;
case PIKA_RUN_NONINTERACTIVE:
itvals.numtiles = PIKA_VALUES_GET_INT (args, 0);
break;
case PIKA_RUN_WITH_LAST_VALS:
pika_get_data (PLUG_IN_PROC, &itvals);
break;
}
@ -376,13 +376,10 @@ tile_run (PikaProcedure *procedure,
{
pika_progress_init (_("Tiling"));
do_tiles (drawable);
do_tiles (config, drawable);
if (run_mode != PIKA_RUN_NONINTERACTIVE)
pika_displays_flush ();
if (run_mode == PIKA_RUN_INTERACTIVE)
pika_set_data (PLUG_IN_PROC, &itvals, sizeof (TileItVals));
}
else
{
@ -418,9 +415,11 @@ spin_button_new (GtkAdjustment **adjustment, /* return value */
}
static gboolean
tileit_dialog (PikaDrawable *drawable)
tileit_dialog (PikaProcedure *procedure,
PikaProcedureConfig *config,
PikaDrawable *drawable)
{
GtkWidget *dlg;
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *vbox;
@ -439,25 +438,20 @@ tileit_dialog (PikaDrawable *drawable)
cache_preview (drawable); /* Get the preview image */
dlg = pika_dialog_new (_("Small Tiles"), PLUG_IN_ROLE,
NULL, 0,
pika_standard_help_func, PLUG_IN_PROC,
dialog = pika_procedure_dialog_new (procedure,
PIKA_PROCEDURE_CONFIG (config),
_("Small Tiles"));
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_OK"), GTK_RESPONSE_OK,
pika_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
NULL);
pika_dialog_set_alternative_button_order (GTK_DIALOG (dlg),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
pika_window_set_transient (GTK_WINDOW (dlg));
pika_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))),
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
main_vbox, TRUE, TRUE, 0);
gtk_widget_show (main_vbox);
@ -658,23 +652,31 @@ tileit_dialog (PikaDrawable *drawable)
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 6);
/* Lower frame saying how many segments */
frame = pika_frame_new (_("Number of Segments"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
scale = pika_scale_entry_new ("_n²", itvals.numtiles, 2, MAX_SEGS, 0);
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog), "segments-label",
_("Number of Segments"), FALSE, FALSE);
scale = pika_procedure_dialog_get_scale_entry (PIKA_PROCEDURE_DIALOG (dialog),
"num-tiles", 1);
g_signal_connect (scale, "value-changed",
G_CALLBACK (tileit_scale_update),
&itvals.numtiles);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_widget_show (scale);
G_CALLBACK (tileit_config_update),
config);
gtk_widget_show (dlg);
pika_procedure_dialog_fill_frame (PIKA_PROCEDURE_DIALOG (dialog),
"num-tiles-frame",
"segments-label", FALSE,
"num-tiles");
pika_procedure_dialog_fill (PIKA_PROCEDURE_DIALOG (dialog), "num-tiles-frame",
NULL);
gtk_widget_show (dialog);
g_object_get (config,
"num-tiles", &itvals.numtiles,
NULL);
dialog_update_preview ();
run = (pika_dialog_run (PIKA_DIALOG (dlg)) == GTK_RESPONSE_OK);
run = pika_procedure_dialog_run (PIKA_PROCEDURE_DIALOG (dialog));
gtk_widget_destroy (dlg);
gtk_widget_destroy (dialog);
return run;
}
@ -895,6 +897,17 @@ tileit_scale_update (PikaLabelSpin *scale,
dialog_update_preview ();
}
static void
tileit_config_update (PikaLabelSpin *scale,
PikaProcedureConfig *config)
{
g_object_get (config,
"num-tiles", &itvals.numtiles,
NULL);
dialog_update_preview ();
}
static void
tileit_reset (GtkWidget *widget,
gpointer data)
@ -979,7 +992,8 @@ cache_preview (PikaDrawable *drawable)
}
static void
do_tiles (PikaDrawable *drawable)
do_tiles (PikaProcedureConfig *config,
PikaDrawable *drawable)
{
GeglBuffer *src_buffer;
GeglBuffer *dest_buffer;
@ -1027,7 +1041,8 @@ do_tiles (PikaDrawable *drawable)
for (col = dest_roi.x; col < (dest_roi.x + dest_roi.width); col++)
{
tiles_xy (sel_width,
tiles_xy (config,
sel_width,
sel_height,
col - sel_x1,
row - sel_y1,
@ -1066,23 +1081,31 @@ do_tiles (PikaDrawable *drawable)
/* Get the xy pos and any action */
static gint
tiles_xy (gint width,
gint height,
gint x,
gint y,
gint *nx,
gint *ny)
tiles_xy (PikaProcedureConfig *config,
gint width,
gint height,
gint x,
gint y,
gint *nx,
gint *ny)
{
gint px,py;
gint rnum,cnum;
gint actiontype;
gdouble rnd = 1 - (1.0 / (gdouble) itvals.numtiles) + 0.01;
gint num_tiles;
gdouble rnd;
rnum = y * itvals.numtiles / height;
g_object_get (config,
"num-tiles", &num_tiles,
NULL);
py = (y * itvals.numtiles) % height;
px = (x * itvals.numtiles) % width;
cnum = x * itvals.numtiles / width;
rnd = 1 - (1.0 / (gdouble) num_tiles) + 0.01;
rnum = y * num_tiles / height;
py = (y * num_tiles) % height;
px = (x * num_tiles) % width;
cnum = x * num_tiles / width;
if ((actiontype = tileactions[cnum][rnum]))
{
@ -1091,7 +1114,7 @@ tiles_xy (gint width,
gdouble pyr;
pyr = height - y - 1 + rnd;
py = ((gint) (pyr * (gdouble) itvals.numtiles)) % height;
py = ((gint) (pyr * (gdouble) num_tiles)) % height;
}
if (actiontype & HORIZONTAL)
@ -1099,14 +1122,14 @@ tiles_xy (gint width,
gdouble pxr;
pxr = width - x - 1 + rnd;
px = ((gint) (pxr * (gdouble) itvals.numtiles)) % width;
px = ((gint) (pxr * (gdouble) num_tiles)) % width;
}
}
*nx = px;
*ny = py;
return(actiontype);
return (actiontype);
}

204
plug-ins/common/tile.c
View File

@ -37,15 +37,6 @@
#define PLUG_IN_ROLE "pika-tile"
typedef struct
{
gint new_width;
gint new_height;
gint constrain;
gint new_image;
} TileVals;
typedef struct _Tile Tile;
typedef struct _TileClass TileClass;
@ -61,7 +52,7 @@ struct _TileClass
#define TILE_TYPE (tile_get_type ())
#define TILE (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TILE_TYPE, Tile))
#define TILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TILE_TYPE, Tile))
GType tile_get_type (void) G_GNUC_CONST;
@ -74,11 +65,14 @@ static PikaValueArray * tile_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static void tile (PikaImage *image,
PikaDrawable *drawable,
gint new_width,
gint new_height,
gboolean create_new_image,
PikaImage **new_image,
PikaLayer **new_layer);
@ -89,7 +83,9 @@ static void tile_gegl (GeglBuffer *src,
gint dst_width,
gint dst_height);
static gboolean tile_dialog (PikaImage *image,
static gboolean tile_dialog (PikaProcedure *procedure,
PikaProcedureConfig *config,
PikaImage *image,
PikaDrawable *drawable);
@ -99,15 +95,6 @@ PIKA_MAIN (TILE_TYPE)
DEFINE_STD_SET_I18N
static TileVals tvals =
{
1, /* new_width */
1, /* new_height */
TRUE, /* constrain */
TRUE /* new_image */
};
static void
tile_class_init (TileClass *klass)
{
@ -166,20 +153,28 @@ tile_create_procedure (PikaPlugIn *plug_in,
"Spencer Kimball & Peter Mattis",
"1996-1997");
/* XXX: we actually don't care about the default value as we always set
* the width/height of the active image, though it would be nice to reuse
* the previously stored value if we run tile on the same image twice.
* TODO: a flag and/or some special handler function would be interesting
* for such specific cases where a hardcoded default value doesn't make
* sense or when we want stored values to only apply when run on a same
* image.
*/
PIKA_PROC_ARG_INT (procedure, "new-width",
"New width",
"New _width",
"New (tiled) image width",
1, PIKA_MAX_IMAGE_SIZE, 1,
G_PARAM_READWRITE);
PIKA_PROC_ARG_INT (procedure, "new-height",
"New height",
"New _height",
"New (tiled) image height",
1, PIKA_MAX_IMAGE_SIZE, 1,
G_PARAM_READWRITE);
PIKA_PROC_ARG_BOOLEAN (procedure, "new-image",
"New image",
"New _image",
"Create a new image",
TRUE,
G_PARAM_READWRITE);
@ -206,13 +201,16 @@ tile_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaLayer *new_layer;
PikaImage *new_image;
PikaDrawable *drawable;
gint new_width;
gint new_height;
gboolean create_new_image;
gegl_init (NULL, NULL);
@ -236,9 +234,7 @@ tile_run (PikaProcedure *procedure,
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
pika_get_data (PLUG_IN_PROC, &tvals);
if (! tile_dialog (image, drawable))
if (! tile_dialog (procedure, config, image, drawable))
{
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
@ -247,29 +243,26 @@ tile_run (PikaProcedure *procedure,
break;
case PIKA_RUN_NONINTERACTIVE:
tvals.new_width = PIKA_VALUES_GET_INT (args, 0);
tvals.new_height = PIKA_VALUES_GET_INT (args, 1);
tvals.new_image = PIKA_VALUES_GET_BOOLEAN (args, 2);
break;
case PIKA_RUN_WITH_LAST_VALS:
pika_get_data (PLUG_IN_PROC, &tvals);
break;
}
g_object_get (config,
"new-width", &new_width,
"new-height", &new_height,
"new-image", &create_new_image,
NULL);
pika_progress_init (_("Tiling"));
tile (image,
drawable,
&new_image,
&new_layer);
if (run_mode == PIKA_RUN_INTERACTIVE)
pika_set_data (PLUG_IN_PROC, &tvals, sizeof (TileVals));
tile (image, drawable, new_width, new_height,
create_new_image, &new_image, &new_layer);
if (run_mode != PIKA_RUN_NONINTERACTIVE)
{
if (tvals.new_image)
if (create_new_image)
pika_display_new (new_image);
else
pika_displays_flush ();
@ -353,20 +346,21 @@ tile_gegl (GeglBuffer *src,
static void
tile (PikaImage *image,
PikaDrawable *drawable,
gint new_width,
gint new_height,
gboolean create_new_image,
PikaImage **new_image,
PikaLayer **new_layer)
{
PikaDrawable *dst_drawable;
GeglBuffer *dst_buffer;
GeglBuffer *src_buffer;
gint dst_width = tvals.new_width;
gint dst_height = tvals.new_height;
gint src_width = pika_drawable_get_width (drawable);
gint src_height = pika_drawable_get_height (drawable);
PikaImageBaseType image_type = PIKA_RGB;
if (tvals.new_image)
if (create_new_image)
{
/* create a new image */
gint32 precision = pika_image_get_precision (image);
@ -389,8 +383,8 @@ tile (PikaImage *image,
break;
}
*new_image = pika_image_new_with_precision (dst_width,
dst_height,
*new_image = pika_image_new_with_precision (new_width,
new_height,
image_type,
precision);
pika_image_undo_disable (*new_image);
@ -407,7 +401,7 @@ tile (PikaImage *image,
}
*new_layer = pika_layer_new (*new_image, _("Background"),
dst_width, dst_height,
new_width, new_height,
pika_drawable_type (drawable),
100,
pika_image_get_default_new_layer_mode (*new_image));
@ -424,17 +418,17 @@ tile (PikaImage *image,
*new_layer = NULL;
pika_image_undo_group_start (image);
pika_image_resize (image, dst_width, dst_height, 0, 0);
pika_image_resize (image, new_width, new_height, 0, 0);
if (pika_item_is_layer (PIKA_ITEM (drawable)))
{
pika_layer_resize (PIKA_LAYER (drawable), dst_width, dst_height, 0, 0);
pika_layer_resize (PIKA_LAYER (drawable), new_width, new_height, 0, 0);
}
else if (pika_item_is_layer_mask (PIKA_ITEM (drawable)))
{
PikaLayer *layer = pika_layer_from_mask (PIKA_LAYER_MASK (drawable));
pika_layer_resize (layer, dst_width, dst_height, 0, 0);
pika_layer_resize (layer, new_width, new_height, 0, 0);
}
dst_drawable = drawable;
@ -444,12 +438,12 @@ tile (PikaImage *image,
dst_buffer = pika_drawable_get_buffer (dst_drawable);
tile_gegl (src_buffer, src_width, src_height,
dst_buffer, dst_width, dst_height);
dst_buffer, new_width, new_height);
gegl_buffer_flush (dst_buffer);
pika_drawable_update (dst_drawable, 0, 0, dst_width, dst_height);
pika_drawable_update (dst_drawable, 0, 0, new_width, new_height);
if (tvals.new_image)
if (create_new_image)
{
pika_image_undo_enable (*new_image);
}
@ -463,98 +457,46 @@ tile (PikaImage *image,
}
static gboolean
tile_dialog (PikaImage *image,
PikaDrawable *drawable)
tile_dialog (PikaProcedure *procedure,
PikaProcedureConfig *config,
PikaImage *image,
PikaDrawable *drawable)
{
GtkWidget *dlg;
GtkWidget *vbox;
GtkWidget *frame;
GtkWidget *sizeentry;
GtkWidget *chainbutton;
GtkWidget *toggle;
gint width;
gint height;
gdouble xres;
gdouble yres;
PikaUnit unit;
gboolean run;
pika_ui_init (PLUG_IN_BINARY);
width = pika_drawable_get_width (drawable);
height = pika_drawable_get_height (drawable);
unit = pika_image_get_unit (image);
pika_image_get_resolution (image, &xres, &yres);
tvals.new_width = width;
tvals.new_height = height;
g_object_set (config,
"new-width", width,
"new-height", height,
NULL);
dlg = pika_dialog_new (_("Tile"), PLUG_IN_ROLE,
NULL, 0,
pika_standard_help_func, PLUG_IN_PROC,
dlg = pika_procedure_dialog_new (procedure,
PIKA_PROCEDURE_CONFIG (config),
_("Tile"));
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dlg),
"new-size-label", _("Tile to New Size"),
FALSE, FALSE);
/* TODO: we should have a new PikaProcedureDialog widget which would tie 2
* arguments for dimensions (or coordinates), and possibly more aux args for
* the constrain boolean choice, the unit, etc.
*/
pika_procedure_dialog_fill_box (PIKA_PROCEDURE_DIALOG (dlg),
"new-size-box",
"new-width", "new-height",
NULL);
pika_procedure_dialog_fill_frame (PIKA_PROCEDURE_DIALOG (dlg),
"new-size-frame", "new-size-label", FALSE,
"new-size-box");
pika_procedure_dialog_fill (PIKA_PROCEDURE_DIALOG (dlg), "new-size-frame", "new-image", NULL);
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_OK"), GTK_RESPONSE_OK,
NULL);
pika_dialog_set_alternative_button_order (GTK_DIALOG (dlg),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
pika_window_set_transient (GTK_WINDOW (dlg));
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 (dlg))),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
frame = pika_frame_new (_("Tile to New Size"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
sizeentry = pika_coordinates_new (unit, "%a", TRUE, TRUE, 8,
PIKA_SIZE_ENTRY_UPDATE_SIZE,
tvals.constrain, TRUE,
_("_Width:"), width, xres,
1, PIKA_MAX_IMAGE_SIZE,
0, width,
_("_Height:"), height, yres,
1, PIKA_MAX_IMAGE_SIZE,
0, height);
gtk_container_add (GTK_CONTAINER (frame), sizeentry);
gtk_widget_show (sizeentry);
chainbutton = GTK_WIDGET (PIKA_COORDINATES_CHAINBUTTON (sizeentry));
toggle = gtk_check_button_new_with_mnemonic (_("C_reate new image"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), tvals.new_image);
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (pika_toggle_button_update),
&tvals.new_image);
gtk_widget_show (dlg);
run = (pika_dialog_run (PIKA_DIALOG (dlg)) == GTK_RESPONSE_OK);
if (run)
{
tvals.new_width =
RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (sizeentry), 0));
tvals.new_height =
RINT (pika_size_entry_get_refval (PIKA_SIZE_ENTRY (sizeentry), 1));
tvals.constrain =
pika_chain_button_get_active (PIKA_CHAIN_BUTTON (chainbutton));
}
run = pika_procedure_dialog_run (PIKA_PROCEDURE_DIALOG (dlg));
gtk_widget_destroy (dlg);

25
plug-ins/common/unit-editor.c
View File

@ -49,7 +49,6 @@ enum
PLURAL,
UNIT,
USER_UNIT,
BG_COLOR,
NUM_COLUMNS
};
@ -80,7 +79,7 @@ static PikaProcedure * editor_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * editor_run (PikaProcedure *procedure,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static PikaUnit new_unit_dialog (GtkWindow *main_window,
@ -224,8 +223,7 @@ on_app_activate (GApplication *gapp, gpointer user_data)
G_TYPE_STRING, /* SINGULAR */
G_TYPE_STRING, /* PLURAL */
PIKA_TYPE_UNIT, /* UNIT */
G_TYPE_BOOLEAN, /* USER_UNIT */
GDK_TYPE_RGBA); /* BG_COLOR */
G_TYPE_BOOLEAN); /* USER_UNIT */
self->tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
g_object_unref (list_store);
@ -322,9 +320,8 @@ on_app_activate (GApplication *gapp, gpointer user_data)
col =
gtk_tree_view_column_new_with_attributes (gettext (columns[SAVE].title),
rend,
"active", SAVE,
"activatable", USER_UNIT,
"cell-background-rgba", BG_COLOR,
"active", SAVE,
"activatable", USER_UNIT,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (self->tv), col);
@ -351,8 +348,7 @@ on_app_activate (GApplication *gapp, gpointer user_data)
col =
gtk_tree_view_column_new_with_attributes (gettext (columns[i].title),
gtk_cell_renderer_text_new (),
"text", i,
"cell-background-rgba", BG_COLOR,
"text", i,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (self->tv), col);
@ -396,7 +392,7 @@ unit_editor_help_clicked (GtkWidget *window)
static PikaValueArray *
editor_run (PikaProcedure *procedure,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaUnitEditor *editor = PIKA_UNIT_EDITOR (run_data);
@ -736,7 +732,6 @@ unit_list_init (GtkTreeView *tv)
GtkTreeIter iter;
gint num_units;
PikaUnit unit;
GdkRGBA color;
list_store = GTK_LIST_STORE (gtk_tree_view_get_model (tv));
@ -744,11 +739,6 @@ unit_list_init (GtkTreeView *tv)
num_units = pika_unit_get_number_of_units ();
color.red = 0.87;
color.green = 0.87;
color.blue = 1;
color.alpha = 1;
for (unit = PIKA_UNIT_INCH; unit < num_units; unit++)
{
gboolean user_unit = (unit >= pika_unit_get_number_of_built_in_units ());
@ -765,9 +755,6 @@ unit_list_init (GtkTreeView *tv)
PLURAL, pika_unit_get_plural (unit),
UNIT, unit,
USER_UNIT, user_unit,
user_unit ? -1 : BG_COLOR, &color,
-1);
}

563
plug-ins/common/van-gogh-lic.c
View File

@ -90,11 +90,13 @@ static PikaValueArray * lic_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static void lic_scale_entry_update (PikaLabelSpin *entry,
gdouble *value);
static gboolean create_main_dialog (PikaProcedure *procedure,
PikaProcedureConfig *config);
static void compute_image (PikaProcedureConfig *config,
PikaDrawable *drawable);
G_DEFINE_TYPE (Lic, lic, PIKA_TYPE_PLUG_IN)
@ -117,6 +119,172 @@ lic_init (Lic *lic)
{
}
static GList *
lic_query_procedures (PikaPlugIn *plug_in)
{
return g_list_append (NULL, g_strdup (PLUG_IN_PROC));
}
static PikaProcedure *
lic_create_procedure (PikaPlugIn *plug_in,
const gchar *name)
{
PikaProcedure *procedure = NULL;
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = pika_image_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
lic_run, NULL, NULL);
pika_procedure_set_image_types (procedure, "RGB*");
pika_procedure_set_sensitivity_mask (procedure,
PIKA_PROCEDURE_SENSITIVE_DRAWABLE);
pika_procedure_set_menu_label (procedure, _("_Van Gogh (LIC)..."));
pika_procedure_add_menu_path (procedure, "<Image>/Filters/Artistic");
pika_procedure_set_documentation (procedure,
_("Special effects that nobody "
"understands"),
"No help yet",
name);
pika_procedure_set_attribution (procedure,
"Tom Bech & Federico Mena Quintero",
"Tom Bech & Federico Mena Quintero",
"Version 0.14, September 24 1997");
PIKA_PROC_ARG_CHOICE (procedure, "effect-channel",
_("E_ffect Channel"),
_("Effect Channel"),
pika_choice_new_with_values ("hue", LIC_HUE, _("Hue"), NULL,
"saturation", LIC_SATURATION, _("Saturation"), NULL,
"brightness", LIC_BRIGHTNESS, _("Brightness"), NULL,
NULL),
"brightness",
G_PARAM_READWRITE);
PIKA_PROC_ARG_CHOICE (procedure, "effect-operator",
_("Effect O_perator"),
_("Effect Operator"),
pika_choice_new_with_values ("derivative", 0, _("Derivative"), NULL,
"gradient", 1, _("Gradient"), NULL,
NULL),
"gradient",
G_PARAM_READWRITE);
PIKA_PROC_ARG_CHOICE (procedure, "effect-convolve",
_("Con_volve"),
_("Convolve"),
pika_choice_new_with_values ("with-white-noise", 0, _("With white noise"), NULL,
"with-source-image", 1, _("With source image"), NULL,
NULL),
"with-source-image",
G_PARAM_READWRITE);
PIKA_PROC_ARG_DRAWABLE (procedure, "effect-image",
_("Effect i_mage"),
_("Effect image"),
TRUE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "filter-length",
_("Fil_ter length"),
_("Filter length"),
0.1, 64.0, 5.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "noise-magnitude",
_("_Noise Magnitude"),
_("Noise Magnitude"),
1.0, 5.0, 2.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "integration-steps",
_("Inte_gration steps"),
_("Integration steps"),
1.0, 40.0, 25.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "min-value",
_("Minimum v_alue"),
_("Minimum value"),
-100.0, 0, -25.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "max-value",
_("Ma_ximum value"),
_("Maximum value"),
0.0, 100, 25.0,
G_PARAM_READWRITE);
}
return procedure;
}
static PikaValueArray *
lic_run (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaDrawable *drawable;
gegl_init (NULL, NULL);
if (n_drawables != 1)
{
GError *error = NULL;
g_set_error (&error, PIKA_PLUG_IN_ERROR, 0,
_("Procedure '%s' only works with one drawable."),
PLUG_IN_PROC);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CALLING_ERROR,
error);
}
else
{
drawable = drawables[0];
}
/* Make sure that the drawable is RGBA or RGB color */
/* ================================================ */
if (pika_drawable_is_rgb (drawable))
{
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
if (! create_main_dialog (procedure, config))
{
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
/* fallthrough */
case PIKA_RUN_WITH_LAST_VALS:
compute_image (config, drawable);
break;
default:
break;
}
}
else
{
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
NULL);
}
return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL);
}
/*****************************/
/* Global variables and such */
@ -124,21 +292,6 @@ lic_init (Lic *lic)
static gdouble G[numx][numy][2];
typedef struct
{
gdouble filtlen;
gdouble noisemag;
gdouble intsteps;
gdouble minv;
gdouble maxv;
gint effect_channel;
gint effect_operator;
gint effect_convolve;
gint32 effect_image_id;
} LicValues;
static LicValues licvals;
static gdouble l = 10.0;
static gdouble dx = 2.0;
static gdouble dy = 2.0;
@ -151,8 +304,6 @@ static gboolean source_drw_has_alpha = FALSE;
static gint effect_width, effect_height;
static gint border_x, border_y, border_w, border_h;
static GtkWidget *dialog;
/************************/
/* Convenience routines */
/************************/
@ -546,15 +697,20 @@ rgb_to_hsl (PikaDrawable *drawable,
static void
compute_lic (PikaDrawable *drawable,
const guchar *scalarfield,
gboolean rotate)
compute_lic (PikaProcedureConfig *config,
PikaDrawable *drawable,
const guchar *scalarfield,
gboolean rotate)
{
GeglBuffer *src_buffer;
GeglBuffer *dest_buffer;
gint xcount, ycount;
PikaRGB color;
gdouble vx, vy, tmp;
gint effect_convolve;
effect_convolve = pika_procedure_config_get_choice_id (config,
"effect-convolve");
src_buffer = pika_drawable_get_buffer (drawable);
dest_buffer = pika_drawable_get_shadow_buffer (drawable);
@ -588,7 +744,7 @@ compute_lic (PikaDrawable *drawable,
/* Convolve with the LIC at (x,y) */
/* ============================== */
if (licvals.effect_convolve == 0)
if (effect_convolve == 0)
{
peek (src_buffer, xcount, ycount, &color);
@ -617,10 +773,37 @@ compute_lic (PikaDrawable *drawable,
}
static void
compute_image (PikaDrawable *drawable)
compute_image (PikaProcedureConfig *config,
PikaDrawable *drawable)
{
PikaDrawable *effect_image;
guchar *scalarfield = NULL;
gdouble filtlen;
gdouble noisemag;
gdouble intsteps;
gdouble minv;
gdouble maxv;
gint effect_channel;
gint effect_operator;
gint effect_convolve;
g_object_get (config,
"filter-length", &filtlen,
"noise-magnitude", &noisemag,
"effect-image", &effect_image,
"integration-steps", &intsteps,
"min-value", &minv,
"max-value", &maxv,
NULL);
effect_channel = pika_procedure_config_get_choice_id (config,
"effect-channel");
effect_operator = pika_procedure_config_get_choice_id (config,
"effect-operator");
effect_convolve = pika_procedure_config_get_choice_id (config,
"effect-convolve");
if (! effect_image)
return;
/* Get some useful info on the input drawable */
/* ========================================== */
@ -631,39 +814,38 @@ compute_image (PikaDrawable *drawable)
pika_progress_init (_("Van Gogh (LIC)"));
if (licvals.effect_convolve == 0)
if (effect_convolve == 0)
generatevectors ();
if (licvals.filtlen < 0.1)
licvals.filtlen = 0.1;
if (filtlen < 0.1)
filtlen = 0.1;
l = licvals.filtlen;
dx = dy = licvals.noisemag;
minv = licvals.minv / 10.0;
maxv = licvals.maxv / 10.0;
isteps = licvals.intsteps;
l = filtlen;
dx = dy = noisemag;
minv = minv / 10.0;
maxv = maxv / 10.0;
isteps = intsteps;
source_drw_has_alpha = pika_drawable_has_alpha (drawable);
effect_image = pika_drawable_get_by_id (licvals.effect_image_id);
effect_width = pika_drawable_get_width (effect_image);
effect_height = pika_drawable_get_height (effect_image);
switch (licvals.effect_channel)
switch (effect_channel)
{
case 0:
case LIC_HUE:
scalarfield = rgb_to_hsl (effect_image, LIC_HUE);
break;
case 1:
case LIC_SATURATION:
scalarfield = rgb_to_hsl (effect_image, LIC_SATURATION);
break;
case 2:
case LIC_BRIGHTNESS:
scalarfield = rgb_to_hsl (effect_image, LIC_BRIGHTNESS);
break;
}
g_clear_object (&effect_image);
compute_lic (drawable, scalarfield, licvals.effect_operator);
compute_lic (config, drawable, scalarfield, effect_operator);
g_free (scalarfield);
@ -681,301 +863,36 @@ compute_image (PikaDrawable *drawable)
/**************************/
static gboolean
effect_image_constrain (PikaImage *image,
PikaItem *item,
gpointer data)
create_main_dialog (PikaProcedure *procedure,
PikaProcedureConfig *config)
{
return pika_drawable_is_rgb (PIKA_DRAWABLE (item));
}
static gboolean
create_main_dialog (void)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *grid;
GtkWidget *combo;
GtkWidget *scale;
gint row;
GtkWidget *dialog;
gboolean run;
pika_ui_init (PLUG_IN_BINARY);
dialog = pika_dialog_new (_("Van Gogh (LIC)"), PLUG_IN_ROLE,
NULL, 0,
pika_standard_help_func, PLUG_IN_PROC,
dialog = pika_procedure_dialog_new (procedure,
PIKA_PROCEDURE_CONFIG (config),
_("Van Gogh (LIC)"));
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_OK"), GTK_RESPONSE_OK,
pika_procedure_dialog_get_scale_entry (PIKA_PROCEDURE_DIALOG (dialog),
"filter-length", 1.0);
pika_procedure_dialog_get_scale_entry (PIKA_PROCEDURE_DIALOG (dialog),
"noise-magnitude", 1.0);
pika_procedure_dialog_get_scale_entry (PIKA_PROCEDURE_DIALOG (dialog),
"integration-steps", 1.0);
pika_procedure_dialog_get_scale_entry (PIKA_PROCEDURE_DIALOG (dialog),
"min-value", 1.0);
pika_procedure_dialog_get_scale_entry (PIKA_PROCEDURE_DIALOG (dialog),
"max-value", 1.0);
NULL);
pika_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
pika_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);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
frame = pika_int_radio_group_new (TRUE, _("Effect Channel"),
G_CALLBACK (pika_radio_button_update),
&licvals.effect_channel, NULL,
licvals.effect_channel,
_("_Hue"), 0, NULL,
_("_Saturation"), 1, NULL,
_("_Brightness"), 2, NULL,
NULL);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
frame = pika_int_radio_group_new (TRUE, _("Effect Operator"),
G_CALLBACK (pika_radio_button_update),
&licvals.effect_operator, NULL,
licvals.effect_operator,
_("_Derivative"), 0, NULL,
_("_Gradient"), 1, NULL,
NULL);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
frame = pika_int_radio_group_new (TRUE, _("Convolve"),
G_CALLBACK (pika_radio_button_update),
&licvals.effect_convolve, NULL,
licvals.effect_convolve,
_("_With white noise"), 0, NULL,
_("W_ith source image"), 1, NULL,
NULL);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
/* Effect image menu */
grid = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
gtk_box_pack_start (GTK_BOX (vbox), grid, FALSE, FALSE, 0);
gtk_widget_show (grid);
combo = pika_drawable_combo_box_new (effect_image_constrain, NULL, NULL);
pika_int_combo_box_connect (PIKA_INT_COMBO_BOX (combo),
licvals.effect_image_id,
G_CALLBACK (pika_int_combo_box_get_active),
&licvals.effect_image_id, NULL);
pika_grid_attach_aligned (GTK_GRID (grid), 0, 0,
_("_Effect image:"), 0.0, 0.5, combo, 2);
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
gtk_box_pack_start (GTK_BOX (vbox), grid, FALSE, FALSE, 0);
gtk_widget_show (grid);
row = 0;
scale = pika_scale_entry_new (_("_Filter length:"), licvals.filtlen, 0.1, 64, 1);
pika_label_spin_set_increments (PIKA_LABEL_SPIN (scale), 1.0, 8.0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (lic_scale_entry_update),
&licvals.filtlen);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
scale = pika_scale_entry_new (_("_Noise magnitude:"), licvals.noisemag, 1, 5, 1);
pika_label_spin_set_increments (PIKA_LABEL_SPIN (scale), 0.1, 1.0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (lic_scale_entry_update),
&licvals.noisemag);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
scale = pika_scale_entry_new (_("In_tegration steps:"), licvals.intsteps, 1, 40, 1);
g_signal_connect (scale, "value-changed",
G_CALLBACK (lic_scale_entry_update),
&licvals.intsteps);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
scale = pika_scale_entry_new (_("_Minimum value:"), licvals.minv, -100, 0, 1);
g_signal_connect (scale, "value-changed",
G_CALLBACK (lic_scale_entry_update),
&licvals.minv);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
scale = pika_scale_entry_new (_("M_aximum value:"),
licvals.maxv, 0, 100, 1);
g_signal_connect (scale, "value-changed",
G_CALLBACK (lic_scale_entry_update),
&licvals.maxv);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
pika_procedure_dialog_fill (PIKA_PROCEDURE_DIALOG (dialog), NULL);
gtk_widget_show (dialog);
run = (pika_dialog_run (PIKA_DIALOG (dialog)) == GTK_RESPONSE_OK);
run = pika_procedure_dialog_run (PIKA_PROCEDURE_DIALOG (dialog));
gtk_widget_destroy (dialog);
return run;
}
/*************************************/
/* Set parameters to standard values */
/*************************************/
static void
set_default_settings (void)
{
licvals.filtlen = 5;
licvals.noisemag = 2;
licvals.intsteps = 25;
licvals.minv = -25;
licvals.maxv = 25;
licvals.effect_channel = 2;
licvals.effect_operator = 1;
licvals.effect_convolve = 1;
licvals.effect_image_id = -1;
}
static GList *
lic_query_procedures (PikaPlugIn *plug_in)
{
return g_list_append (NULL, g_strdup (PLUG_IN_PROC));
}
static PikaProcedure *
lic_create_procedure (PikaPlugIn *plug_in,
const gchar *name)
{
PikaProcedure *procedure = NULL;
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = pika_image_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
lic_run, NULL, NULL);
pika_procedure_set_image_types (procedure, "RGB*");
pika_procedure_set_sensitivity_mask (procedure,
PIKA_PROCEDURE_SENSITIVE_DRAWABLE);
pika_procedure_set_menu_label (procedure, _("_Van Gogh (LIC)..."));
pika_procedure_add_menu_path (procedure, "<Image>/Filters/Artistic");
pika_procedure_set_documentation (procedure,
_("Special effects that nobody "
"understands"),
"No help yet",
name);
pika_procedure_set_attribution (procedure,
"Tom Bech & Federico Mena Quintero",
"Tom Bech & Federico Mena Quintero",
"Version 0.14, September 24 1997");
}
return procedure;
}
static PikaValueArray *
lic_run (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
gpointer run_data)
{
PikaDrawable *drawable;
gegl_init (NULL, NULL);
if (n_drawables != 1)
{
GError *error = NULL;
g_set_error (&error, PIKA_PLUG_IN_ERROR, 0,
_("Procedure '%s' only works with one drawable."),
PLUG_IN_PROC);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CALLING_ERROR,
error);
}
else
{
drawable = drawables[0];
}
/* Set default values */
/* ================== */
set_default_settings ();
/* Possibly retrieve data */
/* ====================== */
pika_get_data (PLUG_IN_PROC, &licvals);
if (! pika_item_id_is_valid (licvals.effect_image_id))
licvals.effect_image_id = -1;
/* Make sure that the drawable is RGBA or RGB color */
/* ================================================ */
if (pika_drawable_is_rgb (drawable))
{
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
if (! create_main_dialog ())
{
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
compute_image (drawable);
pika_set_data (PLUG_IN_PROC, &licvals, sizeof (LicValues));
break;
case PIKA_RUN_WITH_LAST_VALS:
compute_image (drawable);
break;
default:
break;
}
}
else
{
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
NULL);
}
return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL);
}
static void
lic_scale_entry_update (PikaLabelSpin *entry,
gdouble *value)
{
*value = pika_label_spin_get_value (entry);
}

480
plug-ins/common/warp.c
View File

@ -87,24 +87,6 @@ enum
COLOR
};
typedef struct
{
gdouble amount;
gint warp_map_id;
gint iter;
gdouble dither;
gdouble angle;
gint wrap_type;
gint mag_map_id;
gint mag_use;
gint substeps;
gint grad_map_id;
gdouble grad_scale;
gint vector_map_id;
gdouble vector_scale;
gdouble vector_angle;
} WarpVals;
typedef struct _Warp Warp;
typedef struct _WarpClass WarpClass;
@ -121,7 +103,7 @@ struct _WarpClass
#define WARP_TYPE (warp_get_type ())
#define WARP (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), WARP_TYPE, Warp))
#define WARP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), WARP_TYPE, Warp))
GType warp_get_type (void) G_GNUC_CONST;
@ -134,14 +116,15 @@ static PikaValueArray * warp_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static void blur16 (PikaDrawable *drawable);
static void diff (PikaDrawable *drawable,
PikaDrawable **xl,
PikaDrawable **yl);
static void diff (PikaDrawable *drawable,
PikaProcedureConfig *config,
PikaDrawable **xl,
PikaDrawable **yl);
static void diff_prepare_row (GeglBuffer *buffer,
const Babl *format,
@ -150,28 +133,32 @@ static void diff_prepare_row (GeglBuffer *buffer,
gint y,
gint w);
static void warp_one (PikaDrawable *draw,
PikaDrawable *newid,
PikaDrawable *map_x,
PikaDrawable *map_y,
PikaDrawable *mag_draw,
gboolean first_time,
gint step);
static void warp_one (PikaDrawable *draw,
PikaDrawable *newid,
PikaDrawable *map_x,
PikaDrawable *map_y,
PikaDrawable *mag_draw,
gboolean first_time,
gint step,
PikaProcedureConfig *config);
static void warp (PikaDrawable *drawable);
static void warp (PikaDrawable *drawable,
PikaProcedureConfig *config);
static gboolean warp_dialog (PikaDrawable *drawable);
static void warp_pixel (GeglBuffer *buffer,
const Babl *format,
gint width,
gint height,
gint x1,
gint y1,
gint x2,
gint y2,
gint x,
gint y,
guchar *pixel);
static gboolean warp_dialog (PikaDrawable *drawable,
PikaProcedureConfig *config);
static void warp_pixel (GeglBuffer *buffer,
const Babl *format,
gint width,
gint height,
gint x1,
gint y1,
gint x2,
gint y2,
gint x,
gint y,
guchar *pixel,
PikaProcedureConfig *config);
static gboolean warp_map_constrain (PikaImage *image,
PikaItem *item,
@ -187,24 +174,6 @@ PIKA_MAIN (WARP_TYPE)
DEFINE_STD_SET_I18N
static WarpVals dvals =
{
10.0, /* amount */
-1, /* warp_map_id */
5, /* iterations */
0.0, /* dither */
90.0, /* angle */
WRAP, /* wrap_type */
-1, /* mag_map_id */
FALSE, /* mag_use */
1, /* substeps */
-1, /* grad_map_id */
0.0, /* grad_scale */
-1, /* vector_map_id */
0.0, /* vector_scale */
0.0 /* vector_angle */
};
static gint progress = 0; /* progress indicator bar */
static PikaRunMode run_mode; /* interactive, non-, etc. */
static guchar color_pixel[4] = {0, 0, 0, 255}; /* current fg color */
@ -359,7 +328,7 @@ warp_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaDrawable *drawable;
@ -393,45 +362,12 @@ warp_run (PikaProcedure *procedure,
run_mode = _run_mode;
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
pika_get_data (PLUG_IN_PROC, &dvals);
if (run_mode == PIKA_RUN_INTERACTIVE && ! warp_dialog (drawable, config))
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
if (! warp_dialog (drawable))
{
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
break;
case PIKA_RUN_NONINTERACTIVE:
dvals.amount = PIKA_VALUES_GET_DOUBLE (args, 0);
dvals.warp_map_id = PIKA_VALUES_GET_DRAWABLE_ID (args, 1);
dvals.iter = PIKA_VALUES_GET_INT (args, 2);
dvals.dither = PIKA_VALUES_GET_DOUBLE (args, 3);
dvals.angle = PIKA_VALUES_GET_DOUBLE (args, 4);
dvals.wrap_type = PIKA_VALUES_GET_INT (args, 5);
dvals.mag_map_id = PIKA_VALUES_GET_DRAWABLE_ID (args, 6);
dvals.mag_use = PIKA_VALUES_GET_BOOLEAN (args, 7);
dvals.substeps = PIKA_VALUES_GET_INT (args, 8);
dvals.grad_map_id = PIKA_VALUES_GET_DRAWABLE_ID (args, 9);
dvals.grad_scale = PIKA_VALUES_GET_DOUBLE (args, 10);
dvals.vector_map_id = PIKA_VALUES_GET_DRAWABLE_ID (args, 11);
dvals.vector_scale = PIKA_VALUES_GET_DOUBLE (args, 12);
dvals.vector_angle = PIKA_VALUES_GET_DOUBLE (args, 13);
break;
case PIKA_RUN_WITH_LAST_VALS:
pika_get_data (PLUG_IN_PROC, &dvals);
break;
}
warp (drawable);
if (run_mode == PIKA_RUN_INTERACTIVE)
pika_set_data (PLUG_IN_PROC, &dvals, sizeof (WarpVals));
warp (drawable, config);
if (run_mode != PIKA_RUN_NONINTERACTIVE)
pika_displays_flush ();
@ -464,7 +400,8 @@ spin_button_new (GtkAdjustment **adjustment, /* return value */
}
static gboolean
warp_dialog (PikaDrawable *drawable)
warp_dialog (PikaDrawable *drawable,
PikaProcedureConfig *config)
{
GtkWidget *dlg;
GtkWidget *vbox;
@ -481,8 +418,53 @@ warp_dialog (PikaDrawable *drawable)
GSList *group = NULL;
gboolean run;
PikaDrawable *warp_map;
PikaDrawable *mag_map;
PikaDrawable *grad_map;
PikaDrawable *vector_map;
gdouble amount;
gdouble dither;
gdouble angle;
gdouble grad_scale;
gdouble vector_scale;
gdouble vector_angle;
gboolean use_mag;
gint substeps;
gint iter_count;
gint wrap_type;
gint32 warp_map_id;
gint32 mag_map_id;
gint32 grad_map_id;
gint32 vector_map_id;
pika_ui_init (PLUG_IN_BINARY);
g_object_get (config,
"amount", &amount,
"warp-map", &warp_map,
"iter", &iter_count,
"dither", &dither,
"angle", &angle,
"wrap-type", &wrap_type,
"mag-map", &mag_map,
"mag-use", &use_mag,
"substeps", &substeps,
"grad-map", &grad_map,
"grad-scale", &grad_scale,
"vector-map", &vector_map,
"vector-scale", &vector_scale,
"vector-angle", &vector_angle,
NULL);
warp_map_id = pika_item_get_id (PIKA_ITEM (warp_map));
mag_map_id = pika_item_get_id (PIKA_ITEM (mag_map));
grad_map_id = pika_item_get_id (PIKA_ITEM (grad_map));
vector_map_id = pika_item_get_id (PIKA_ITEM (vector_map));
g_clear_object (&warp_map);
g_clear_object (&mag_map);
g_clear_object (&grad_map);
g_clear_object (&vector_map);
dlg = pika_dialog_new (_("Warp"), PLUG_IN_ROLE,
NULL, 0,
pika_standard_help_func, PLUG_IN_PROC,
@ -519,7 +501,7 @@ warp_dialog (PikaDrawable *drawable)
label_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
/* amount, iter */
spinbutton = spin_button_new (&adj, dvals.amount,
spinbutton = spin_button_new (&adj, amount,
-1000, 1000, /* ??? */
1, 10, 0, 1, 2);
gtk_size_group_add_widget (spin_group, spinbutton);
@ -533,9 +515,9 @@ warp_dialog (PikaDrawable *drawable)
g_signal_connect (adj, "value-changed",
G_CALLBACK (pika_double_adjustment_update),
&dvals.amount);
&amount);
spinbutton = spin_button_new (&adj, dvals.iter,
spinbutton = spin_button_new (&adj, iter_count,
1, 100, 1, 5, 0, 1, 0);
gtk_size_group_add_widget (spin_group, spinbutton);
@ -546,7 +528,7 @@ warp_dialog (PikaDrawable *drawable)
g_signal_connect (adj, "value-changed",
G_CALLBACK (pika_int_adjustment_update),
&dvals.iter);
&iter_count);
/* Displacement map menu */
label = gtk_label_new (_("Displacement map:"));
@ -562,9 +544,9 @@ warp_dialog (PikaDrawable *drawable)
NULL);
gtk_widget_set_margin_start (combo, 12);
pika_int_combo_box_connect (PIKA_INT_COMBO_BOX (combo),
dvals.warp_map_id,
warp_map_id,
G_CALLBACK (pika_int_combo_box_get_active),
&dvals.warp_map_id, NULL);
&warp_map_id, NULL);
gtk_grid_attach (GTK_GRID (grid), combo, 2, 1, 1, 1);
// GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
@ -594,10 +576,10 @@ warp_dialog (PikaDrawable *drawable)
g_signal_connect (toggle, "toggled",
G_CALLBACK (pika_radio_button_update),
&dvals.wrap_type);
&wrap_type);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
dvals.wrap_type == WRAP);
wrap_type == WRAP);
toggle = gtk_radio_button_new_with_label (group, _("Smear"));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (toggle));
@ -609,10 +591,10 @@ warp_dialog (PikaDrawable *drawable)
g_signal_connect (toggle, "toggled",
G_CALLBACK (pika_radio_button_update),
&dvals.wrap_type);
&wrap_type);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
dvals.wrap_type == SMEAR);
wrap_type == SMEAR);
toggle = gtk_radio_button_new_with_label (group, _("Black"));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (toggle));
@ -624,10 +606,10 @@ warp_dialog (PikaDrawable *drawable)
g_signal_connect (toggle, "toggled",
G_CALLBACK (pika_radio_button_update),
&dvals.wrap_type);
&wrap_type);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
dvals.wrap_type == BLACK);
wrap_type == BLACK);
toggle = gtk_radio_button_new_with_label (group, _("Foreground color"));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (toggle));
@ -639,10 +621,10 @@ warp_dialog (PikaDrawable *drawable)
g_signal_connect (toggle, "toggled",
G_CALLBACK (pika_radio_button_update),
&dvals.wrap_type);
&wrap_type);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
dvals.wrap_type == COLOR);
wrap_type == COLOR);
@ -659,7 +641,7 @@ warp_dialog (PikaDrawable *drawable)
gtk_container_add (GTK_CONTAINER (frame), grid);
gtk_widget_show (grid);
spinbutton = spin_button_new (&adj, dvals.dither,
spinbutton = spin_button_new (&adj, dither,
0, 100, 1, 10, 0, 1, 2);
gtk_size_group_add_widget (spin_group, spinbutton);
@ -670,9 +652,9 @@ warp_dialog (PikaDrawable *drawable)
g_signal_connect (adj, "value-changed",
G_CALLBACK (pika_double_adjustment_update),
&dvals.dither);
&dither);
spinbutton = spin_button_new (&adj, dvals.angle,
spinbutton = spin_button_new (&adj, angle,
0, 360, 1, 15, 0, 1, 1);
gtk_size_group_add_widget (spin_group, spinbutton);
@ -683,9 +665,9 @@ warp_dialog (PikaDrawable *drawable)
g_signal_connect (adj, "value-changed",
G_CALLBACK (pika_double_adjustment_update),
&dvals.angle);
&angle);
spinbutton = spin_button_new (&adj, dvals.substeps,
spinbutton = spin_button_new (&adj, substeps,
1, 100, 1, 5, 0, 1, 0);
gtk_size_group_add_widget (spin_group, spinbutton);
@ -696,7 +678,7 @@ warp_dialog (PikaDrawable *drawable)
g_signal_connect (adj, "value-changed",
G_CALLBACK (pika_int_adjustment_update),
&dvals.substeps);
&substeps);
/* Magnitude map menu */
label = gtk_label_new (_("Magnitude map:"));
@ -712,9 +694,9 @@ warp_dialog (PikaDrawable *drawable)
NULL);
gtk_widget_set_margin_start (combo, 12);
pika_int_combo_box_connect (PIKA_INT_COMBO_BOX (combo),
dvals.mag_map_id,
mag_map_id,
G_CALLBACK (pika_int_combo_box_get_active),
&dvals.mag_map_id, NULL);
&mag_map_id, NULL);
gtk_grid_attach (GTK_GRID (grid), combo, 2, 1, 1, 1);
// GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
@ -730,12 +712,12 @@ warp_dialog (PikaDrawable *drawable)
toggle = gtk_check_button_new_with_label (_("Use magnitude map"));
gtk_widget_set_margin_start (toggle, 12);
gtk_box_pack_start (GTK_BOX (toggle_hbox), toggle, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), dvals.mag_use);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), use_mag);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (pika_toggle_button_update),
&dvals.mag_use);
&use_mag);
/* -------------------------------------------------------------------- */
@ -751,7 +733,7 @@ warp_dialog (PikaDrawable *drawable)
gtk_container_add (GTK_CONTAINER (frame), grid);
gtk_widget_show (grid);
spinbutton = spin_button_new (&adj, dvals.grad_scale,
spinbutton = spin_button_new (&adj, grad_scale,
-1000, 1000, /* ??? */
0.01, 0.1, 0, 1, 3);
gtk_size_group_add_widget (spin_group, spinbutton);
@ -763,7 +745,7 @@ warp_dialog (PikaDrawable *drawable)
g_signal_connect (adj, "value-changed",
G_CALLBACK (pika_double_adjustment_update),
&dvals.grad_scale);
&grad_scale);
/* --------- Gradient map menu ---------------- */
@ -776,15 +758,15 @@ warp_dialog (PikaDrawable *drawable)
gtk_widget_show (combo);
pika_int_combo_box_connect (PIKA_INT_COMBO_BOX (combo),
dvals.grad_map_id,
grad_map_id,
G_CALLBACK (pika_int_combo_box_get_active),
&dvals.grad_map_id, NULL);
&grad_map_id, NULL);
pika_help_set_help_data (combo, _("Gradient map selection menu"), NULL);
/* ---------------------------------------------- */
spinbutton = spin_button_new (&adj, dvals.vector_scale,
spinbutton = spin_button_new (&adj, vector_scale,
-1000, 1000, /* ??? */
0.01, 0.1, 0, 1, 3);
gtk_size_group_add_widget (spin_group, spinbutton);
@ -796,11 +778,11 @@ warp_dialog (PikaDrawable *drawable)
g_signal_connect (adj, "value-changed",
G_CALLBACK (pika_double_adjustment_update),
&dvals.vector_scale);
&vector_scale);
/* -------------------------------------------------------- */
spinbutton = spin_button_new (&adj, dvals.vector_angle,
spinbutton = spin_button_new (&adj, vector_angle,
0, 360, 1, 15, 0, 1, 1);
gtk_size_group_add_widget (spin_group, spinbutton);
@ -811,7 +793,7 @@ warp_dialog (PikaDrawable *drawable)
g_signal_connect (adj, "value-changed",
G_CALLBACK (pika_double_adjustment_update),
&dvals.vector_angle);
&vector_angle);
/* --------- Vector map menu ---------------- */
combo = pika_drawable_combo_box_new (warp_map_constrain,
@ -823,9 +805,9 @@ warp_dialog (PikaDrawable *drawable)
gtk_widget_show (combo);
pika_int_combo_box_connect (PIKA_INT_COMBO_BOX (combo),
dvals.vector_map_id,
vector_map_id,
G_CALLBACK (pika_int_combo_box_get_active),
&dvals.vector_map_id, NULL);
&vector_map_id, NULL);
pika_help_set_help_data (combo,
_("Fixed-direction-vector map selection menu"),
@ -837,6 +819,23 @@ warp_dialog (PikaDrawable *drawable)
gtk_widget_destroy (dlg);
g_object_set (config,
"amount", amount,
"warp-map", pika_drawable_get_by_id (warp_map_id),
"iter", iter_count,
"dither", dither,
"angle", angle,
"wrap-type", wrap_type,
"mag-map", pika_drawable_get_by_id (mag_map_id),
"mag-use", use_mag,
"substeps", substeps,
"grad-map", pika_drawable_get_by_id (grad_map_id),
"grad-scale", grad_scale,
"vector-map", pika_drawable_get_by_id (vector_map_id),
"vector-scale", vector_scale,
"vector-angle", vector_angle,
NULL);
return run;
}
@ -1016,15 +1015,13 @@ diff_prepare_row (GeglBuffer *buffer,
/* -------------------------------------------------------------------------- */
static void
diff (PikaDrawable *drawable,
PikaDrawable **xl,
PikaDrawable **yl)
diff (PikaDrawable *drawable,
PikaProcedureConfig *config,
PikaDrawable **xl,
PikaDrawable **yl)
{
PikaDrawable *draw_xd;
PikaDrawable *draw_yd; /* vector disp. drawables */
PikaDrawable *mdraw;
PikaDrawable *vdraw;
PikaDrawable *gdraw;
PikaImage *image; /* image holding X and Y diff. arrays */
PikaImage *new_image; /* image holding X and Y diff. layers */
GList *selected_layers; /* currently selected layers */
@ -1074,15 +1071,34 @@ diff (PikaDrawable *drawable,
gdouble r, theta, dtheta; /* rectangular<-> spherical coordinate transform for vector rotation */
gdouble scale_vec_x, scale_vec_y; /* fixed vector X,Y component scaling factors */
PikaDrawable *mag_map;
PikaDrawable *grad_map;
PikaDrawable *vector_map;
gdouble angle;
gdouble grad_scale;
gdouble vector_scale;
gdouble vector_angle;
gboolean use_mag;
pika_ui_init (PLUG_IN_BINARY);
g_object_get (config,
"angle", &angle,
"mag-use", &use_mag,
"grad-scale", &grad_scale,
"vector-scale", &vector_scale,
"vector-angle", &vector_angle,
NULL);
/* ----------------------------------------------------------------------- */
if (dvals.grad_scale != 0.0)
if (grad_scale != 0.0)
do_gradmap = TRUE; /* add in gradient of gradmap if scale != 0.000 */
if (dvals.vector_scale != 0.0) /* add in gradient of vectormap if scale != 0.000 */
if (vector_scale != 0.0) /* add in gradient of vectormap if scale != 0.000 */
do_vecmap = TRUE;
do_magmap = (dvals.mag_use == TRUE); /* multiply by magnitude map if so requested */
do_magmap = (use_mag == TRUE); /* multiply by magnitude map if so requested */
/* Get the input area. This is the bounding box of the selection in
* the image (or the entire image if there is no selection). Only
@ -1094,6 +1110,12 @@ diff (PikaDrawable *drawable,
&x1, &y1, &width, &height))
return;
g_object_get (config,
"mag-map", &mag_map,
"grad-map", &grad_map,
"vector-map", &vector_map,
NULL);
x2 = x1 + width;
y2 = y1 + height;
@ -1180,21 +1202,19 @@ diff (PikaDrawable *drawable,
diff_prepare_row (src_buffer, src_format, cr, x1, y1+1, (x2 - x1));
/* fixed-vector (x,y) component scale factors */
scale_vec_x = (dvals.vector_scale *
cos ((90 - dvals.vector_angle) * G_PI / 180.0) * 256.0 / 10);
scale_vec_y = (dvals.vector_scale *
sin ((90 - dvals.vector_angle) * G_PI / 180.0) * 256.0 / 10);
scale_vec_x = (vector_scale *
cos ((90 - vector_angle) * G_PI / 180.0) * 256.0 / 10);
scale_vec_y = (vector_scale *
sin ((90 - vector_angle) * G_PI / 180.0) * 256.0 / 10);
if (do_vecmap)
{
vdraw = pika_drawable_get_by_id (dvals.vector_map_id);
/* bytes per pixel in SOURCE drawable */
vformat = get_u8_format (vdraw);
vformat = get_u8_format (vector_map);
vbytes = babl_format_get_bytes_per_pixel (vformat);
/* fixed-vector scale-map */
vec_buffer = pika_drawable_get_buffer (vdraw);
vec_buffer = pika_drawable_get_buffer (vector_map);
crv = cur_row_v + vbytes;
diff_prepare_row (vec_buffer, vformat, crv, x1, y1, (x2 - x1));
@ -1202,13 +1222,11 @@ diff (PikaDrawable *drawable,
if (do_gradmap)
{
gdraw = pika_drawable_get_by_id (dvals.grad_map_id);
gformat = get_u8_format (gdraw);
gformat = get_u8_format (grad_map);
gbytes = babl_format_get_bytes_per_pixel (gformat);
/* fixed-vector scale-map */
grad_buffer = pika_drawable_get_buffer (gdraw);
grad_buffer = pika_drawable_get_buffer (grad_map);
prg = prev_row_g + gbytes;
crg = cur_row_g + gbytes;
@ -1219,23 +1237,21 @@ diff (PikaDrawable *drawable,
if (do_magmap)
{
mdraw = pika_drawable_get_by_id (dvals.mag_map_id);
mformat = get_u8_format (mdraw);
mformat = get_u8_format (mag_map);
mbytes = babl_format_get_bytes_per_pixel (mformat);
/* fixed-vector scale-map */
mag_buffer = pika_drawable_get_buffer (mdraw);
mag_buffer = pika_drawable_get_buffer (mag_map);
crm = cur_row_m + mbytes;
diff_prepare_row (mag_buffer, mformat, crm, x1, y1, (x2 - x1));
}
dtheta = dvals.angle * G_PI / 180.0;
dtheta = angle * G_PI / 180.0;
/* note that '3' is rather arbitrary here. */
rscalefac = 256.0 / (3 * src_bytes);
/* scale factor for gradient map components */
gscalefac = dvals.grad_scale * 256.0 / (3 * gbytes);
gscalefac = grad_scale * 256.0 / (3 * gbytes);
/* loop through the rows, applying the differential convolution */
for (row = y1; row < y2; row++)
@ -1377,6 +1393,10 @@ diff (PikaDrawable *drawable,
g_object_unref (destx_buffer);
g_object_unref (desty_buffer);
g_clear_object (&mag_map);
g_clear_object (&grad_map);
g_clear_object (&vector_map);
pika_drawable_update (draw_xd, x1, y1, (x2 - x1), (y2 - y1));
pika_drawable_update (draw_yd, x1, y1, (x2 - x1), (y2 - y1));
@ -1409,13 +1429,15 @@ diff (PikaDrawable *drawable,
/* -------------------------------------------------------------------------- */
static void
warp (PikaDrawable *orig_draw)
warp (PikaDrawable *orig_draw,
PikaProcedureConfig *config)
{
PikaDrawable *disp_map; /* Displacement map, ie, control array */
PikaDrawable *mag_draw; /* Magnitude multiplier factor map */
PikaDrawable *map_x = NULL;
PikaDrawable *map_y = NULL;
gboolean first_time = TRUE;
gint iter_count;
gint width;
gint height;
gint x1, y1, x2, y2;
@ -1424,9 +1446,6 @@ warp (PikaDrawable *orig_draw)
/* index var. over all "warp" Displacement iterations */
gint warp_iter;
disp_map = pika_drawable_get_by_id (dvals.warp_map_id);
mag_draw = pika_drawable_get_by_id (dvals.mag_map_id);
/* calculate new X,Y Displacement image maps */
pika_progress_init (_("Finding XY gradient"));
@ -1436,6 +1455,12 @@ warp (PikaDrawable *orig_draw)
&x1, &y1, &width, &height))
return;
g_object_get (config,
"warp-map", &disp_map,
"mag-map", &mag_draw,
"iter", &iter_count,
NULL);
x2 = x1 + width;
y2 = y1 + height;
@ -1443,16 +1468,16 @@ warp (PikaDrawable *orig_draw)
height = pika_drawable_get_height (orig_draw);
/* generate x,y differential images (arrays) */
diff (disp_map, &map_x, &map_y);
diff (disp_map, config, &map_x, &map_y);
for (warp_iter = 0; warp_iter < dvals.iter; warp_iter++)
for (warp_iter = 0; warp_iter < iter_count; warp_iter++)
{
pika_progress_init_printf (_("Flow step %d"), warp_iter+1);
progress = 0;
warp_one (orig_draw, orig_draw,
map_x, map_y, mag_draw,
first_time, warp_iter);
first_time, warp_iter, config);
pika_drawable_update (orig_draw,
x1, y1, (x2 - x1), (y2 - y1));
@ -1466,18 +1491,21 @@ warp (PikaDrawable *orig_draw)
image = pika_item_get_image (PIKA_ITEM (map_x));
pika_image_delete (image);
g_clear_object (&disp_map);
g_clear_object (&mag_draw);
}
/* -------------------------------------------------------------------------- */
static void
warp_one (PikaDrawable *draw,
PikaDrawable *new,
PikaDrawable *map_x,
PikaDrawable *map_y,
PikaDrawable *mag_draw,
gboolean first_time,
gint step)
warp_one (PikaDrawable *draw,
PikaDrawable *new,
PikaDrawable *map_x,
PikaDrawable *map_y,
PikaDrawable *mag_draw,
gboolean first_time,
gint step,
PikaProcedureConfig *config)
{
GeglBuffer *src_buffer;
GeglBuffer *dest_buffer;
@ -1524,7 +1552,12 @@ warp_one (PikaDrawable *draw,
gint mag_bytes = 1;
gboolean mag_alpha = FALSE;
GRand *gr;
GRand *gr;
gdouble amount;
gdouble dither;
gboolean use_mag;
gint substeps;
gr = g_rand_new (); /* Seed Pseudo Random Number Generator */
@ -1536,6 +1569,13 @@ warp_one (PikaDrawable *draw,
&x1, &y1, &width, &height))
return;
g_object_get (config,
"amount", &amount,
"dither", &dither,
"mag-use", &use_mag,
"substeps", &substeps,
NULL);
x2 = x1 + width;
y2 = y1 + height;
@ -1592,7 +1632,7 @@ warp_one (PikaDrawable *draw,
GEGL_ACCESS_READ, GEGL_ABYSS_NONE);
if (dvals.mag_use)
if (use_mag)
{
mag_buffer = pika_drawable_get_buffer (mag_draw);
@ -1608,7 +1648,7 @@ warp_one (PikaDrawable *draw,
}
/* substep displacement vector scale factor */
dscalefac = dvals.amount / (256 * 127.5 * dvals.substeps);
dscalefac = amount / (256 * 127.5 * substeps);
while (gegl_buffer_iterator_next (iter))
{
@ -1619,7 +1659,7 @@ warp_one (PikaDrawable *draw,
guchar *myrow = iter->items[3].data;
guchar *mmagrow = NULL;
if (dvals.mag_use)
if (use_mag)
mmagrow = iter->items[4].data;
/* loop over destination pixels */
@ -1630,7 +1670,7 @@ warp_one (PikaDrawable *draw,
guchar *my = myrow;
guchar *mmag = NULL;
if (dvals.mag_use == TRUE)
if (use_mag == TRUE)
mmag = mmagrow;
for (x = roi.x; x < (roi.x + roi.width); x++)
@ -1640,7 +1680,7 @@ warp_one (PikaDrawable *draw,
dx = dscalefac * ((256.0 * mx[0]) + mx[1] -32768); /* 16-bit values */
dy = dscalefac * ((256.0 * my[0]) + my[1] -32768);
if (dvals.mag_use)
if (use_mag)
{
scalefac = warp_map_mag_give_value (mmag,
mag_alpha,
@ -1649,15 +1689,15 @@ warp_one (PikaDrawable *draw,
dy *= scalefac;
}
if (dvals.dither != 0.0)
{ /* random dither is +/- dvals.dither pixels */
dx += g_rand_double_range (gr, -dvals.dither, dvals.dither);
dy += g_rand_double_range (gr, -dvals.dither, dvals.dither);
if (dither != 0.0)
{ /* random dither is +/- dither pixels */
dx += g_rand_double_range (gr, -dither, dither);
dy += g_rand_double_range (gr, -dither, dither);
}
if (dvals.substeps != 1)
if (substeps != 1)
{ /* trace (substeps) iterations of displacement vector */
for (substep = 1; substep < dvals.substeps; substep++)
for (substep = 1; substep < substeps; substep++)
{
/* In this (substep) loop, (x,y) remain fixed. (dx,dy) vary each step. */
needx = x + dx;
@ -1678,22 +1718,22 @@ warp_one (PikaDrawable *draw,
width, height,
x1, y1, x2, y2,
xi, yi,
pixel[0]);
pixel[0], config);
warp_pixel (map_x_buffer, map_x_format,
width, height,
x1, y1, x2, y2,
xi + 1, yi,
pixel[1]);
pixel[1], config);
warp_pixel (map_x_buffer, map_x_format,
width, height,
x1, y1, x2, y2,
xi, yi + 1,
pixel[2]);
pixel[2], config);
warp_pixel (map_x_buffer, map_x_format,
width, height,
x1, y1, x2, y2,
xi + 1, yi + 1,
pixel[3]);
pixel[3], config);
ivalues[0] = 256 * pixel[0][0] + pixel[0][1];
ivalues[1] = 256 * pixel[1][0] + pixel[1][1];
@ -1707,22 +1747,22 @@ warp_one (PikaDrawable *draw,
width, height,
x1, y1, x2, y2,
xi, yi,
pixel[0]);
pixel[0], config);
warp_pixel (map_y_buffer, map_y_format,
width, height,
x1, y1, x2, y2,
xi + 1, yi,
pixel[1]);
pixel[1], config);
warp_pixel (map_y_buffer, map_y_format,
width, height,
x1, y1, x2, y2,
xi, yi + 1,
pixel[2]);
pixel[2], config);
warp_pixel (map_y_buffer, map_y_format,
width, height,
x1, y1, x2, y2,
xi + 1, yi + 1,
pixel[3]);
pixel[3], config);
ivalues[0] = 256 * pixel[0][0] + pixel[0][1];
ivalues[1] = 256 * pixel[1][0] + pixel[1][1];
@ -1746,7 +1786,7 @@ warp_one (PikaDrawable *draw,
mx += map_x_bytes; /* pointers into x,y displacement maps */
my += map_y_bytes;
if (dvals.mag_use == TRUE)
if (use_mag == TRUE)
mmag += mag_bytes;
/* Calculations complete; now copy the proper pixel */
@ -1768,22 +1808,22 @@ warp_one (PikaDrawable *draw,
width, height,
x1, y1, x2, y2,
xi, yi,
pixel[0]);
pixel[0], config);
warp_pixel (src_buffer, src_format,
width, height,
x1, y1, x2, y2,
xi + 1, yi,
pixel[1]);
pixel[1], config);
warp_pixel (src_buffer, src_format,
width, height,
x1, y1, x2, y2,
xi, yi + 1,
pixel[2]);
pixel[2], config);
warp_pixel (src_buffer, src_format,
width, height,
x1, y1, x2, y2,
xi + 1, yi + 1,
pixel[3]);
pixel[3], config);
for (k = 0; k < dest_bytes; k++)
{
@ -1804,7 +1844,7 @@ warp_one (PikaDrawable *draw,
mxrow += map_x_bytes * roi.width;
myrow += map_y_bytes * roi.width;
if (dvals.mag_use == TRUE)
if (use_mag == TRUE)
mmagrow += mag_bytes * roi.width;
}
@ -1817,7 +1857,7 @@ warp_one (PikaDrawable *draw,
g_object_unref (map_x_buffer);
g_object_unref (map_y_buffer);
if (dvals.mag_use == TRUE)
if (use_mag == TRUE)
g_object_unref (mag_buffer);
pika_progress_update (1.0);
@ -1852,23 +1892,29 @@ warp_map_mag_give_value (guchar *pt,
static void
warp_pixel (GeglBuffer *buffer,
const Babl *format,
gint width,
gint height,
gint x1,
gint y1,
gint x2,
gint y2,
gint x,
gint y,
guchar *pixel)
warp_pixel (GeglBuffer *buffer,
const Babl *format,
gint width,
gint height,
gint x1,
gint y1,
gint x2,
gint y2,
gint x,
gint y,
guchar *pixel,
PikaProcedureConfig *config)
{
static guchar empty_pixel[4] = { 0, 0, 0, 0 };
guchar *data;
gint wrap_type;
g_object_get (config,
"wrap-type", &wrap_type,
NULL);
/* Tile the image. */
if (dvals.wrap_type == WRAP)
if (wrap_type == WRAP)
{
if (x < 0)
x = width - (-x % width);
@ -1881,7 +1927,7 @@ warp_pixel (GeglBuffer *buffer,
y %= height;
}
/* Smear out the edges of the image by repeating pixels. */
else if (dvals.wrap_type == SMEAR)
else if (wrap_type == SMEAR)
{
if (x < 0)
x = 0;
@ -1904,7 +1950,7 @@ warp_pixel (GeglBuffer *buffer,
gint bpp = babl_format_get_bytes_per_pixel (format);
gint b;
if (dvals.wrap_type == BLACK)
if (wrap_type == BLACK)
data = empty_pixel;
else
data = color_pixel; /* must have selected COLOR type */

68
plug-ins/common/wavelet-decompose.c
View File

@ -47,7 +47,7 @@ struct _WaveletClass
#define WAVELET_TYPE (wavelet_get_type ())
#define WAVELET (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), WAVELET_TYPE, Wavelet))
#define WAVELET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), WAVELET_TYPE, Wavelet))
GType wavelet_get_type (void) G_GNUC_CONST;
@ -60,7 +60,7 @@ static PikaValueArray * wavelet_run (PikaProcedure *procedur
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static void wavelet_blur (PikaDrawable *drawable,
@ -157,20 +157,19 @@ wavelet_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaProcedureConfig *config;
PikaLayer **scale_layers;
PikaLayer *new_scale;
PikaLayer *parent = NULL;
PikaDrawable *drawable;
PikaLayerMode grain_extract_mode = PIKA_LAYER_MODE_GRAIN_EXTRACT;
PikaLayerMode grain_merge_mode = PIKA_LAYER_MODE_GRAIN_MERGE;
gint id;
gint scales;
gboolean create_group;
gboolean create_masks;
PikaLayer **scale_layers;
PikaLayer *new_scale;
PikaLayer *parent = NULL;
PikaDrawable *drawable;
PikaLayerMode grain_extract_mode = PIKA_LAYER_MODE_GRAIN_EXTRACT;
PikaLayerMode grain_merge_mode = PIKA_LAYER_MODE_GRAIN_MERGE;
gint id;
gint scales;
gboolean create_group;
gboolean create_masks;
gegl_init (NULL, NULL);
@ -191,36 +190,16 @@ wavelet_run (PikaProcedure *procedure,
drawable = drawables[0];
}
config = pika_procedure_create_config (procedure);
pika_procedure_config_begin_run (config, NULL, run_mode, args);
if (run_mode == PIKA_RUN_INTERACTIVE && ! wavelet_decompose_dialog (procedure, G_OBJECT (config)))
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
if (! wavelet_decompose_dialog (procedure, G_OBJECT (config)))
{
pika_procedure_config_end_run (config, PIKA_PDB_CANCEL);
g_object_unref (config);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
break;
case PIKA_RUN_NONINTERACTIVE:
case PIKA_RUN_WITH_LAST_VALS:
break;
default:
break;
}
g_object_get (config,
"scales", &scales,
"create-group", &create_group,
"create-masks", &create_masks,
NULL);
g_object_get (config,
"scales", &scales,
"create-group", &create_group,
"create-masks", &create_masks,
NULL);
pika_progress_init (_("Wavelet-Decompose"));
@ -356,9 +335,6 @@ wavelet_run (PikaProcedure *procedure,
pika_displays_flush ();
pika_procedure_config_end_run (config, PIKA_PDB_SUCCESS);
g_object_unref (config);
gegl_exit ();
return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL);

13
plug-ins/common/web-browser.c
View File

@ -62,7 +62,7 @@ struct _BrowserClass
#define BROWSER_TYPE (browser_get_type ())
#define BROWSER (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), BROWSER_TYPE, Browser))
#define BROWSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), BROWSER_TYPE, Browser))
GType browser_get_type (void) G_GNUC_CONST;
@ -71,7 +71,7 @@ static PikaProcedure * browser_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * browser_run (PikaProcedure *procedure,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static gboolean browser_open_url (GtkWindow *window,
@ -141,19 +141,22 @@ browser_create_procedure (PikaPlugIn *plug_in,
static PikaValueArray *
browser_run (PikaProcedure *procedure,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
GError *error = NULL;
gchar *url = NULL;
if (! browser_open_url (NULL, PIKA_VALUES_GET_STRING (args, 0),
&error))
g_object_get (config, "url", &url, NULL);
if (! browser_open_url (NULL, url, &error))
{
g_free (url);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
error);
}
g_free (url);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,
NULL);

403
plug-ins/common/web-page.c
View File

@ -43,20 +43,9 @@
typedef struct
{
char *url;
gint32 width;
gint font_size;
PikaImage *image;
GError *error;
} WebpageVals;
typedef struct
{
char url[MAX_URL_LEN];
gint32 width;
gint font_size;
} WebpageSaveVals;
} WebpageResult;
typedef struct _Webpage Webpage;
typedef struct _WebpageClass WebpageClass;
@ -73,7 +62,7 @@ struct _WebpageClass
#define WEBPAGE_TYPE (webpage_get_type ())
#define WEBPAGE (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), WEBPAGE_TYPE, Webpage))
#define WEBPAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), WEBPAGE_TYPE, Webpage))
GType webpage_get_type (void) G_GNUC_CONST;
@ -82,11 +71,13 @@ static PikaProcedure * webpage_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * webpage_run (PikaProcedure *procedure,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static gboolean webpage_dialog (void);
static PikaImage * webpage_capture (void);
static gboolean webpage_dialog (PikaProcedure *procedure,
PikaProcedureConfig *config);
static PikaImage * webpage_capture (PikaProcedureConfig *config,
GError **error);
G_DEFINE_TYPE (Webpage, webpage, PIKA_TYPE_PLUG_IN)
@ -95,9 +86,6 @@ PIKA_MAIN (WEBPAGE_TYPE)
DEFINE_STD_SET_I18N
static WebpageVals webpagevals;
static void
webpage_class_init (WebpageClass *klass)
{
@ -152,20 +140,20 @@ webpage_create_procedure (PikaPlugIn *plug_in,
G_PARAM_READWRITE);
PIKA_PROC_ARG_STRING (procedure, "url",
"URL",
"URL of the webpage to screenshot",
_("Enter location (_URI)"),
_("URL of the webpage to screenshot"),
"https://heckin.technology/AlderconeStudio/PIKApp/",
G_PARAM_READWRITE);
PIKA_PROC_ARG_INT (procedure, "width",
"Width",
"The width of the screenshot (in pixels)",
_("_Width (pixels)"),
_("The width of the screenshot (in pixels)"),
100, PIKA_MAX_IMAGE_SIZE, 1024,
G_PARAM_READWRITE);
PIKA_PROC_ARG_INT (procedure, "font-size",
"Font size",
"The font size to use in the page (in pt)",
_("_Font size"),
_("The font size to use in the page (in pt)"),
1, 1000, 12,
G_PARAM_READWRITE);
@ -181,68 +169,27 @@ webpage_create_procedure (PikaPlugIn *plug_in,
static PikaValueArray *
webpage_run (PikaProcedure *procedure,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaValueArray *return_vals;
PikaRunMode run_mode;
PikaImage *image;
WebpageSaveVals save = { "https://heckin.technology/AlderconeStudio/PIKApp/", 1024, 12 };
GError *error = NULL;
pika_get_data (PLUG_IN_PROC, &save);
g_object_get (config, "run-mode", &run_mode, NULL);
run_mode = PIKA_VALUES_GET_ENUM (args, 0);
webpagevals.url = g_strdup (save.url);
webpagevals.width = save.width;
webpagevals.font_size = save.font_size;
/* how are we running today? */
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
if (! webpage_dialog ())
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
break;
case PIKA_RUN_WITH_LAST_VALS:
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CALLING_ERROR,
NULL);
break;
case PIKA_RUN_NONINTERACTIVE:
webpagevals.url = (gchar *) PIKA_VALUES_GET_STRING (args, 1);
webpagevals.width = PIKA_VALUES_GET_INT (args, 2);
webpagevals.font_size = PIKA_VALUES_GET_INT (args, 3);
break;
default:
break;
}
image = webpage_capture ();
if (run_mode == PIKA_RUN_INTERACTIVE &&
! webpage_dialog (procedure, config))
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
image = webpage_capture (config, &error);
if (! image)
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
webpagevals.error);
save.width = webpagevals.width;
save.font_size = webpagevals.font_size;
if (strlen (webpagevals.url) < MAX_URL_LEN)
{
g_strlcpy (save.url, webpagevals.url, MAX_URL_LEN);
}
else
{
memset (save.url, 0, MAX_URL_LEN);
}
pika_set_data (PLUG_IN_PROC, &save, sizeof save);
error);
if (run_mode == PIKA_RUN_INTERACTIVE)
pika_display_new (image);
@ -257,152 +204,34 @@ webpage_run (PikaProcedure *procedure,
}
static gboolean
webpage_dialog (void)
webpage_dialog (PikaProcedure *procedure,
PikaProcedureConfig *config)
{
GtkWidget *dialog;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *image;
GtkWidget *label;
GtkWidget *entry;
GtkSizeGroup *sizegroup;
GtkAdjustment *adjustment;
GtkWidget *spinbutton;
GtkWidget *combo;
gint active;
gint status;
gboolean ret = FALSE;
GtkWidget *dialog;
GtkListStore *store;
gboolean run;
pika_ui_init (PLUG_IN_BINARY);
dialog = pika_dialog_new (_("Create from webpage"), PLUG_IN_ROLE,
NULL, 0,
pika_standard_help_func, PLUG_IN_PROC,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("Cre_ate"), GTK_RESPONSE_OK,
NULL);
pika_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
pika_window_set_transient (GTK_WINDOW (dialog));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
image = gtk_image_new_from_icon_name (PIKA_ICON_WEB,
GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start (GTK_BOX (vbox), image, FALSE, FALSE, 0);
gtk_widget_show (image);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
label = gtk_label_new (_("Enter location (URI):"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
entry = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
gtk_widget_set_size_request (entry, 400, -1);
gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
if (webpagevals.url)
gtk_entry_set_text (GTK_ENTRY (entry),
webpagevals.url);
gtk_widget_show (entry);
sizegroup = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
/* Width */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox),
hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Width (pixels):"));
gtk_size_group_add_widget (sizegroup, label);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
adjustment = gtk_adjustment_new (webpagevals.width,
1, 8192, 1, 10, 0);
spinbutton = pika_spin_button_new (adjustment, 1.0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
/* Font size */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox),
hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Font size:"));
gtk_size_group_add_widget (sizegroup, label);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
combo = pika_int_combo_box_new (_("Huge"), 16,
_("Large"), 14,
C_("web-page", "Default"), 12,
_("Small"), 10,
_("Tiny"), 8,
NULL);
switch (webpagevals.font_size)
{
case 16:
case 14:
case 12:
case 10:
case 8:
active = webpagevals.font_size;
break;
default:
active = 12;
}
pika_int_combo_box_set_active (PIKA_INT_COMBO_BOX (combo), active);
gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0);
gtk_widget_show (combo);
g_object_unref (sizegroup);
status = pika_dialog_run (PIKA_DIALOG (dialog));
if (status == GTK_RESPONSE_OK)
{
g_free (webpagevals.url);
webpagevals.url = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
webpagevals.width = (gint) gtk_adjustment_get_value (adjustment);
pika_int_combo_box_get_active (PIKA_INT_COMBO_BOX (combo),
&webpagevals.font_size);
ret = TRUE;
}
dialog = pika_procedure_dialog_new (procedure,
PIKA_PROCEDURE_CONFIG (config),
_("Create from webpage"));
pika_procedure_dialog_set_ok_label (PIKA_PROCEDURE_DIALOG (dialog),
_("Cre_ate"));
store = pika_int_store_new (_("Huge"), 16,
_("Large"), 14,
C_("web-page", "Default"), 12,
_("Small"), 10,
_("Tiny"), 8,
NULL);
pika_procedure_dialog_get_int_combo (PIKA_PROCEDURE_DIALOG (dialog),
"font-size", PIKA_INT_STORE (store));
pika_procedure_dialog_fill (PIKA_PROCEDURE_DIALOG (dialog),
"url", "width", "font-size", NULL);
run = pika_procedure_dialog_run (PIKA_PROCEDURE_DIALOG (dialog));
gtk_widget_destroy (dialog);
return ret;
return run;
}
static void
@ -411,8 +240,9 @@ notify_progress_cb (WebKitWebView *view,
gpointer user_data)
{
static gdouble old_progress = 0.0;
gdouble progress = webkit_web_view_get_estimated_load_progress (view);
gdouble progress;
progress = webkit_web_view_get_estimated_load_progress (view);
if ((progress - old_progress) > 0.01)
{
pika_progress_update (progress);
@ -427,7 +257,9 @@ load_failed_cb (WebKitWebView *view,
gpointer web_error,
gpointer user_data)
{
webpagevals.error = g_error_copy ((GError *) web_error);
GError **error = user_data;
*error = g_error_copy ((GError *) web_error);
gtk_main_quit ();
@ -439,11 +271,14 @@ snapshot_ready (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
WebKitWebView *view = WEBKIT_WEB_VIEW (source_object);
WebpageResult *retval = user_data;
WebKitWebView *view = WEBKIT_WEB_VIEW (source_object);
cairo_surface_t *surface;
pika_progress_pulse ();
surface = webkit_web_view_get_snapshot_finish (view, result,
&webpagevals.error);
&retval->error);
pika_progress_pulse ();
if (surface)
{
@ -454,70 +289,33 @@ snapshot_ready (GObject *source_object,
width = cairo_image_surface_get_width (surface);
height = cairo_image_surface_get_height (surface);
webpagevals.image = pika_image_new (width, height, PIKA_RGB);
retval->image = pika_image_new (width, height, PIKA_RGB);
pika_image_undo_disable (webpagevals.image);
layer = pika_layer_new_from_surface (webpagevals.image, _("Webpage"),
pika_image_undo_disable (retval->image);
layer = pika_layer_new_from_surface (retval->image, _("Webpage"),
surface,
0.25, 1.0);
pika_image_insert_layer (webpagevals.image, layer, NULL, 0);
pika_image_undo_enable (webpagevals.image);
pika_image_insert_layer (retval->image, layer, NULL, 0);
pika_image_undo_enable (retval->image);
cairo_surface_destroy (surface);
}
pika_progress_update (1.0);
gtk_main_quit ();
}
static gboolean
load_finished_idle (gpointer data)
{
static gint count = 0;
pika_progress_update ((gdouble) count * 0.025);
count++;
if (count < 10)
return G_SOURCE_CONTINUE;
webkit_web_view_get_snapshot (WEBKIT_WEB_VIEW (data),
WEBKIT_SNAPSHOT_REGION_FULL_DOCUMENT,
WEBKIT_SNAPSHOT_OPTIONS_NONE,
NULL,
snapshot_ready,
NULL);
count = 0;
return G_SOURCE_REMOVE;
}
static void
load_changed_cb (WebKitWebView *view,
WebKitLoadEvent event,
gpointer user_data)
{
if (event == WEBKIT_LOAD_FINISHED)
{
if (! webpagevals.error)
{
pika_progress_init_printf (_("Transferring webpage image for '%s'"),
webpagevals.url);
g_timeout_add (100, load_finished_idle, view);
return;
}
gtk_main_quit ();
}
gtk_main_quit ();
}
static PikaImage *
webpage_capture (void)
webpage_capture (PikaProcedureConfig *config,
GError **error)
{
gchar *scheme;
GtkWidget *window;
@ -525,37 +323,43 @@ webpage_capture (void)
WebKitSettings *settings;
char *ua;
if (! webpagevals.url || strlen (webpagevals.url) == 0)
gchar *url;
gint width;
gint font_size;
WebpageResult result;
g_object_get (config,
"url", &url,
"width", &width,
"font-size", &font_size,
NULL);
if (! url || strlen (url) == 0)
{
g_set_error (&webpagevals.error, 0, 0, _("No URL was specified"));
g_set_error (error, 0, 0, _("No URL was specified"));
return NULL;
}
scheme = g_uri_parse_scheme (webpagevals.url);
scheme = g_uri_parse_scheme (url);
if (! scheme)
{
char *url;
gchar *scheme_url;
/* If we were not given a well-formed URL, make one. */
url = g_strconcat ("http://", webpagevals.url, NULL);
g_free (webpagevals.url);
webpagevals.url = url;
g_free (scheme);
scheme_url = g_strconcat ("https://", url, NULL);
g_free (url);
url = scheme_url;
}
g_free (scheme);
if (webpagevals.width < 32)
if (width < 32)
{
g_warning ("Width '%d' is too small. Clamped to 32.",
webpagevals.width);
webpagevals.width = 32;
g_warning ("Width '%d' is too small. Clamped to 32.", width);
width = 32;
}
else if (webpagevals.width > 8192)
else if (width > 8192)
{
g_warning ("Width '%d' is too large. Clamped to 8192.",
webpagevals.width);
webpagevals.width = 8192;
g_warning ("Width '%d' is too large. Clamped to 8192.", width);
width = 8192;
}
window = gtk_offscreen_window_new ();
@ -565,7 +369,7 @@ webpage_capture (void)
gtk_widget_show (view);
gtk_widget_set_vexpand (view, TRUE);
gtk_widget_set_size_request (view, webpagevals.width, -1);
gtk_widget_set_size_request (view, width, -1);
gtk_container_add (GTK_CONTAINER (window), view);
/* Append "PIKA/<PIKA_VERSION>" to the user agent string */
@ -577,28 +381,45 @@ webpage_capture (void)
g_free (ua);
/* Set font size */
webkit_settings_set_default_font_size (settings, webpagevals.font_size);
webkit_settings_set_default_font_size (settings, font_size);
g_signal_connect (view, "notify::estimated-load-progress",
G_CALLBACK (notify_progress_cb),
window);
g_signal_connect (view, "load-failed",
G_CALLBACK (load_failed_cb),
window);
error);
g_signal_connect (view, "load-changed",
G_CALLBACK (load_changed_cb),
window);
pika_progress_init_printf (_("Downloading webpage '%s'"), webpagevals.url);
webkit_web_view_load_uri (WEBKIT_WEB_VIEW (view),
webpagevals.url);
pika_progress_init_printf (_("Downloading webpage '%s'"), url);
webkit_web_view_load_uri (WEBKIT_WEB_VIEW (view), url);
gtk_main ();
result.error = NULL;
result.image = NULL;
if (*error == NULL)
{
pika_progress_init_printf (_("Transferring webpage image for '%s'"), url);
pika_progress_pulse ();
webkit_web_view_get_snapshot (WEBKIT_WEB_VIEW (view),
WEBKIT_SNAPSHOT_REGION_FULL_DOCUMENT,
WEBKIT_SNAPSHOT_OPTIONS_NONE,
NULL,
snapshot_ready,
&result);
gtk_main ();
if (result.error != NULL)
g_propagate_error (error, result.error);
}
gtk_widget_destroy (window);
pika_progress_update (1.0);
return webpagevals.image;
return result.image;
}