dallasgroot/Gimp
dallasgroot/Gimp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Gimp/app/tools/gimptransformgridtool.h

119 lines
5.5 KiB
C
Raw Normal View History

app: add GimpTransformGridTool; derive most transform tools from it While most of our transform tools use an interactive transform grid, and have similar behavior, the flip tool is an odd one out. The new "auto straighten" function of the measure tool introduces another tool that performs transformations, while not behaving like the rest of the transform tools. Factor out the parts of GimpTransformTool that handle user interaction into GimpTransformGridTool (with corresponding GimpTransformGridOptions, and GimpTransformGridToolUndo), and only leave the basic transform functionality and options in GimpTransformTool (and GimpTransformOptions). Derive all the transform tools (and transform-tool base classes) that previously derived from GimpTransformTool, from GimpTransformGridTool. The one exception is GimpFlipTool, which still derives from GimpTransformTool directly. The next commit will derive GimpMeasureTool from GimpTransformTool as well.
2018-06-09 13:25:03 -07:00
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995-2001 Spencer Kimball, Peter Mattis, and others
*
* 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 3 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
Change the license URL from http://www.gnu.org/licenses/ to https://
2018-07-11 14:27:07 -07:00
* along with this program. If not, see <https://www.gnu.org/licenses/>.
app: add GimpTransformGridTool; derive most transform tools from it While most of our transform tools use an interactive transform grid, and have similar behavior, the flip tool is an odd one out. The new "auto straighten" function of the measure tool introduces another tool that performs transformations, while not behaving like the rest of the transform tools. Factor out the parts of GimpTransformTool that handle user interaction into GimpTransformGridTool (with corresponding GimpTransformGridOptions, and GimpTransformGridToolUndo), and only leave the basic transform functionality and options in GimpTransformTool (and GimpTransformOptions). Derive all the transform tools (and transform-tool base classes) that previously derived from GimpTransformTool, from GimpTransformGridTool. The one exception is GimpFlipTool, which still derives from GimpTransformTool directly. The next commit will derive GimpMeasureTool from GimpTransformTool as well.
2018-06-09 13:25:03 -07:00
*/
#ifndef __GIMP_TRANSFORM_GRID_TOOL_H__
#define __GIMP_TRANSFORM_GRID_TOOL_H__
#include "gimptransformtool.h"
/* This is not the number of items in the enum above, but the max size
* of the enums at the top of each transformation tool, stored in
* trans_info and related
*/
#define TRANS_INFO_SIZE 17
typedef gdouble TransInfo[TRANS_INFO_SIZE];
#define GIMP_TYPE_TRANSFORM_GRID_TOOL (gimp_transform_grid_tool_get_type ())
#define GIMP_TRANSFORM_GRID_TOOL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_TRANSFORM_GRID_TOOL, GimpTransformGridTool))
#define GIMP_TRANSFORM_GRID_TOOL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_TRANSFORM_GRID_TOOL, GimpTransformGridToolClass))
#define GIMP_IS_TRANSFORM_GRID_TOOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_TRANSFORM_GRID_TOOL))
#define GIMP_IS_TRANSFORM_GRID_TOOL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_TRANSFORM_GRID_TOOL))
#define GIMP_TRANSFORM_GRID_TOOL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_TRANSFORM_GRID_TOOL, GimpTransformGridToolClass))
#define GIMP_TRANSFORM_GRID_TOOL_GET_OPTIONS(t) (GIMP_TRANSFORM_GRID_OPTIONS (gimp_tool_get_options (GIMP_TOOL (t))))
typedef struct _GimpTransformGridToolClass GimpTransformGridToolClass;
struct _GimpTransformGridTool
{
app: add "Composited preview" option to transform tools Add a "Composited preview" option to all transform-grid tools, which displays the transform preview as part of the image composition (i.e., as it would actually look when applying the transformation, keeping the layer at the right position in the stack, and with the right layer mode), instead of using an overlay. This option is off by default, since it's generally slower to render than an overlay, due to the lack of mipmap rendering. We're also still using an overlay when transfoming a selection, and not a whole layer.
2020-01-15 14:17:56 -08:00
GimpTransformTool parent_instance;
TransInfo init_trans_info; /* initial transformation info */
TransInfo trans_infos[2]; /* forward/backward transformation info */
gdouble *trans_info; /* current transformation info */
GList *undo_list; /* list of all states,
head is current == prev_trans_info,
tail is original == old_trans_info */
GList *redo_list; /* list of all undone states,
NULL when nothing undone */
app: GimpTransformTool multi-layer aware. This implied a lot of other core changes, which also pushed me into improving some of the edit actions and PDB calls to be multi-layer aware in the same time. Note that it is still work-in-progress, but I just had to commit something in an acceptable intermediate state otherwise I was just going crazy. In particular now the various transform tools are multi-layer aware and work simultaneously on all selected layers (and the linked layers if any of the selected layers is linked too). Both preview and final transform processing works. In the limitations, preview doesn't work well (only one layer in the preview) when there is a selection (though the actual transform works). Also I am left to wonder how we should process this case of canvas selection+transform on multi-layers. Indeed currently I am just creating a floating selection (like we used to for the selection+transform case) containing a transform result of the composited version of all selected layers. This is a possible expected result, but another could be to get several transformed layers (without composition). But then should the "Floating Selection" concept allow for multiple Floating Selections? Sooo many questions left to answer.
2020-05-26 07:15:15 -07:00
GList *hidden_objects; /* the objects that was hidden during
app: add "Composited preview" option to transform tools Add a "Composited preview" option to all transform-grid tools, which displays the transform preview as part of the image composition (i.e., as it would actually look when applying the transformation, keeping the layer at the right position in the stack, and with the right layer mode), instead of using an overlay. This option is off by default, since it's generally slower to render than an overlay, due to the lack of mipmap rendering. We're also still using an overlay when transfoming a selection, and not a whole layer.
2020-01-15 14:17:56 -08:00
the transform */
GimpToolWidget *widget;
GimpToolWidget *grab_widget;
app: fix preview for multi-layer transform. Though it was working in the "Composited preview" case, it was only showing one of the multiple layers being transformed in the basic case.
2022-10-12 08:46:24 -07:00
GList *previews;
app: add "Composited preview" option to transform tools Add a "Composited preview" option to all transform-grid tools, which displays the transform preview as part of the image composition (i.e., as it would actually look when applying the transformation, keeping the layer at the right position in the stack, and with the right layer mode), instead of using an overlay. This option is off by default, since it's generally slower to render than an overlay, due to the lack of mipmap rendering. We're also still using an overlay when transfoming a selection, and not a whole layer.
2020-01-15 14:17:56 -08:00
GimpCanvasItem *boundary_in;
GimpCanvasItem *boundary_out;
GPtrArray *strokes;
app: add "Preview linked items" option to transform tools Add a new "Preview linked items" option to the transform-grid tools. When this option is enabled, together with composited previews, the transform preview includes all linked layers/channels when transforming a layer/channel. Note that paths aren't included for now. Ultimately, we'd probably want to cut down on the various preview options and enable this by default, but let's make this optional for now. This commit also improves composited-preview clipping in some cases.
2020-01-18 05:11:51 -08:00
GHashTable *filters;
GList *preview_drawables;
app: add "Composited preview" option to transform tools Add a "Composited preview" option to all transform-grid tools, which displays the transform preview as part of the image composition (i.e., as it would actually look when applying the transformation, keeping the layer at the right position in the stack, and with the right layer mode), instead of using an overlay. This option is off by default, since it's generally slower to render than an overlay, due to the lack of mipmap rendering. We're also still using an overlay when transfoming a selection, and not a whole layer.
2020-01-15 14:17:56 -08:00
GimpToolGui *gui;
app: add GimpTransformGridTool; derive most transform tools from it While most of our transform tools use an interactive transform grid, and have similar behavior, the flip tool is an odd one out. The new "auto straighten" function of the measure tool introduces another tool that performs transformations, while not behaving like the rest of the transform tools. Factor out the parts of GimpTransformTool that handle user interaction into GimpTransformGridTool (with corresponding GimpTransformGridOptions, and GimpTransformGridToolUndo), and only leave the basic transform functionality and options in GimpTransformTool (and GimpTransformOptions). Derive all the transform tools (and transform-tool base classes) that previously derived from GimpTransformTool, from GimpTransformGridTool. The one exception is GimpFlipTool, which still derives from GimpTransformTool directly. The next commit will derive GimpMeasureTool from GimpTransformTool as well.
2018-06-09 13:25:03 -07:00
};
struct _GimpTransformGridToolClass
{
GimpTransformToolClass parent_class;
/* virtual functions */
app: in GimpTransformGridTool, allow simultaneous forward and backward transforms In GimpTransformGridTool, allow performing simultaneous forward (normal) and backward (corrective) transforms, by having each transform direction operate on an independent set of parameters. In other words, whereas the transform-grid tools previously had a single transform, which could be applied either normally or correctively using the "direction" tool-option, they now have two independent transforms, one applied normally and the other applied correctively, which are toggled using the "direction" option. The overall transform is the combination of the backward transform, followed by the forward transform. Another way to think about it, is that the tool transforms a source shape into a destination shape. The source shape is defined by the backward transform, and the destination shape is defined by the forward transform. Wherewas previously only one of these shapes could be controlled (the other shape always being the item bounds), it's now possible to control both shapes in a single transform. The next commit will allow modifying both shapes simultaneously, making this even more useful. Note that since both transforms start off as the identity, using only one of the transform directions has the same behavior as before.
2019-02-04 07:30:18 -08:00
gboolean (* info_to_matrix) (GimpTransformGridTool *tg_tool,
GimpMatrix3 *transform);
app: in GimpTransformGridTool, allow linking forward/backward transforms Add a GimpTransformGridTool::matrix_to_info() virtual function, which should extract the tool-specific transformation parameters given a transformation matrix, and the old parameter set (which is needed in some tools, to derive the parameters that aren't encoded in the matrix, such as the pivot point). The transformation matrix can be any combination of matrices calculated by the tool, and their inverses. Subclasses should only implement this function if every such matrix can be mapped back to transformation parameters. This is currently the case for all the transform-grid tools, except for the shear tool (since it only supports shearing along one of the horizontal or the vertical directions, however, the combined matrix may require shearing in both directions). When a transform-grid tool implements this function, show a chain- button between the two transform-direction radio-buttons in the tool options. When the chain-button is linked, whenever the transform corresponding to the active direction is modified, adjust the transform corresponding to the non-active direction such that the overall transform remains the same. One notable workflow that this enables is transforming a layer while adjusting a different area than its boundary, by first defining the area while the transform-directions are linked, and then transforming the area while the transform-directions are unlinked.
2019-02-04 12:33:44 -08:00
void (* matrix_to_info) (GimpTransformGridTool *tg_tool,
const GimpMatrix3 *transform);
app: add GimpTransformGridTool::apply_info() vfunc ... which copies a TransInfo array to the current info array, possibly with modifications. While the default implementation simply copies the array as-is, the following commit will override the function for the Unified Transform tool, to avoid copying the pivot position when the pivot is locked. Use the function in GimpTransformGridTool, instead of copying the array directly, as necessary.
2020-04-27 06:44:40 -07:00
void (* apply_info) (GimpTransformGridTool *tg_tool,
const TransInfo info);
app: in GimpTransformGridTool, allow simultaneous forward and backward transforms In GimpTransformGridTool, allow performing simultaneous forward (normal) and backward (corrective) transforms, by having each transform direction operate on an independent set of parameters. In other words, whereas the transform-grid tools previously had a single transform, which could be applied either normally or correctively using the "direction" tool-option, they now have two independent transforms, one applied normally and the other applied correctively, which are toggled using the "direction" option. The overall transform is the combination of the backward transform, followed by the forward transform. Another way to think about it, is that the tool transforms a source shape into a destination shape. The source shape is defined by the backward transform, and the destination shape is defined by the forward transform. Wherewas previously only one of these shapes could be controlled (the other shape always being the item bounds), it's now possible to control both shapes in a single transform. The next commit will allow modifying both shapes simultaneously, making this even more useful. Note that since both transforms start off as the identity, using only one of the transform directions has the same behavior as before.
2019-02-04 07:30:18 -08:00
gchar * (* get_undo_desc) (GimpTransformGridTool *tg_tool);
app: clean up GimpTransformGridTool; adapt subclasses Get rid of GimpTransformGridTool::recalc_matrix() and gimp_transform_grid_tool_recalc_matrix(), and have GimpTransformGridTool and its subclasses use GimpTransformTool::recalc_matrix() and gimp_transform_tool_recalc_matrix() directly instead. In order to break the GimpToolWidget::changed/ GimpTransformTool::recalc_matrix() loop, add a GimpTransformGridTool::update_widget() vfunc, which subclasses should override to update their tool-widget (instead of doing this in ::recalc_matrix()), and ::widget_changed(), which is called when the tool-widget changes (and which subclasses should override instead of connecting to the tool-widget's "changed" signal directly.) GimpTransformGridTool calls these functions as necessary, instead of relying on extra parameters passed to recalc_matrix(). Adapt all the direct and indirect subclasses of GimpTransformGridTool to the change.
2018-06-15 12:42:19 -07:00
void (* dialog) (GimpTransformGridTool *tg_tool);
void (* dialog_update) (GimpTransformGridTool *tg_tool);
void (* prepare) (GimpTransformGridTool *tg_tool);
app: add "Readjust" function to transform-grid tools Add an optional GimpTransformGridTool::radjust() virtual function, which subclasses can implement to radjust the transformation based on the current state of the display, such that it's easy to control. This is especially useful when the image is zoomed-in, and the transform handles, which are initially across the layer bounds, are out of view. When a transform tool implements radjust(), show a "Readjust" button in the tool GUI. While readjusting the transformation, we modify the opposite transformation such that the overall transform remains unchanged, as if both transform-directions were linked, so that only the transform grid is readjusted.
2019-03-07 13:05:18 -08:00
void (* readjust) (GimpTransformGridTool *tg_tool);
app: clean up GimpTransformGridTool; adapt subclasses Get rid of GimpTransformGridTool::recalc_matrix() and gimp_transform_grid_tool_recalc_matrix(), and have GimpTransformGridTool and its subclasses use GimpTransformTool::recalc_matrix() and gimp_transform_tool_recalc_matrix() directly instead. In order to break the GimpToolWidget::changed/ GimpTransformTool::recalc_matrix() loop, add a GimpTransformGridTool::update_widget() vfunc, which subclasses should override to update their tool-widget (instead of doing this in ::recalc_matrix()), and ::widget_changed(), which is called when the tool-widget changes (and which subclasses should override instead of connecting to the tool-widget's "changed" signal directly.) GimpTransformGridTool calls these functions as necessary, instead of relying on extra parameters passed to recalc_matrix(). Adapt all the direct and indirect subclasses of GimpTransformGridTool to the change.
2018-06-15 12:42:19 -07:00
GimpToolWidget * (* get_widget) (GimpTransformGridTool *tg_tool);
void (* update_widget) (GimpTransformGridTool *tg_tool);
void (* widget_changed) (GimpTransformGridTool *tg_tool);
GeglBuffer * (* transform) (GimpTransformGridTool *tg_tool,
app: GimpTransformTool multi-layer aware. This implied a lot of other core changes, which also pushed me into improving some of the edit actions and PDB calls to be multi-layer aware in the same time. Note that it is still work-in-progress, but I just had to commit something in an acceptable intermediate state otherwise I was just going crazy. In particular now the various transform tools are multi-layer aware and work simultaneously on all selected layers (and the linked layers if any of the selected layers is linked too). Both preview and final transform processing works. In the limitations, preview doesn't work well (only one layer in the preview) when there is a selection (though the actual transform works). Also I am left to wonder how we should process this case of canvas selection+transform on multi-layers. Indeed currently I am just creating a floating selection (like we used to for the selection+transform case) containing a transform result of the composited version of all selected layers. This is a possible expected result, but another could be to get several transformed layers (without composition). But then should the "Floating Selection" concept allow for multiple Floating Selections? Sooo many questions left to answer.
2020-05-26 07:15:15 -07:00
GList *objects,
app: clean up GimpTransformGridTool; adapt subclasses Get rid of GimpTransformGridTool::recalc_matrix() and gimp_transform_grid_tool_recalc_matrix(), and have GimpTransformGridTool and its subclasses use GimpTransformTool::recalc_matrix() and gimp_transform_tool_recalc_matrix() directly instead. In order to break the GimpToolWidget::changed/ GimpTransformTool::recalc_matrix() loop, add a GimpTransformGridTool::update_widget() vfunc, which subclasses should override to update their tool-widget (instead of doing this in ::recalc_matrix()), and ::widget_changed(), which is called when the tool-widget changes (and which subclasses should override instead of connecting to the tool-widget's "changed" signal directly.) GimpTransformGridTool calls these functions as necessary, instead of relying on extra parameters passed to recalc_matrix(). Adapt all the direct and indirect subclasses of GimpTransformGridTool to the change.
2018-06-15 12:42:19 -07:00
GeglBuffer *orig_buffer,
gint orig_offset_x,
gint orig_offset_y,
GimpColorProfile **buffer_profile,
gint *new_offset_x,
gint *new_offset_y);
app: add GimpTransformGridTool; derive most transform tools from it While most of our transform tools use an interactive transform grid, and have similar behavior, the flip tool is an odd one out. The new "auto straighten" function of the measure tool introduces another tool that performs transformations, while not behaving like the rest of the transform tools. Factor out the parts of GimpTransformTool that handle user interaction into GimpTransformGridTool (with corresponding GimpTransformGridOptions, and GimpTransformGridToolUndo), and only leave the basic transform functionality and options in GimpTransformTool (and GimpTransformOptions). Derive all the transform tools (and transform-tool base classes) that previously derived from GimpTransformTool, from GimpTransformGridTool. The one exception is GimpFlipTool, which still derives from GimpTransformTool directly. The next commit will derive GimpMeasureTool from GimpTransformTool as well.
2018-06-09 13:25:03 -07:00
const gchar *ok_button_label;
};
app: in GimpTransformGridTool, allow simultaneous forward and backward transforms In GimpTransformGridTool, allow performing simultaneous forward (normal) and backward (corrective) transforms, by having each transform direction operate on an independent set of parameters. In other words, whereas the transform-grid tools previously had a single transform, which could be applied either normally or correctively using the "direction" tool-option, they now have two independent transforms, one applied normally and the other applied correctively, which are toggled using the "direction" option. The overall transform is the combination of the backward transform, followed by the forward transform. Another way to think about it, is that the tool transforms a source shape into a destination shape. The source shape is defined by the backward transform, and the destination shape is defined by the forward transform. Wherewas previously only one of these shapes could be controlled (the other shape always being the item bounds), it's now possible to control both shapes in a single transform. The next commit will allow modifying both shapes simultaneously, making this even more useful. Note that since both transforms start off as the identity, using only one of the transform directions has the same behavior as before.
2019-02-04 07:30:18 -08:00
GType gimp_transform_grid_tool_get_type (void) G_GNUC_CONST;
app: add GimpTransformGridTool; derive most transform tools from it While most of our transform tools use an interactive transform grid, and have similar behavior, the flip tool is an odd one out. The new "auto straighten" function of the measure tool introduces another tool that performs transformations, while not behaving like the rest of the transform tools. Factor out the parts of GimpTransformTool that handle user interaction into GimpTransformGridTool (with corresponding GimpTransformGridOptions, and GimpTransformGridToolUndo), and only leave the basic transform functionality and options in GimpTransformTool (and GimpTransformOptions). Derive all the transform tools (and transform-tool base classes) that previously derived from GimpTransformTool, from GimpTransformGridTool. The one exception is GimpFlipTool, which still derives from GimpTransformTool directly. The next commit will derive GimpMeasureTool from GimpTransformTool as well.
2018-06-09 13:25:03 -07:00
app: in GimpTransformGridTool, allow simultaneous forward and backward transforms In GimpTransformGridTool, allow performing simultaneous forward (normal) and backward (corrective) transforms, by having each transform direction operate on an independent set of parameters. In other words, whereas the transform-grid tools previously had a single transform, which could be applied either normally or correctively using the "direction" tool-option, they now have two independent transforms, one applied normally and the other applied correctively, which are toggled using the "direction" option. The overall transform is the combination of the backward transform, followed by the forward transform. Another way to think about it, is that the tool transforms a source shape into a destination shape. The source shape is defined by the backward transform, and the destination shape is defined by the forward transform. Wherewas previously only one of these shapes could be controlled (the other shape always being the item bounds), it's now possible to control both shapes in a single transform. The next commit will allow modifying both shapes simultaneously, making this even more useful. Note that since both transforms start off as the identity, using only one of the transform directions has the same behavior as before.
2019-02-04 07:30:18 -08:00
gboolean gimp_transform_grid_tool_info_to_matrix (GimpTransformGridTool *tg_tool,
GimpMatrix3 *transform);
app: in GimpTransformGridTool, allow linking forward/backward transforms Add a GimpTransformGridTool::matrix_to_info() virtual function, which should extract the tool-specific transformation parameters given a transformation matrix, and the old parameter set (which is needed in some tools, to derive the parameters that aren't encoded in the matrix, such as the pivot point). The transformation matrix can be any combination of matrices calculated by the tool, and their inverses. Subclasses should only implement this function if every such matrix can be mapped back to transformation parameters. This is currently the case for all the transform-grid tools, except for the shear tool (since it only supports shearing along one of the horizontal or the vertical directions, however, the combined matrix may require shearing in both directions). When a transform-grid tool implements this function, show a chain- button between the two transform-direction radio-buttons in the tool options. When the chain-button is linked, whenever the transform corresponding to the active direction is modified, adjust the transform corresponding to the non-active direction such that the overall transform remains the same. One notable workflow that this enables is transforming a layer while adjusting a different area than its boundary, by first defining the area while the transform-directions are linked, and then transforming the area while the transform-directions are unlinked.
2019-02-04 12:33:44 -08:00
void gimp_transform_grid_tool_matrix_to_info (GimpTransformGridTool *tg_tool,
const GimpMatrix3 *transform);
app: in GimpTransformGridTool, allow simultaneous forward and backward transforms In GimpTransformGridTool, allow performing simultaneous forward (normal) and backward (corrective) transforms, by having each transform direction operate on an independent set of parameters. In other words, whereas the transform-grid tools previously had a single transform, which could be applied either normally or correctively using the "direction" tool-option, they now have two independent transforms, one applied normally and the other applied correctively, which are toggled using the "direction" option. The overall transform is the combination of the backward transform, followed by the forward transform. Another way to think about it, is that the tool transforms a source shape into a destination shape. The source shape is defined by the backward transform, and the destination shape is defined by the forward transform. Wherewas previously only one of these shapes could be controlled (the other shape always being the item bounds), it's now possible to control both shapes in a single transform. The next commit will allow modifying both shapes simultaneously, making this even more useful. Note that since both transforms start off as the identity, using only one of the transform directions has the same behavior as before.
2019-02-04 07:30:18 -08:00
app: in GimpTransformGridTool, compress successive undo steps Add a boolean 'compress' parameter to gimp_transform_grid_tool_push_internal_undo(). When TRUE, successive undo steps added rapidly are compressed into a single step. In the various subclasses, compress undo steps for dialog changes, since we push an undo step for every intermediate change for those (such as while dragging a spin-scale). In contrast, we only push tool-widget undo steps upon button release, hence there's no need to compress them.
2020-01-06 02:00:27 -08:00
void gimp_transform_grid_tool_push_internal_undo (GimpTransformGridTool *tg_tool,
gboolean compress);
app: add GimpTransformGridTool; derive most transform tools from it While most of our transform tools use an interactive transform grid, and have similar behavior, the flip tool is an odd one out. The new "auto straighten" function of the measure tool introduces another tool that performs transformations, while not behaving like the rest of the transform tools. Factor out the parts of GimpTransformTool that handle user interaction into GimpTransformGridTool (with corresponding GimpTransformGridOptions, and GimpTransformGridToolUndo), and only leave the basic transform functionality and options in GimpTransformTool (and GimpTransformOptions). Derive all the transform tools (and transform-tool base classes) that previously derived from GimpTransformTool, from GimpTransformGridTool. The one exception is GimpFlipTool, which still derives from GimpTransformTool directly. The next commit will derive GimpMeasureTool from GimpTransformTool as well.
2018-06-09 13:25:03 -07:00
#endif /* __GIMP_TRANSFORM_GRID_TOOL_H__ */
Reference in a new issue Copy permalink