eUgEntOptIc44/gimp
1
1
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-10-06 01:12:40 +02:00
Code Issues Releases Activity
Files
master
gimp/app/tools/gimptransformgridoptions.c

685 lines
24 KiB
C
Raw Permalink 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 16:25:03 -04:00
/* GIMP - The GNU 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 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 23:27:07 +02: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 16:25:03 -04:00
*/
#include "config.h"
#include <gegl.h>
#include <gtk/gtk.h>
libgimbase: merge gimpparam.h into gimpparamspecs.h which means that it's now included normally via gimpbase.h and not any longer via gimpbasetypes.h which we only did out of lazyness. A *lot* of files in libgimp* and app/ now need to
2019-07-31 10:16:21 +02:00
#include "libgimpbase/gimpbase.h"
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 16:25:03 -04:00
#include "libgimpconfig/gimpconfig.h"
#include "libgimpwidgets/gimpwidgets.h"
#include "tools-types.h"
#include "core/gimp.h"
#include "core/gimptoolinfo.h"
#include "widgets/gimppropwidgets.h"
#include "widgets/gimpwidgets-utils.h"
app: add "Constrain handles", "Around center" options to the perspective tool Add "Constrain handles" and "Around center" options to the perspective-transform tool's GUI, which are similar to the corresponding options of the unified-transform tool. Both of these options can already be controlled using Shift and Ctrl, respectively, through the transform-grid widget, so we might as well provide GUI toggles for them.
2019-02-28 15:43:05 -05:00
#include "gimpperspectivetool.h"
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 16:25:03 -04:00
#include "gimprotatetool.h"
#include "gimpscaletool.h"
#include "gimpunifiedtransformtool.h"
#include "gimptooloptions-gui.h"
#include "gimptransformgridoptions.h"
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 15:33:44 -05:00
#include "gimptransformgridtool.h"
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 16:25:03 -04:00
#include "gimp-intl.h"
enum
{
PROP_0,
PROP_DIRECTION,
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 15:33:44 -05:00
PROP_DIRECTION_LINKED,
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 16:25:03 -04:00
PROP_SHOW_PREVIEW,
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-16 00:17:56 +02:00
PROP_COMPOSITED_PREVIEW,
app: add "Synchronous preview" option to transform tools Add a "Synchronous preview" option to the transform-grid tools, which renders the composited preview synchronously. This reduces the lag for painting the preview, but can harm responsiveness for bigger images, where rendering the preview is slow. This is mostly an experimental option for now; it will become more interesting once we have mipmap rendering.
2020-01-16 11:34:17 +02:00
PROP_SYNCHRONOUS_PREVIEW,
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 16:25:03 -04:00
PROP_PREVIEW_OPACITY,
PROP_GRID_TYPE,
PROP_GRID_SIZE,
PROP_CONSTRAIN_MOVE,
PROP_CONSTRAIN_SCALE,
PROP_CONSTRAIN_ROTATE,
PROP_CONSTRAIN_SHEAR,
PROP_CONSTRAIN_PERSPECTIVE,
PROP_FROMPIVOT_SCALE,
PROP_FROMPIVOT_SHEAR,
PROP_FROMPIVOT_PERSPECTIVE,
PROP_CORNERSNAP,
PROP_FIXEDPIVOT,
};
static void gimp_transform_grid_options_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_transform_grid_options_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static gboolean gimp_transform_grid_options_sync_grid (GBinding *binding,
const GValue *source_value,
GValue *target_value,
gpointer user_data);
G_DEFINE_TYPE (GimpTransformGridOptions, gimp_transform_grid_options,
GIMP_TYPE_TRANSFORM_OPTIONS)
#define parent_class gimp_transform_grid_options_parent_class
static void
gimp_transform_grid_options_class_init (GimpTransformGridOptionsClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->set_property = gimp_transform_grid_options_set_property;
object_class->get_property = gimp_transform_grid_options_get_property;
g_object_class_override_property (object_class, PROP_DIRECTION,
"direction");
app: unlink transform directions on tool halt; make chain button insensitive In GimpTransformGridTool, keep the transform-direction chain-button insensitive while the tool is not active, and always unlink the button when halting the tool. This avoids the directions from accidentally being kept linked, resulting in the tool seemingly having no effect.
2020-04-27 16:41:43 +03:00
g_object_class_install_property (object_class, PROP_DIRECTION_LINKED,
g_param_spec_boolean ("direction-linked",
NULL, NULL,
FALSE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
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 15:33:44 -05:00
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 16:25:03 -04:00
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SHOW_PREVIEW,
"show-preview",
_("Show image preview"),
Issue #2786: a few string issues. Several en_GB to en_US. Also "Show a preview of the transform_grided image". "grided" should be "gridded", but I also have a problem with the underscore. Should it be "transform-gridded"? Even so, does it really make sense? I chose to just read "Show a preview of the transformed image", which I think is simpler and the most understandable (we don't need to leak the implementation with a transform grid into the human read text IMO). If anyone think that was not the right choice, feel free to propose otherwise. Thanks to Bruce Cowan for noticing these.
2019-01-12 17:17:58 +01:00
_("Show a preview of the transformed image"),
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 16:25:03 -04:00
TRUE,
GIMP_PARAM_STATIC_STRINGS);
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-16 00:17:56 +02:00
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_COMPOSITED_PREVIEW,
"composited-preview",
_("Composited preview"),
_("Show preview as part of the image composition"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
app: add "Synchronous preview" option to transform tools Add a "Synchronous preview" option to the transform-grid tools, which renders the composited preview synchronously. This reduces the lag for painting the preview, but can harm responsiveness for bigger images, where rendering the preview is slow. This is mostly an experimental option for now; it will become more interesting once we have mipmap rendering.
2020-01-16 11:34:17 +02:00
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SYNCHRONOUS_PREVIEW,
"synchronous-preview",
_("Synchronous preview"),
_("Render the preview synchronously"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
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 16:25:03 -04:00
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_PREVIEW_OPACITY,
"preview-opacity",
_("Image opacity"),
_("Opacity of the preview image"),
0.0, 1.0, 1.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_GRID_TYPE,
"grid-type",
_("Guides"),
_("Composition guides such as rule of thirds"),
GIMP_TYPE_GUIDES_TYPE,
GIMP_GUIDES_NONE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_INT (object_class, PROP_GRID_SIZE,
"grid-size",
NULL,
_("Size of a grid cell for variable number "
"of composition guides"),
1, 128, 15,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_MOVE,
"constrain-move",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_SCALE,
"constrain-scale",
NULL, NULL,
Unified transform: enable Constraint:Scale by default
2018-12-21 01:49:44 +03:00
TRUE,
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 16:25:03 -04:00
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_ROTATE,
"constrain-rotate",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_SHEAR,
"constrain-shear",
NULL, NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_PERSPECTIVE,
"constrain-perspective",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FROMPIVOT_SCALE,
"frompivot-scale",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FROMPIVOT_SHEAR,
"frompivot-shear",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FROMPIVOT_PERSPECTIVE,
"frompivot-perspective",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_CORNERSNAP,
"cornersnap",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FIXEDPIVOT,
"fixedpivot",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
}
static void
gimp_transform_grid_options_init (GimpTransformGridOptions *options)
{
}
static void
gimp_transform_grid_options_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpTransformGridOptions *options = GIMP_TRANSFORM_GRID_OPTIONS (object);
GimpTransformOptions *transform_options = GIMP_TRANSFORM_OPTIONS (object);
switch (property_id)
{
case PROP_DIRECTION:
transform_options->direction = g_value_get_enum (value);
/* Expected default for corrective transform_grid is to see the
* original image only.
*/
g_object_set (options,
"show-preview",
transform_options->direction != GIMP_TRANSFORM_BACKWARD,
NULL);
break;
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 15:33:44 -05:00
case PROP_DIRECTION_LINKED:
options->direction_linked = g_value_get_boolean (value);
break;
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 16:25:03 -04:00
case PROP_SHOW_PREVIEW:
options->show_preview = g_value_get_boolean (value);
break;
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-16 00:17:56 +02:00
case PROP_COMPOSITED_PREVIEW:
options->composited_preview = g_value_get_boolean (value);
break;
app: add "Synchronous preview" option to transform tools Add a "Synchronous preview" option to the transform-grid tools, which renders the composited preview synchronously. This reduces the lag for painting the preview, but can harm responsiveness for bigger images, where rendering the preview is slow. This is mostly an experimental option for now; it will become more interesting once we have mipmap rendering.
2020-01-16 11:34:17 +02:00
case PROP_SYNCHRONOUS_PREVIEW:
options->synchronous_preview = g_value_get_boolean (value);
break;
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 16:25:03 -04:00
case PROP_PREVIEW_OPACITY:
options->preview_opacity = g_value_get_double (value);
break;
case PROP_GRID_TYPE:
options->grid_type = g_value_get_enum (value);
break;
case PROP_GRID_SIZE:
options->grid_size = g_value_get_int (value);
break;
case PROP_CONSTRAIN_MOVE:
options->constrain_move = g_value_get_boolean (value);
break;
case PROP_CONSTRAIN_SCALE:
options->constrain_scale = g_value_get_boolean (value);
break;
case PROP_CONSTRAIN_ROTATE:
options->constrain_rotate = g_value_get_boolean (value);
break;
case PROP_CONSTRAIN_SHEAR:
options->constrain_shear = g_value_get_boolean (value);
break;
case PROP_CONSTRAIN_PERSPECTIVE:
options->constrain_perspective = g_value_get_boolean (value);
break;
case PROP_FROMPIVOT_SCALE:
options->frompivot_scale = g_value_get_boolean (value);
break;
case PROP_FROMPIVOT_SHEAR:
options->frompivot_shear = g_value_get_boolean (value);
break;
case PROP_FROMPIVOT_PERSPECTIVE:
options->frompivot_perspective = g_value_get_boolean (value);
break;
case PROP_CORNERSNAP:
options->cornersnap = g_value_get_boolean (value);
break;
case PROP_FIXEDPIVOT:
options->fixedpivot = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_transform_grid_options_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpTransformGridOptions *options = GIMP_TRANSFORM_GRID_OPTIONS (object);
GimpTransformOptions *transform_options = GIMP_TRANSFORM_OPTIONS (object);
switch (property_id)
{
case PROP_DIRECTION:
g_value_set_enum (value, transform_options->direction);
break;
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 15:33:44 -05:00
case PROP_DIRECTION_LINKED:
g_value_set_boolean (value, options->direction_linked);
break;
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 16:25:03 -04:00
case PROP_SHOW_PREVIEW:
g_value_set_boolean (value, options->show_preview);
break;
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-16 00:17:56 +02:00
case PROP_COMPOSITED_PREVIEW:
g_value_set_boolean (value, options->composited_preview);
break;
app: add "Synchronous preview" option to transform tools Add a "Synchronous preview" option to the transform-grid tools, which renders the composited preview synchronously. This reduces the lag for painting the preview, but can harm responsiveness for bigger images, where rendering the preview is slow. This is mostly an experimental option for now; it will become more interesting once we have mipmap rendering.
2020-01-16 11:34:17 +02:00
case PROP_SYNCHRONOUS_PREVIEW:
g_value_set_boolean (value, options->synchronous_preview);
break;
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 16:25:03 -04:00
case PROP_PREVIEW_OPACITY:
g_value_set_double (value, options->preview_opacity);
break;
case PROP_GRID_TYPE:
g_value_set_enum (value, options->grid_type);
break;
case PROP_GRID_SIZE:
g_value_set_int (value, options->grid_size);
break;
case PROP_CONSTRAIN_MOVE:
g_value_set_boolean (value, options->constrain_move);
break;
case PROP_CONSTRAIN_SCALE:
g_value_set_boolean (value, options->constrain_scale);
break;
case PROP_CONSTRAIN_ROTATE:
g_value_set_boolean (value, options->constrain_rotate);
break;
case PROP_CONSTRAIN_SHEAR:
g_value_set_boolean (value, options->constrain_shear);
break;
case PROP_CONSTRAIN_PERSPECTIVE:
g_value_set_boolean (value, options->constrain_perspective);
break;
case PROP_FROMPIVOT_SCALE:
g_value_set_boolean (value, options->frompivot_scale);
break;
case PROP_FROMPIVOT_SHEAR:
g_value_set_boolean (value, options->frompivot_shear);
break;
case PROP_FROMPIVOT_PERSPECTIVE:
g_value_set_boolean (value, options->frompivot_perspective);
break;
case PROP_CORNERSNAP:
g_value_set_boolean (value, options->cornersnap);
break;
case PROP_FIXEDPIVOT:
g_value_set_boolean (value, options->fixedpivot);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
/**
* gimp_transform_grid_options_gui:
* @tool_options: a #GimpToolOptions
*
* Build the TransformGrid Tool Options.
*
Use "Returns:" to annotate return values To be able to annotate return values through GObject-introspection, you need to make sure it is tagged with `Returns:` and not something else.
2019-08-03 00:10:14 +02:00
* Returns: a container holding the transform_grid tool options
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 16:25:03 -04:00
**/
GtkWidget *
gimp_transform_grid_options_gui (GimpToolOptions *tool_options)
{
app: unlink transform directions on tool halt; make chain button insensitive In GimpTransformGridTool, keep the transform-direction chain-button insensitive while the tool is not active, and always unlink the button when halting the tool. This avoids the directions from accidentally being kept linked, resulting in the tool seemingly having no effect.
2020-04-27 16:41:43 +03:00
GObject *config = G_OBJECT (tool_options);
GimpTransformGridOptions *options = GIMP_TRANSFORM_GRID_OPTIONS (tool_options);
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 15:33:44 -05:00
GimpTransformGridToolClass *tg_class;
GtkWidget *vbox;
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-16 00:17:56 +02:00
GtkWidget *vbox2;
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 15:11:51 +02:00
GtkWidget *vbox3;
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-16 00:17:56 +02:00
GtkWidget *button;
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 15:33:44 -05:00
GtkWidget *frame;
GtkWidget *combo;
GtkWidget *scale;
GtkWidget *grid_box;
GdkModifierType extend_mask = gimp_get_extend_selection_mask ();
GdkModifierType constrain_mask = gimp_get_constrain_behavior_mask ();
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 16:25:03 -04:00
vbox = gimp_transform_options_gui (tool_options, TRUE, TRUE, TRUE);
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 15:33:44 -05:00
tg_class = g_type_class_ref (tool_options->tool_info->tool_type);
/* the direction-link button */
if (tg_class->matrix_to_info)
{
GimpTransformOptions *tr_options = GIMP_TRANSFORM_OPTIONS (tool_options);
GtkWidget *hbox;
vbox2 = gtk_bin_get_child (GTK_BIN (tr_options->direction_frame));
g_object_ref (vbox2);
gtk_container_remove (GTK_CONTAINER (tr_options->direction_frame), vbox2);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1);
gtk_container_add (GTK_CONTAINER (tr_options->direction_frame), hbox);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
g_object_unref (vbox2);
button = gimp_chain_button_new (GIMP_CHAIN_RIGHT);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
app: unlink transform directions on tool halt; make chain button insensitive In GimpTransformGridTool, keep the transform-direction chain-button insensitive while the tool is not active, and always unlink the button when halting the tool. This avoids the directions from accidentally being kept linked, resulting in the tool seemingly having no effect.
2020-04-27 16:41:43 +03:00
gtk_widget_set_sensitive (button, FALSE);
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 15:33:44 -05:00
gimp_chain_button_set_icon_size (GIMP_CHAIN_BUTTON (button),
GTK_ICON_SIZE_MENU);
gtk_widget_show (button);
g_object_bind_property (config, "direction-linked",
button, "active",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
app: unlink transform directions on tool halt; make chain button insensitive In GimpTransformGridTool, keep the transform-direction chain-button insensitive while the tool is not active, and always unlink the button when halting the tool. This avoids the directions from accidentally being kept linked, resulting in the tool seemingly having no effect.
2020-04-27 16:41:43 +03:00
options->direction_chain_button = button;
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 15:33:44 -05:00
}
g_type_class_unref (tg_class);
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 16:25:03 -04:00
/* the preview frame */
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-16 00:17:56 +02:00
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
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 15:11:51 +02:00
vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
app: add "Synchronous preview" option to transform tools Add a "Synchronous preview" option to the transform-grid tools, which renders the composited preview synchronously. This reduces the lag for painting the preview, but can harm responsiveness for bigger images, where rendering the preview is slow. This is mostly an experimental option for now; it will become more interesting once we have mipmap rendering.
2020-01-16 11:34:17 +02:00
button = gimp_prop_check_button_new (config, "synchronous-preview", NULL);
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 15:11:51 +02:00
gtk_box_pack_start (GTK_BOX (vbox3), button, FALSE, FALSE, 0);
gtk_widget_show (button);
app: add "Synchronous preview" option to transform tools Add a "Synchronous preview" option to the transform-grid tools, which renders the composited preview synchronously. This reduces the lag for painting the preview, but can harm responsiveness for bigger images, where rendering the preview is slow. This is mostly an experimental option for now; it will become more interesting once we have mipmap rendering.
2020-01-16 11:34:17 +02:00
frame = gimp_prop_expanding_frame_new (config, "composited-preview", NULL,
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 15:11:51 +02:00
vbox3, NULL);
app: add "Synchronous preview" option to transform tools Add a "Synchronous preview" option to the transform-grid tools, which renders the composited preview synchronously. This reduces the lag for painting the preview, but can harm responsiveness for bigger images, where rendering the preview is slow. This is mostly an experimental option for now; it will become more interesting once we have mipmap rendering.
2020-01-16 11:34:17 +02:00
gtk_box_pack_start (GTK_BOX (vbox2), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
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-16 00:17:56 +02:00
app, libgimpwidgets: move gimp_prop_spin_scale_new() and… … gimp_prop_widget_set_factor() to libgimpwidgets. Now that GimpSpinScale is in libgimpwidgets, it's time to move the associated prop too, to make it a prop widget with such a widget easily creatable by plug-ins. While doing so, I update both these functions logic, binding properties together with the g_object_bind_property*() APIs (as we do already in some other recent prop functions) rather than connecting to signals ourselves. It makes for much simpler code.
2022-02-18 22:49:45 +01:00
scale = gimp_prop_spin_scale_new (config, "preview-opacity",
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 16:25:03 -04:00
0.01, 0.1, 0);
app, libgimpwidgets: move gimp_prop_spin_scale_new() and… … gimp_prop_widget_set_factor() to libgimpwidgets. Now that GimpSpinScale is in libgimpwidgets, it's time to move the associated prop too, to make it a prop widget with such a widget easily creatable by plug-ins. While doing so, I update both these functions logic, binding properties together with the g_object_bind_property*() APIs (as we do already in some other recent prop functions) rather than connecting to signals ourselves. It makes for much simpler code.
2022-02-18 22:49:45 +01:00
gimp_prop_widget_set_factor (scale, 100.0, 1.0, 10.0, 1);
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-16 00:17:56 +02:00
gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
g_object_bind_property (config, "composited-preview",
scale, "sensitive",
G_BINDING_SYNC_CREATE |
G_BINDING_INVERT_BOOLEAN);
app, libgimpwidgets: return visible widgets from all gimp_prop_foo_new() and remove a gazillion gtk_widget_show() all over the place, some places need a gtk_widget_hide() now, and I'm pretty sure I broke at least one thing in all those files...
2019-09-25 20:24:06 +02:00
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 16:25:03 -04:00
frame = gimp_prop_expanding_frame_new (config, "show-preview", NULL,
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-16 00:17:56 +02:00
vbox2, NULL);
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 16:25:03 -04:00
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
/* the guides frame */
frame = gimp_frame_new (NULL);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
/* the guides type menu */
combo = gimp_prop_enum_combo_box_new (config, "grid-type", 0, 0);
gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (combo), _("Guides"));
g_object_set (combo, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_frame_set_label_widget (GTK_FRAME (frame), combo);
/* the grid density scale */
app, libgimpwidgets: move gimp_prop_spin_scale_new() and… … gimp_prop_widget_set_factor() to libgimpwidgets. Now that GimpSpinScale is in libgimpwidgets, it's time to move the associated prop too, to make it a prop widget with such a widget easily creatable by plug-ins. While doing so, I update both these functions logic, binding properties together with the g_object_bind_property*() APIs (as we do already in some other recent prop functions) rather than connecting to signals ourselves. It makes for much simpler code.
2022-02-18 22:49:45 +01:00
scale = gimp_prop_spin_scale_new (config, "grid-size",
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 16:25:03 -04:00
1.8, 8.0, 0);
gimp_spin_scale_set_label (GIMP_SPIN_SCALE (scale), NULL);
gtk_container_add (GTK_CONTAINER (frame), scale);
g_object_bind_property_full (config, "grid-type",
scale, "visible",
G_BINDING_SYNC_CREATE,
gimp_transform_grid_options_sync_grid,
NULL,
NULL, NULL);
if (tool_options->tool_info->tool_type == GIMP_TYPE_ROTATE_TOOL)
{
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-16 00:17:56 +02:00
gchar *label;
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 16:25:03 -04:00
label = g_strdup_printf (_("15 degrees (%s)"),
gimp_get_mod_string (extend_mask));
button = gimp_prop_check_button_new (config, "constrain-rotate", label);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gimp_help_set_help_data (button, _("Limit rotation steps to 15 degrees"),
NULL);
g_free (label);
}
else if (tool_options->tool_info->tool_type == GIMP_TYPE_SCALE_TOOL)
{
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-16 00:17:56 +02:00
gchar *label;
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 16:25:03 -04:00
label = g_strdup_printf (_("Keep aspect (%s)"),
gimp_get_mod_string (extend_mask));
button = gimp_prop_check_button_new (config, "constrain-scale", label);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gimp_help_set_help_data (button, _("Keep the original aspect ratio"),
NULL);
g_free (label);
label = g_strdup_printf (_("Around center (%s)"),
gimp_get_mod_string (constrain_mask));
button = gimp_prop_check_button_new (config, "frompivot-scale", label);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gimp_help_set_help_data (button, _("Scale around the center point"),
NULL);
app: add "Constrain handles", "Around center" options to the perspective tool Add "Constrain handles" and "Around center" options to the perspective-transform tool's GUI, which are similar to the corresponding options of the unified-transform tool. Both of these options can already be controlled using Shift and Ctrl, respectively, through the transform-grid widget, so we might as well provide GUI toggles for them.
2019-02-28 15:43:05 -05:00
g_free (label);
}
else if (tool_options->tool_info->tool_type == GIMP_TYPE_PERSPECTIVE_TOOL)
{
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-16 00:17:56 +02:00
gchar *label;
app: add "Constrain handles", "Around center" options to the perspective tool Add "Constrain handles" and "Around center" options to the perspective-transform tool's GUI, which are similar to the corresponding options of the unified-transform tool. Both of these options can already be controlled using Shift and Ctrl, respectively, through the transform-grid widget, so we might as well provide GUI toggles for them.
2019-02-28 15:43:05 -05:00
label = g_strdup_printf (_("Constrain handles (%s)"),
gimp_get_mod_string (extend_mask));
button = gimp_prop_check_button_new (config, "constrain-perspective", label);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gimp_help_set_help_data (
button, _("Constrain handles to move along edges and diagonal (%s)"),
NULL);
g_free (label);
label = g_strdup_printf (_("Around center (%s)"),
gimp_get_mod_string (constrain_mask));
button = gimp_prop_check_button_new (config, "frompivot-perspective", label);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gimp_help_set_help_data (
button, _("Transform around the center point"),
NULL);
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 16:25:03 -04:00
g_free (label);
}
else if (tool_options->tool_info->tool_type == GIMP_TYPE_UNIFIED_TRANSFORM_TOOL)
{
struct
{
GdkModifierType mod;
gchar *name;
gchar *desc;
gchar *tip;
}
opt_list[] =
{
{ extend_mask, NULL, N_("Constrain (%s)") },
{ extend_mask, "constrain-move", N_("Move"),
N_("Constrain movement to 45 degree angles from center (%s)") },
{ extend_mask, "constrain-scale", N_("Scale"),
N_("Maintain aspect ratio when scaling (%s)") },
{ extend_mask, "constrain-rotate", N_("Rotate"),
N_("Constrain rotation to 15 degree increments (%s)") },
{ extend_mask, "constrain-shear", N_("Shear"),
N_("Shear along edge direction only (%s)") },
{ extend_mask, "constrain-perspective", N_("Perspective"),
N_("Constrain perspective handles to move along edges and diagonal (%s)") },
{ constrain_mask, NULL,
N_("From pivot (%s)") },
{ constrain_mask, "frompivot-scale", N_("Scale"),
N_("Scale from pivot point (%s)") },
{ constrain_mask, "frompivot-shear", N_("Shear"),
N_("Shear opposite edge by same amount (%s)") },
{ constrain_mask, "frompivot-perspective", N_("Perspective"),
N_("Maintain position of pivot while changing perspective (%s)") },
{ 0, NULL,
N_("Pivot") },
{ extend_mask, "cornersnap", N_("Snap (%s)"),
N_("Snap pivot to corners and center (%s)") },
{ 0, "fixedpivot", N_("Lock"),
N_("Lock pivot position to canvas") },
};
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-16 00:17:56 +02:00
gchar *label;
gint i;
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 16:25:03 -04:00
frame = NULL;
for (i = 0; i < G_N_ELEMENTS (opt_list); i++)
{
if (! opt_list[i].name && ! opt_list[i].desc)
{
frame = NULL;
continue;
}
label = g_strdup_printf (gettext (opt_list[i].desc),
gimp_get_mod_string (opt_list[i].mod));
if (opt_list[i].name)
{
button = gimp_prop_check_button_new (config, opt_list[i].name,
label);
gtk_box_pack_start (GTK_BOX (frame ? grid_box : vbox),
button, FALSE, FALSE, 0);
g_free (label);
label = g_strdup_printf (gettext (opt_list[i].tip),
gimp_get_mod_string (opt_list[i].mod));
gimp_help_set_help_data (button, label, NULL);
}
else
{
frame = gimp_frame_new (label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
grid_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_container_add (GTK_CONTAINER (frame), grid_box);
gtk_widget_show (grid_box);
}
g_free (label);
}
}
return vbox;
}
gboolean
gimp_transform_grid_options_show_preview (GimpTransformGridOptions *options)
{
GimpTransformOptions *transform_options;
g_return_val_if_fail (GIMP_IS_TRANSFORM_GRID_OPTIONS (options), FALSE);
transform_options = GIMP_TRANSFORM_OPTIONS (options);
app: add "Image" transform type to transform tools Add a new "Image" transform type to the transform tools, in addition to the existing "Layer", "Selection", and "Path" transform types. The "Image" mode transforms the entire image, rather than a single item. In tools with a preview, the preview shows the transformed image projection. The clipping mode controls how the canvas is clipped during the transform; in particular, the ADJUST clipping mode resizes the canvas to fit its transformed size.
2019-08-10 22:57:55 +03:00
if (options->show_preview)
{
switch (transform_options->type)
{
case GIMP_TRANSFORM_TYPE_LAYER:
case GIMP_TRANSFORM_TYPE_IMAGE:
return TRUE;
case GIMP_TRANSFORM_TYPE_SELECTION:
case GIMP_TRANSFORM_TYPE_PATH:
return FALSE;
}
}
return FALSE;
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 16:25:03 -04:00
}
/* private functions */
static gboolean
gimp_transform_grid_options_sync_grid (GBinding *binding,
const GValue *source_value,
GValue *target_value,
gpointer user_data)
{
GimpGuidesType type = g_value_get_enum (source_value);
g_value_set_boolean (target_value,
type == GIMP_GUIDES_N_LINES ||
type == GIMP_GUIDES_SPACING);
return TRUE;
}
Copy Permalink