static GimpValueArray *
image_add_vguide_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
gint32 xposition;
gint32 guide = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
xposition = g_value_get_int (gimp_value_array_index (args, 1));
if (success)
{
if (xposition <= gimp_image_get_width (image))
{
GimpGuide *g;
g = gimp_image_add_vguide (image, xposition, TRUE);
guide = gimp_guide_get_ID (g);
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
g_value_set_uint (gimp_value_array_index (return_vals, 1), guide);
return return_vals;
}
static GValueArray *
image_add_vguide_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GValueArray *args)
{
gboolean success = TRUE;
GValueArray *return_vals;
GimpImage *image;
gint32 xposition;
gint32 guide = 0;
image = gimp_value_get_image (&args->values[0], gimp);
xposition = g_value_get_int (&args->values[1]);
if (success)
{
if (xposition <= image->width)
{
GimpGuide *g;
g = gimp_image_add_vguide (image, xposition, TRUE);
guide = gimp_guide_get_ID (g);
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success);
if (success)
g_value_set_uint (&return_vals->values[1], guide);
return return_vals;
}
static void
gimp_move_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
GimpMoveTool *move = GIMP_MOVE_TOOL (tool);
GimpGuiConfig *config = GIMP_GUI_CONFIG (display->gimp->config);
GimpDisplayShell *shell = gimp_display_get_shell (display);
GimpImage *image = gimp_display_get_image (display);
if (gimp_tool_control_is_active (tool->control))
gimp_tool_control_halt (tool->control);
if (move->moving_guide)
{
gboolean delete_guide = FALSE;
gint x, y, width, height;
gimp_tool_pop_status (tool, display);
gimp_tool_control_set_scroll_lock (tool->control, FALSE);
gimp_tool_control_set_precision (tool->control,
GIMP_CURSOR_PRECISION_PIXEL_CENTER);
gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool));
if (release_type == GIMP_BUTTON_RELEASE_CANCEL)
{
move->moving_guide = FALSE;
move->guide_position = GUIDE_POSITION_INVALID;
move->guide_orientation = GIMP_ORIENTATION_UNKNOWN;
gimp_display_shell_selection_resume (shell);
return;
}
gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height);
switch (move->guide_orientation)
{
case GIMP_ORIENTATION_HORIZONTAL:
if ((move->guide_position < y) ||
(move->guide_position > (y + height)))
delete_guide = TRUE;
break;
case GIMP_ORIENTATION_VERTICAL:
if ((move->guide_position < x) ||
(move->guide_position > (x + width)))
delete_guide = TRUE;
break;
default:
break;
}
if (delete_guide)
{
if (move->guide)
{
gimp_image_remove_guide (image, move->guide, TRUE);
move->guide = NULL;
}
}
else
{
if (move->guide)
{
gimp_image_move_guide (image, move->guide,
move->guide_position, TRUE);
}
else
{
switch (move->guide_orientation)
{
case GIMP_ORIENTATION_HORIZONTAL:
move->guide = gimp_image_add_hguide (image,
move->guide_position,
TRUE);
break;
case GIMP_ORIENTATION_VERTICAL:
move->guide = gimp_image_add_vguide (image,
move->guide_position,
TRUE);
break;
default:
g_assert_not_reached ();
}
}
}
gimp_display_shell_selection_resume (shell);
gimp_image_flush (image);
move->moving_guide = FALSE;
move->guide_position = GUIDE_POSITION_INVALID;
move->guide_orientation = GIMP_ORIENTATION_UNKNOWN;
if (move->guide)
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
}
else
{
gboolean flush = FALSE;
if (! config->move_tool_changes_active ||
(release_type == GIMP_BUTTON_RELEASE_CANCEL))
{
if (move->old_active_layer)
{
gimp_image_set_active_layer (image, move->old_active_layer);
move->old_active_layer = NULL;
flush = TRUE;
}
if (move->old_active_vectors)
{
gimp_image_set_active_vectors (image, move->old_active_vectors);
move->old_active_vectors = NULL;
flush = TRUE;
}
}
if (release_type != GIMP_BUTTON_RELEASE_CANCEL)
{
if (move->floating_layer)
{
floating_sel_anchor (move->floating_layer);
flush = TRUE;
}
}
if (flush)
gimp_image_flush (image);
}
}
static void
gimp_guide_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
GimpGuideTool *guide_tool = GIMP_GUIDE_TOOL (tool);
GimpDisplayShell *shell = gimp_display_get_shell (display);
GimpImage *image = gimp_display_get_image (display);
gimp_tool_pop_status (tool, display);
gimp_tool_control_halt (tool->control);
gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool));
if (release_type == GIMP_BUTTON_RELEASE_CANCEL)
{
/* custom guides are moved live */
if (guide_tool->guide_custom)
gimp_image_move_guide (image, guide_tool->guide,
guide_tool->guide_old_position, TRUE);
}
else
{
gint max_position;
if (guide_tool->guide_orientation == GIMP_ORIENTATION_HORIZONTAL)
max_position = gimp_image_get_height (image);
else
max_position = gimp_image_get_width (image);
if (guide_tool->guide_position == GIMP_GUIDE_POSITION_UNDEFINED ||
guide_tool->guide_position < 0 ||
guide_tool->guide_position > max_position)
{
if (guide_tool->guide)
{
gimp_image_remove_guide (image, guide_tool->guide, TRUE);
guide_tool->guide = NULL;
}
}
else
{
if (guide_tool->guide)
{
/* custom guides are moved live */
if (! guide_tool->guide_custom)
gimp_image_move_guide (image, guide_tool->guide,
guide_tool->guide_position, TRUE);
}
else
{
switch (guide_tool->guide_orientation)
{
case GIMP_ORIENTATION_HORIZONTAL:
guide_tool->guide =
gimp_image_add_hguide (image,
guide_tool->guide_position,
TRUE);
break;
case GIMP_ORIENTATION_VERTICAL:
guide_tool->guide =
gimp_image_add_vguide (image,
guide_tool->guide_position,
TRUE);
break;
default:
gimp_assert_not_reached ();
}
}
}
gimp_image_flush (image);
}
gimp_display_shell_selection_resume (shell);
guide_tool->guide_position = GIMP_GUIDE_POSITION_UNDEFINED;
guide_tool->guide_orientation = GIMP_ORIENTATION_UNKNOWN;
tool_manager_pop_tool (display->gimp);
g_object_unref (guide_tool);
{
GimpTool *active_tool = tool_manager_get_active (display->gimp);
if (GIMP_IS_DRAW_TOOL (active_tool))
gimp_draw_tool_pause (GIMP_DRAW_TOOL (active_tool));
tool_manager_oper_update_active (display->gimp, coords, state,
TRUE, display);
tool_manager_cursor_update_active (display->gimp, coords, state,
display);
if (GIMP_IS_DRAW_TOOL (active_tool))
gimp_draw_tool_resume (GIMP_DRAW_TOOL (active_tool));
}
}
/* -------------------------------
* p_set_2_vector_points
* -------------------------------
* remove all strokes from the active path vectors
* and set a new stroke containing targetCoords (one or 2 depend on the valid flag)
* For better visualisation set guide lines crossing at the first target coords.
*/
static void
p_set_2_vector_points(gint32 imageId, PixelCoords *targetCoords, PixelCoords *targetCoords2)
{
gint32 activeVectorsId;
/* gint newStrokeId; */
gdouble *points;
gint num_points;
gboolean closed;
GimpVectorsStrokeType type;
gimp_image_add_hguide(imageId, targetCoords->py);
gimp_image_add_vguide(imageId, targetCoords->px);
activeVectorsId = gimp_image_get_active_vectors(imageId);
if(activeVectorsId >= 0)
{
gint num_strokes;
gint *strokes;
strokes = gimp_vectors_get_strokes (activeVectorsId, &num_strokes);
if(strokes)
{
if(num_strokes > 0)
{
gint ii;
for(ii=0; ii < num_strokes; ii++)
{
gimp_vectors_remove_stroke(activeVectorsId, strokes[ii]);
}
}
g_free(strokes);
}
if (targetCoords->valid)
{
closed = FALSE;
num_points = 6;
if (targetCoords2->valid)
{
num_points = 12;
}
points = g_new (gdouble, num_points);
points[0] = targetCoords->px;
points[1] = targetCoords->py;
points[2] = targetCoords->px;
points[3] = targetCoords->py;
points[4] = targetCoords->px;
points[5] = targetCoords->py;
if(targetCoords2->valid)
{
points[6] = targetCoords2->px;
points[7] = targetCoords2->py;
points[8] = targetCoords2->px;
points[9] = targetCoords2->py;
points[10] = targetCoords2->px;
points[11] = targetCoords2->py;
}
type = GIMP_VECTORS_STROKE_TYPE_BEZIER;
/* newStrokeId = */ gimp_vectors_stroke_new_from_points (activeVectorsId
, type
, num_points
, points
, closed
);
g_free(points);
}
}
} /* end p_set_2_vector_points */
GimpImage *
gimp_image_duplicate (GimpImage *image)
{
GimpImage *new_image;
GimpLayer *floating_layer;
GList *list;
GimpLayer *active_layer = NULL;
GimpChannel *active_channel = NULL;
GimpVectors *active_vectors = NULL;
GimpDrawable *new_floating_sel_drawable = NULL;
GimpDrawable *floating_sel_drawable = NULL;
gchar *filename;
gint count;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
gimp_set_busy_until_idle (image->gimp);
/* Create a new image */
new_image = gimp_create_image (image->gimp,
image->width, image->height,
image->base_type,
FALSE);
gimp_image_undo_disable (new_image);
/* Store the folder to be used by the save dialog */
filename = gimp_image_get_filename (image);
if (filename)
{
g_object_set_data_full (G_OBJECT (new_image), "gimp-image-dirname",
g_path_get_dirname (filename),
(GDestroyNotify) g_free);
g_free (filename);
}
/* Copy the colormap if necessary */
if (new_image->base_type == GIMP_INDEXED)
gimp_image_set_colormap (new_image,
gimp_image_get_colormap (image),
gimp_image_get_colormap_size (image),
FALSE);
/* Copy resolution information */
new_image->xresolution = image->xresolution;
new_image->yresolution = image->yresolution;
new_image->resolution_unit = image->resolution_unit;
/* Copy floating layer */
floating_layer = gimp_image_floating_sel (image);
if (floating_layer)
{
floating_sel_relax (floating_layer, FALSE);
floating_sel_drawable = floating_layer->fs.drawable;
floating_layer = NULL;
}
/* Copy the layers */
for (list = GIMP_LIST (image->layers)->list, count = 0;
list;
list = g_list_next (list))
{
GimpLayer *layer = list->data;
GimpLayer *new_layer;
new_layer = GIMP_LAYER (gimp_item_convert (GIMP_ITEM (layer),
new_image,
G_TYPE_FROM_INSTANCE (layer),
FALSE));
/* Make sure the copied layer doesn't say: "<old layer> copy" */
gimp_object_set_name (GIMP_OBJECT (new_layer),
gimp_object_get_name (GIMP_OBJECT (layer)));
/* Make sure that if the layer has a layer mask,
* its name isn't screwed up
*/
if (new_layer->mask)
gimp_object_set_name (GIMP_OBJECT (new_layer->mask),
gimp_object_get_name (GIMP_OBJECT (layer->mask)));
if (gimp_image_get_active_layer (image) == layer)
active_layer = new_layer;
if (image->floating_sel == layer)
floating_layer = new_layer;
if (floating_sel_drawable == GIMP_DRAWABLE (layer))
new_floating_sel_drawable = GIMP_DRAWABLE (new_layer);
if (floating_layer != new_layer)
gimp_image_add_layer (new_image, new_layer, count++);
}
/* Copy the channels */
for (list = GIMP_LIST (image->channels)->list, count = 0;
list;
list = g_list_next (list))
{
GimpChannel *channel = list->data;
GimpChannel *new_channel;
new_channel =
GIMP_CHANNEL (gimp_item_convert (GIMP_ITEM (channel),
new_image,
G_TYPE_FROM_INSTANCE (channel),
FALSE));
/* Make sure the copied channel doesn't say: "<old channel> copy" */
gimp_object_set_name (GIMP_OBJECT (new_channel),
gimp_object_get_name (GIMP_OBJECT (channel)));
if (gimp_image_get_active_channel (image) == channel)
active_channel = (new_channel);
if (floating_sel_drawable == GIMP_DRAWABLE (channel))
new_floating_sel_drawable = GIMP_DRAWABLE (new_channel);
gimp_image_add_channel (new_image, new_channel, count++);
}
/* Copy any vectors */
for (list = GIMP_LIST (image->vectors)->list, count = 0;
list;
list = g_list_next (list))
{
GimpVectors *vectors = list->data;
GimpVectors *new_vectors;
new_vectors =
GIMP_VECTORS (gimp_item_convert (GIMP_ITEM (vectors),
new_image,
G_TYPE_FROM_INSTANCE (vectors),
FALSE));
/* Make sure the copied vectors doesn't say: "<old vectors> copy" */
gimp_object_set_name (GIMP_OBJECT (new_vectors),
gimp_object_get_name (GIMP_OBJECT (vectors)));
if (gimp_image_get_active_vectors (image) == vectors)
active_vectors = new_vectors;
gimp_image_add_vectors (new_image, new_vectors, count++);
}
/* Copy the selection mask */
{
TileManager *src_tiles;
TileManager *dest_tiles;
PixelRegion srcPR, destPR;
src_tiles =
gimp_drawable_get_tiles (GIMP_DRAWABLE (image->selection_mask));
dest_tiles =
gimp_drawable_get_tiles (GIMP_DRAWABLE (new_image->selection_mask));
pixel_region_init (&srcPR, src_tiles,
0, 0, image->width, image->height, FALSE);
pixel_region_init (&destPR, dest_tiles,
0, 0, image->width, image->height, TRUE);
copy_region (&srcPR, &destPR);
new_image->selection_mask->bounds_known = FALSE;
new_image->selection_mask->boundary_known = FALSE;
}
if (floating_layer)
floating_sel_attach (floating_layer, new_floating_sel_drawable);
/* Set active layer, active channel, active vectors */
if (active_layer)
gimp_image_set_active_layer (new_image, active_layer);
if (active_channel)
gimp_image_set_active_channel (new_image, active_channel);
if (active_vectors)
gimp_image_set_active_vectors (new_image, active_vectors);
/* Copy state of all color channels */
for (count = 0; count < MAX_CHANNELS; count++)
{
new_image->visible[count] = image->visible[count];
new_image->active[count] = image->active[count];
}
/* Copy any guides */
for (list = image->guides; list; list = g_list_next (list))
{
GimpGuide *guide = list->data;
gint position = gimp_guide_get_position (guide);
switch (gimp_guide_get_orientation (guide))
{
case GIMP_ORIENTATION_HORIZONTAL:
gimp_image_add_hguide (new_image, position, FALSE);
break;
case GIMP_ORIENTATION_VERTICAL:
gimp_image_add_vguide (new_image, position, FALSE);
break;
default:
g_error ("Unknown guide orientation.\n");
}
}
/* Copy any sample points */
for (list = image->sample_points; list; list = g_list_next (list))
{
GimpSamplePoint *sample_point = list->data;
gimp_image_add_sample_point_at_pos (new_image,
sample_point->x,
sample_point->y,
FALSE);
}
/* Copy the grid */
if (image->grid)
gimp_image_set_grid (new_image, image->grid, FALSE);
/* Copy the quick mask info */
new_image->quick_mask_state = image->quick_mask_state;
new_image->quick_mask_inverted = image->quick_mask_inverted;
new_image->quick_mask_color = image->quick_mask_color;
/* Copy parasites */
if (image->parasites)
{
g_object_unref (new_image->parasites);
new_image->parasites = gimp_parasite_list_copy (image->parasites);
}
gimp_image_undo_enable (new_image);
return new_image;
}
/* The main rotate function */
static void
rotate (void)
{
GimpDrawable *drawable;
gint32 *layers;
gint i;
gint nlayers;
gint32 guide_ID;
GuideInfo *guide;
GList *guides = NULL;
GList *list;
if (rotvals.angle == 0) return;
/* if there's a selection and we try to rotate the whole image */
/* create an error message and exit */
if (rotvals.everything)
{
if (! gimp_selection_is_empty (image_ID))
{
gimp_message (_("You can not rotate the whole image if there's a selection."));
gimp_drawable_detach (active_drawable);
return;
}
if (gimp_item_is_layer (active_drawable->drawable_id) &&
gimp_layer_is_floating_sel (active_drawable->drawable_id))
{
gimp_message (_("You can not rotate the whole image if there's a floating selection."));
gimp_drawable_detach (active_drawable);
return;
}
}
else
/* if we are trying to rotate a channel or a mask,
create an error message and exit */
{
if (! gimp_item_is_layer (active_drawable->drawable_id))
{
gimp_message (_("Sorry, channels and masks can not be rotated."));
gimp_drawable_detach (active_drawable);
return;
}
}
gimp_progress_init (_("Rotating"));
gimp_image_undo_group_start (image_ID);
if (rotvals.everything) /* rotate the whole image */
{
gint32 width = gimp_image_width (image_ID);
gint32 height = gimp_image_height (image_ID);
gimp_drawable_detach (active_drawable);
layers = gimp_image_get_layers (image_ID, &nlayers);
for (i = 0; i < nlayers; i++)
{
drawable = gimp_drawable_get (layers[i]);
rotate_drawable (drawable);
gimp_drawable_detach (drawable);
}
g_free (layers);
/* build a list of all guides and remove them */
guide_ID = 0;
while ((guide_ID = gimp_image_find_next_guide (image_ID, guide_ID)) != 0)
{
guide = g_new (GuideInfo, 1);
guide->ID = guide_ID;
guide->orientation = gimp_image_get_guide_orientation (image_ID,
guide_ID);
guide->position = gimp_image_get_guide_position (image_ID, guide_ID);
guides = g_list_prepend (guides, guide);
}
for (list = guides; list; list = list->next)
{
guide = (GuideInfo *) list->data;
gimp_image_delete_guide (image_ID, guide->ID);
}
/* if rotation is not 180 degrees, resize the image */
/* Do it now after the guides are removed, since */
/* gimp_image_resize() moves the guides. */
if (rotvals.angle != 2)
gimp_image_resize (image_ID, height, width, 0, 0);
/* add the guides back to the image */
if (guides)
{
switch (rotvals.angle)
{
case 1:
for (list = guides; list; list = list->next)
{
guide = (GuideInfo *)list->data;
if (guide->orientation == GIMP_ORIENTATION_HORIZONTAL)
gimp_image_add_vguide (image_ID, height - guide->position);
else
gimp_image_add_hguide (image_ID, guide->position);
g_free (guide);
}
break;
case 2:
for (list = guides; list; list = list->next)
{
guide = (GuideInfo *)list->data;
if (guide->orientation == GIMP_ORIENTATION_HORIZONTAL)
gimp_image_add_hguide (image_ID, height - guide->position);
else
gimp_image_add_vguide (image_ID, width - guide->position);
g_free (guide);
}
break;
case 3:
for (list = guides; list; list = list->next)
{
guide = (GuideInfo *)list->data;
if (guide->orientation == GIMP_ORIENTATION_HORIZONTAL)
gimp_image_add_vguide (image_ID, guide->position);
else
gimp_image_add_hguide (image_ID, width - guide->position);
g_free (guide);
}
break;
default:
break;
}
g_list_free (guides);
}
}
else /* rotate only the active layer */
{
/* check for active selection and float it */
if (! gimp_selection_is_empty (image_ID) &&
! gimp_layer_is_floating_sel (active_drawable->drawable_id))
{
active_drawable =
gimp_drawable_get (gimp_selection_float (image_ID,
active_drawable->drawable_id,
0, 0));
}
rotate_drawable (active_drawable);
gimp_drawable_detach (active_drawable);
}
gimp_image_undo_group_end (image_ID);
return;
}