static GimpValueArray * image_add_hguide_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; gint32 yposition; gint32 guide = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); yposition = g_value_get_int (gimp_value_array_index (args, 1)); if (success) { if (yposition <= gimp_image_get_height (image)) { GimpGuide *g; g = gimp_image_add_hguide (image, yposition, 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_hguide_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GValueArray *args) { gboolean success = TRUE; GValueArray *return_vals; GimpImage *image; gint32 yposition; gint32 guide = 0; image = gimp_value_get_image (&args->values[0], gimp); yposition = g_value_get_int (&args->values[1]); if (success) { if (yposition <= image->height) { GimpGuide *g; g = gimp_image_add_hguide (image, yposition, 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; }