mirror of
https://gitlab.gnome.org/GNOME/gimp
synced 2024-10-24 06:05:04 +00:00
8522a8470d
2001-05-11 Hans Breuer <hans@breuer.org> * app/makefile.msc : add appconfig.lib. Statically link libgimptool/gimptool.lib. * app/main.c : use gimp_locale_directory() * app/config/gimpconfig-utils.c : <string.h> * app/config/makefile.msc : add gimpscanner * app/core/gimpimagefile.c : some G_OS_WIN32 mess to get mkdir() and chmod() * app/display/gimpdisplayshell.c app/plug-in/plug-in-progrss.c app/tool/gimpcolorpickertool.c app/tool/gimpcroptool.c app/tool/gimpmeasuretool.c app/tool/gimpperspectivetool.c app/tool/gimprotatetool.c app/tool/gimpscaletool.c app/tool/gimpsheartool.c app/tool/gimptransformtool.c app/widgets/gimpcolormapeditor.c app/widgets/gimpcolorpanel.c app/widgets/gimptoolbox-color-area.c add #ifdef __GNUC__ to avoid breaking on non standard pragma #warning * app/tools/makefile.msc : add gimptoolcontrol remove tools-enum * app/tools/tool_manager.c : need to include libgimptool/gimptoolcontrol.h after core includes otherwise we would compile without prototypes or break miserably * app/gui/plug-in-menus.c : replace LOCALEDIR with gimp_locale_directory () * app/gui/preferences-dialog.c (prefs_notebook_append_page) : only try to gdk_pixbuf_new_from_file() with a valid filename. It should simply return NULL otherwise, but fails if the filename is an empty string. * app/paint-funcs/makefile.msc : add -FImsvc_recommended_pragmas.h * app/widgets/gimpcolormapeditor.c : the 'row' allocated needs to be 'xn * cellsize * 2' (to avoid accessing unowned memory) not only width, which has become allocation.width by someone commenting out the correct size calculation * app/widgets/gimpdialogfactory.c : varargs to macros are GCCism or at least non standard. #define DEBUG to g_print or nothing - without arguments - does fix it somewhat dirty as the compiler needs to tolerate the '(blah, foo, bar);' statement than * app/widgets/makefile.msc : updated * app/xcf/makefile.msc : add -FImsvc_recommended_pragmas.h * etc/gimprc.win32 : use ';' to separate theme-path * libgimpbase/gimpenv.c : #include <stdio.h> for sprintf() * app/widgets/gimpdnd.c (gimp_dnd_set_file_data) : the passed in vals chunk is not always null-terminated (at least not on win32). Use the length parameter too to avoid reading junk filenames. * libgimp/gimp.def : export gimp_image_get_name() * libgimpbase/gimpbase.def : export gimp_locale_directory() * libgimpbase/gimpenv.[ch] : added gimp_locale_directory () * libgimpbase/makefile.msc : define DATADIR and SYSCONFDIR to empty string to let gimp find its files in the common place (win32: relative to the top level gimp dir) * plug-ins/common/pixelize.c : <string.h> * plug-ins/flame/cmap.c : #include <glib.h> for g_random_int() * plug-ins/makefile.msc : -FImsvc_recommended_pragams.h and a little hack to give imagemap the prototypes it desires without changing the lexed source * themes/Default/images/makefile.msc : now added (see below) * themes/Default/images/stock-button-reset.png : made it binary
1412 lines
41 KiB
C
1412 lines
41 KiB
C
/* The GIMP -- an image manipulation program
|
|
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <gtk/gtk.h>
|
|
#include <gdk/gdkkeysyms.h>
|
|
|
|
#include "libgimpmath/gimpmath.h"
|
|
#include "libgimpbase/gimpbase.h"
|
|
#include "libgimpwidgets/gimpwidgets.h"
|
|
|
|
#include "tools-types.h"
|
|
|
|
#ifdef __GNUC__
|
|
#warning FIXME #include "gui/gui-types.h"
|
|
#endif
|
|
#include "gui/gui-types.h"
|
|
|
|
#include "core/gimpdrawable.h"
|
|
#include "core/gimpimage.h"
|
|
#include "core/gimpimage-crop.h"
|
|
#include "core/gimpimage-mask.h"
|
|
#include "core/gimptoolinfo.h"
|
|
|
|
#include "display/gimpdisplay.h"
|
|
#include "display/gimpdisplay-foreach.h"
|
|
#include "display/gimpdisplayshell.h"
|
|
|
|
#include "gui/info-dialog.h"
|
|
|
|
#include "widgets/gimpenummenu.h"
|
|
|
|
#include "gimpcroptool.h"
|
|
#include "tool_manager.h"
|
|
#include "tool_options.h"
|
|
|
|
#include "app_procs.h"
|
|
#include "gimprc.h"
|
|
|
|
#include "libgimp/gimpintl.h"
|
|
|
|
|
|
/* speed of key movement */
|
|
#define ARROW_VELOCITY 25
|
|
|
|
/* possible crop functions */
|
|
enum
|
|
{
|
|
CREATING,
|
|
MOVING,
|
|
RESIZING_LEFT,
|
|
RESIZING_RIGHT,
|
|
CROPPING
|
|
};
|
|
|
|
|
|
typedef struct _CropOptions CropOptions;
|
|
|
|
struct _CropOptions
|
|
{
|
|
GimpToolOptions tool_options;
|
|
|
|
gboolean layer_only;
|
|
gboolean layer_only_d;
|
|
GtkWidget *layer_only_w;
|
|
|
|
gboolean allow_enlarge;
|
|
gboolean allow_enlarge_d;
|
|
GtkWidget *allow_enlarge_w;
|
|
|
|
GimpCropType type;
|
|
GimpCropType type_d;
|
|
GtkWidget *type_w;
|
|
};
|
|
|
|
|
|
static void gimp_crop_tool_class_init (GimpCropToolClass *klass);
|
|
static void gimp_crop_tool_init (GimpCropTool *crop_tool);
|
|
|
|
static void gimp_crop_tool_finalize (GObject *object);
|
|
|
|
static void gimp_crop_tool_control (GimpTool *tool,
|
|
GimpToolAction action,
|
|
GimpDisplay *gdisp);
|
|
static void gimp_crop_tool_button_press (GimpTool *tool,
|
|
GimpCoords *coords,
|
|
guint32 time,
|
|
GdkModifierType state,
|
|
GimpDisplay *gdisp);
|
|
static void gimp_crop_tool_button_release (GimpTool *tool,
|
|
GimpCoords *coords,
|
|
guint32 time,
|
|
GdkModifierType state,
|
|
GimpDisplay *gdisp);
|
|
static void gimp_crop_tool_motion (GimpTool *tool,
|
|
GimpCoords *coords,
|
|
guint32 time,
|
|
GdkModifierType state,
|
|
GimpDisplay *gdisp);
|
|
static void gimp_crop_tool_arrow_key (GimpTool *tool,
|
|
GdkEventKey *kevent,
|
|
GimpDisplay *gdisp);
|
|
static void gimp_crop_tool_modifier_key (GimpTool *tool,
|
|
GdkModifierType key,
|
|
gboolean press,
|
|
GdkModifierType state,
|
|
GimpDisplay *gdisp);
|
|
static void gimp_crop_tool_cursor_update (GimpTool *tool,
|
|
GimpCoords *coords,
|
|
GdkModifierType state,
|
|
GimpDisplay *gdisp);
|
|
|
|
static void gimp_crop_tool_draw (GimpDrawTool *draw_tool);
|
|
|
|
/* Crop helper functions */
|
|
static void crop_tool_crop_image (GimpImage *gimage,
|
|
gint x1,
|
|
gint y1,
|
|
gint x2,
|
|
gint y2,
|
|
gboolean layer_only,
|
|
gboolean crop_layers);
|
|
|
|
static void crop_recalc (GimpTool *tool,
|
|
GimpCropTool *crop);
|
|
static void crop_start (GimpTool *tool,
|
|
GimpCropTool *crop);
|
|
|
|
/* Crop dialog functions */
|
|
static void crop_info_update (GimpTool *tool);
|
|
static void crop_info_create (GimpTool *tool);
|
|
static void crop_crop_callback (GtkWidget *widget,
|
|
gpointer data);
|
|
static void crop_resize_callback (GtkWidget *widget,
|
|
gpointer data);
|
|
static void crop_close_callback (GtkWidget *widget,
|
|
gpointer data);
|
|
|
|
static void crop_selection_callback (GtkWidget *widget,
|
|
gpointer data);
|
|
static void crop_automatic_callback (GtkWidget *widget,
|
|
gpointer data);
|
|
|
|
static void crop_origin_changed (GtkWidget *widget,
|
|
gpointer data);
|
|
static void crop_size_changed (GtkWidget *widget,
|
|
gpointer data);
|
|
|
|
static GimpToolOptions * crop_options_new (GimpToolInfo *tool_info);
|
|
static void crop_options_reset (GimpToolOptions *tool_options);
|
|
|
|
|
|
static InfoDialog *crop_info = NULL;
|
|
|
|
static gdouble orig_vals[2];
|
|
static gdouble size_vals[2];
|
|
|
|
static GtkWidget *origin_sizeentry;
|
|
static GtkWidget *size_sizeentry;
|
|
|
|
static GimpDrawToolClass *parent_class = NULL;
|
|
|
|
|
|
/* public functions */
|
|
|
|
void
|
|
gimp_crop_tool_register (GimpToolRegisterCallback callback,
|
|
gpointer data)
|
|
{
|
|
(* callback) (GIMP_TYPE_CROP_TOOL,
|
|
crop_options_new,
|
|
FALSE,
|
|
"gimp-crop-tool",
|
|
_("Crop Tool"),
|
|
_("Crop or Resize an image"),
|
|
N_("/Tools/Transform Tools/Crop Tool"), "<shift>C",
|
|
NULL, "tools/crop_tool.html",
|
|
GIMP_STOCK_TOOL_CROP,
|
|
data);
|
|
}
|
|
|
|
GType
|
|
gimp_crop_tool_get_type (void)
|
|
{
|
|
static GType tool_type = 0;
|
|
|
|
if (! tool_type)
|
|
{
|
|
static const GTypeInfo tool_info =
|
|
{
|
|
sizeof (GimpCropToolClass),
|
|
(GBaseInitFunc) NULL,
|
|
(GBaseFinalizeFunc) NULL,
|
|
(GClassInitFunc) gimp_crop_tool_class_init,
|
|
NULL, /* class_finalize */
|
|
NULL, /* class_data */
|
|
sizeof (GimpCropTool),
|
|
0, /* n_preallocs */
|
|
(GInstanceInitFunc) gimp_crop_tool_init,
|
|
};
|
|
|
|
tool_type = g_type_register_static (GIMP_TYPE_DRAW_TOOL,
|
|
"GimpCropTool",
|
|
&tool_info, 0);
|
|
}
|
|
|
|
return tool_type;
|
|
}
|
|
|
|
static void
|
|
gimp_crop_tool_class_init (GimpCropToolClass *klass)
|
|
{
|
|
GObjectClass *object_class;
|
|
GimpToolClass *tool_class;
|
|
GimpDrawToolClass *draw_tool_class;
|
|
|
|
object_class = G_OBJECT_CLASS (klass);
|
|
tool_class = GIMP_TOOL_CLASS (klass);
|
|
draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
|
|
|
|
parent_class = g_type_class_peek_parent (klass);
|
|
|
|
object_class->finalize = gimp_crop_tool_finalize;
|
|
|
|
tool_class->control = gimp_crop_tool_control;
|
|
tool_class->button_press = gimp_crop_tool_button_press;
|
|
tool_class->button_release = gimp_crop_tool_button_release;
|
|
tool_class->motion = gimp_crop_tool_motion;
|
|
tool_class->arrow_key = gimp_crop_tool_arrow_key;
|
|
tool_class->modifier_key = gimp_crop_tool_modifier_key;
|
|
tool_class->cursor_update = gimp_crop_tool_cursor_update;
|
|
|
|
draw_tool_class->draw = gimp_crop_tool_draw;
|
|
}
|
|
|
|
static void
|
|
gimp_crop_tool_init (GimpCropTool *crop_tool)
|
|
{
|
|
GimpTool *tool;
|
|
|
|
tool = GIMP_TOOL (crop_tool);
|
|
|
|
gimp_tool_control_set_preserve (tool->control, FALSE);
|
|
gimp_tool_control_set_tool_cursor (tool->control, GIMP_CROP_TOOL_CURSOR);
|
|
}
|
|
|
|
static void
|
|
gimp_crop_tool_finalize (GObject *object)
|
|
{
|
|
if (crop_info)
|
|
{
|
|
info_dialog_free (crop_info);
|
|
crop_info = NULL;
|
|
}
|
|
|
|
G_OBJECT_CLASS (parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
gimp_crop_tool_control (GimpTool *tool,
|
|
GimpToolAction action,
|
|
GimpDisplay *gdisp)
|
|
{
|
|
GimpCropTool *crop_tool;
|
|
|
|
crop_tool = GIMP_CROP_TOOL (tool);
|
|
|
|
switch (action)
|
|
{
|
|
case PAUSE:
|
|
break;
|
|
|
|
case RESUME:
|
|
crop_recalc (tool, crop_tool);
|
|
break;
|
|
|
|
case HALT:
|
|
crop_close_callback (NULL, NULL);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
GIMP_TOOL_CLASS (parent_class)->control (tool, action, gdisp);
|
|
}
|
|
|
|
static void
|
|
gimp_crop_tool_button_press (GimpTool *tool,
|
|
GimpCoords *coords,
|
|
guint32 time,
|
|
GdkModifierType state,
|
|
GimpDisplay *gdisp)
|
|
{
|
|
GimpCropTool *crop;
|
|
GimpDrawTool *draw_tool;
|
|
|
|
crop = GIMP_CROP_TOOL (tool);
|
|
draw_tool = GIMP_DRAW_TOOL (tool);
|
|
|
|
if (!gimp_tool_control_is_active (tool->control) || gdisp != tool->gdisp)
|
|
{
|
|
crop->function = CREATING;
|
|
}
|
|
else
|
|
{
|
|
/* If the cursor is in either the upper left or lower right boxes,
|
|
* The new function will be to resize the current crop area
|
|
*/
|
|
if (gimp_draw_tool_on_handle (draw_tool, gdisp,
|
|
coords->x, coords->y,
|
|
GIMP_HANDLE_SQUARE,
|
|
crop->x1, crop->y1,
|
|
crop->dcw, crop->dch,
|
|
GTK_ANCHOR_NORTH_WEST,
|
|
FALSE))
|
|
{
|
|
crop->function = RESIZING_LEFT;
|
|
}
|
|
else if (gimp_draw_tool_on_handle (draw_tool, gdisp,
|
|
coords->x, coords->y,
|
|
GIMP_HANDLE_SQUARE,
|
|
crop->x2, crop->y2,
|
|
crop->dcw, crop->dch,
|
|
GTK_ANCHOR_SOUTH_EAST,
|
|
FALSE))
|
|
{
|
|
crop->function = RESIZING_RIGHT;
|
|
}
|
|
/* If the cursor is in either the upper right or lower left boxes,
|
|
* The new function will be to translate the current crop area
|
|
*/
|
|
else if (gimp_draw_tool_on_handle (draw_tool, gdisp,
|
|
coords->x, coords->y,
|
|
GIMP_HANDLE_SQUARE,
|
|
crop->x2, crop->y1,
|
|
crop->dcw, crop->dch,
|
|
GTK_ANCHOR_NORTH_EAST,
|
|
FALSE) ||
|
|
gimp_draw_tool_on_handle (draw_tool, gdisp,
|
|
coords->x, coords->y,
|
|
GIMP_HANDLE_SQUARE,
|
|
crop->x1, crop->y2,
|
|
crop->dcw, crop->dch,
|
|
GTK_ANCHOR_SOUTH_WEST,
|
|
FALSE))
|
|
{
|
|
crop->function = MOVING;
|
|
}
|
|
/* If the pointer is in the rectangular region, crop or resize it!
|
|
*/
|
|
else if (coords->x > crop->x1 &&
|
|
coords->x < crop->x2 &&
|
|
coords->y > crop->y1 &&
|
|
coords->y < crop->y2)
|
|
{
|
|
crop->function = CROPPING;
|
|
}
|
|
/* otherwise, the new function will be creating, since we want
|
|
* to start a new
|
|
*/
|
|
else
|
|
{
|
|
crop->function = CREATING;
|
|
}
|
|
}
|
|
|
|
if (crop->function == CREATING)
|
|
{
|
|
if (gimp_tool_control_is_active (tool->control))
|
|
gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool));
|
|
|
|
tool->gdisp = gdisp;
|
|
|
|
crop->x2 = crop->x1 = ROUND (coords->x);
|
|
crop->y2 = crop->y1 = ROUND (coords->y);
|
|
|
|
crop_start (tool, crop);
|
|
}
|
|
|
|
crop->lastx = crop->startx = ROUND (coords->x);
|
|
crop->lasty = crop->starty = ROUND (coords->y);
|
|
|
|
gimp_tool_control_activate (tool->control);
|
|
}
|
|
|
|
static void
|
|
gimp_crop_tool_button_release (GimpTool *tool,
|
|
GimpCoords *coords,
|
|
guint32 time,
|
|
GdkModifierType state,
|
|
GimpDisplay *gdisp)
|
|
{
|
|
GimpCropTool *crop;
|
|
CropOptions *options;
|
|
|
|
crop = GIMP_CROP_TOOL (tool);
|
|
|
|
options = (CropOptions *) tool->tool_info->tool_options;
|
|
|
|
gimp_tool_pop_status (tool);
|
|
|
|
if (! (state & GDK_BUTTON3_MASK))
|
|
{
|
|
if (crop->function == CROPPING)
|
|
{
|
|
if (options->type == GIMP_CROP)
|
|
crop_tool_crop_image (gdisp->gimage,
|
|
crop->x1, crop->y1,
|
|
crop->x2, crop->y2,
|
|
options->layer_only,
|
|
TRUE);
|
|
else
|
|
crop_tool_crop_image (gdisp->gimage,
|
|
crop->x1, crop->y1,
|
|
crop->x2, crop->y2,
|
|
options->layer_only,
|
|
FALSE);
|
|
|
|
/* Finish the tool */
|
|
crop_close_callback (NULL, NULL);
|
|
}
|
|
else
|
|
{
|
|
crop_info_update (tool);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
gimp_crop_tool_motion (GimpTool *tool,
|
|
GimpCoords *coords,
|
|
guint32 time,
|
|
GdkModifierType state,
|
|
GimpDisplay *gdisp)
|
|
{
|
|
GimpCropTool *crop;
|
|
CropOptions *options;
|
|
GimpLayer *layer;
|
|
gint x1, y1, x2, y2;
|
|
gint curx, cury;
|
|
gint inc_x, inc_y;
|
|
gint min_x, min_y, max_x, max_y;
|
|
|
|
crop = GIMP_CROP_TOOL (tool);
|
|
|
|
options = (CropOptions *) tool->tool_info->tool_options;
|
|
|
|
/* This is the only case when the motion events should be ignored--
|
|
we're just waiting for the button release event to crop the image */
|
|
if (crop->function == CROPPING)
|
|
return;
|
|
|
|
curx = ROUND (coords->x);
|
|
cury = ROUND (coords->y);
|
|
|
|
x1 = crop->startx;
|
|
y1 = crop->starty;
|
|
x2 = curx;
|
|
y2 = cury;
|
|
|
|
inc_x = (x2 - x1);
|
|
inc_y = (y2 - y1);
|
|
|
|
/* If there have been no changes... return */
|
|
if (crop->lastx == x2 && crop->lasty == y2)
|
|
return;
|
|
|
|
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
|
|
|
|
if (options->layer_only)
|
|
{
|
|
layer = gimp_image_get_active_layer (gdisp->gimage);
|
|
gimp_drawable_offsets (GIMP_DRAWABLE (layer), &min_x, &min_y);
|
|
max_x = gimp_drawable_width (GIMP_DRAWABLE (layer)) + min_x;
|
|
max_y = gimp_drawable_height (GIMP_DRAWABLE (layer)) + min_y;
|
|
}
|
|
else
|
|
{
|
|
min_x = min_y = 0;
|
|
max_x = gdisp->gimage->width;
|
|
max_y = gdisp->gimage->height;
|
|
}
|
|
|
|
switch (crop->function)
|
|
{
|
|
case CREATING:
|
|
if (! options->allow_enlarge)
|
|
{
|
|
x1 = CLAMP (x1, min_x, max_x);
|
|
y1 = CLAMP (y1, min_y, max_y);
|
|
x2 = CLAMP (x2, min_x, max_x);
|
|
y2 = CLAMP (y2, min_y, max_y);
|
|
}
|
|
break;
|
|
|
|
case RESIZING_LEFT:
|
|
x1 = crop->x1 + inc_x;
|
|
y1 = crop->y1 + inc_y;
|
|
if (! options->allow_enlarge)
|
|
{
|
|
x1 = CLAMP (x1, min_x, max_x);
|
|
y1 = CLAMP (y1, min_y, max_y);
|
|
}
|
|
x2 = MAX (x1, crop->x2);
|
|
y2 = MAX (y1, crop->y2);
|
|
crop->startx = curx;
|
|
crop->starty = cury;
|
|
break;
|
|
|
|
case RESIZING_RIGHT:
|
|
x2 = crop->x2 + inc_x;
|
|
y2 = crop->y2 + inc_y;
|
|
if (! options->allow_enlarge)
|
|
{
|
|
x2 = CLAMP (x2, min_x, max_x);
|
|
y2 = CLAMP (y2, min_y, max_y);
|
|
}
|
|
x1 = MIN (crop->x1, x2);
|
|
y1 = MIN (crop->y1, y2);
|
|
crop->startx = curx;
|
|
crop->starty = cury;
|
|
break;
|
|
|
|
case MOVING:
|
|
if (! options->allow_enlarge)
|
|
{
|
|
inc_x = CLAMP (inc_x, min_x - crop->x1, max_x - crop->x2);
|
|
inc_y = CLAMP (inc_y, min_y - crop->y1, max_y - crop->y2);
|
|
}
|
|
x1 = crop->x1 + inc_x;
|
|
x2 = crop->x2 + inc_x;
|
|
y1 = crop->y1 + inc_y;
|
|
y2 = crop->y2 + inc_y;
|
|
crop->startx = curx;
|
|
crop->starty = cury;
|
|
break;
|
|
}
|
|
|
|
/* make sure that the coords are in bounds */
|
|
crop->x1 = MIN (x1, x2);
|
|
crop->y1 = MIN (y1, y2);
|
|
crop->x2 = MAX (x1, x2);
|
|
crop->y2 = MAX (y1, y2);
|
|
|
|
crop->lastx = curx;
|
|
crop->lasty = cury;
|
|
|
|
/* recalculate the coordinates for crop_draw based on the new values */
|
|
crop_recalc (tool, crop);
|
|
|
|
if (crop->function == CREATING ||
|
|
crop->function == RESIZING_LEFT ||
|
|
crop->function == RESIZING_RIGHT)
|
|
{
|
|
gimp_tool_pop_status (tool);
|
|
|
|
gimp_tool_push_status_coords (tool,
|
|
_("Crop: "),
|
|
crop->x2 - crop->x1,
|
|
" x ",
|
|
crop->y2 - crop->y1);
|
|
}
|
|
|
|
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
|
|
}
|
|
|
|
static void
|
|
gimp_crop_tool_arrow_key (GimpTool *tool,
|
|
GdkEventKey *kevent,
|
|
GimpDisplay *gdisp)
|
|
{
|
|
GimpCropTool *crop;
|
|
CropOptions *options;
|
|
GimpLayer *layer;
|
|
gint inc_x, inc_y;
|
|
gint min_x, min_y;
|
|
gint max_x, max_y;
|
|
|
|
crop = GIMP_CROP_TOOL (tool);
|
|
|
|
options = (CropOptions *) tool->tool_info->tool_options;
|
|
|
|
if (gimp_tool_control_is_active (tool->control))
|
|
{
|
|
inc_x = inc_y = 0;
|
|
|
|
switch (kevent->keyval)
|
|
{
|
|
case GDK_Up : inc_y = -1; break;
|
|
case GDK_Left : inc_x = -1; break;
|
|
case GDK_Right : inc_x = 1; break;
|
|
case GDK_Down : inc_y = 1; break;
|
|
}
|
|
|
|
/* If the shift key is down, move by an accelerated increment */
|
|
if (kevent->state & GDK_SHIFT_MASK)
|
|
{
|
|
inc_y *= ARROW_VELOCITY;
|
|
inc_x *= ARROW_VELOCITY;
|
|
}
|
|
|
|
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
|
|
|
|
if (options->layer_only)
|
|
{
|
|
layer = gimp_image_get_active_layer (gdisp->gimage);
|
|
gimp_drawable_offsets (GIMP_DRAWABLE (layer), &min_x, &min_y);
|
|
max_x = gimp_drawable_width (GIMP_DRAWABLE (layer)) + min_x;
|
|
max_y = gimp_drawable_height (GIMP_DRAWABLE (layer)) + min_y;
|
|
}
|
|
else
|
|
{
|
|
min_x = min_y = 0;
|
|
max_x = gdisp->gimage->width;
|
|
max_y = gdisp->gimage->height;
|
|
}
|
|
|
|
if (kevent->state & GDK_CONTROL_MASK) /* RESIZING */
|
|
{
|
|
crop->x2 = crop->x2 + inc_x;
|
|
crop->y2 = crop->y2 + inc_y;
|
|
if (! options->allow_enlarge)
|
|
{
|
|
crop->x2 = CLAMP (crop->x2, min_x, max_x);
|
|
crop->y2 = CLAMP (crop->y2, min_y, max_y);
|
|
}
|
|
crop->x1 = MIN (crop->x1, crop->x2);
|
|
crop->y1 = MIN (crop->y1, crop->y2);
|
|
}
|
|
else
|
|
{
|
|
if (! options->allow_enlarge)
|
|
{
|
|
inc_x = CLAMP (inc_x,
|
|
-crop->x1, gdisp->gimage->width - crop->x2);
|
|
inc_y = CLAMP (inc_y,
|
|
-crop->y1, gdisp->gimage->height - crop->y2);
|
|
}
|
|
crop->x1 += inc_x;
|
|
crop->x2 += inc_x;
|
|
crop->y1 += inc_y;
|
|
crop->y2 += inc_y;
|
|
}
|
|
|
|
crop_recalc (tool, crop);
|
|
|
|
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
|
|
}
|
|
}
|
|
|
|
static void
|
|
gimp_crop_tool_modifier_key (GimpTool *tool,
|
|
GdkModifierType key,
|
|
gboolean press,
|
|
GdkModifierType state,
|
|
GimpDisplay *gdisp)
|
|
{
|
|
CropOptions *options;
|
|
|
|
options = (CropOptions *) tool->tool_info->tool_options;
|
|
|
|
if (state & GDK_MOD1_MASK)
|
|
{
|
|
if (! options->allow_enlarge)
|
|
{
|
|
gtk_toggle_button_set_active
|
|
(GTK_TOGGLE_BUTTON (options->allow_enlarge_w), TRUE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (options->allow_enlarge)
|
|
{
|
|
gtk_toggle_button_set_active
|
|
(GTK_TOGGLE_BUTTON (options->allow_enlarge_w), FALSE);
|
|
}
|
|
}
|
|
|
|
if (key == GDK_CONTROL_MASK)
|
|
{
|
|
switch (options->type)
|
|
{
|
|
case GIMP_CROP:
|
|
gimp_radio_group_set_active (GTK_RADIO_BUTTON (options->type_w),
|
|
GINT_TO_POINTER (GIMP_RESIZE));
|
|
break;
|
|
case GIMP_RESIZE:
|
|
gimp_radio_group_set_active (GTK_RADIO_BUTTON (options->type_w),
|
|
GINT_TO_POINTER (GIMP_CROP));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
gimp_crop_tool_cursor_update (GimpTool *tool,
|
|
GimpCoords *coords,
|
|
GdkModifierType state,
|
|
GimpDisplay *gdisp)
|
|
{
|
|
GimpCropTool *crop;
|
|
GimpDrawTool *draw_tool;
|
|
CropOptions *options;
|
|
GdkCursorType ctype = GIMP_MOUSE_CURSOR;
|
|
GimpCursorModifier cmodifier = GIMP_CURSOR_MODIFIER_NONE;
|
|
|
|
crop = GIMP_CROP_TOOL (tool);
|
|
draw_tool = GIMP_DRAW_TOOL (tool);
|
|
|
|
options = (CropOptions *) tool->tool_info->tool_options;
|
|
|
|
if (!gimp_tool_control_is_active (tool->control) ||
|
|
(gimp_tool_control_is_active (tool->control) && tool->gdisp != gdisp))
|
|
/* this expression can be simplified to !..._is_active () || t->g != g */
|
|
{
|
|
ctype = GIMP_CROSSHAIR_SMALL_CURSOR;
|
|
}
|
|
else if (gimp_draw_tool_on_handle (draw_tool, gdisp,
|
|
coords->x, coords->y,
|
|
GIMP_HANDLE_SQUARE,
|
|
crop->x1, crop->y1,
|
|
crop->dcw, crop->dch,
|
|
GTK_ANCHOR_NORTH_WEST,
|
|
FALSE) ||
|
|
gimp_draw_tool_on_handle (draw_tool, gdisp,
|
|
coords->x, coords->y,
|
|
GIMP_HANDLE_SQUARE,
|
|
crop->x2, crop->y2,
|
|
crop->dcw, crop->dch,
|
|
GTK_ANCHOR_SOUTH_EAST,
|
|
FALSE))
|
|
{
|
|
cmodifier = GIMP_CURSOR_MODIFIER_RESIZE;
|
|
}
|
|
else if (gimp_draw_tool_on_handle (draw_tool, gdisp,
|
|
coords->x, coords->y,
|
|
GIMP_HANDLE_SQUARE,
|
|
crop->x2, crop->y1,
|
|
crop->dcw, crop->dch,
|
|
GTK_ANCHOR_NORTH_EAST,
|
|
FALSE) ||
|
|
gimp_draw_tool_on_handle (draw_tool, gdisp,
|
|
coords->x, coords->y,
|
|
GIMP_HANDLE_SQUARE,
|
|
crop->x1, crop->y2,
|
|
crop->dcw, crop->dch,
|
|
GTK_ANCHOR_SOUTH_WEST,
|
|
FALSE))
|
|
{
|
|
cmodifier = GIMP_CURSOR_MODIFIER_MOVE;
|
|
}
|
|
else if (! (coords->x > crop->x1 && coords->x < crop->x2 &&
|
|
coords->y > crop->y1 && coords->y < crop->y2))
|
|
{
|
|
ctype = GIMP_CROSSHAIR_SMALL_CURSOR;
|
|
}
|
|
|
|
gimp_tool_control_set_cursor (tool->control, ctype);
|
|
gimp_tool_control_set_tool_cursor (tool->control, (options->type == GIMP_CROP ?
|
|
GIMP_CROP_TOOL_CURSOR :
|
|
GIMP_RESIZE_TOOL_CURSOR));
|
|
gimp_tool_control_set_cursor_modifier (tool->control, cmodifier);
|
|
|
|
GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, gdisp);
|
|
}
|
|
|
|
void
|
|
gimp_crop_tool_draw (GimpDrawTool *draw)
|
|
{
|
|
GimpCropTool *crop;
|
|
GimpTool *tool;
|
|
GimpDisplayShell *shell;
|
|
|
|
crop = GIMP_CROP_TOOL (draw);
|
|
tool = GIMP_TOOL (draw);
|
|
|
|
shell = GIMP_DISPLAY_SHELL (tool->gdisp->shell);
|
|
|
|
gdk_draw_line (draw->win, draw->gc,
|
|
crop->dx1, crop->dy1,
|
|
shell->disp_width, crop->dy1);
|
|
gdk_draw_line (draw->win, draw->gc,
|
|
crop->dx1, crop->dy1,
|
|
crop->dx1, shell->disp_height);
|
|
gdk_draw_line (draw->win, draw->gc,
|
|
crop->dx2, crop->dy2,
|
|
0, crop->dy2);
|
|
gdk_draw_line (draw->win, draw->gc,
|
|
crop->dx2, crop->dy2,
|
|
crop->dx2, 0);
|
|
|
|
gimp_draw_tool_draw_handle (draw,
|
|
GIMP_HANDLE_FILLED_SQUARE,
|
|
crop->x1, crop->y1,
|
|
crop->dcw, crop->dch,
|
|
GTK_ANCHOR_NORTH_WEST,
|
|
FALSE);
|
|
gimp_draw_tool_draw_handle (draw,
|
|
GIMP_HANDLE_FILLED_SQUARE,
|
|
crop->x2, crop->y1,
|
|
crop->dcw, crop->dch,
|
|
GTK_ANCHOR_NORTH_EAST,
|
|
FALSE);
|
|
gimp_draw_tool_draw_handle (draw,
|
|
GIMP_HANDLE_FILLED_SQUARE,
|
|
crop->x1, crop->y2,
|
|
crop->dcw, crop->dch,
|
|
GTK_ANCHOR_SOUTH_WEST,
|
|
FALSE);
|
|
gimp_draw_tool_draw_handle (draw,
|
|
GIMP_HANDLE_FILLED_SQUARE,
|
|
crop->x2, crop->y2,
|
|
crop->dcw, crop->dch,
|
|
GTK_ANCHOR_SOUTH_EAST,
|
|
FALSE);
|
|
|
|
crop_info_update (tool);
|
|
}
|
|
|
|
static void
|
|
crop_tool_crop_image (GimpImage *gimage,
|
|
gint x1,
|
|
gint y1,
|
|
gint x2,
|
|
gint y2,
|
|
gboolean layer_only,
|
|
gboolean crop_layers)
|
|
{
|
|
if (!(x2 - x1) || !(y2 - y1))
|
|
return;
|
|
|
|
gimp_image_crop (gimage,
|
|
x1, y1, x2, y2,
|
|
layer_only,
|
|
crop_layers);
|
|
}
|
|
|
|
static void
|
|
crop_recalc (GimpTool *tool,
|
|
GimpCropTool *crop)
|
|
{
|
|
gdisplay_transform_coords (tool->gdisp,
|
|
crop->x1, crop->y1,
|
|
&crop->dx1, &crop->dy1,
|
|
FALSE);
|
|
gdisplay_transform_coords (tool->gdisp,
|
|
crop->x2, crop->y2,
|
|
&crop->dx2, &crop->dy2,
|
|
FALSE);
|
|
|
|
#define SRW 10
|
|
#define SRH 10
|
|
|
|
crop->dcw = ((crop->dx2 - crop->dx1) < SRW) ? (crop->dx2 - crop->dx1) : SRW;
|
|
crop->dch = ((crop->dy2 - crop->dy1) < SRH) ? (crop->dy2 - crop->dy1) : SRH;
|
|
|
|
#undef SRW
|
|
#undef SRH
|
|
}
|
|
|
|
static void
|
|
crop_start (GimpTool *tool,
|
|
GimpCropTool *crop)
|
|
{
|
|
static GimpDisplay *old_gdisp = NULL;
|
|
|
|
crop_recalc (tool, crop);
|
|
|
|
if (! crop_info)
|
|
crop_info_create (tool);
|
|
|
|
g_signal_handlers_block_by_func (G_OBJECT (origin_sizeentry),
|
|
crop_origin_changed,
|
|
crop_info);
|
|
g_signal_handlers_block_by_func (G_OBJECT (size_sizeentry),
|
|
crop_size_changed,
|
|
crop_info);
|
|
|
|
gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (origin_sizeentry), 0,
|
|
tool->gdisp->gimage->xresolution, FALSE);
|
|
gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (origin_sizeentry), 1,
|
|
tool->gdisp->gimage->yresolution, FALSE);
|
|
|
|
gimp_size_entry_set_size (GIMP_SIZE_ENTRY (origin_sizeentry), 0,
|
|
0, tool->gdisp->gimage->width);
|
|
gimp_size_entry_set_size (GIMP_SIZE_ENTRY (origin_sizeentry), 1,
|
|
0, tool->gdisp->gimage->height);
|
|
|
|
gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (size_sizeentry), 0,
|
|
tool->gdisp->gimage->xresolution, FALSE);
|
|
gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (size_sizeentry), 1,
|
|
tool->gdisp->gimage->yresolution, FALSE);
|
|
|
|
gimp_size_entry_set_size (GIMP_SIZE_ENTRY (size_sizeentry), 0,
|
|
0, tool->gdisp->gimage->width);
|
|
gimp_size_entry_set_size (GIMP_SIZE_ENTRY (size_sizeentry), 1,
|
|
0, tool->gdisp->gimage->height);
|
|
|
|
if (old_gdisp != tool->gdisp)
|
|
{
|
|
gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (origin_sizeentry),
|
|
tool->gdisp->gimage->unit) ;
|
|
gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (size_sizeentry),
|
|
tool->gdisp->gimage->unit);
|
|
|
|
if (tool->gdisp->dot_for_dot)
|
|
{
|
|
gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (origin_sizeentry),
|
|
GIMP_UNIT_PIXEL);
|
|
gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (size_sizeentry),
|
|
GIMP_UNIT_PIXEL);
|
|
}
|
|
}
|
|
|
|
g_signal_handlers_unblock_by_func (G_OBJECT (origin_sizeentry),
|
|
crop_origin_changed,
|
|
crop_info);
|
|
g_signal_handlers_unblock_by_func (G_OBJECT (size_sizeentry),
|
|
crop_size_changed,
|
|
crop_info);
|
|
|
|
old_gdisp = tool->gdisp;
|
|
|
|
/* initialize the statusbar display */
|
|
gimp_tool_push_status (tool, _("Crop: 0 x 0"));
|
|
|
|
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), tool->gdisp);
|
|
}
|
|
|
|
|
|
/***************************/
|
|
/* Crop dialog functions */
|
|
/***************************/
|
|
|
|
static void
|
|
crop_info_create (GimpTool *tool)
|
|
{
|
|
GimpDisplay *gdisp;
|
|
GtkWidget *spinbutton;
|
|
GtkWidget *bbox;
|
|
GtkWidget *button;
|
|
|
|
gdisp = (GimpDisplay *) tool->gdisp;
|
|
|
|
/* create the info dialog */
|
|
crop_info = info_dialog_new (_("Crop & Resize Information"),
|
|
tool_manager_help_func, NULL);
|
|
|
|
/* create the action area */
|
|
gimp_dialog_create_action_area (GIMP_DIALOG (crop_info->shell),
|
|
|
|
GTK_STOCK_CLOSE, crop_close_callback,
|
|
NULL, NULL, NULL, FALSE, FALSE,
|
|
|
|
_("Resize"), crop_resize_callback,
|
|
NULL, NULL, NULL, FALSE, FALSE,
|
|
|
|
_("Crop"), crop_crop_callback,
|
|
NULL, NULL, NULL, TRUE, FALSE,
|
|
|
|
NULL);
|
|
|
|
/* add the information fields */
|
|
spinbutton = info_dialog_add_spinbutton (crop_info, _("Origin X:"), NULL,
|
|
-1, 1, 1, 10, 1, 1, 2, NULL, NULL);
|
|
origin_sizeentry =
|
|
info_dialog_add_sizeentry (crop_info, _("Y:"), orig_vals, 1,
|
|
gdisp->dot_for_dot ?
|
|
GIMP_UNIT_PIXEL : gdisp->gimage->unit, "%a",
|
|
TRUE, TRUE, FALSE, GIMP_SIZE_ENTRY_UPDATE_SIZE,
|
|
G_CALLBACK (crop_origin_changed),
|
|
crop_info);
|
|
gimp_size_entry_add_field (GIMP_SIZE_ENTRY (origin_sizeentry),
|
|
GTK_SPIN_BUTTON (spinbutton), NULL);
|
|
|
|
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (origin_sizeentry), 0,
|
|
-65536, 65536);
|
|
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (origin_sizeentry), 1,
|
|
-65536, 65536);
|
|
|
|
spinbutton = info_dialog_add_spinbutton (crop_info, _("Width:"), NULL,
|
|
-1, 1, 1, 10, 1, 1, 2, NULL, NULL);
|
|
size_sizeentry =
|
|
info_dialog_add_sizeentry (crop_info, _("Height:"), size_vals, 1,
|
|
gdisp->dot_for_dot ?
|
|
GIMP_UNIT_PIXEL : gdisp->gimage->unit, "%a",
|
|
TRUE, TRUE, FALSE, GIMP_SIZE_ENTRY_UPDATE_SIZE,
|
|
G_CALLBACK (crop_size_changed),
|
|
crop_info);
|
|
gimp_size_entry_add_field (GIMP_SIZE_ENTRY (size_sizeentry),
|
|
GTK_SPIN_BUTTON (spinbutton), NULL);
|
|
|
|
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (size_sizeentry), 0,
|
|
-65536, 65536);
|
|
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (size_sizeentry), 1,
|
|
-65536, 65536);
|
|
|
|
gtk_table_set_row_spacing (GTK_TABLE (crop_info->info_table), 0, 0);
|
|
gtk_table_set_row_spacing (GTK_TABLE (crop_info->info_table), 1, 6);
|
|
gtk_table_set_row_spacing (GTK_TABLE (crop_info->info_table), 2, 0);
|
|
|
|
/* Create the area selection buttons */
|
|
bbox = gtk_hbutton_box_new ();
|
|
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_SPREAD);
|
|
gtk_box_set_spacing (GTK_BOX (bbox), 4);
|
|
|
|
button = gtk_button_new_with_label (_("From Selection"));
|
|
gtk_container_add (GTK_CONTAINER(bbox), button);
|
|
g_signal_connect (G_OBJECT (button) , "clicked",
|
|
G_CALLBACK (crop_selection_callback),
|
|
NULL);
|
|
gtk_widget_show (button);
|
|
|
|
button = gtk_button_new_with_label (_("Auto Shrink"));
|
|
gtk_container_add (GTK_CONTAINER (bbox), button);
|
|
g_signal_connect (G_OBJECT (button) , "clicked",
|
|
G_CALLBACK (crop_automatic_callback),
|
|
NULL);
|
|
gtk_widget_show (button);
|
|
|
|
gtk_box_pack_start (GTK_BOX (crop_info->vbox), bbox, FALSE, FALSE, 2);
|
|
gtk_widget_show (bbox);
|
|
}
|
|
|
|
static void
|
|
crop_info_update (GimpTool *tool)
|
|
{
|
|
GimpCropTool *crop;
|
|
|
|
crop = GIMP_CROP_TOOL (tool);
|
|
|
|
orig_vals[0] = crop->x1;
|
|
orig_vals[1] = crop->y1;
|
|
size_vals[0] = crop->x2 - crop->x1;
|
|
size_vals[1] = crop->y2 - crop->y1;
|
|
|
|
info_dialog_update (crop_info);
|
|
info_dialog_popup (crop_info);
|
|
}
|
|
|
|
static void
|
|
crop_crop_callback (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
GimpTool *tool;
|
|
|
|
/* XXX active_tool is bad */
|
|
tool = tool_manager_get_active (the_gimp);
|
|
|
|
if (GIMP_IS_CROP_TOOL (tool))
|
|
{
|
|
GimpCropTool *crop;
|
|
CropOptions *options;
|
|
|
|
crop = GIMP_CROP_TOOL (tool);
|
|
|
|
options = (CropOptions *) tool->tool_info->tool_options;
|
|
|
|
crop_tool_crop_image (tool->gdisp->gimage,
|
|
crop->x1, crop->y1,
|
|
crop->x2, crop->y2,
|
|
options->layer_only,
|
|
TRUE);
|
|
}
|
|
|
|
/* Finish the tool */
|
|
crop_close_callback (NULL, NULL);
|
|
}
|
|
|
|
static void
|
|
crop_resize_callback (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
GimpTool *tool;
|
|
|
|
/* XXX active_tool is bad */
|
|
tool = tool_manager_get_active (the_gimp);
|
|
|
|
if (GIMP_IS_CROP_TOOL (tool))
|
|
{
|
|
GimpCropTool *crop;
|
|
CropOptions *options;
|
|
|
|
crop = GIMP_CROP_TOOL (tool);
|
|
|
|
options = (CropOptions *) tool->tool_info->tool_options;
|
|
|
|
crop_tool_crop_image (tool->gdisp->gimage,
|
|
crop->x1, crop->y1,
|
|
crop->x2, crop->y2,
|
|
options->layer_only,
|
|
FALSE);
|
|
}
|
|
|
|
/* Finish the tool */
|
|
crop_close_callback (NULL, NULL);
|
|
}
|
|
|
|
static void
|
|
crop_close_callback (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
GimpTool *tool;
|
|
|
|
/* XXX active_tool is bad */
|
|
tool = tool_manager_get_active (the_gimp);
|
|
|
|
if (GIMP_IS_CROP_TOOL (tool))
|
|
{
|
|
if (gimp_tool_control_is_active (tool->control))
|
|
gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool));
|
|
|
|
gimp_tool_control_halt (tool->control); /* sets paused_count to 0 -- is this ok? */
|
|
}
|
|
|
|
info_dialog_popdown (crop_info);
|
|
}
|
|
|
|
static void
|
|
crop_selection_callback (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
GimpTool *tool;
|
|
|
|
/* XXX active_tool is bad */
|
|
tool = tool_manager_get_active (the_gimp);
|
|
|
|
if (GIMP_IS_CROP_TOOL (tool))
|
|
{
|
|
GimpCropTool *crop;
|
|
CropOptions *options;
|
|
GimpLayer *layer;
|
|
GimpDisplay *gdisp;
|
|
|
|
crop = GIMP_CROP_TOOL (tool);
|
|
|
|
options = (CropOptions *) tool->tool_info->tool_options;
|
|
|
|
gdisp = tool->gdisp;
|
|
|
|
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
|
|
|
|
if (! gimp_image_mask_bounds (gdisp->gimage,
|
|
&crop->x1, &crop->y1,
|
|
&crop->x2, &crop->y2))
|
|
{
|
|
if (options->layer_only)
|
|
{
|
|
layer = gimp_image_get_active_layer (gdisp->gimage);
|
|
gimp_drawable_offsets (GIMP_DRAWABLE (layer),
|
|
&crop->x1, &crop->y1);
|
|
crop->x2 = gimp_drawable_width (GIMP_DRAWABLE (layer)) + crop->x1;
|
|
crop->y2 = gimp_drawable_height (GIMP_DRAWABLE (layer)) + crop->y1;
|
|
}
|
|
else
|
|
{
|
|
crop->x1 = crop->y1 = 0;
|
|
crop->x2 = gdisp->gimage->width;
|
|
crop->y2 = gdisp->gimage->height;
|
|
}
|
|
}
|
|
|
|
crop_recalc (tool, crop);
|
|
|
|
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
|
|
}
|
|
}
|
|
|
|
static void
|
|
crop_automatic_callback (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
GimpTool *tool;
|
|
|
|
/* FIXME: active_tool is bad */
|
|
tool = tool_manager_get_active (the_gimp);
|
|
|
|
if (GIMP_IS_CROP_TOOL (tool))
|
|
{
|
|
GimpCropTool *crop;
|
|
CropOptions *options;
|
|
GimpDisplay *gdisp;
|
|
GimpDrawable *active_drawable;
|
|
gint offset_x, offset_y;
|
|
gint width, height;
|
|
gint x1, y1, x2, y2;
|
|
gint shrunk_x1;
|
|
gint shrunk_y1;
|
|
gint shrunk_x2;
|
|
gint shrunk_y2;
|
|
|
|
crop = GIMP_CROP_TOOL (tool);
|
|
|
|
options = (CropOptions *) tool->tool_info->tool_options;
|
|
|
|
gdisp = tool->gdisp;
|
|
|
|
if (options->layer_only)
|
|
{
|
|
active_drawable = gimp_image_active_drawable (gdisp->gimage);
|
|
|
|
if (! active_drawable)
|
|
return;
|
|
|
|
width = gimp_drawable_width (GIMP_DRAWABLE (active_drawable));
|
|
height = gimp_drawable_height (GIMP_DRAWABLE (active_drawable));
|
|
gimp_drawable_offsets (GIMP_DRAWABLE (active_drawable),
|
|
&offset_x, &offset_y);
|
|
}
|
|
else
|
|
{
|
|
width = gdisp->gimage->width;
|
|
height = gdisp->gimage->height;
|
|
offset_x = 0;
|
|
offset_y = 0;
|
|
}
|
|
|
|
x1 = crop->x1 - offset_x > 0 ? crop->x1 - offset_x : 0;
|
|
x2 = crop->x2 - offset_x < width ? crop->x2 - offset_x : width;
|
|
y1 = crop->y1 - offset_y > 0 ? crop->y1 - offset_y : 0;
|
|
y2 = crop->y2 - offset_y < height ? crop->y2 - offset_y : height;
|
|
|
|
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
|
|
|
|
if (gimp_image_crop_auto_shrink (gdisp->gimage,
|
|
x1, y1, x2, y2,
|
|
options->layer_only,
|
|
&shrunk_x1,
|
|
&shrunk_y1,
|
|
&shrunk_x2,
|
|
&shrunk_y2))
|
|
{
|
|
crop->x1 = offset_x + shrunk_x1;
|
|
crop->x2 = offset_x + shrunk_x2;
|
|
crop->y1 = offset_y + shrunk_y1;
|
|
crop->y2 = offset_y + shrunk_y2;
|
|
|
|
crop_recalc (tool, crop);
|
|
}
|
|
|
|
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
|
|
}
|
|
}
|
|
|
|
static void
|
|
crop_origin_changed (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
GimpTool *tool;
|
|
GimpCropTool *crop;
|
|
gint ox;
|
|
gint oy;
|
|
|
|
/* XXX active_tool is bad */
|
|
tool = tool_manager_get_active (the_gimp);
|
|
|
|
if (GIMP_IS_CROP_TOOL (tool))
|
|
{
|
|
crop = GIMP_CROP_TOOL (tool);
|
|
|
|
ox = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0));
|
|
oy = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1));
|
|
|
|
if ((ox != crop->x1) ||
|
|
(oy != crop->y1))
|
|
{
|
|
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
|
|
|
|
crop->x2 = crop->x2 + (ox - crop->x1);
|
|
crop->x1 = ox;
|
|
crop->y2 = crop->y2 + (oy - crop->y1);
|
|
crop->y1 = oy;
|
|
|
|
crop_recalc (tool, crop);
|
|
|
|
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
crop_size_changed (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
GimpTool *tool;
|
|
GimpCropTool *crop;
|
|
gint sx;
|
|
gint sy;
|
|
|
|
/* XXX active_tool is bad */
|
|
tool = tool_manager_get_active (the_gimp);
|
|
|
|
if (GIMP_IS_CROP_TOOL (tool))
|
|
{
|
|
crop = GIMP_CROP_TOOL (tool);
|
|
|
|
sx = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0);
|
|
sy = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1);
|
|
|
|
if ((sx != (crop->x2 - crop->x1)) ||
|
|
(sy != (crop->y2 - crop->y1)))
|
|
{
|
|
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
|
|
|
|
crop->x2 = sx + crop->x1;
|
|
crop->y2 = sy + crop->y1;
|
|
|
|
crop_recalc (tool, crop);
|
|
|
|
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* tool options stuff */
|
|
|
|
static GimpToolOptions *
|
|
crop_options_new (GimpToolInfo *tool_info)
|
|
{
|
|
CropOptions *options;
|
|
GtkWidget *vbox;
|
|
GtkWidget *frame;
|
|
|
|
options = g_new0 (CropOptions, 1);
|
|
|
|
tool_options_init ((GimpToolOptions *) options, tool_info);
|
|
|
|
((GimpToolOptions *) options)->reset_func = crop_options_reset;
|
|
|
|
options->layer_only = options->layer_only_d = FALSE;
|
|
options->allow_enlarge = options->allow_enlarge_d = FALSE;
|
|
options->type = options->type_d = GIMP_CROP;
|
|
|
|
/* the main vbox */
|
|
vbox = options->tool_options.main_vbox;
|
|
|
|
/* tool toggle */
|
|
frame = gimp_enum_radio_frame_new (GIMP_TYPE_CROP_TYPE,
|
|
gtk_label_new (_("Tool Toggle (<Ctrl>)")),
|
|
2,
|
|
G_CALLBACK (gimp_radio_button_update),
|
|
&options->type,
|
|
&options->type_w);
|
|
gimp_radio_group_set_active (GTK_RADIO_BUTTON (options->type_w),
|
|
GINT_TO_POINTER (options->type));
|
|
|
|
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
|
|
gtk_widget_show (frame);
|
|
|
|
/* layer toggle */
|
|
options->layer_only_w =
|
|
gtk_check_button_new_with_label (_("Current Layer only"));
|
|
gtk_box_pack_start (GTK_BOX (vbox), options->layer_only_w,
|
|
FALSE, FALSE, 0);
|
|
g_signal_connect (G_OBJECT (options->layer_only_w), "toggled",
|
|
G_CALLBACK (gimp_toggle_button_update),
|
|
&options->layer_only);
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->layer_only_w),
|
|
options->layer_only);
|
|
gtk_widget_show (options->layer_only_w);
|
|
|
|
/* enlarge toggle */
|
|
options->allow_enlarge_w =
|
|
gtk_check_button_new_with_label (_("Allow Enlarging (<Alt>)"));
|
|
gtk_box_pack_start (GTK_BOX (vbox), options->allow_enlarge_w,
|
|
FALSE, FALSE, 0);
|
|
g_signal_connect (G_OBJECT (options->allow_enlarge_w), "toggled",
|
|
G_CALLBACK (gimp_toggle_button_update),
|
|
&options->allow_enlarge);
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->allow_enlarge_w),
|
|
options->allow_enlarge);
|
|
gtk_widget_show (options->allow_enlarge_w);
|
|
|
|
return (GimpToolOptions *) options;
|
|
}
|
|
|
|
static void
|
|
crop_options_reset (GimpToolOptions *tool_options)
|
|
{
|
|
CropOptions *options;
|
|
|
|
options = (CropOptions *) tool_options;
|
|
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->layer_only_w),
|
|
options->layer_only_d);
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(options->allow_enlarge_w),
|
|
options->allow_enlarge_d);
|
|
|
|
gimp_radio_group_set_active (GTK_RADIO_BUTTON (options->type_w),
|
|
GINT_TO_POINTER (options->type_d));
|
|
}
|