mirror of
https://gitlab.gnome.org/GNOME/gimp
synced 2024-10-23 04:51:44 +00:00
ef9b04c535
2005-12-27 Michael Natterer <mitch@gimp.org> Fixed incomplete core/ui separation of paint tools and paint methods: * app/core/core-enums.h * app/core/gimpcontext.[ch]: added a "paint-info" property and API so the current paint method can be selected without the need for an active tool. (gimp_context_real_set_tool): set the paint-info to tool_info->paint_info so the paint method follows the active tool just as the active image follows the active display. * app/core/gimp.h (struct Gimp) * app/core/gimppaintinfo.[ch]: added "standard_paint_info" API and stuff to be consistent with other context object properties. * app/paint/gimp-paint.c: set the paintbrush as standard_paint_info. * app/core/gimpstrokedesc.c (gimp_stroke_desc_new): removed the hack of falling back to the paintbrush when there is no active tool and use the active paint method instead. Fall back to the standard paint method if there is no active one. (nothing in the core uses the active tool any more now). * app/widgets/gimpdeviceinfo.h: add the paint info to the properties which are saved in devicerc. Added identifiers (names) and stock-ids to GimpPaintInfo: * app/core/gimppaintinfo.[ch] (gimp_paint_info_new): added identifier and stock-id parameters. * app/core/gimptoolinfo.c (gimp_tool_info_new): removed the hack of setting the paint-info stock-id from the tool-info stock-id. * app/paint/paint-types.h * app/paint/gimp-paint.c: changed GimpPaintRegisterCallback accordingly. * app/tools/gimp-tools.c (gimp_tools_register): changed paint info names accordingly. * app/paint/*.c (gimp_*_register): pass identifier and stock-id accordingly.
373 lines
12 KiB
C
373 lines
12 KiB
C
/* The GIMP -- an image manipulation program
|
|
* Copyright (C) 1995-1999 Spencer Kimball and Peter Mattis
|
|
*
|
|
* gimpstrokedesc.c
|
|
* Copyright (C) 2004 Michael Natterer <mitch@gimp.org>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <glib-object.h>
|
|
|
|
#include "libgimpbase/gimpbase.h"
|
|
#include "libgimpconfig/gimpconfig.h"
|
|
|
|
#include "core-types.h"
|
|
|
|
#include "config/gimpcoreconfig.h"
|
|
|
|
#include "gimp.h"
|
|
#include "gimpcontainer.h"
|
|
#include "gimpcontext.h"
|
|
#include "gimppaintinfo.h"
|
|
#include "gimpstrokedesc.h"
|
|
#include "gimpstrokeoptions.h"
|
|
|
|
#include "paint/gimppaintoptions.h"
|
|
|
|
|
|
enum
|
|
{
|
|
PROP_0,
|
|
PROP_GIMP,
|
|
PROP_METHOD,
|
|
PROP_STROKE_OPTIONS,
|
|
PROP_PAINT_INFO,
|
|
PROP_PAINT_OPTIONS
|
|
};
|
|
|
|
|
|
static GObject * gimp_stroke_desc_constructor (GType type,
|
|
guint n_params,
|
|
GObjectConstructParam *params);
|
|
static void gimp_stroke_desc_finalize (GObject *object);
|
|
static void gimp_stroke_desc_set_property (GObject *object,
|
|
guint property_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec);
|
|
static void gimp_stroke_desc_get_property (GObject *object,
|
|
guint property_id,
|
|
GValue *value,
|
|
GParamSpec *pspec);
|
|
|
|
|
|
G_DEFINE_TYPE_WITH_CODE (GimpStrokeDesc, gimp_stroke_desc, GIMP_TYPE_OBJECT,
|
|
G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONFIG, NULL));
|
|
|
|
#define parent_class gimp_stroke_desc_parent_class
|
|
|
|
|
|
static void
|
|
gimp_stroke_desc_class_init (GimpStrokeDescClass *klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
|
|
object_class->constructor = gimp_stroke_desc_constructor;
|
|
object_class->finalize = gimp_stroke_desc_finalize;
|
|
object_class->set_property = gimp_stroke_desc_set_property;
|
|
object_class->get_property = gimp_stroke_desc_get_property;
|
|
|
|
g_object_class_install_property (object_class, PROP_GIMP,
|
|
g_param_spec_object ("gimp",
|
|
NULL, NULL,
|
|
GIMP_TYPE_GIMP,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT_ONLY));
|
|
|
|
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_METHOD,
|
|
"method", NULL,
|
|
GIMP_TYPE_STROKE_METHOD,
|
|
GIMP_STROKE_METHOD_LIBART,
|
|
0);
|
|
|
|
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_STROKE_OPTIONS,
|
|
"stroke-options", NULL,
|
|
GIMP_TYPE_STROKE_OPTIONS,
|
|
GIMP_CONFIG_PARAM_AGGREGATE);
|
|
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_PAINT_INFO,
|
|
"paint-info", NULL,
|
|
GIMP_TYPE_PAINT_INFO,
|
|
0);
|
|
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_PAINT_OPTIONS,
|
|
"paint-options", NULL,
|
|
GIMP_TYPE_PAINT_OPTIONS,
|
|
0);
|
|
}
|
|
|
|
static void
|
|
gimp_stroke_desc_init (GimpStrokeDesc *desc)
|
|
{
|
|
}
|
|
|
|
static GObject *
|
|
gimp_stroke_desc_constructor (GType type,
|
|
guint n_params,
|
|
GObjectConstructParam *params)
|
|
{
|
|
GObject *object;
|
|
GimpStrokeDesc *desc;
|
|
|
|
object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
|
|
|
|
desc = GIMP_STROKE_DESC (object);
|
|
|
|
g_assert (GIMP_IS_GIMP (desc->gimp));
|
|
|
|
desc->stroke_options = g_object_new (GIMP_TYPE_STROKE_OPTIONS,
|
|
"gimp", desc->gimp,
|
|
NULL);
|
|
|
|
return object;
|
|
}
|
|
|
|
static void
|
|
gimp_stroke_desc_finalize (GObject *object)
|
|
{
|
|
GimpStrokeDesc *desc = GIMP_STROKE_DESC (object);
|
|
|
|
if (desc->stroke_options)
|
|
{
|
|
g_object_unref (desc->stroke_options);
|
|
desc->stroke_options = NULL;
|
|
}
|
|
|
|
if (desc->paint_info)
|
|
{
|
|
g_object_unref (desc->paint_info);
|
|
desc->paint_info = NULL;
|
|
}
|
|
|
|
if (desc->paint_options)
|
|
{
|
|
g_object_unref (desc->paint_options);
|
|
desc->paint_options = NULL;
|
|
}
|
|
|
|
G_OBJECT_CLASS (parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
gimp_stroke_desc_set_property (GObject *object,
|
|
guint property_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
GimpStrokeDesc *desc = GIMP_STROKE_DESC (object);
|
|
|
|
switch (property_id)
|
|
{
|
|
case PROP_GIMP:
|
|
desc->gimp = g_value_get_object (value);
|
|
break;
|
|
case PROP_METHOD:
|
|
desc->method = g_value_get_enum (value);
|
|
break;
|
|
case PROP_STROKE_OPTIONS:
|
|
if (g_value_get_object (value))
|
|
gimp_config_sync (g_value_get_object (value),
|
|
G_OBJECT (desc->stroke_options), 0);
|
|
break;
|
|
case PROP_PAINT_INFO:
|
|
if (desc->paint_info)
|
|
g_object_unref (desc->paint_info);
|
|
desc->paint_info = (GimpPaintInfo *) g_value_dup_object (value);
|
|
break;
|
|
case PROP_PAINT_OPTIONS:
|
|
if (desc->paint_options)
|
|
g_object_unref (desc->paint_options);
|
|
desc->paint_options = (GimpPaintOptions *) g_value_dup_object (value);
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gimp_stroke_desc_get_property (GObject *object,
|
|
guint property_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
GimpStrokeDesc *desc = GIMP_STROKE_DESC (object);
|
|
|
|
switch (property_id)
|
|
{
|
|
case PROP_GIMP:
|
|
g_value_set_object (value, desc->gimp);
|
|
break;
|
|
case PROP_METHOD:
|
|
g_value_set_enum (value, desc->method);
|
|
break;
|
|
case PROP_STROKE_OPTIONS:
|
|
g_value_set_object (value, desc->stroke_options);
|
|
break;
|
|
case PROP_PAINT_INFO:
|
|
g_value_set_object (value, desc->paint_info);
|
|
break;
|
|
case PROP_PAINT_OPTIONS:
|
|
g_value_set_object (value, desc->paint_options);
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/* public functions */
|
|
|
|
GimpStrokeDesc *
|
|
gimp_stroke_desc_new (Gimp *gimp,
|
|
GimpContext *context)
|
|
{
|
|
GimpPaintInfo *paint_info = NULL;
|
|
GimpStrokeDesc *desc;
|
|
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
g_return_val_if_fail (context == NULL || GIMP_IS_CONTEXT (context), NULL);
|
|
|
|
if (context)
|
|
{
|
|
paint_info = gimp_context_get_paint_info (context);
|
|
|
|
if (! paint_info)
|
|
paint_info = gimp_paint_info_get_standard (gimp);
|
|
}
|
|
|
|
desc = g_object_new (GIMP_TYPE_STROKE_DESC,
|
|
"gimp", gimp,
|
|
"paint-info", paint_info,
|
|
NULL);
|
|
|
|
gimp_context_define_properties (GIMP_CONTEXT (desc->stroke_options),
|
|
GIMP_CONTEXT_FOREGROUND_MASK |
|
|
GIMP_CONTEXT_PATTERN_MASK,
|
|
FALSE);
|
|
|
|
if (context)
|
|
gimp_context_set_parent (GIMP_CONTEXT (desc->stroke_options), context);
|
|
|
|
return desc;
|
|
}
|
|
|
|
GimpStrokeDesc *
|
|
gimp_stroke_desc_duplicate (GimpStrokeDesc *desc)
|
|
{
|
|
GimpStrokeDesc *new_desc;
|
|
GimpStrokeOptions *stroke_options = NULL;
|
|
GimpPaintInfo *paint_info = NULL;
|
|
GimpPaintOptions *paint_options = NULL;
|
|
|
|
new_desc = gimp_stroke_desc_new (desc->gimp,
|
|
GIMP_CONTEXT (desc->stroke_options));
|
|
|
|
new_desc->method = desc->method;
|
|
|
|
g_object_get (G_OBJECT (desc),
|
|
"stroke-options", stroke_options,
|
|
"paint-info", paint_info,
|
|
"paint-options", paint_options,
|
|
NULL);
|
|
|
|
g_object_set (G_OBJECT (new_desc),
|
|
"stroke-options", stroke_options,
|
|
"paint-info", paint_info,
|
|
"paint-options", paint_options,
|
|
NULL);
|
|
|
|
return new_desc;
|
|
}
|
|
|
|
void
|
|
gimp_stroke_desc_prepare (GimpStrokeDesc *desc,
|
|
GimpContext *context,
|
|
gboolean use_default_values)
|
|
{
|
|
g_return_if_fail (GIMP_IS_STROKE_DESC (desc));
|
|
g_return_if_fail (GIMP_IS_CONTEXT (context));
|
|
|
|
switch (desc->method)
|
|
{
|
|
case GIMP_STROKE_METHOD_LIBART:
|
|
break;
|
|
|
|
case GIMP_STROKE_METHOD_PAINT_CORE:
|
|
{
|
|
GimpPaintInfo *paint_info = desc->paint_info;
|
|
GimpPaintOptions *paint_options;
|
|
|
|
if (use_default_values)
|
|
{
|
|
paint_options = gimp_paint_options_new (paint_info);
|
|
|
|
/* undefine the paint-relevant context properties and get them
|
|
* from the passed context
|
|
*/
|
|
gimp_context_define_properties (GIMP_CONTEXT (paint_options),
|
|
GIMP_CONTEXT_PAINT_PROPS_MASK,
|
|
FALSE);
|
|
gimp_context_set_parent (GIMP_CONTEXT (paint_options), context);
|
|
}
|
|
else
|
|
{
|
|
GimpCoreConfig *config = context->gimp->config;
|
|
GimpContextPropMask global_props = 0;
|
|
|
|
paint_options =
|
|
gimp_config_duplicate (GIMP_CONFIG (paint_info->paint_options));
|
|
|
|
/* FG and BG are always shared between all tools */
|
|
global_props |= GIMP_CONTEXT_FOREGROUND_MASK;
|
|
global_props |= GIMP_CONTEXT_BACKGROUND_MASK;
|
|
|
|
if (config->global_brush)
|
|
global_props |= GIMP_CONTEXT_BRUSH_MASK;
|
|
if (config->global_pattern)
|
|
global_props |= GIMP_CONTEXT_PATTERN_MASK;
|
|
if (config->global_palette)
|
|
global_props |= GIMP_CONTEXT_PALETTE_MASK;
|
|
if (config->global_gradient)
|
|
global_props |= GIMP_CONTEXT_GRADIENT_MASK;
|
|
if (config->global_font)
|
|
global_props |= GIMP_CONTEXT_FONT_MASK;
|
|
|
|
gimp_context_copy_properties (context,
|
|
GIMP_CONTEXT (paint_options),
|
|
global_props);
|
|
}
|
|
|
|
g_object_set (desc, "paint-options", paint_options, NULL);
|
|
g_object_unref (paint_options);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
g_return_if_reached ();
|
|
}
|
|
}
|
|
|
|
void
|
|
gimp_stroke_desc_finish (GimpStrokeDesc *desc)
|
|
{
|
|
g_return_if_fail (GIMP_IS_STROKE_DESC (desc));
|
|
|
|
g_object_set (desc, "paint-options", NULL, NULL);
|
|
}
|