mirror of
https://gitlab.gnome.org/GNOME/gimp
synced 2024-10-22 20:41:43 +00:00
17335326d5
2001-02-24 Michael Natterer <mitch@gimp.org> * TODO.xml: updated. * app/appenums.h * app/apptypes.h: prefixed the cursor stuff with "Gimp", added the new stock tool cursor enum. Removed the old ToolType enum. * app/cursorutil.[ch] * app/gdisplay.[ch]: removed the old ToolType enum and prefixed the functions with "gimp_". Also stripped all "toggle cursor" stuff from the cursor code, so the new API is easier and not depending on the tool system. All existing tool cursors can be used via the new stock tool cursor enum, so no tool has to fiddle around with bitmap cursors. There will be an cursorutil function for registering stock tool cursor types on the fly. * app/disp_callbacks.c * app/scroll.[ch]: moved the display scrollbar callbacks from scroll.[ch] to disp_callbacks.c. Removed some crap from scroll.h * app/tools/tool.[ch]: removed the BitmapCursor pointers from the tool class struct and add cursor and toggle cursor IDs to the GimpTool struct. Work in progress. * app/dialog_handler.c * app/tools/bezier_select.c * app/tools/blend.c * app/tools/bucket_fill.c * app/tools/by_color_select.c * app/tools/clone.c * app/tools/color_picker.c * app/tools/convolve.c * app/tools/crop.c * app/tools/dodgeburn.c * app/tools/edit_selection.c * app/tools/ellipse_select.c * app/tools/flip_tool.c * app/tools/free_select.c * app/tools/fuzzy_select.c * app/tools/ink.c * app/tools/iscissors.c * app/tools/magnify.c * app/tools/measure.c * app/tools/move.c * app/tools/paint_core.[ch] * app/tools/perspective_tool.c * app/tools/rect_select.c * app/tools/rotate_tool.c * app/tools/scale_tool.c * app/tools/shear_tool.c * app/tools/text_tool.c * app/tools/transform_core.[ch]: changed accordingly. Did this "blind" for most tools because they don't compile. The changes are minimal, so there should be no conflicts.
419 lines
11 KiB
C
419 lines
11 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 "libgimpmath/gimpmath.h"
|
|
#include "libgimpwidgets/gimpwidgets.h"
|
|
|
|
#include "apptypes.h"
|
|
|
|
#include "draw_core.h"
|
|
#include "drawable.h"
|
|
#include "gdisplay.h"
|
|
#include "gimage_mask.h"
|
|
#include "gimpimage.h"
|
|
#include "gimpprogress.h"
|
|
#include "info_dialog.h"
|
|
#include "selection.h"
|
|
#include "tile_manager.h"
|
|
#include "undo.h"
|
|
|
|
#include "rotate_tool.h"
|
|
#include "tool_options.h"
|
|
#include "tools.h"
|
|
#include "transform_core.h"
|
|
#include "transform_tool.h"
|
|
|
|
#include "libgimp/gimpintl.h"
|
|
|
|
|
|
/* index into trans_info array */
|
|
#define ANGLE 0
|
|
#define REAL_ANGLE 1
|
|
#define CENTER_X 2
|
|
#define CENTER_Y 3
|
|
|
|
#define EPSILON 0.018 /* ~ 1 degree */
|
|
#define FIFTEEN_DEG (G_PI / 12.0)
|
|
|
|
|
|
/* forward function declarations */
|
|
static TileManager * rotate_tool_transform (Tool *tool,
|
|
GDisplay *gdisp,
|
|
TransformState state);
|
|
|
|
static void rotate_tool_recalc (Tool *tool,
|
|
GDisplay *gdisp);
|
|
static void rotate_tool_motion (Tool *tool,
|
|
GDisplay *gdisp);
|
|
static void rotate_info_update (Tool *tool);
|
|
|
|
static void rotate_angle_changed (GtkWidget *entry,
|
|
gpointer data);
|
|
static void rotate_center_changed (GtkWidget *entry,
|
|
gpointer data);
|
|
|
|
|
|
/* variables local to this file */
|
|
static gdouble angle_val;
|
|
static gdouble center_vals[2];
|
|
|
|
/* needed for size update */
|
|
static GtkWidget *sizeentry = NULL;
|
|
|
|
|
|
static TileManager *
|
|
rotate_tool_transform (Tool *tool,
|
|
GDisplay *gdisp,
|
|
TransformState state)
|
|
{
|
|
TransformCore *transform_core;
|
|
GtkWidget *widget;
|
|
GtkWidget *spinbutton2;
|
|
|
|
transform_core = (TransformCore *) tool->private;
|
|
|
|
switch (state)
|
|
{
|
|
case TRANSFORM_INIT:
|
|
angle_val = 0.0;
|
|
center_vals[0] = transform_core->cx;
|
|
center_vals[1] = transform_core->cy;
|
|
|
|
if (!transform_info)
|
|
{
|
|
transform_info = info_dialog_new (_("Rotation Information"),
|
|
gimp_standard_help_func,
|
|
"tools/transform_rotate.html");
|
|
|
|
widget =
|
|
info_dialog_add_spinbutton (transform_info, _("Angle:"),
|
|
&angle_val,
|
|
-180, 180, 1, 15, 1, 1, 2,
|
|
(GtkSignalFunc) rotate_angle_changed,
|
|
tool);
|
|
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (widget), TRUE);
|
|
|
|
/* this looks strange (-180, 181), but it works */
|
|
widget = info_dialog_add_scale (transform_info, "", &angle_val,
|
|
-180, 181, 0.01, 0.1, 1, -1,
|
|
(GtkSignalFunc) rotate_angle_changed,
|
|
tool);
|
|
gtk_widget_set_usize (widget, 180, 0);
|
|
|
|
spinbutton2 =
|
|
info_dialog_add_spinbutton (transform_info, _("Center X:"), NULL,
|
|
-1, 1, 1, 10, 1, 1, 2, NULL, NULL);
|
|
sizeentry =
|
|
info_dialog_add_sizeentry (transform_info, _("Y:"),
|
|
center_vals, 1,
|
|
gdisp->gimage->unit, "%a",
|
|
TRUE, TRUE, FALSE,
|
|
GIMP_SIZE_ENTRY_UPDATE_SIZE,
|
|
rotate_center_changed, tool);
|
|
|
|
gimp_size_entry_add_field (GIMP_SIZE_ENTRY (sizeentry),
|
|
GTK_SPIN_BUTTON (spinbutton2), NULL);
|
|
|
|
gtk_table_set_row_spacing (GTK_TABLE (transform_info->info_table),
|
|
1, 6);
|
|
gtk_table_set_row_spacing (GTK_TABLE (transform_info->info_table),
|
|
2, 0);
|
|
}
|
|
|
|
gtk_signal_handler_block_by_data (GTK_OBJECT (sizeentry), tool);
|
|
|
|
gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (sizeentry),
|
|
gdisp->gimage->unit);
|
|
if (gdisp->dot_for_dot)
|
|
gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (sizeentry), GIMP_UNIT_PIXEL);
|
|
|
|
gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (sizeentry), 0,
|
|
gdisp->gimage->xresolution, FALSE);
|
|
gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (sizeentry), 1,
|
|
gdisp->gimage->yresolution, FALSE);
|
|
|
|
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (sizeentry), 0,
|
|
-65536,
|
|
65536 + gdisp->gimage->width);
|
|
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (sizeentry), 1,
|
|
-65536,
|
|
65536 + gdisp->gimage->height);
|
|
|
|
gimp_size_entry_set_size (GIMP_SIZE_ENTRY (sizeentry), 0,
|
|
transform_core->x1, transform_core->x2);
|
|
gimp_size_entry_set_size (GIMP_SIZE_ENTRY (sizeentry), 1,
|
|
transform_core->y1, transform_core->y2);
|
|
|
|
gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (sizeentry), 0,
|
|
center_vals[0]);
|
|
gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (sizeentry), 1,
|
|
center_vals[1]);
|
|
|
|
gtk_widget_set_sensitive (transform_info->shell, TRUE);
|
|
|
|
gtk_signal_handler_unblock_by_data (GTK_OBJECT (sizeentry), tool);
|
|
|
|
transform_core->trans_info[ANGLE] = angle_val;
|
|
transform_core->trans_info[REAL_ANGLE] = angle_val;
|
|
transform_core->trans_info[CENTER_X] = center_vals[0];
|
|
transform_core->trans_info[CENTER_Y] = center_vals[1];
|
|
|
|
return NULL;
|
|
break;
|
|
|
|
case TRANSFORM_MOTION:
|
|
rotate_tool_motion (tool, gdisp);
|
|
rotate_tool_recalc (tool, gdisp);
|
|
break;
|
|
|
|
case TRANSFORM_RECALC:
|
|
rotate_tool_recalc (tool, gdisp);
|
|
break;
|
|
|
|
case TRANSFORM_FINISH:
|
|
gtk_widget_set_sensitive (GTK_WIDGET (transform_info->shell), FALSE);
|
|
return rotate_tool_rotate (gdisp->gimage,
|
|
gimp_image_active_drawable (gdisp->gimage),
|
|
gdisp,
|
|
transform_core->trans_info[ANGLE],
|
|
transform_core->original,
|
|
transform_tool_smoothing (),
|
|
transform_core->transform);
|
|
break;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
Tool *
|
|
tools_new_rotate_tool (void)
|
|
{
|
|
Tool *tool;
|
|
TransformCore *private;
|
|
|
|
tool = transform_core_new (ROTATE, TRUE);
|
|
|
|
tool->tool_cursor = GIMP_ROTATE_TOOL_CURSOR;
|
|
|
|
private = tool->private;
|
|
|
|
/* set the rotation specific transformation attributes */
|
|
private->trans_func = rotate_tool_transform;
|
|
private->trans_info[ANGLE] = 0.0;
|
|
private->trans_info[REAL_ANGLE] = 0.0;
|
|
private->trans_info[CENTER_X] = 0.0;
|
|
private->trans_info[CENTER_Y] = 0.0;
|
|
|
|
/* assemble the transformation matrix */
|
|
gimp_matrix3_identity (private->transform);
|
|
|
|
return tool;
|
|
}
|
|
|
|
void
|
|
tools_free_rotate_tool (Tool *tool)
|
|
{
|
|
transform_core_free (tool);
|
|
}
|
|
|
|
static void
|
|
rotate_info_update (Tool *tool)
|
|
{
|
|
TransformCore *transform_core;
|
|
|
|
transform_core = (TransformCore *) tool->private;
|
|
|
|
angle_val = gimp_rad_to_deg (transform_core->trans_info[ANGLE]);
|
|
center_vals[0] = transform_core->cx;
|
|
center_vals[1] = transform_core->cy;
|
|
|
|
info_dialog_update (transform_info);
|
|
info_dialog_popup (transform_info);
|
|
}
|
|
|
|
static void
|
|
rotate_angle_changed (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
Tool *tool;
|
|
TransformCore *transform_core;
|
|
gdouble value;
|
|
|
|
tool = (Tool *) data;
|
|
|
|
if (tool)
|
|
{
|
|
transform_core = (TransformCore *) tool->private;
|
|
|
|
value = gimp_deg_to_rad (GTK_ADJUSTMENT (widget)->value);
|
|
|
|
if (value != transform_core->trans_info[ANGLE])
|
|
{
|
|
draw_core_pause (transform_core->core, tool);
|
|
transform_core->trans_info[ANGLE] = value;
|
|
rotate_tool_recalc (tool, tool->gdisp);
|
|
draw_core_resume (transform_core->core, tool);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
rotate_center_changed (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
Tool *tool;
|
|
TransformCore *transform_core;
|
|
gint cx;
|
|
gint cy;
|
|
|
|
tool = (Tool *) data;
|
|
|
|
if (tool)
|
|
{
|
|
transform_core = (TransformCore *) tool->private;
|
|
|
|
cx = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0));
|
|
cy = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1));
|
|
|
|
if ((cx != transform_core->cx) ||
|
|
(cy != transform_core->cy))
|
|
{
|
|
draw_core_pause (transform_core->core, tool);
|
|
transform_core->cx = cx;
|
|
transform_core->cy = cy;
|
|
rotate_tool_recalc (tool, tool->gdisp);
|
|
draw_core_resume (transform_core->core, tool);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
rotate_tool_motion (Tool *tool,
|
|
GDisplay *gdisp)
|
|
{
|
|
TransformCore *transform_core;
|
|
gdouble angle1, angle2, angle;
|
|
gdouble cx, cy;
|
|
gdouble x1, y1, x2, y2;
|
|
|
|
transform_core = (TransformCore *) tool->private;
|
|
|
|
if (transform_core->function == TRANSFORM_HANDLE_CENTER)
|
|
{
|
|
transform_core->cx = transform_core->curx;
|
|
transform_core->cy = transform_core->cury;
|
|
|
|
return;
|
|
}
|
|
|
|
cx = transform_core->cx;
|
|
cy = transform_core->cy;
|
|
|
|
x1 = transform_core->curx - cx;
|
|
x2 = transform_core->lastx - cx;
|
|
y1 = cy - transform_core->cury;
|
|
y2 = cy - transform_core->lasty;
|
|
|
|
/* find the first angle */
|
|
angle1 = atan2 (y1, x1);
|
|
|
|
/* find the angle */
|
|
angle2 = atan2 (y2, x2);
|
|
|
|
angle = angle2 - angle1;
|
|
|
|
if (angle > G_PI || angle < -G_PI)
|
|
angle = angle2 - ((angle1 < 0) ? 2.0 * G_PI + angle1 : angle1 - 2.0 * G_PI);
|
|
|
|
/* increment the transform tool's angle */
|
|
transform_core->trans_info[REAL_ANGLE] += angle;
|
|
|
|
/* limit the angle to between 0 and 360 degrees */
|
|
if (transform_core->trans_info[REAL_ANGLE] < - G_PI)
|
|
transform_core->trans_info[REAL_ANGLE] =
|
|
2.0 * G_PI - transform_core->trans_info[REAL_ANGLE];
|
|
else if (transform_core->trans_info[REAL_ANGLE] > G_PI)
|
|
transform_core->trans_info[REAL_ANGLE] =
|
|
transform_core->trans_info[REAL_ANGLE] - 2.0 * G_PI;
|
|
|
|
/* constrain the angle to 15-degree multiples if ctrl is held down */
|
|
if (transform_core->state & GDK_CONTROL_MASK)
|
|
transform_core->trans_info[ANGLE] =
|
|
FIFTEEN_DEG * (int) ((transform_core->trans_info[REAL_ANGLE] +
|
|
FIFTEEN_DEG / 2.0) /
|
|
FIFTEEN_DEG);
|
|
else
|
|
transform_core->trans_info[ANGLE] = transform_core->trans_info[REAL_ANGLE];
|
|
}
|
|
|
|
static void
|
|
rotate_tool_recalc (Tool *tool,
|
|
GDisplay *gdisp)
|
|
{
|
|
TransformCore *transform_core;
|
|
gdouble cx, cy;
|
|
|
|
transform_core = (TransformCore *) tool->private;
|
|
|
|
cx = transform_core->cx;
|
|
cy = transform_core->cy;
|
|
|
|
/* assemble the transformation matrix */
|
|
gimp_matrix3_identity (transform_core->transform);
|
|
gimp_matrix3_translate (transform_core->transform, -cx, -cy);
|
|
gimp_matrix3_rotate (transform_core->transform,
|
|
transform_core->trans_info[ANGLE]);
|
|
gimp_matrix3_translate (transform_core->transform, +cx, +cy);
|
|
|
|
/* transform the bounding box */
|
|
transform_core_transform_bounding_box (tool);
|
|
|
|
/* update the information dialog */
|
|
rotate_info_update (tool);
|
|
}
|
|
|
|
TileManager *
|
|
rotate_tool_rotate (GImage *gimage,
|
|
GimpDrawable *drawable,
|
|
GDisplay *gdisp,
|
|
gdouble angle,
|
|
TileManager *float_tiles,
|
|
gboolean interpolation,
|
|
GimpMatrix3 matrix)
|
|
{
|
|
GimpProgress *progress;
|
|
TileManager *ret;
|
|
|
|
progress = progress_start (gdisp, _("Rotating..."), FALSE, NULL, NULL);
|
|
|
|
ret = transform_core_do (gimage, drawable, float_tiles,
|
|
interpolation, matrix,
|
|
progress ? progress_update_and_flush :
|
|
(GimpProgressFunc) NULL,
|
|
progress);
|
|
|
|
if (progress)
|
|
progress_end (progress);
|
|
|
|
return ret;
|
|
}
|