static void
gimp_layer_prop_undo_constructed (GObject *object)
{
GimpLayerPropUndo *layer_prop_undo = GIMP_LAYER_PROP_UNDO (object);
GimpLayer *layer;
G_OBJECT_CLASS (parent_class)->constructed (object);
g_assert (GIMP_IS_LAYER (GIMP_ITEM_UNDO (object)->item));
layer = GIMP_LAYER (GIMP_ITEM_UNDO (object)->item);
switch (GIMP_UNDO (object)->undo_type)
{
case GIMP_UNDO_LAYER_MODE:
layer_prop_undo->mode = gimp_layer_get_mode (layer);
break;
case GIMP_UNDO_LAYER_OPACITY:
layer_prop_undo->opacity = gimp_layer_get_opacity (layer);
break;
case GIMP_UNDO_LAYER_LOCK_ALPHA:
layer_prop_undo->lock_alpha = gimp_layer_get_lock_alpha (layer);
break;
default:
g_assert_not_reached ();
}
}
static void
gimp_layer_prop_undo_pop (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum)
{
GimpLayerPropUndo *layer_prop_undo = GIMP_LAYER_PROP_UNDO (undo);
GimpLayer *layer = GIMP_LAYER (GIMP_ITEM_UNDO (undo)->item);
GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum);
switch (undo->undo_type)
{
case GIMP_UNDO_LAYER_REPOSITION:
{
gint position;
position = gimp_image_get_layer_index (undo->image, layer);
gimp_image_position_layer (undo->image, layer,
layer_prop_undo->position,
FALSE, NULL);
layer_prop_undo->position = position;
}
break;
case GIMP_UNDO_LAYER_MODE:
{
GimpLayerModeEffects mode;
mode = gimp_layer_get_mode (layer);
gimp_layer_set_mode (layer, layer_prop_undo->mode, FALSE);
layer_prop_undo->mode = mode;
}
break;
case GIMP_UNDO_LAYER_OPACITY:
{
gdouble opacity;
opacity = gimp_layer_get_opacity (layer);
gimp_layer_set_opacity (layer, layer_prop_undo->opacity, FALSE);
layer_prop_undo->opacity = opacity;
}
break;
case GIMP_UNDO_LAYER_LOCK_ALPHA:
{
gboolean lock_alpha;
lock_alpha = gimp_layer_get_lock_alpha (layer);
gimp_layer_set_lock_alpha (layer, layer_prop_undo->lock_alpha, FALSE);
layer_prop_undo->lock_alpha = lock_alpha;
}
break;
default:
g_assert_not_reached ();
}
}
static GObject *
gimp_layer_prop_undo_constructor (GType type,
guint n_params,
GObjectConstructParam *params)
{
GObject *object;
GimpLayerPropUndo *layer_prop_undo;
GimpImage *image;
GimpLayer *layer;
object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
layer_prop_undo = GIMP_LAYER_PROP_UNDO (object);
g_assert (GIMP_IS_LAYER (GIMP_ITEM_UNDO (object)->item));
image = GIMP_UNDO (object)->image;
layer = GIMP_LAYER (GIMP_ITEM_UNDO (object)->item);
switch (GIMP_UNDO (object)->undo_type)
{
case GIMP_UNDO_LAYER_REPOSITION:
layer_prop_undo->position = gimp_image_get_layer_index (image, layer);
break;
case GIMP_UNDO_LAYER_MODE:
layer_prop_undo->mode = gimp_layer_get_mode (layer);
break;
case GIMP_UNDO_LAYER_OPACITY:
layer_prop_undo->opacity = gimp_layer_get_opacity (layer);
break;
case GIMP_UNDO_LAYER_LOCK_ALPHA:
layer_prop_undo->lock_alpha = gimp_layer_get_lock_alpha (layer);
break;
default:
g_assert_not_reached ();
}
return object;
}
/**
* gimp_text_layer_from_layer:
* @layer: a #GimpLayer object
* @text: a #GimpText object
*
* Converts a standard #GimpLayer and a #GimpText object into a
* #GimpTextLayer. The new text layer takes ownership of the @text and
* @layer objects. The @layer object is rendered unusable by this
* function. Don't even try to use if afterwards!
*
* This is a gross hack that is needed in order to load text layers
* from XCF files in a backwards-compatible way. Please don't use it
* for anything else!
*
* Return value: a newly allocated #GimpTextLayer object
**/
static GimpLayer *
gimp_text_layer_from_layer (GimpLayer *layer,
GimpText *text)
{
GimpTextLayer *text_layer;
GimpDrawable *drawable;
g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL);
g_return_val_if_fail (GIMP_IS_TEXT (text), NULL);
text_layer = g_object_new (GIMP_TYPE_TEXT_LAYER,
"image", gimp_item_get_image (GIMP_ITEM (layer)),
NULL);
gimp_item_replace_item (GIMP_ITEM (text_layer), GIMP_ITEM (layer));
drawable = GIMP_DRAWABLE (text_layer);
gimp_drawable_steal_buffer (drawable, GIMP_DRAWABLE (layer));
gimp_layer_set_opacity (GIMP_LAYER (text_layer),
gimp_layer_get_opacity (layer), FALSE);
gimp_layer_set_mode (GIMP_LAYER (text_layer),
gimp_layer_get_mode (layer), FALSE);
gimp_layer_set_blend_space (GIMP_LAYER (text_layer),
gimp_layer_get_blend_space (layer), FALSE);
gimp_layer_set_composite_space (GIMP_LAYER (text_layer),
gimp_layer_get_composite_space (layer), FALSE);
gimp_layer_set_composite_mode (GIMP_LAYER (text_layer),
gimp_layer_get_composite_mode (layer), FALSE);
gimp_layer_set_lock_alpha (GIMP_LAYER (text_layer),
gimp_layer_get_lock_alpha (layer), FALSE);
gimp_text_layer_set_text (text_layer, text);
g_object_unref (text);
g_object_unref (layer);
return GIMP_LAYER (text_layer);
}
static gboolean
vpropagate_dialog (GimpDrawable *drawable)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *toggle_vbox;
GtkWidget *button;
GtkObject *adj;
GSList *group = NULL;
gint index = 0;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
dialog = gimp_dialog_new (_("Value Propagate"), PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func, VPROPAGATE_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_window_set_transient (GTK_WINDOW (dialog));
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);
preview = gimp_drawable_preview_new (drawable, NULL);
gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0);
gtk_widget_show (preview);
g_signal_connect_swapped (preview, "invalidated",
G_CALLBACK (value_propagate_body),
drawable);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
/* Propagate Mode */
frame = gimp_frame_new (_("Mode"));
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
toggle_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_container_add (GTK_CONTAINER (frame), toggle_vbox);
gtk_widget_show (toggle_vbox);
for (index = 0; index < num_mode; index++)
{
button =
gtk_radio_button_new_with_mnemonic (group,
gettext (modes[index].name));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
gtk_box_pack_start (GTK_BOX (toggle_vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_object_set_data (G_OBJECT (button), "gimp-item-data",
GINT_TO_POINTER (index));
g_signal_connect (button, "toggled",
G_CALLBACK (gimp_radio_button_update),
&vpvals.propagate_mode);
g_signal_connect_swapped (button, "toggled",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
index == vpvals.propagate_mode);
}
/* Parameter settings */
frame = gimp_frame_new (_("Propagate"));
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (8, 3, FALSE); /* 4 raw, 2 columns(name and value) */
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacing (GTK_TABLE (table), 2, 12);
gtk_table_set_row_spacing (GTK_TABLE (table), 5, 12);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("Lower t_hreshold:"), SCALE_WIDTH, 4,
vpvals.lower_limit, 0, 255, 1, 8, 0,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
&vpvals.lower_limit);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
_("_Upper threshold:"), SCALE_WIDTH, 4,
vpvals.upper_limit, 0, 255, 1, 8, 0,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
&vpvals.upper_limit);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2,
_("_Propagating rate:"), SCALE_WIDTH, 4,
vpvals.propagating_rate, 0, 1, 0.01, 0.1, 2,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&vpvals.propagating_rate);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_table_add_toggle (table, _("To l_eft"), 0, 1, 4,
G_CALLBACK (vpropagate_toggle_button_update),
&direction_mask_vec[Right2Left]);
gtk_table_add_toggle (table, _("To _right"), 2, 3, 4,
G_CALLBACK (vpropagate_toggle_button_update),
&direction_mask_vec[Left2Right]);
gtk_table_add_toggle (table, _("To _top"), 1, 2, 3,
G_CALLBACK (vpropagate_toggle_button_update),
&direction_mask_vec[Bottom2Top]);
gtk_table_add_toggle (table, _("To _bottom"), 1, 2, 5,
G_CALLBACK (vpropagate_toggle_button_update),
&direction_mask_vec[Top2Bottom]);
if (gimp_drawable_has_alpha (drawable->drawable_id))
{
GtkWidget *toggle;
toggle =
gtk_table_add_toggle (table, _("Propagating _alpha channel"),
0, 3, 6,
G_CALLBACK (vpropagate_toggle_button_update),
&propagate_alpha);
if (gimp_layer_get_lock_alpha (drawable->drawable_id))
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), 0);
gtk_widget_set_sensitive (toggle, FALSE);
}
gtk_table_add_toggle (table, _("Propagating value channel"), 0, 3, 7,
G_CALLBACK (vpropagate_toggle_button_update),
&propagate_value);
}
gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
if (run)
{
gint i, result;
for (i = result = 0; i < 4; i++)
result |= (direction_mask_vec[i] ? 1 : 0) << i;
vpvals.direction_mask = result;
vpvals.propagating_channel = ((propagate_alpha ? PROPAGATING_ALPHA : 0) |
(propagate_value ? PROPAGATING_VALUE : 0));
}
gtk_widget_destroy (dialog);
return run;
}
/**
* gimp_layer_get_preserve_trans:
* @layer_ID: The layer.
*
* This procedure is deprecated! Use gimp_layer_get_lock_alpha() instead.
*
* Returns: The layer's preserve transperancy setting.
*/
gboolean
gimp_layer_get_preserve_trans (gint32 layer_ID)
{
return gimp_layer_get_lock_alpha (layer_ID);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpDrawable *drawable;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpRunMode run_mode;
gint32 image_ID;
run_mode = param[0].data.d_int32;
*nreturn_vals = 1;
*return_vals = values;
INIT_I18N ();
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
image_ID = param[1].data.d_image;
drawable = gimp_drawable_get (param[2].data.d_drawable);
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
gimp_get_data (PLUG_IN_PROC, &pvals);
if (! color_to_alpha_dialog (drawable))
{
gimp_drawable_detach (drawable);
return;
}
break;
case GIMP_RUN_NONINTERACTIVE:
if (nparams != 4)
status = GIMP_PDB_CALLING_ERROR;
if (status == GIMP_PDB_SUCCESS)
pvals.color = param[3].data.d_color;
break;
case GIMP_RUN_WITH_LAST_VALS:
gimp_get_data (PLUG_IN_PROC, &pvals);
break;
default:
break;
}
if (status == GIMP_PDB_SUCCESS &&
gimp_drawable_is_rgb (drawable->drawable_id) &&
gimp_item_is_layer (drawable->drawable_id))
{
gboolean lock_alpha;
gimp_image_undo_group_start (image_ID);
/* Add alpha if not present */
gimp_layer_add_alpha (drawable->drawable_id);
/* Reget the drawable, bpp might have changed */
drawable = gimp_drawable_get (drawable->drawable_id);
/* Unset 'Lock alpha' */
lock_alpha = gimp_layer_get_lock_alpha (drawable->drawable_id);
gimp_layer_set_lock_alpha (drawable->drawable_id, FALSE);
gimp_progress_init (_("Removing color"));
gimp_rgn_iterate2 (drawable, 0 /* unused */, to_alpha_func, NULL);
gimp_layer_set_lock_alpha (drawable->drawable_id, lock_alpha);
gimp_image_undo_group_end (image_ID);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
gimp_drawable_detach (drawable);
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &pvals, sizeof (pvals));
values[0].data.d_status = status;
}
void
layers_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpImage *image = action_data_get_image (data);
GimpLayer *layer = NULL;
GimpLayerMask *mask = NULL; /* layer mask */
gboolean fs = FALSE; /* floating sel */
gboolean ac = FALSE; /* active channel */
gboolean sel = FALSE;
gboolean alpha = FALSE; /* alpha channel present */
gboolean indexed = FALSE; /* is indexed */
gboolean lock_alpha = FALSE;
gboolean text_layer = FALSE;
GList *next = NULL;
GList *prev = NULL;
if (image)
{
fs = (gimp_image_floating_sel (image) != NULL);
ac = (gimp_image_get_active_channel (image) != NULL);
sel = ! gimp_channel_is_empty (gimp_image_get_mask (image));
indexed = (gimp_image_base_type (image) == GIMP_INDEXED);
layer = gimp_image_get_active_layer (image);
if (layer)
{
GList *list;
mask = gimp_layer_get_mask (layer);
lock_alpha = gimp_layer_get_lock_alpha (layer);
alpha = gimp_drawable_has_alpha (GIMP_DRAWABLE (layer));
list = g_list_find (GIMP_LIST (image->layers)->list, layer);
if (list)
{
prev = g_list_previous (list);
next = g_list_next (list);
}
if (layer)
text_layer = gimp_drawable_is_text_layer (GIMP_DRAWABLE (layer));
}
}
#define SET_VISIBLE(action,condition) \
gimp_action_group_set_action_visible (group, action, (condition) != 0)
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
SET_VISIBLE ("layers-text-tool", text_layer && !ac);
SET_SENSITIVE ("layers-edit-attributes", layer && !fs && !ac);
SET_SENSITIVE ("layers-new", image);
SET_SENSITIVE ("layers-new-last-values", image);
SET_SENSITIVE ("layers-duplicate", layer && !fs && !ac);
SET_SENSITIVE ("layers-delete", layer && !ac);
SET_SENSITIVE ("layers-select-top", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-select-bottom", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-select-previous", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-select-next", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-raise", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-raise-to-top", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-lower", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-lower-to-bottom", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-anchor", layer && fs && !ac);
SET_SENSITIVE ("layers-merge-down", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-merge-layers", layer && !fs && !ac);
SET_SENSITIVE ("layers-flatten-image", layer && !fs && !ac);
SET_VISIBLE ("layers-text-discard", text_layer && !ac);
SET_VISIBLE ("layers-text-to-vectors", text_layer && !ac);
SET_VISIBLE ("layers-text-along-vectors", text_layer && !ac);
SET_VISIBLE ("layers-text-selection-replace", text_layer && !ac);
SET_VISIBLE ("layers-text-selection-add", text_layer && !ac);
SET_VISIBLE ("layers-text-selection-subtract", text_layer && !ac);
SET_VISIBLE ("layers-text-selection-intersect", text_layer && !ac);
SET_SENSITIVE ("layers-resize", layer && !ac);
SET_SENSITIVE ("layers-resize-to-image", layer && !ac);
SET_SENSITIVE ("layers-scale", layer && !ac);
SET_SENSITIVE ("layers-crop", layer && sel);
SET_SENSITIVE ("layers-alpha-add", layer && !fs && !alpha);
SET_SENSITIVE ("layers-alpha-remove", layer && !fs && alpha);
SET_SENSITIVE ("layers-lock-alpha", layer);
SET_ACTIVE ("layers-lock-alpha", lock_alpha);
SET_SENSITIVE ("layers-mask-add", layer && !fs && !ac && !mask);
SET_SENSITIVE ("layers-mask-apply", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-delete", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-edit", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-show", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-disable", layer && !fs && !ac && mask);
SET_ACTIVE ("layers-mask-edit", mask && gimp_layer_mask_get_edit (mask));
SET_ACTIVE ("layers-mask-show", mask && gimp_layer_mask_get_show (mask));
SET_ACTIVE ("layers-mask-disable", mask && !gimp_layer_mask_get_apply (mask));
SET_SENSITIVE ("layers-mask-selection-replace", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-selection-add", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-selection-subtract", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-selection-intersect", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-alpha-selection-replace", layer && !fs && !ac);
SET_SENSITIVE ("layers-alpha-selection-add", layer && !fs && !ac);
SET_SENSITIVE ("layers-alpha-selection-subtract", layer && !fs && !ac);
SET_SENSITIVE ("layers-alpha-selection-intersect", layer && !fs && !ac);
#undef SET_VISIBLE
#undef SET_SENSITIVE
#undef SET_ACTIVE
}
void
layers_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpImage *image = action_data_get_image (data);
GimpLayer *layer = NULL;
GimpLayerMask *mask = NULL; /* layer mask */
gboolean fs = FALSE; /* floating sel */
gboolean ac = FALSE; /* active channel */
gboolean sel = FALSE;
gboolean alpha = FALSE; /* alpha channel present */
gboolean indexed = FALSE; /* is indexed */
gboolean lock_alpha = FALSE;
gboolean can_lock_alpha = FALSE;
gboolean text_layer = FALSE;
gboolean writable = FALSE;
gboolean children = FALSE;
GList *next = NULL;
GList *next_visible = NULL;
GList *prev = NULL;
if (image)
{
fs = (gimp_image_get_floating_selection (image) != NULL);
ac = (gimp_image_get_active_channel (image) != NULL);
sel = ! gimp_channel_is_empty (gimp_image_get_mask (image));
indexed = (gimp_image_base_type (image) == GIMP_INDEXED);
layer = gimp_image_get_active_layer (image);
if (layer)
{
GList *layer_list;
GList *list;
mask = gimp_layer_get_mask (layer);
lock_alpha = gimp_layer_get_lock_alpha (layer);
can_lock_alpha = gimp_layer_can_lock_alpha (layer);
alpha = gimp_drawable_has_alpha (GIMP_DRAWABLE (layer));
writable = ! gimp_item_is_content_locked (GIMP_ITEM (layer));
if (gimp_viewable_get_children (GIMP_VIEWABLE (layer)))
children = TRUE;
layer_list = gimp_item_get_container_iter (GIMP_ITEM (layer));
list = g_list_find (layer_list, layer);
if (list)
{
prev = g_list_previous (list);
next = g_list_next (list);
for (next_visible = next;
next_visible;
next_visible = g_list_next (next_visible))
{
if (gimp_item_get_visible (next_visible->data))
{
/* "next_visible" is actually "next_visible" and
* "writable" and "not group"
*/
if (gimp_item_is_content_locked (next_visible->data) ||
gimp_viewable_get_children (next_visible->data))
next_visible = NULL;
break;
}
}
}
text_layer = gimp_item_is_text_layer (GIMP_ITEM (layer));
}
}
#define SET_VISIBLE(action,condition) \
gimp_action_group_set_action_visible (group, action, (condition) != 0)
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
#define SET_LABEL(action,label) \
gimp_action_group_set_action_label (group, action, label)
SET_VISIBLE ("layers-text-tool", text_layer && !ac);
SET_SENSITIVE ("layers-edit-attributes", layer && !fs && !ac);
if (layer && gimp_layer_is_floating_sel (layer))
{
SET_LABEL ("layers-new", C_("layers-action", "To _New Layer"));
SET_LABEL ("layers-new-last-values", C_("layers-action", "To _New Layer"));
}
else
{
SET_LABEL ("layers-new", C_("layers-action", "_New Layer..."));
SET_LABEL ("layers-new-last-values", C_("layers-action", "_New Layer"));
}
SET_SENSITIVE ("layers-new", image);
SET_SENSITIVE ("layers-new-last-values", image);
SET_SENSITIVE ("layers-new-from-visible", image);
SET_SENSITIVE ("layers-new-group", image && !indexed);
SET_SENSITIVE ("layers-duplicate", layer && !fs && !ac);
SET_SENSITIVE ("layers-delete", layer && !ac);
SET_SENSITIVE ("layers-select-top", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-select-bottom", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-select-previous", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-select-next", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-raise", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-raise-to-top", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-lower", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-lower-to-bottom", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-anchor", layer && fs && !ac);
SET_SENSITIVE ("layers-merge-down", layer && !fs && !ac && next_visible);
SET_VISIBLE ("layers-merge-group", children);
SET_SENSITIVE ("layers-merge-group", layer && !fs && !ac && children);
SET_SENSITIVE ("layers-merge-layers", layer && !fs && !ac);
SET_SENSITIVE ("layers-flatten-image", layer && !fs && !ac);
SET_VISIBLE ("layers-text-discard", text_layer && !ac);
SET_VISIBLE ("layers-text-to-vectors", text_layer && !ac);
SET_VISIBLE ("layers-text-along-vectors", text_layer && !ac);
SET_SENSITIVE ("layers-resize", writable && !ac);
SET_SENSITIVE ("layers-resize-to-image", writable && !ac);
SET_SENSITIVE ("layers-scale", writable && !ac);
SET_SENSITIVE ("layers-crop", writable && sel);
SET_SENSITIVE ("layers-alpha-add", writable && !children && !fs && !alpha);
SET_SENSITIVE ("layers-alpha-remove", writable && !children && !fs && alpha);
SET_SENSITIVE ("layers-lock-alpha", can_lock_alpha);
SET_ACTIVE ("layers-lock-alpha", lock_alpha);
SET_SENSITIVE ("layers-mask-add", layer && !fs && !ac && !mask && !children);
SET_SENSITIVE ("layers-mask-apply", writable && !fs && !ac && mask && !children);
SET_SENSITIVE ("layers-mask-delete", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-edit", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-show", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-disable", layer && !fs && !ac && mask);
SET_ACTIVE ("layers-mask-edit", mask && gimp_layer_mask_get_edit (mask));
SET_ACTIVE ("layers-mask-show", mask && gimp_layer_mask_get_show (mask));
SET_ACTIVE ("layers-mask-disable", mask && !gimp_layer_mask_get_apply (mask));
SET_SENSITIVE ("layers-mask-selection-replace", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-selection-add", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-selection-subtract", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-selection-intersect", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-alpha-selection-replace", layer && !fs && !ac);
SET_SENSITIVE ("layers-alpha-selection-add", layer && !fs && !ac);
SET_SENSITIVE ("layers-alpha-selection-subtract", layer && !fs && !ac);
SET_SENSITIVE ("layers-alpha-selection-intersect", layer && !fs && !ac);
#undef SET_VISIBLE
#undef SET_SENSITIVE
#undef SET_ACTIVE
#undef SET_LABEL
}
static void
rotate_drawable (GimpDrawable *drawable)
{
GimpPixelRgn srcPR, destPR;
gint width, height;
gint longside;
gint bytes;
gint row, col;
gint offsetx, offsety;
gboolean was_lock_alpha = FALSE;
guchar *buffer;
guchar *src_row, *dest_row;
/* initialize */
row = 0;
/* Get the size of the input drawable. */
width = drawable->width;
height = drawable->height;
bytes = drawable->bpp;
if (gimp_layer_get_lock_alpha (drawable->drawable_id))
{
was_lock_alpha = TRUE;
gimp_layer_set_lock_alpha (drawable->drawable_id, FALSE);
}
if (rotvals.angle == 2) /* we're rotating by 180° */
{
gimp_tile_cache_ntiles (2 * (width / gimp_tile_width() + 1));
gimp_pixel_rgn_init (&srcPR, drawable, 0, 0, width, height,
FALSE, FALSE);
gimp_pixel_rgn_init (&destPR, drawable, 0, 0, width, height,
TRUE, TRUE);
src_row = (guchar *) g_malloc (width * bytes);
dest_row = (guchar *) g_malloc (width * bytes);
for (row = 0; row < height; row++)
{
gimp_pixel_rgn_get_row (&srcPR, src_row, 0, row, width);
for (col = 0; col < width; col++)
{
memcpy (dest_row + col * bytes,
src_row + (width - 1 - col) * bytes,
bytes);
}
gimp_pixel_rgn_set_row (&destPR, dest_row, 0, (height - row - 1),
width);
if ((row % 5) == 0)
gimp_progress_update ((double) row / (double) height);
}
g_free (src_row);
g_free (dest_row);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, 0, 0, width, height);
}
else /* we're rotating by 90° or 270° */
{
(width > height) ? (longside = width) : (longside = height);
gimp_layer_resize (drawable->drawable_id, longside, longside, 0, 0);
drawable = gimp_drawable_get (drawable->drawable_id);
gimp_drawable_flush (drawable);
gimp_tile_cache_ntiles ((longside / gimp_tile_width () + 1) +
(longside / gimp_tile_height () + 1));
gimp_pixel_rgn_init (&srcPR, drawable, 0, 0, longside, longside,
FALSE, FALSE);
gimp_pixel_rgn_init (&destPR, drawable, 0, 0, longside, longside,
TRUE, TRUE);
buffer = g_malloc (longside * bytes);
if (rotvals.angle == 1) /* we're rotating by 90° */
{
for (row = 0; row < height; row++)
{
gimp_pixel_rgn_get_row (&srcPR, buffer, 0, row, width);
gimp_pixel_rgn_set_col (&destPR, buffer, (height - row - 1), 0,
width);
if ((row % 5) == 0)
gimp_progress_update ((double) row / (double) height);
}
}
else /* we're rotating by 270° */
{
for (col = 0; col < width; col++)
{
gimp_pixel_rgn_get_col (&srcPR, buffer, col, 0, height);
gimp_pixel_rgn_set_row (&destPR, buffer, 0, (width - col - 1),
height);
if ((col % 5) == 0)
gimp_progress_update ((double) col / (double) width);
}
}
g_free (buffer);
gimp_progress_update (1.0);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, 0, 0, height, width);
gimp_layer_resize (drawable->drawable_id, height, width, 0, 0);
drawable = gimp_drawable_get (drawable->drawable_id);
gimp_drawable_flush (drawable);
gimp_drawable_update (drawable->drawable_id, 0, 0, height, width);
}
gimp_drawable_offsets (drawable->drawable_id, &offsetx, &offsety);
rotate_compute_offsets (&offsetx, &offsety,
gimp_image_width (image_ID),
gimp_image_height (image_ID),
width, height);
gimp_layer_set_offsets (drawable->drawable_id, offsetx, offsety);
if (was_lock_alpha)
gimp_layer_set_lock_alpha (drawable->drawable_id, TRUE);
return;
}
void
floating_sel_composite (GimpLayer *layer,
gint x,
gint y,
gint w,
gint h,
gboolean push_undo)
{
GimpImage *image;
g_return_if_fail (GIMP_IS_LAYER (layer));
g_return_if_fail (gimp_layer_is_floating_sel (layer));
if (! (image = gimp_item_get_image (GIMP_ITEM (layer))))
return;
/* What this function does is composite the specified area of the
* drawble with the floating selection. We do this when the image
* is constructed, before any other composition takes place.
*/
/* If this isn't the first composite,
* restore the image underneath
*/
if (! layer->fs.initial)
floating_sel_restore (layer, x, y, w, h);
else if (gimp_item_get_visible (GIMP_ITEM (layer)))
layer->fs.initial = FALSE;
/* First restore what's behind the image if necessary,
* then check for visibility
*/
if (gimp_item_get_visible (GIMP_ITEM (layer)))
{
gint offx, offy;
gint x1, y1, x2, y2;
/* Find the minimum area we need to composite -- in image space */
gimp_item_offsets (GIMP_ITEM (layer->fs.drawable), &offx, &offy);
x1 = MAX (GIMP_ITEM (layer)->offset_x, offx);
y1 = MAX (GIMP_ITEM (layer)->offset_y, offy);
x2 = MIN (GIMP_ITEM (layer)->offset_x +
GIMP_ITEM (layer)->width,
offx + gimp_item_width (GIMP_ITEM (layer->fs.drawable)));
y2 = MIN (GIMP_ITEM (layer)->offset_y +
GIMP_ITEM (layer)->height,
offy + gimp_item_height (GIMP_ITEM (layer->fs.drawable)));
x1 = CLAMP (x, x1, x2);
y1 = CLAMP (y, y1, y2);
x2 = CLAMP (x + w, x1, x2);
y2 = CLAMP (y + h, y1, y2);
if ((x2 - x1) > 0 && (y2 - y1) > 0)
{
PixelRegion fsPR;
GimpLayer *d_layer = NULL;
gboolean lock_alpha;
/* composite the area from the layer to the drawable */
pixel_region_init (&fsPR, GIMP_DRAWABLE (layer)->tiles,
(x1 - GIMP_ITEM (layer)->offset_x),
(y1 - GIMP_ITEM (layer)->offset_y),
(x2 - x1), (y2 - y1), FALSE);
/* a kludge here to prevent the case of the drawable
* underneath having lock alpha on, and disallowing
* the composited floating selection from being shown
*/
if (GIMP_IS_LAYER (layer->fs.drawable))
{
d_layer = GIMP_LAYER (layer->fs.drawable);
if ((lock_alpha = gimp_layer_get_lock_alpha (d_layer)))
gimp_layer_set_lock_alpha (d_layer, FALSE, FALSE);
}
else
lock_alpha = FALSE;
/* apply the fs with the undo specified by the value
* passed to this function
*/
gimp_drawable_apply_region (layer->fs.drawable, &fsPR,
push_undo, NULL,
layer->opacity,
layer->mode,
NULL,
(x1 - offx), (y1 - offy));
/* restore lock alpha */
if (lock_alpha)
gimp_layer_set_lock_alpha (d_layer, TRUE, FALSE);
}
}
}
