dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

app, libgimp*, modules: don't use g_type_class_add_private() ... 

... and G_TYPE_INSTANCE_GET_PRIVATE()

g_type_class_add_private() and G_TYPE_INSTANCE_GET_PRIVATE() were
deprecated in GLib 2.58.  Instead, use
G_DEFINE_[ABSTRACT_]TYPE_WITH_PRIVATE(), and
G_ADD_PRIVATE[_DYNAMIC](), and the implictly-defined
foo_get_instance_private() functions, all of which are available in
the GLib versions we depend on.

This commit only covers types registered using one of the
G_DEFINE_FOO() macros (i.e., most types), but not types with a
custom registration function, of which we still have a few -- GLib
currently only provides a (non-deprecated) public API for adding a
private struct using the G_DEFINE_FOO() macros.

Note that this commit was 99% auto-generated (because I'm not
*that* crazy :), so if there are any style mismatches... we'll have
to live with them for now.
This commit is contained in:
Ell 2018-09-18 12:09:39 -04:00
parent d5586ed9d0
commit 3b0040c043
193 changed files with 540 additions and 1184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
app/config/gimpdialogconfig.c
View File

@ -121,9 +121,7 @@ struct _GimpDialogConfigPrivate
};
#define GET_PRIVATE(config) \
G_TYPE_INSTANCE_GET_PRIVATE (config, \
GIMP_TYPE_DIALOG_CONFIG, \
GimpDialogConfigPrivate)
((GimpDialogConfigPrivate *) gimp_dialog_config_get_instance_private ((GimpDialogConfig *) (config)))
static void gimp_dialog_config_constructed (GObject *object);
@ -145,7 +143,8 @@ static void gimp_dialog_config_stroke_options_notify (GObject *object,
gpointer data);
G_DEFINE_TYPE (GimpDialogConfig, gimp_dialog_config, GIMP_TYPE_GUI_CONFIG)
G_DEFINE_TYPE_WITH_PRIVATE (GimpDialogConfig, gimp_dialog_config,
GIMP_TYPE_GUI_CONFIG)
#define parent_class gimp_dialog_config_parent_class
@ -524,8 +523,6 @@ gimp_dialog_config_class_init (GimpDialogConfigClass *klass)
GIMP_TYPE_STROKE_OPTIONS,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_AGGREGATE);
g_type_class_add_private (klass, sizeof (GimpDialogConfigPrivate));
}
static void

7
app/core/gimpasync.c
View File

@ -112,6 +112,7 @@ static void gimp_async_run_callbacks (GimpAsync *async
G_DEFINE_TYPE_WITH_CODE (GimpAsync, gimp_async, G_TYPE_OBJECT,
G_ADD_PRIVATE (GimpAsync)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_WAITABLE,
gimp_async_waitable_iface_init)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_CANCELABLE,
@ -134,8 +135,6 @@ gimp_async_class_init (GimpAsyncClass *klass)
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gimp_async_finalize;
g_type_class_add_private (klass, sizeof (GimpAsyncPrivate));
}
static void
@ -155,9 +154,7 @@ gimp_async_cancelable_iface_init (GimpCancelableInterface *iface)
static void
gimp_async_init (GimpAsync *async)
{
async->priv = G_TYPE_INSTANCE_GET_PRIVATE (async,
GIMP_TYPE_ASYNC,
GimpAsyncPrivate);
async->priv = gimp_async_get_instance_private (async);
g_mutex_init (&async->priv->mutex);
g_cond_init (&async->priv->cond);

7
app/core/gimpasyncset.c
View File

@ -73,6 +73,7 @@ static void gimp_async_set_async_callback (GimpAsync
G_DEFINE_TYPE_WITH_CODE (GimpAsyncSet, gimp_async_set, G_TYPE_OBJECT,
G_ADD_PRIVATE (GimpAsyncSet)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_WAITABLE,
gimp_async_set_waitable_iface_init)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_CANCELABLE,
@ -99,8 +100,6 @@ gimp_async_set_class_init (GimpAsyncSetClass *klass)
NULL, NULL,
FALSE,
GIMP_PARAM_READABLE));
g_type_class_add_private (klass, sizeof (GimpAsyncSetPrivate));
}
static void
@ -120,9 +119,7 @@ gimp_async_set_cancelable_iface_init (GimpCancelableInterface *iface)
static void
gimp_async_set_init (GimpAsyncSet *async_set)
{
async_set->priv = G_TYPE_INSTANCE_GET_PRIVATE (async_set,
GIMP_TYPE_ASYNC_SET,
GimpAsyncSetPrivate);
async_set->priv = gimp_async_set_get_instance_private (async_set);
async_set->priv->asyncs = g_hash_table_new (NULL, NULL);
}

8
app/core/gimpauxitem.c
View File

@ -53,7 +53,7 @@ static void gimp_aux_item_set_property (GObject *object,
GParamSpec *pspec);
G_DEFINE_ABSTRACT_TYPE (GimpAuxItem, gimp_aux_item, G_TYPE_OBJECT)
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GimpAuxItem, gimp_aux_item, G_TYPE_OBJECT)
static guint gimp_aux_item_signals[LAST_SIGNAL] = { 0 };
@ -82,16 +82,12 @@ gimp_aux_item_class_init (GimpAuxItemClass *klass)
0, G_MAXUINT32, 0,
G_PARAM_CONSTRUCT_ONLY |
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpAuxItemPrivate));
}
static void
gimp_aux_item_init (GimpAuxItem *aux_item)
{
aux_item->priv = G_TYPE_INSTANCE_GET_PRIVATE (aux_item,
GIMP_TYPE_AUX_ITEM,
GimpAuxItemPrivate);
aux_item->priv = gimp_aux_item_get_instance_private (aux_item);
}
static void

7
app/core/gimpbrush.c
View File

@ -96,6 +96,7 @@ static gchar * gimp_brush_get_checksum (GimpTagged *tag
G_DEFINE_TYPE_WITH_CODE (GimpBrush, gimp_brush, GIMP_TYPE_DATA,
G_ADD_PRIVATE (GimpBrush)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_TAGGED,
gimp_brush_tagged_iface_init))
@ -151,8 +152,6 @@ gimp_brush_class_init (GimpBrushClass *klass)
1.0, 5000.0, 20.0,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_type_class_add_private (klass, sizeof (GimpBrushPrivate));
}
static void
@ -164,9 +163,7 @@ gimp_brush_tagged_iface_init (GimpTaggedInterface *iface)
static void
gimp_brush_init (GimpBrush *brush)
{
brush->priv = G_TYPE_INSTANCE_GET_PRIVATE (brush,
GIMP_TYPE_BRUSH,
GimpBrushPrivate);
brush->priv = gimp_brush_get_instance_private (brush);
brush->priv->spacing = 20;
brush->priv->x_axis.x = 15.0;

9
app/core/gimpcontainer.c
View File

@ -69,7 +69,7 @@ typedef struct
GQuark quark; /* used to attach the signal id's of child signals */
} GimpContainerHandler;
struct _GimpContainerPriv
struct _GimpContainerPrivate
{
GType children_type;
GimpContainerPolicy policy;
@ -116,6 +116,7 @@ static void gimp_container_disconnect_callback (GimpObject *object,
G_DEFINE_TYPE_WITH_CODE (GimpContainer, gimp_container, GIMP_TYPE_OBJECT,
G_ADD_PRIVATE (GimpContainer)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONFIG,
gimp_container_config_iface_init))
@ -212,8 +213,6 @@ gimp_container_class_init (GimpContainerClass *klass)
GIMP_CONTAINER_POLICY_STRONG,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_type_class_add_private (klass, sizeof (GimpContainerPriv));
}
static void
@ -226,9 +225,7 @@ gimp_container_config_iface_init (GimpConfigInterface *iface)
static void
gimp_container_init (GimpContainer *container)
{
container->priv = G_TYPE_INSTANCE_GET_PRIVATE (container,
GIMP_TYPE_CONTAINER,
GimpContainerPriv);
container->priv = gimp_container_get_instance_private (container);
container->priv->handlers = NULL;
container->priv->freeze_count = 0;

8
app/core/gimpcontainer.h
View File

@ -33,14 +33,14 @@
#define GIMP_CONTAINER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_CONTAINER, GimpContainerClass))
typedef struct _GimpContainerClass GimpContainerClass;
typedef struct _GimpContainerPriv GimpContainerPriv;
typedef struct _GimpContainerClass GimpContainerClass;
typedef struct _GimpContainerPrivate GimpContainerPrivate;
struct _GimpContainer
{
GimpObject parent_instance;
GimpObject parent_instance;
GimpContainerPriv *priv;
GimpContainerPrivate *priv;
};
struct _GimpContainerClass

9
app/core/gimpdatafactory.c
View File

@ -106,7 +106,8 @@ static GFile * gimp_data_factory_get_save_dir (GimpDataFactory *fa
GError **error);
G_DEFINE_ABSTRACT_TYPE (GimpDataFactory, gimp_data_factory, GIMP_TYPE_OBJECT)
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GimpDataFactory, gimp_data_factory,
GIMP_TYPE_OBJECT)
#define parent_class gimp_data_factory_parent_class
@ -174,16 +175,12 @@ gimp_data_factory_class_init (GimpDataFactoryClass *klass)
NULL, NULL,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_type_class_add_private (klass, sizeof (GimpDataFactoryPrivate));
}
static void
gimp_data_factory_init (GimpDataFactory *factory)
{
factory->priv = G_TYPE_INSTANCE_GET_PRIVATE (factory,
GIMP_TYPE_DATA_FACTORY,
GimpDataFactoryPrivate);
factory->priv = gimp_data_factory_get_instance_private (factory);
factory->priv->async_set = gimp_async_set_new ();
}

10
app/core/gimpdataloaderfactory.c
View File

@ -99,8 +99,8 @@ static GimpDataLoader * gimp_data_loader_new (const gchar *name,
static void gimp_data_loader_free (GimpDataLoader *loader);
G_DEFINE_TYPE (GimpDataLoaderFactory, gimp_data_loader_factory,
GIMP_TYPE_DATA_FACTORY)
G_DEFINE_TYPE_WITH_PRIVATE (GimpDataLoaderFactory, gimp_data_loader_factory,
GIMP_TYPE_DATA_FACTORY)
#define parent_class gimp_data_loader_factory_parent_class
@ -115,16 +115,12 @@ gimp_data_loader_factory_class_init (GimpDataLoaderFactoryClass *klass)
factory_class->data_init = gimp_data_loader_factory_data_init;
factory_class->data_refresh = gimp_data_loader_factory_data_refresh;
g_type_class_add_private (klass, sizeof (GimpDataLoaderFactoryPrivate));
}
static void
gimp_data_loader_factory_init (GimpDataLoaderFactory *factory)
{
factory->priv = G_TYPE_INSTANCE_GET_PRIVATE (factory,
GIMP_TYPE_DATA_LOADER_FACTORY,
GimpDataLoaderFactoryPrivate);
factory->priv = gimp_data_loader_factory_get_instance_private (factory);
}
static void

7
app/core/gimpdrawable.c
View File

@ -199,6 +199,7 @@ static GeglNode * gimp_drawable_real_get_source_node (GimpDrawable *drawable)
G_DEFINE_TYPE_WITH_CODE (GimpDrawable, gimp_drawable, GIMP_TYPE_ITEM,
G_ADD_PRIVATE (GimpDrawable)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_COLOR_MANAGED,
gimp_color_managed_iface_init)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_PICKABLE,
@ -277,16 +278,12 @@ gimp_drawable_class_init (GimpDrawableClass *klass)
klass->get_source_node = gimp_drawable_real_get_source_node;
g_object_class_override_property (object_class, PROP_BUFFER, "buffer");
g_type_class_add_private (klass, sizeof (GimpDrawablePrivate));
}
static void
gimp_drawable_init (GimpDrawable *drawable)
{
drawable->private = G_TYPE_INSTANCE_GET_PRIVATE (drawable,
GIMP_TYPE_DRAWABLE,
GimpDrawablePrivate);
drawable->private = gimp_drawable_get_instance_private (drawable);
drawable->private->filter_stack = gimp_filter_stack_new (GIMP_TYPE_FILTER);
}

9
app/core/gimpdynamics.c
View File

@ -74,9 +74,7 @@ struct _GimpDynamicsPrivate
};
#define GET_PRIVATE(output) \
G_TYPE_INSTANCE_GET_PRIVATE (output, \
GIMP_TYPE_DYNAMICS, \
GimpDynamicsPrivate)
((GimpDynamicsPrivate *) gimp_dynamics_get_instance_private ((GimpDynamics *) (output)))
static void gimp_dynamics_finalize (GObject *object);
@ -106,8 +104,7 @@ static void gimp_dynamics_output_notify (GObject *output,
GimpDynamics *dynamics);
G_DEFINE_TYPE (GimpDynamics, gimp_dynamics,
GIMP_TYPE_DATA)
G_DEFINE_TYPE_WITH_PRIVATE (GimpDynamics, gimp_dynamics, GIMP_TYPE_DATA)
#define parent_class gimp_dynamics_parent_class
@ -201,8 +198,6 @@ gimp_dynamics_class_init (GimpDynamicsClass *klass)
NULL, NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
g_type_class_add_private (klass, sizeof (GimpDynamicsPrivate));
}
static void

7
app/core/gimpdynamicsoutput.c
View File

@ -91,9 +91,7 @@ struct _GimpDynamicsOutputPrivate
};
#define GET_PRIVATE(output) \
G_TYPE_INSTANCE_GET_PRIVATE (output, \
GIMP_TYPE_DYNAMICS_OUTPUT, \
GimpDynamicsOutputPrivate)
((GimpDynamicsOutputPrivate *) gimp_dynamics_output_get_instance_private ((GimpDynamicsOutput *) (output)))
static void gimp_dynamics_output_finalize (GObject *object);
@ -117,6 +115,7 @@ static void gimp_dynamics_output_curve_dirty (GimpCurve *curve,
G_DEFINE_TYPE_WITH_CODE (GimpDynamicsOutput, gimp_dynamics_output,
GIMP_TYPE_OBJECT,
G_ADD_PRIVATE (GimpDynamicsOutput)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONFIG, NULL))
#define parent_class gimp_dynamics_output_parent_class
@ -222,8 +221,6 @@ gimp_dynamics_output_class_init (GimpDynamicsOutputClass *klass)
NULL, NULL,
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
g_type_class_add_private (klass, sizeof (GimpDynamicsOutputPrivate));
}
static void

8
app/core/gimpextension.c
View File

@ -108,7 +108,7 @@ static void appstream_text_characters (GMarkupParseContext *contex
gpointer user_data,
GError **error);
G_DEFINE_TYPE (GimpExtension, gimp_extension, GIMP_TYPE_OBJECT)
G_DEFINE_TYPE_WITH_PRIVATE (GimpExtension, gimp_extension, GIMP_TYPE_OBJECT)
#define parent_class gimp_extension_parent_class
@ -136,16 +136,12 @@ gimp_extension_class_init (GimpExtensionClass *klass)
g_param_spec_boolean ("running",
NULL, NULL, FALSE,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpExtensionPrivate));
}
static void
gimp_extension_init (GimpExtension *extension)
{
extension->p = G_TYPE_INSTANCE_GET_PRIVATE (extension,
GIMP_TYPE_EXTENSION,
GimpExtensionPrivate);
extension->p = gimp_extension_get_instance_private (extension);
}
static void

10
app/core/gimpextensionmanager.c
View File

@ -115,7 +115,9 @@ static void gimp_extension_manager_extension_running (GimpExtension
GParamSpec *pspec,
GimpExtensionManager *manager);
G_DEFINE_TYPE_WITH_CODE (GimpExtensionManager, gimp_extension_manager, GIMP_TYPE_OBJECT,
G_DEFINE_TYPE_WITH_CODE (GimpExtensionManager, gimp_extension_manager,
GIMP_TYPE_OBJECT,
G_ADD_PRIVATE (GimpExtensionManager)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONFIG,
gimp_extension_manager_config_iface_init))
@ -176,16 +178,12 @@ gimp_extension_manager_class_init (GimpExtensionManagerClass *klass)
g_param_spec_pointer ("plug-in-paths",
NULL, NULL,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpExtensionManagerPrivate));
}
static void
gimp_extension_manager_init (GimpExtensionManager *manager)
{
manager->p = G_TYPE_INSTANCE_GET_PRIVATE (manager,
GIMP_TYPE_EXTENSION_MANAGER,
GimpExtensionManagerPrivate);
manager->p = gimp_extension_manager_get_instance_private (manager);
manager->p->extensions = NULL;
manager->p->sys_extensions = NULL;
}

7
app/core/gimpfilloptions.c
View File

@ -64,9 +64,7 @@ struct _GimpFillOptionsPrivate
};
#define GET_PRIVATE(options) \
G_TYPE_INSTANCE_GET_PRIVATE (options, \
GIMP_TYPE_FILL_OPTIONS, \
GimpFillOptionsPrivate)
((GimpFillOptionsPrivate *) gimp_fill_options_get_instance_private ((GimpFillOptions *) (options)))
static void gimp_fill_options_config_init (GimpConfigInterface *iface);
@ -86,6 +84,7 @@ static gboolean gimp_fill_options_serialize (GimpConfig *config,
G_DEFINE_TYPE_WITH_CODE (GimpFillOptions, gimp_fill_options, GIMP_TYPE_CONTEXT,
G_ADD_PRIVATE (GimpFillOptions)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONFIG,
gimp_fill_options_config_init))
@ -129,8 +128,6 @@ gimp_fill_options_class_init (GimpFillOptionsClass *klass)
GIMP_VIEW_SIZE_SMALL,
G_PARAM_CONSTRUCT |
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpFillOptionsPrivate));
}
static void

8
app/core/gimpfilter.c
View File

@ -56,9 +56,7 @@ struct _GimpFilterPrivate
GimpApplicator *applicator;
};
#define GET_PRIVATE(filter) G_TYPE_INSTANCE_GET_PRIVATE (filter, \
GIMP_TYPE_FILTER, \
GimpFilterPrivate)
#define GET_PRIVATE(filter) ((GimpFilterPrivate *) gimp_filter_get_instance_private ((GimpFilter *) (filter)))
/* local function prototypes */
@ -79,7 +77,7 @@ static gint64 gimp_filter_get_memsize (GimpObject *object,
static GeglNode * gimp_filter_real_get_node (GimpFilter *filter);
G_DEFINE_TYPE (GimpFilter, gimp_filter, GIMP_TYPE_VIEWABLE)
G_DEFINE_TYPE_WITH_PRIVATE (GimpFilter, gimp_filter, GIMP_TYPE_VIEWABLE)
#define parent_class gimp_filter_parent_class
@ -120,8 +118,6 @@ gimp_filter_class_init (GimpFilterClass *klass)
NULL, NULL,
FALSE,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpFilterPrivate));
}
static void

7
app/core/gimpgrouplayer.c
View File

@ -74,9 +74,7 @@ struct _GimpGroupLayerPrivate
gint reallocate_height;
};
#define GET_PRIVATE(item) G_TYPE_INSTANCE_GET_PRIVATE (item, \
GIMP_TYPE_GROUP_LAYER, \
GimpGroupLayerPrivate)
#define GET_PRIVATE(item) ((GimpGroupLayerPrivate *) gimp_group_layer_get_instance_private ((GimpGroupLayer *) (item)))
static void gimp_projectable_iface_init (GimpProjectableInterface *iface);
@ -232,6 +230,7 @@ static void gimp_group_layer_proj_update (GimpProjection *proj,
G_DEFINE_TYPE_WITH_CODE (GimpGroupLayer, gimp_group_layer, GIMP_TYPE_LAYER,
G_ADD_PRIVATE (GimpGroupLayer)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_PROJECTABLE,
gimp_projectable_iface_init)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_PICKABLE,
@ -302,8 +301,6 @@ gimp_group_layer_class_init (GimpGroupLayerClass *klass)
layer_class->get_effective_mode = gimp_group_layer_get_effective_mode;
layer_class->get_excludes_backdrop = gimp_group_layer_get_excludes_backdrop;
g_type_class_add_private (klass, sizeof (GimpGroupLayerPrivate));
if (g_getenv ("GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION"))
no_pass_through_strength_reduction = TRUE;
}

7
app/core/gimpguide.c
View File

@ -58,7 +58,7 @@ static void gimp_guide_set_property (GObject *object,
GParamSpec *pspec);
G_DEFINE_TYPE (GimpGuide, gimp_guide, GIMP_TYPE_AUX_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpGuide, gimp_guide, GIMP_TYPE_AUX_ITEM)
static void
@ -90,15 +90,12 @@ gimp_guide_class_init (GimpGuideClass *klass)
GIMP_TYPE_GUIDE_STYLE,
GIMP_GUIDE_STYLE_NONE,
0);
g_type_class_add_private (klass, sizeof (GimpGuidePrivate));
}
static void
gimp_guide_init (GimpGuide *guide)
{
guide->priv = G_TYPE_INSTANCE_GET_PRIVATE (guide, GIMP_TYPE_GUIDE,
GimpGuidePrivate);
guide->priv = gimp_guide_get_instance_private (guide);
}
static void

8
app/core/gimphistogram.c
View File

@ -115,7 +115,7 @@ static void gimp_histogram_calculate_async_callback (GimpAsync *a
CalculateContext *context);
G_DEFINE_TYPE (GimpHistogram, gimp_histogram, GIMP_TYPE_OBJECT)
G_DEFINE_TYPE_WITH_PRIVATE (GimpHistogram, gimp_histogram, GIMP_TYPE_OBJECT)
#define parent_class gimp_histogram_parent_class
@ -147,16 +147,12 @@ gimp_histogram_class_init (GimpHistogramClass *klass)
g_param_spec_boolean ("values", NULL, NULL,
FALSE,
G_PARAM_READABLE));
g_type_class_add_private (klass, sizeof (GimpHistogramPrivate));
}
static void
gimp_histogram_init (GimpHistogram *histogram)
{
histogram->priv = G_TYPE_INSTANCE_GET_PRIVATE (histogram,
GIMP_TYPE_HISTOGRAM,
GimpHistogramPrivate);
histogram->priv = gimp_histogram_get_instance_private (histogram);
histogram->priv->n_bins = 256;
}

16
app/core/gimpidtable.c
View File

@ -33,7 +33,7 @@
#define GIMP_ID_TABLE_END_ID G_MAXINT
struct _GimpIdTablePriv
struct _GimpIdTablePrivate
{
GHashTable *id_table;
gint next_id;
@ -45,7 +45,7 @@ static gint64 gimp_id_table_get_memsize (GimpObject *object,
gint64 *gui_size);
G_DEFINE_TYPE (GimpIdTable, gimp_id_table, GIMP_TYPE_OBJECT)
G_DEFINE_TYPE_WITH_PRIVATE (GimpIdTable, gimp_id_table, GIMP_TYPE_OBJECT)
#define parent_class gimp_id_table_parent_class
@ -53,24 +53,18 @@ G_DEFINE_TYPE (GimpIdTable, gimp_id_table, GIMP_TYPE_OBJECT)
static void
gimp_id_table_class_init (GimpIdTableClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpObjectClass *gimp_object_class = GIMP_OBJECT_CLASS (klass);
GimpIdTableClass *gimp_id_table_class = GIMP_ID_TABLE_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpObjectClass *gimp_object_class = GIMP_OBJECT_CLASS (klass);
object_class->finalize = gimp_id_table_finalize;
gimp_object_class->get_memsize = gimp_id_table_get_memsize;
g_type_class_add_private (gimp_id_table_class,
sizeof (GimpIdTablePriv));
}
static void
gimp_id_table_init (GimpIdTable *id_table)
{
id_table->priv = G_TYPE_INSTANCE_GET_PRIVATE (id_table,
GIMP_TYPE_ID_TABLE,
GimpIdTablePriv);
id_table->priv = gimp_id_table_get_instance_private (id_table);
id_table->priv->id_table = g_hash_table_new (g_direct_hash, NULL);
id_table->priv->next_id = GIMP_ID_TABLE_START_ID;

8
app/core/gimpidtable.h
View File

@ -33,14 +33,14 @@
#define GIMP_ID_TABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_ID_TABLE, GimpIdTableClass))
typedef struct _GimpIdTableClass GimpIdTableClass;
typedef struct _GimpIdTablePriv GimpIdTablePriv;
typedef struct _GimpIdTableClass GimpIdTableClass;
typedef struct _GimpIdTablePrivate GimpIdTablePrivate;
struct _GimpIdTable
{
GimpObject parent_instance;
GimpObject parent_instance;
GimpIdTablePriv *priv;
GimpIdTablePrivate *priv;
};
struct _GimpIdTableClass

7
app/core/gimpimage-private.h
View File

@ -30,8 +30,6 @@ struct _GimpImageFlushAccumulator
};
typedef struct _GimpImagePrivate GimpImagePrivate;
struct _GimpImagePrivate
{
gint ID; /* provides a unique ID */
@ -132,10 +130,7 @@ struct _GimpImagePrivate
GimpImageFlushAccumulator flush_accum;
};
#define GIMP_IMAGE_GET_PRIVATE(image) \
G_TYPE_INSTANCE_GET_PRIVATE (image, \
GIMP_TYPE_IMAGE, \
GimpImagePrivate)
#define GIMP_IMAGE_GET_PRIVATE(image) (((GimpImage *) (image))->priv)
void gimp_image_take_mask (GimpImage *image,
GimpChannel *mask);

7
app/core/gimpimage.c
View File

@ -250,6 +250,7 @@ static void gimp_image_active_vectors_notify (GimpItemTree *tree,
G_DEFINE_TYPE_WITH_CODE (GimpImage, gimp_image, GIMP_TYPE_VIEWABLE,
G_ADD_PRIVATE (GimpImage)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_COLOR_MANAGED,
gimp_color_managed_iface_init)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_PROJECTABLE,
@ -650,8 +651,6 @@ gimp_image_class_init (GimpImageClass *klass)
GIMP_TYPE_SYMMETRY,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_type_class_add_private (klass, sizeof (GimpImagePrivate));
}
static void
@ -691,9 +690,11 @@ gimp_pickable_iface_init (GimpPickableInterface *iface)
static void
gimp_image_init (GimpImage *image)
{
GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
GimpImagePrivate *private = gimp_image_get_instance_private (image);
gint i;
image->priv = private;
private->ID = 0;
private->load_proc = NULL;

9
app/core/gimpimage.h
View File

@ -33,13 +33,16 @@
#define GIMP_IMAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_IMAGE, GimpImageClass))
typedef struct _GimpImageClass GimpImageClass;
typedef struct _GimpImageClass GimpImageClass;
typedef struct _GimpImagePrivate GimpImagePrivate;
struct _GimpImage
{
GimpViewable parent_instance;
GimpViewable parent_instance;
Gimp *gimp; /* the GIMP the image belongs to */
Gimp *gimp; /* the GIMP the image belongs to */
GimpImagePrivate *priv;
};
struct _GimpImageClass

8
app/core/gimpimagefile.c
View File

@ -73,9 +73,7 @@ struct _GimpImagefilePrivate
gboolean static_desc;
};
#define GET_PRIVATE(imagefile) G_TYPE_INSTANCE_GET_PRIVATE (imagefile, \
GIMP_TYPE_IMAGEFILE, \
GimpImagefilePrivate)
#define GET_PRIVATE(imagefile) ((GimpImagefilePrivate *) gimp_imagefile_get_instance_private ((GimpImagefile *) (imagefile)))
static void gimp_imagefile_dispose (GObject *object);
@ -118,7 +116,7 @@ static void gimp_thumbnail_set_info (GimpThumbnail *thumbnail,
gint num_layers);
G_DEFINE_TYPE (GimpImagefile, gimp_imagefile, GIMP_TYPE_VIEWABLE)
G_DEFINE_TYPE_WITH_PRIVATE (GimpImagefile, gimp_imagefile, GIMP_TYPE_VIEWABLE)
#define parent_class gimp_imagefile_parent_class
@ -159,8 +157,6 @@ gimp_imagefile_class_init (GimpImagefileClass *klass)
gimp_thumb_init (creator, NULL);
g_free (creator);
g_type_class_add_private (klass, sizeof (GimpImagefilePrivate));
}
static void

8
app/core/gimpitem.c
View File

@ -106,9 +106,7 @@ struct _GimpItemPrivate
GList *offset_nodes; /* offset nodes to manage */
};
#define GET_PRIVATE(item) G_TYPE_INSTANCE_GET_PRIVATE (item, \
GIMP_TYPE_ITEM, \
GimpItemPrivate)
#define GET_PRIVATE(item) ((GimpItemPrivate *) gimp_item_get_instance_private ((GimpItem *) (item)))
/* local function prototypes */
@ -168,7 +166,7 @@ static void gimp_item_real_resize (GimpItem *item,
G_DEFINE_TYPE (GimpItem, gimp_item, GIMP_TYPE_FILTER)
G_DEFINE_TYPE_WITH_PRIVATE (GimpItem, gimp_item, GIMP_TYPE_FILTER)
#define parent_class gimp_item_parent_class
@ -347,8 +345,6 @@ gimp_item_class_init (GimpItemClass *klass)
NULL, NULL,
FALSE,
GIMP_PARAM_READABLE));
g_type_class_add_private (klass, sizeof (GimpItemPrivate));
}
static void

8
app/core/gimpitemtree.c
View File

@ -60,9 +60,7 @@ struct _GimpItemTreePrivate
};
#define GIMP_ITEM_TREE_GET_PRIVATE(object) \
G_TYPE_INSTANCE_GET_PRIVATE (object, \
GIMP_TYPE_ITEM_TREE, \
GimpItemTreePrivate)
((GimpItemTreePrivate *) gimp_item_tree_get_instance_private ((GimpItemTree *) (object)))
/* local function prototypes */
@ -86,7 +84,7 @@ static void gimp_item_tree_uniquefy_name (GimpItemTree *tree,
const gchar *new_name);
G_DEFINE_TYPE (GimpItemTree, gimp_item_tree, GIMP_TYPE_OBJECT)
G_DEFINE_TYPE_WITH_PRIVATE (GimpItemTree, gimp_item_tree, GIMP_TYPE_OBJECT)
#define parent_class gimp_item_tree_parent_class
@ -130,8 +128,6 @@ gimp_item_tree_class_init (GimpItemTreeClass *klass)
NULL, NULL,
GIMP_TYPE_ITEM,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpItemTreePrivate));
}
static void

7
app/core/gimpmybrush.c
View File

@ -59,6 +59,7 @@ static gchar * gimp_mybrush_get_checksum (GimpTagged *t
G_DEFINE_TYPE_WITH_CODE (GimpMybrush, gimp_mybrush, GIMP_TYPE_DATA,
G_ADD_PRIVATE (GimpMybrush)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_TAGGED,
gimp_mybrush_tagged_iface_init))
@ -84,8 +85,6 @@ gimp_mybrush_class_init (GimpMybrushClass *klass)
data_class->dirty = gimp_mybrush_dirty;
data_class->get_extension = gimp_mybrush_get_extension;
g_type_class_add_private (klass, sizeof (GimpMybrushPrivate));
}
static void
@ -97,9 +96,7 @@ gimp_mybrush_tagged_iface_init (GimpTaggedInterface *iface)
static void
gimp_mybrush_init (GimpMybrush *brush)
{
brush->priv = G_TYPE_INSTANCE_GET_PRIVATE (brush,
GIMP_TYPE_MYBRUSH,
GimpMybrushPrivate);
brush->priv = gimp_mybrush_get_instance_private (brush);
brush->priv->radius = 1.0;
brush->priv->opaque = 1.0;

7
app/core/gimpprojection.c
View File

@ -221,6 +221,7 @@ static gint gimp_projection_round_chunk_height (gdouble heigh
G_DEFINE_TYPE_WITH_CODE (GimpProjection, gimp_projection, GIMP_TYPE_OBJECT,
G_ADD_PRIVATE (GimpProjection)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_PICKABLE,
gimp_projection_pickable_iface_init))
@ -258,8 +259,6 @@ gimp_projection_class_init (GimpProjectionClass *klass)
g_object_class_override_property (object_class, PROP_BUFFER, "buffer");
g_type_class_add_private (klass, sizeof (GimpProjectionPrivate));
if (g_getenv ("GIMP_NO_ADAPTIVE_CHUNK_SIZE"))
GIMP_PROJECTION_ADAPTIVE_CHUNK_SIZE = FALSE;
@ -285,9 +284,7 @@ gimp_projection_class_init (GimpProjectionClass *klass)
static void
gimp_projection_init (GimpProjection *proj)
{
proj->priv = G_TYPE_INSTANCE_GET_PRIVATE (proj,
GIMP_TYPE_PROJECTION,
GimpProjectionPrivate);
proj->priv = gimp_projection_get_instance_private (proj);
}
static void

9
app/core/gimpsamplepoint.c
View File

@ -54,7 +54,8 @@ static void gimp_sample_point_set_property (GObject *object,
GParamSpec *pspec);
G_DEFINE_TYPE (GimpSamplePoint, gimp_sample_point, GIMP_TYPE_AUX_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpSamplePoint, gimp_sample_point,
GIMP_TYPE_AUX_ITEM)
static void
@ -87,16 +88,12 @@ gimp_sample_point_class_init (GimpSamplePointClass *klass)
GIMP_TYPE_COLOR_PICK_MODE,
GIMP_COLOR_PICK_MODE_PIXEL,
0);
g_type_class_add_private (klass, sizeof (GimpSamplePointPrivate));
}
static void
gimp_sample_point_init (GimpSamplePoint *sample_point)
{
sample_point->priv = G_TYPE_INSTANCE_GET_PRIVATE (sample_point,
GIMP_TYPE_SAMPLE_POINT,
GimpSamplePointPrivate);
sample_point->priv = gimp_sample_point_get_instance_private (sample_point);
}
static void

7
app/core/gimpstrokeoptions.c
View File

@ -96,9 +96,7 @@ struct _GimpStrokeOptionsPrivate
};
#define GET_PRIVATE(options) \
G_TYPE_INSTANCE_GET_PRIVATE (options, \
GIMP_TYPE_STROKE_OPTIONS, \
GimpStrokeOptionsPrivate)
((GimpStrokeOptionsPrivate *) gimp_stroke_options_get_instance_private ((GimpStrokeOptions *) (options)))
static void gimp_stroke_options_config_iface_init (gpointer iface,
@ -119,6 +117,7 @@ static GimpConfig * gimp_stroke_options_duplicate (GimpConfig *config);
G_DEFINE_TYPE_WITH_CODE (GimpStrokeOptions, gimp_stroke_options,
GIMP_TYPE_FILL_OPTIONS,
G_ADD_PRIVATE (GimpStrokeOptions)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONFIG,
gimp_stroke_options_config_iface_init))
@ -225,8 +224,6 @@ gimp_stroke_options_class_init (GimpStrokeOptionsClass *klass)
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
g_type_class_add_private (klass, sizeof (GimpStrokeOptionsPrivate));
}
static void

16
app/core/gimptagcache.c
View File

@ -68,7 +68,7 @@ typedef struct
GimpTagCacheRecord current_record;
} GimpTagCacheParseData;
struct _GimpTagCachePriv
struct _GimpTagCachePrivate
{
GArray *records;
GList *containers;
@ -110,7 +110,7 @@ static const gchar * gimp_tag_cache_attribute_name_to_value
static GQuark gimp_tag_cache_get_error_domain (void);
G_DEFINE_TYPE (GimpTagCache, gimp_tag_cache, GIMP_TYPE_OBJECT)
G_DEFINE_TYPE_WITH_PRIVATE (GimpTagCache, gimp_tag_cache, GIMP_TYPE_OBJECT)
#define parent_class gimp_tag_cache_parent_class
@ -118,24 +118,18 @@ G_DEFINE_TYPE (GimpTagCache, gimp_tag_cache, GIMP_TYPE_OBJECT)
static void
gimp_tag_cache_class_init (GimpTagCacheClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpObjectClass *gimp_object_class = GIMP_OBJECT_CLASS (klass);
GimpTagCacheClass *gimp_tag_cache_class = GIMP_TAG_CACHE_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpObjectClass *gimp_object_class = GIMP_OBJECT_CLASS (klass);
object_class->finalize = gimp_tag_cache_finalize;
gimp_object_class->get_memsize = gimp_tag_cache_get_memsize;
g_type_class_add_private (gimp_tag_cache_class,
sizeof (GimpTagCachePriv));
}
static void
gimp_tag_cache_init (GimpTagCache *cache)
{
cache->priv = G_TYPE_INSTANCE_GET_PRIVATE (cache,
GIMP_TYPE_TAG_CACHE,
GimpTagCachePriv);
cache->priv = gimp_tag_cache_get_instance_private (cache);
cache->priv->records = g_array_new (FALSE, FALSE,
sizeof (GimpTagCacheRecord));

8
app/core/gimptagcache.h
View File

@ -33,14 +33,14 @@
#define GIMP_TAG_CACHE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_TAG_CACHE, GimpTagCacheClass))
typedef struct _GimpTagCacheClass GimpTagCacheClass;
typedef struct _GimpTagCachePriv GimpTagCachePriv;
typedef struct _GimpTagCacheClass GimpTagCacheClass;
typedef struct _GimpTagCachePrivate GimpTagCachePrivate;
struct _GimpTagCache
{
GimpObject parent_instance;
GimpObject parent_instance;
GimpTagCachePriv *priv;
GimpTagCachePrivate *priv;
};
struct _GimpTagCacheClass

7
app/core/gimptemplate.c
View File

@ -92,9 +92,7 @@ struct _GimpTemplatePrivate
guint64 initial_size;
};
#define GET_PRIVATE(template) G_TYPE_INSTANCE_GET_PRIVATE (template, \
GIMP_TYPE_TEMPLATE, \
GimpTemplatePrivate)
#define GET_PRIVATE(template) ((GimpTemplatePrivate *) gimp_template_get_instance_private ((GimpTemplate *) (template)))
static void gimp_template_finalize (GObject *object);
@ -111,6 +109,7 @@ static void gimp_template_notify (GObject *object,
G_DEFINE_TYPE_WITH_CODE (GimpTemplate, gimp_template, GIMP_TYPE_VIEWABLE,
G_ADD_PRIVATE (GimpTemplate)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONFIG, NULL))
#define parent_class gimp_template_parent_class
@ -247,8 +246,6 @@ gimp_template_class_init (GimpTemplateClass *klass)
NULL,
NULL,
GIMP_PARAM_STATIC_STRINGS);
g_type_class_add_private (klass, sizeof (GimpTemplatePrivate));
}
static void

7
app/core/gimpviewable.c
View File

@ -73,9 +73,7 @@ struct _GimpViewablePrivate
GdkPixbuf *preview_pixbuf;
};
#define GET_PRIVATE(viewable) G_TYPE_INSTANCE_GET_PRIVATE (viewable, \
GIMP_TYPE_VIEWABLE, \
GimpViewablePrivate)
#define GET_PRIVATE(viewable) ((GimpViewablePrivate *) gimp_viewable_get_instance_private ((GimpViewable *) (viewable)))
static void gimp_viewable_config_iface_init (GimpConfigInterface *iface);
@ -131,6 +129,7 @@ static gboolean gimp_viewable_deserialize_property (GimpConfig *config,
G_DEFINE_TYPE_WITH_CODE (GimpViewable, gimp_viewable, GIMP_TYPE_OBJECT,
G_ADD_PRIVATE (GimpViewable)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONFIG,
gimp_viewable_config_iface_init))
@ -232,8 +231,6 @@ gimp_viewable_class_init (GimpViewableClass *klass)
NULL, NULL,
FALSE,
GIMP_PARAM_READABLE));
g_type_class_add_private (klass, sizeof (GimpViewablePrivate));
}
static void

10
app/display/gimpcanvasarc.c
View File

@ -61,9 +61,7 @@ struct _GimpCanvasArcPrivate
};
#define GET_PRIVATE(arc) \
G_TYPE_INSTANCE_GET_PRIVATE (arc, \
GIMP_TYPE_CANVAS_ARC, \
GimpCanvasArcPrivate)
((GimpCanvasArcPrivate *) gimp_canvas_arc_get_instance_private ((GimpCanvasArc *) (arc)))
/* local function prototypes */
@ -81,8 +79,8 @@ static void gimp_canvas_arc_draw (GimpCanvasItem *item,
static cairo_region_t * gimp_canvas_arc_get_extents (GimpCanvasItem *item);
G_DEFINE_TYPE (GimpCanvasArc, gimp_canvas_arc,
GIMP_TYPE_CANVAS_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasArc, gimp_canvas_arc,
GIMP_TYPE_CANVAS_ITEM)
#define parent_class gimp_canvas_arc_parent_class
@ -135,8 +133,6 @@ gimp_canvas_arc_class_init (GimpCanvasArcClass *klass)
g_param_spec_boolean ("filled", NULL, NULL,
FALSE,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasArcPrivate));
}
static void

10
app/display/gimpcanvasboundary.c
View File

@ -59,9 +59,7 @@ struct _GimpCanvasBoundaryPrivate
};
#define GET_PRIVATE(boundary) \
G_TYPE_INSTANCE_GET_PRIVATE (boundary, \
GIMP_TYPE_CANVAS_BOUNDARY, \
GimpCanvasBoundaryPrivate)
((GimpCanvasBoundaryPrivate *) gimp_canvas_boundary_get_instance_private ((GimpCanvasBoundary *) (boundary)))
/* local function prototypes */
@ -80,8 +78,8 @@ static void gimp_canvas_boundary_draw (GimpCanvasItem *item,
static cairo_region_t * gimp_canvas_boundary_get_extents (GimpCanvasItem *item);
G_DEFINE_TYPE (GimpCanvasBoundary, gimp_canvas_boundary,
GIMP_TYPE_CANVAS_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasBoundary, gimp_canvas_boundary,
GIMP_TYPE_CANVAS_ITEM)
#define parent_class gimp_canvas_boundary_parent_class
@ -118,8 +116,6 @@ gimp_canvas_boundary_class_init (GimpCanvasBoundaryClass *klass)
-GIMP_MAX_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasBoundaryPrivate));
}
static void

10
app/display/gimpcanvasbufferpreview.c
View File

@ -50,9 +50,7 @@ struct _GimpCanvasBufferPreviewPrivate
#define GET_PRIVATE(transform_preview) \
G_TYPE_INSTANCE_GET_PRIVATE (transform_preview, \
GIMP_TYPE_CANVAS_BUFFER_PREVIEW, \
GimpCanvasBufferPreviewPrivate)
((GimpCanvasBufferPreviewPrivate *) gimp_canvas_buffer_preview_get_instance_private ((GimpCanvasBufferPreview *) (transform_preview)))
/* local function prototypes */
@ -73,8 +71,8 @@ static void gimp_canvas_buffer_preview_compute_bounds (GimpCanvasIte
cairo_rectangle_int_t *bounds);
G_DEFINE_TYPE (GimpCanvasBufferPreview, gimp_canvas_buffer_preview,
GIMP_TYPE_CANVAS_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasBufferPreview, gimp_canvas_buffer_preview,
GIMP_TYPE_CANVAS_ITEM)
#define parent_class gimp_canvas_buffer_preview_parent_class
@ -96,8 +94,6 @@ gimp_canvas_buffer_preview_class_init (GimpCanvasBufferPreviewClass *klass)
NULL, NULL,
GEGL_TYPE_BUFFER,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasBufferPreviewPrivate));
}
static void

10
app/display/gimpcanvascorner.c
View File

@ -61,9 +61,7 @@ struct _GimpCanvasCornerPrivate
};
#define GET_PRIVATE(corner) \
G_TYPE_INSTANCE_GET_PRIVATE (corner, \
GIMP_TYPE_CANVAS_CORNER, \
GimpCanvasCornerPrivate)
((GimpCanvasCornerPrivate *) gimp_canvas_corner_get_instance_private ((GimpCanvasCorner *) (corner)))
/* local function prototypes */
@ -81,8 +79,8 @@ static void gimp_canvas_corner_draw (GimpCanvasItem *item,
static cairo_region_t * gimp_canvas_corner_get_extents (GimpCanvasItem *item);
G_DEFINE_TYPE (GimpCanvasCorner, gimp_canvas_corner,
GIMP_TYPE_CANVAS_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasCorner, gimp_canvas_corner,
GIMP_TYPE_CANVAS_ITEM)
#define parent_class gimp_canvas_corner_parent_class
@ -143,8 +141,6 @@ gimp_canvas_corner_class_init (GimpCanvasCornerClass *klass)
g_param_spec_boolean ("outside", NULL, NULL,
FALSE,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasCornerPrivate));
}
static void

10
app/display/gimpcanvascursor.c
View File

@ -54,9 +54,7 @@ struct _GimpCanvasCursorPrivate
};
#define GET_PRIVATE(cursor) \
G_TYPE_INSTANCE_GET_PRIVATE (cursor, \
GIMP_TYPE_CANVAS_CURSOR, \
GimpCanvasCursorPrivate)
((GimpCanvasCursorPrivate *) gimp_canvas_cursor_get_instance_private ((GimpCanvasCursor *) (cursor)))
/* local function prototypes */
@ -74,8 +72,8 @@ static void gimp_canvas_cursor_draw (GimpCanvasItem *item,
static cairo_region_t * gimp_canvas_cursor_get_extents (GimpCanvasItem *item);
G_DEFINE_TYPE (GimpCanvasCursor, gimp_canvas_cursor,
GIMP_TYPE_CANVAS_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasCursor, gimp_canvas_cursor,
GIMP_TYPE_CANVAS_ITEM)
#define parent_class gimp_canvas_cursor_parent_class
@ -103,8 +101,6 @@ gimp_canvas_cursor_class_init (GimpCanvasCursorClass *klass)
-GIMP_MAX_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasCursorPrivate));
}
static void

9
app/display/gimpcanvasgrid.c
View File

@ -54,9 +54,7 @@ struct _GimpCanvasGridPrivate
};
#define GET_PRIVATE(grid) \
G_TYPE_INSTANCE_GET_PRIVATE (grid, \
GIMP_TYPE_CANVAS_GRID, \
GimpCanvasGridPrivate)
((GimpCanvasGridPrivate *) gimp_canvas_grid_get_instance_private ((GimpCanvasGrid *) (grid)))
/* local function prototypes */
@ -77,7 +75,8 @@ static void gimp_canvas_grid_stroke (GimpCanvasItem *item,
cairo_t *cr);
G_DEFINE_TYPE (GimpCanvasGrid, gimp_canvas_grid, GIMP_TYPE_CANVAS_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasGrid, gimp_canvas_grid,
GIMP_TYPE_CANVAS_ITEM)
#define parent_class gimp_canvas_grid_parent_class
@ -106,8 +105,6 @@ gimp_canvas_grid_class_init (GimpCanvasGridClass *klass)
NULL, NULL,
FALSE,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasGridPrivate));
}
static void

9
app/display/gimpcanvasgroup.c
View File

@ -71,7 +71,8 @@ static void gimp_canvas_group_child_update (GimpCanvasItem *item,
GimpCanvasGroup *group);
G_DEFINE_TYPE (GimpCanvasGroup, gimp_canvas_group, GIMP_TYPE_CANVAS_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasGroup, gimp_canvas_group,
GIMP_TYPE_CANVAS_ITEM)
#define parent_class gimp_canvas_group_parent_class
@ -101,16 +102,12 @@ gimp_canvas_group_class_init (GimpCanvasGroupClass *klass)
NULL, NULL,
FALSE,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasGroupPrivate));
}
static void
gimp_canvas_group_init (GimpCanvasGroup *group)
{
group->priv = G_TYPE_INSTANCE_GET_PRIVATE (group,
GIMP_TYPE_CANVAS_GROUP,
GimpCanvasGroupPrivate);
group->priv = gimp_canvas_group_get_instance_private (group);
group->priv->items = g_queue_new ();
}

9
app/display/gimpcanvasguide.c
View File

@ -53,9 +53,7 @@ struct _GimpCanvasGuidePrivate
};
#define GET_PRIVATE(guide) \
G_TYPE_INSTANCE_GET_PRIVATE (guide, \
GIMP_TYPE_CANVAS_GUIDE, \
GimpCanvasGuidePrivate)
((GimpCanvasGuidePrivate *) gimp_canvas_guide_get_instance_private ((GimpCanvasGuide *) (guide)))
/* local function prototypes */
@ -75,7 +73,8 @@ static void gimp_canvas_guide_stroke (GimpCanvasItem *item,
cairo_t *cr);
G_DEFINE_TYPE (GimpCanvasGuide, gimp_canvas_guide, GIMP_TYPE_CANVAS_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasGuide, gimp_canvas_guide,
GIMP_TYPE_CANVAS_ITEM)
#define parent_class gimp_canvas_guide_parent_class
@ -110,8 +109,6 @@ gimp_canvas_guide_class_init (GimpCanvasGuideClass *klass)
GIMP_TYPE_GUIDE_STYLE,
GIMP_GUIDE_STYLE_NONE,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasGuidePrivate));
}
static void

10
app/display/gimpcanvashandle.c
View File

@ -69,9 +69,7 @@ struct _GimpCanvasHandlePrivate
};
#define GET_PRIVATE(handle) \
G_TYPE_INSTANCE_GET_PRIVATE (handle, \
GIMP_TYPE_CANVAS_HANDLE, \
GimpCanvasHandlePrivate)
((GimpCanvasHandlePrivate *) gimp_canvas_handle_get_instance_private ((GimpCanvasHandle *) (handle)))
/* local function prototypes */
@ -92,8 +90,8 @@ static gboolean gimp_canvas_handle_hit (GimpCanvasItem *item,
gdouble y);
G_DEFINE_TYPE (GimpCanvasHandle, gimp_canvas_handle,
GIMP_TYPE_CANVAS_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasHandle, gimp_canvas_handle,
GIMP_TYPE_CANVAS_ITEM)
#define parent_class gimp_canvas_handle_parent_class
@ -154,8 +152,6 @@ gimp_canvas_handle_class_init (GimpCanvasHandleClass *klass)
g_param_spec_double ("slice-angle", NULL, NULL,
-1000, 1000, 2 * G_PI,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasHandlePrivate));
}
static void

9
app/display/gimpcanvasitem.c
View File

@ -93,8 +93,7 @@ static gboolean gimp_canvas_item_real_hit (GimpCanvasItem *item
gdouble y);
G_DEFINE_TYPE (GimpCanvasItem, gimp_canvas_item,
GIMP_TYPE_OBJECT)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasItem, gimp_canvas_item, GIMP_TYPE_OBJECT)
#define parent_class gimp_canvas_item_parent_class
@ -155,8 +154,6 @@ gimp_canvas_item_class_init (GimpCanvasItemClass *klass)
NULL, NULL,
FALSE,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasItemPrivate));
}
static void
@ -164,9 +161,7 @@ gimp_canvas_item_init (GimpCanvasItem *item)
{
GimpCanvasItemPrivate *private;
item->private = G_TYPE_INSTANCE_GET_PRIVATE (item,
GIMP_TYPE_CANVAS_ITEM,
GimpCanvasItemPrivate);
item->private = gimp_canvas_item_get_instance_private (item);
private = item->private;
private->shell = NULL;

10
app/display/gimpcanvaslayerboundary.c
View File

@ -54,9 +54,7 @@ struct _GimpCanvasLayerBoundaryPrivate
};
#define GET_PRIVATE(layer_boundary) \
G_TYPE_INSTANCE_GET_PRIVATE (layer_boundary, \
GIMP_TYPE_CANVAS_LAYER_BOUNDARY, \
GimpCanvasLayerBoundaryPrivate)
((GimpCanvasLayerBoundaryPrivate *) gimp_canvas_layer_boundary_get_instance_private ((GimpCanvasLayerBoundary *) (layer_boundary)))
/* local function prototypes */
@ -77,8 +75,8 @@ static void gimp_canvas_layer_boundary_stroke (GimpCanvasItem
cairo_t *cr);
G_DEFINE_TYPE (GimpCanvasLayerBoundary, gimp_canvas_layer_boundary,
GIMP_TYPE_CANVAS_RECTANGLE)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasLayerBoundary, gimp_canvas_layer_boundary,
GIMP_TYPE_CANVAS_RECTANGLE)
#define parent_class gimp_canvas_layer_boundary_parent_class
@ -106,8 +104,6 @@ gimp_canvas_layer_boundary_class_init (GimpCanvasLayerBoundaryClass *klass)
g_param_spec_boolean ("edit-mask", NULL, NULL,
FALSE,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasLayerBoundaryPrivate));
}
static void

9
app/display/gimpcanvasline.c
View File

@ -53,9 +53,7 @@ struct _GimpCanvasLinePrivate
};
#define GET_PRIVATE(line) \
G_TYPE_INSTANCE_GET_PRIVATE (line, \
GIMP_TYPE_CANVAS_LINE, \
GimpCanvasLinePrivate)
((GimpCanvasLinePrivate *) gimp_canvas_line_get_instance_private ((GimpCanvasLine *) (line)))
/* local function prototypes */
@ -73,7 +71,8 @@ static void gimp_canvas_line_draw (GimpCanvasItem *item,
static cairo_region_t * gimp_canvas_line_get_extents (GimpCanvasItem *item);
G_DEFINE_TYPE (GimpCanvasLine, gimp_canvas_line, GIMP_TYPE_CANVAS_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasLine, gimp_canvas_line,
GIMP_TYPE_CANVAS_ITEM)
#define parent_class gimp_canvas_line_parent_class
@ -113,8 +112,6 @@ gimp_canvas_line_class_init (GimpCanvasLineClass *klass)
-GIMP_MAX_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasLinePrivate));
}
static void

10
app/display/gimpcanvaspassepartout.c
View File

@ -46,9 +46,7 @@ struct _GimpCanvasPassePartoutPrivate
};
#define GET_PRIVATE(item) \
G_TYPE_INSTANCE_GET_PRIVATE (item, \
GIMP_TYPE_CANVAS_PASSE_PARTOUT, \
GimpCanvasPassePartoutPrivate)
((GimpCanvasPassePartoutPrivate *) gimp_canvas_passe_partout_get_instance_private ((GimpCanvasPassePartout *) (item)))
/* local function prototypes */
@ -68,8 +66,8 @@ static void gimp_canvas_passe_partout_fill (GimpCanvasItem *
cairo_t *cr);
G_DEFINE_TYPE (GimpCanvasPassePartout, gimp_canvas_passe_partout,
GIMP_TYPE_CANVAS_RECTANGLE)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasPassePartout, gimp_canvas_passe_partout,
GIMP_TYPE_CANVAS_RECTANGLE)
#define parent_class gimp_canvas_passe_partout_parent_class
@ -92,8 +90,6 @@ gimp_canvas_passe_partout_class_init (GimpCanvasPassePartoutClass *klass)
0.0,
1.0, 0.5,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasPassePartoutPrivate));
}
static void

10
app/display/gimpcanvaspath.c
View File

@ -59,9 +59,7 @@ struct _GimpCanvasPathPrivate
};
#define GET_PRIVATE(path) \
G_TYPE_INSTANCE_GET_PRIVATE (path, \
GIMP_TYPE_CANVAS_PATH, \
GimpCanvasPathPrivate)
((GimpCanvasPathPrivate *) gimp_canvas_path_get_instance_private ((GimpCanvasPath *) (path)))
/* local function prototypes */
@ -81,8 +79,8 @@ static void gimp_canvas_path_stroke (GimpCanvasItem *item,
cairo_t *cr);
G_DEFINE_TYPE (GimpCanvasPath, gimp_canvas_path,
GIMP_TYPE_CANVAS_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasPath, gimp_canvas_path,
GIMP_TYPE_CANVAS_ITEM)
#define parent_class gimp_canvas_path_parent_class
@ -129,8 +127,6 @@ gimp_canvas_path_class_init (GimpCanvasPathClass *klass)
GIMP_TYPE_PATH_STYLE,
GIMP_PATH_STYLE_DEFAULT,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasPathPrivate));
}
static void

10
app/display/gimpcanvaspen.c
View File

@ -54,9 +54,7 @@ struct _GimpCanvasPenPrivate
};
#define GET_PRIVATE(pen) \
G_TYPE_INSTANCE_GET_PRIVATE (pen, \
GIMP_TYPE_CANVAS_PEN, \
GimpCanvasPenPrivate)
((GimpCanvasPenPrivate *) gimp_canvas_pen_get_instance_private ((GimpCanvasPen *) (pen)))
/* local function prototypes */
@ -74,8 +72,8 @@ static void gimp_canvas_pen_stroke (GimpCanvasItem *item,
cairo_t *cr);
G_DEFINE_TYPE (GimpCanvasPen, gimp_canvas_pen,
GIMP_TYPE_CANVAS_POLYGON)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasPen, gimp_canvas_pen,
GIMP_TYPE_CANVAS_POLYGON)
#define parent_class gimp_canvas_pen_parent_class
@ -101,8 +99,6 @@ gimp_canvas_pen_class_init (GimpCanvasPenClass *klass)
g_param_spec_int ("width", NULL, NULL,
1, G_MAXINT, 1,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasPenPrivate));
}
static void

10
app/display/gimpcanvaspolygon.c
View File

@ -55,9 +55,7 @@ struct _GimpCanvasPolygonPrivate
};
#define GET_PRIVATE(polygon) \
G_TYPE_INSTANCE_GET_PRIVATE (polygon, \
GIMP_TYPE_CANVAS_POLYGON, \
GimpCanvasPolygonPrivate)
((GimpCanvasPolygonPrivate *) gimp_canvas_polygon_get_instance_private ((GimpCanvasPolygon *) (polygon)))
/* local function prototypes */
@ -79,8 +77,8 @@ static gboolean gimp_canvas_polygon_hit (GimpCanvasItem *item,
gdouble y);
G_DEFINE_TYPE (GimpCanvasPolygon, gimp_canvas_polygon,
GIMP_TYPE_CANVAS_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasPolygon, gimp_canvas_polygon,
GIMP_TYPE_CANVAS_ITEM)
#define parent_class gimp_canvas_polygon_parent_class
@ -111,8 +109,6 @@ gimp_canvas_polygon_class_init (GimpCanvasPolygonClass *klass)
g_param_spec_boolean ("filled", NULL, NULL,
FALSE,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasPolygonPrivate));
}
static void

7
app/display/gimpcanvasprogress.c
View File

@ -67,9 +67,7 @@ struct _GimpCanvasProgressPrivate
};
#define GET_PRIVATE(progress) \
G_TYPE_INSTANCE_GET_PRIVATE (progress, \
GIMP_TYPE_CANVAS_PROGRESS, \
GimpCanvasProgressPrivate)
((GimpCanvasProgressPrivate *) gimp_canvas_progress_get_instance_private ((GimpCanvasProgress *) (progress)))
/* local function prototypes */
@ -112,6 +110,7 @@ static gboolean gimp_canvas_progress_message (GimpProgress
G_DEFINE_TYPE_WITH_CODE (GimpCanvasProgress, gimp_canvas_progress,
GIMP_TYPE_CANVAS_ITEM,
G_ADD_PRIVATE (GimpCanvasProgress)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_PROGRESS,
gimp_canvas_progress_iface_init))
@ -149,8 +148,6 @@ gimp_canvas_progress_class_init (GimpCanvasProgressClass *klass)
-GIMP_MAX_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasProgressPrivate));
}
static void

10
app/display/gimpcanvasproxygroup.c
View File

@ -47,9 +47,7 @@ struct _GimpCanvasProxyGroupPrivate
};
#define GET_PRIVATE(proxy_group) \
G_TYPE_INSTANCE_GET_PRIVATE (proxy_group, \
GIMP_TYPE_CANVAS_PROXY_GROUP, \
GimpCanvasProxyGroupPrivate)
((GimpCanvasProxyGroupPrivate *) gimp_canvas_proxy_group_get_instance_private ((GimpCanvasProxyGroup *) (proxy_group)))
/* local function prototypes */
@ -65,8 +63,8 @@ static void gimp_canvas_proxy_group_get_property (GObject *objec
GParamSpec *pspec);
G_DEFINE_TYPE (GimpCanvasProxyGroup, gimp_canvas_proxy_group,
GIMP_TYPE_CANVAS_GROUP)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasProxyGroup, gimp_canvas_proxy_group,
GIMP_TYPE_CANVAS_GROUP)
#define parent_class gimp_canvas_proxy_group_parent_class
@ -79,8 +77,6 @@ gimp_canvas_proxy_group_class_init (GimpCanvasProxyGroupClass *klass)
object_class->finalize = gimp_canvas_proxy_group_finalize;
object_class->set_property = gimp_canvas_proxy_group_set_property;
object_class->get_property = gimp_canvas_proxy_group_get_property;
g_type_class_add_private (klass, sizeof (GimpCanvasProxyGroupPrivate));
}
static void

10
app/display/gimpcanvasrectangle.c
View File

@ -55,9 +55,7 @@ struct _GimpCanvasRectanglePrivate
};
#define GET_PRIVATE(rectangle) \
G_TYPE_INSTANCE_GET_PRIVATE (rectangle, \
GIMP_TYPE_CANVAS_RECTANGLE, \
GimpCanvasRectanglePrivate)
((GimpCanvasRectanglePrivate *) gimp_canvas_rectangle_get_instance_private ((GimpCanvasRectangle *) (rectangle)))
/* local function prototypes */
@ -75,8 +73,8 @@ static void gimp_canvas_rectangle_draw (GimpCanvasItem *item
static cairo_region_t * gimp_canvas_rectangle_get_extents (GimpCanvasItem *item);
G_DEFINE_TYPE (GimpCanvasRectangle, gimp_canvas_rectangle,
GIMP_TYPE_CANVAS_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasRectangle, gimp_canvas_rectangle,
GIMP_TYPE_CANVAS_ITEM)
#define parent_class gimp_canvas_rectangle_parent_class
@ -121,8 +119,6 @@ gimp_canvas_rectangle_class_init (GimpCanvasRectangleClass *klass)
g_param_spec_boolean ("filled", NULL, NULL,
FALSE,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasRectanglePrivate));
}
static void

10
app/display/gimpcanvasrectangleguides.c
View File

@ -60,9 +60,7 @@ struct _GimpCanvasRectangleGuidesPrivate
};
#define GET_PRIVATE(rectangle) \
G_TYPE_INSTANCE_GET_PRIVATE (rectangle, \
GIMP_TYPE_CANVAS_RECTANGLE_GUIDES, \
GimpCanvasRectangleGuidesPrivate)
((GimpCanvasRectangleGuidesPrivate *) gimp_canvas_rectangle_guides_get_instance_private ((GimpCanvasRectangleGuides *) (rectangle)))
/* local function prototypes */
@ -80,8 +78,8 @@ static void gimp_canvas_rectangle_guides_draw (GimpCanvasIte
static cairo_region_t * gimp_canvas_rectangle_guides_get_extents (GimpCanvasItem *item);
G_DEFINE_TYPE (GimpCanvasRectangleGuides, gimp_canvas_rectangle_guides,
GIMP_TYPE_CANVAS_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasRectangleGuides,
gimp_canvas_rectangle_guides, GIMP_TYPE_CANVAS_ITEM)
#define parent_class gimp_canvas_rectangle_guides_parent_class
@ -132,8 +130,6 @@ gimp_canvas_rectangle_guides_class_init (GimpCanvasRectangleGuidesClass *klass)
g_param_spec_int ("n-guides", NULL, NULL,
1, 128, 4,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasRectangleGuidesPrivate));
}
static void

10
app/display/gimpcanvassamplepoint.c
View File

@ -58,9 +58,7 @@ struct _GimpCanvasSamplePointPrivate
};
#define GET_PRIVATE(sample_point) \
G_TYPE_INSTANCE_GET_PRIVATE (sample_point, \
GIMP_TYPE_CANVAS_SAMPLE_POINT, \
GimpCanvasSamplePointPrivate)
((GimpCanvasSamplePointPrivate *) gimp_canvas_sample_point_get_instance_private ((GimpCanvasSamplePoint *) (sample_point)))
/* local function prototypes */
@ -82,8 +80,8 @@ static void gimp_canvas_sample_point_fill (GimpCanvasItem *i
cairo_t *cr);
G_DEFINE_TYPE (GimpCanvasSamplePoint, gimp_canvas_sample_point,
GIMP_TYPE_CANVAS_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasSamplePoint, gimp_canvas_sample_point,
GIMP_TYPE_CANVAS_ITEM)
#define parent_class gimp_canvas_sample_point_parent_class
@ -124,8 +122,6 @@ gimp_canvas_sample_point_class_init (GimpCanvasSamplePointClass *klass)
NULL, NULL,
FALSE,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasSamplePointPrivate));
}
static void

10
app/display/gimpcanvastextcursor.c
View File

@ -57,9 +57,7 @@ struct _GimpCanvasTextCursorPrivate
};
#define GET_PRIVATE(text_cursor) \
G_TYPE_INSTANCE_GET_PRIVATE (text_cursor, \
GIMP_TYPE_CANVAS_TEXT_CURSOR, \
GimpCanvasTextCursorPrivate)
((GimpCanvasTextCursorPrivate *) gimp_canvas_text_cursor_get_instance_private ((GimpCanvasTextCursor *) (text_cursor)))
/* local function prototypes */
@ -77,8 +75,8 @@ static void gimp_canvas_text_cursor_draw (GimpCanvasItem *it
static cairo_region_t * gimp_canvas_text_cursor_get_extents (GimpCanvasItem *item);
G_DEFINE_TYPE (GimpCanvasTextCursor, gimp_canvas_text_cursor,
GIMP_TYPE_CANVAS_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasTextCursor, gimp_canvas_text_cursor,
GIMP_TYPE_CANVAS_ITEM)
#define parent_class gimp_canvas_text_cursor_parent_class
@ -129,8 +127,6 @@ gimp_canvas_text_cursor_class_init (GimpCanvasTextCursorClass *klass)
gimp_text_direction_get_type(),
GIMP_TEXT_DIRECTION_LTR,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasTextCursorPrivate));
}
static void

10
app/display/gimpcanvastransformguides.c
View File

@ -65,9 +65,7 @@ struct _GimpCanvasTransformGuidesPrivate
};
#define GET_PRIVATE(transform) \
G_TYPE_INSTANCE_GET_PRIVATE (transform, \
GIMP_TYPE_CANVAS_TRANSFORM_GUIDES, \
GimpCanvasTransformGuidesPrivate)
((GimpCanvasTransformGuidesPrivate *) gimp_canvas_transform_guides_get_instance_private ((GimpCanvasTransformGuides *) (transform)))
/* local function prototypes */
@ -85,8 +83,8 @@ static void gimp_canvas_transform_guides_draw (GimpCanvasIte
static cairo_region_t * gimp_canvas_transform_guides_get_extents (GimpCanvasItem *item);
G_DEFINE_TYPE (GimpCanvasTransformGuides, gimp_canvas_transform_guides,
GIMP_TYPE_CANVAS_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasTransformGuides,
gimp_canvas_transform_guides, GIMP_TYPE_CANVAS_ITEM)
#define parent_class gimp_canvas_transform_guides_parent_class
@ -156,8 +154,6 @@ gimp_canvas_transform_guides_class_init (GimpCanvasTransformGuidesClass *klass)
g_param_spec_boolean ("clip", NULL, NULL,
FALSE,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasTransformGuidesPrivate));
}
static void

11
app/display/gimpcanvastransformpreview.c
View File

@ -90,9 +90,7 @@ struct _GimpCanvasTransformPreviewPrivate
};
#define GET_PRIVATE(transform_preview) \
G_TYPE_INSTANCE_GET_PRIVATE (transform_preview, \
GIMP_TYPE_CANVAS_TRANSFORM_PREVIEW, \
GimpCanvasTransformPreviewPrivate)
((GimpCanvasTransformPreviewPrivate *) gimp_canvas_transform_preview_get_instance_private ((GimpCanvasTransformPreview *) (transform_preview)))
/* local function prototypes */
@ -119,8 +117,9 @@ static void gimp_canvas_transform_preview_set_drawable (GimpCanvasT
static void gimp_canvas_transform_preview_sync_node (GimpCanvasTransformPreview *transform_preview);
G_DEFINE_TYPE (GimpCanvasTransformPreview, gimp_canvas_transform_preview,
GIMP_TYPE_CANVAS_ITEM)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasTransformPreview,
gimp_canvas_transform_preview,
GIMP_TYPE_CANVAS_ITEM)
#define parent_class gimp_canvas_transform_preview_parent_class
@ -190,8 +189,6 @@ gimp_canvas_transform_preview_class_init (GimpCanvasTransformPreviewClass *klass
NULL, NULL,
0.0, 1.0, 1.0,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpCanvasTransformPreviewPrivate));
}
static void

9
app/display/gimpcursorview.c
View File

@ -59,7 +59,7 @@ enum
};
struct _GimpCursorViewPriv
struct _GimpCursorViewPrivate
{
GimpEditor parent_instance;
@ -138,6 +138,7 @@ static gboolean gimp_cursor_view_cursor_idle (GimpCursorView *v
G_DEFINE_TYPE_WITH_CODE (GimpCursorView, gimp_cursor_view, GIMP_TYPE_EDITOR,
G_ADD_PRIVATE (GimpCursorView)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_DOCKED,
gimp_cursor_view_docked_iface_init))
@ -164,8 +165,6 @@ gimp_cursor_view_class_init (GimpCursorViewClass* klass)
TRUE,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_type_class_add_private (klass, sizeof (GimpCursorViewPriv));
}
static void
@ -176,9 +175,7 @@ gimp_cursor_view_init (GimpCursorView *view)
GtkWidget *toggle;
gint content_spacing;
view->priv = G_TYPE_INSTANCE_GET_PRIVATE (view,
GIMP_TYPE_CURSOR_VIEW,
GimpCursorViewPriv);
view->priv = gimp_cursor_view_get_instance_private (view);
view->priv->sample_merged = TRUE;
view->priv->context = NULL;

8
app/display/gimpcursorview.h
View File

@ -33,14 +33,14 @@
#define GIMP_CURSOR_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_CURSOR_VIEW, GimpCursorViewClass))
typedef struct _GimpCursorViewClass GimpCursorViewClass;
typedef struct _GimpCursorViewPriv GimpCursorViewPriv;
typedef struct _GimpCursorViewClass GimpCursorViewClass;
typedef struct _GimpCursorViewPrivate GimpCursorViewPrivate;
struct _GimpCursorView
{
GimpEditor parent_instance;
GimpEditor parent_instance;
GimpCursorViewPriv *priv;
GimpCursorViewPrivate *priv;
};
struct _GimpCursorViewClass

7
app/display/gimpdisplay.c
View File

@ -79,9 +79,7 @@ struct _GimpDisplayPrivate
};
#define GIMP_DISPLAY_GET_PRIVATE(display) \
G_TYPE_INSTANCE_GET_PRIVATE (display, \
GIMP_TYPE_DISPLAY, \
GimpDisplayPrivate)
((GimpDisplayPrivate *) gimp_display_get_instance_private ((GimpDisplay *) (display)))
/* local function prototypes */
@ -126,6 +124,7 @@ static void gimp_display_paint_area (GimpDisplay *displa
G_DEFINE_TYPE_WITH_CODE (GimpDisplay, gimp_display, GIMP_TYPE_OBJECT,
G_ADD_PRIVATE (GimpDisplay)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_PROGRESS,
gimp_display_progress_iface_init))
@ -164,8 +163,6 @@ gimp_display_class_init (GimpDisplayClass *klass)
NULL, NULL,
GIMP_TYPE_DISPLAY_SHELL,
GIMP_PARAM_READABLE));
g_type_class_add_private (klass, sizeof (GimpDisplayPrivate));
}
static void

7
app/display/gimpimagewindow.c
View File

@ -145,9 +145,7 @@ typedef struct
#define GIMP_IMAGE_WINDOW_GET_PRIVATE(window) \
G_TYPE_INSTANCE_GET_PRIVATE (window, \
GIMP_TYPE_IMAGE_WINDOW, \
GimpImageWindowPrivate)
((GimpImageWindowPrivate *) gimp_image_window_get_instance_private ((GimpImageWindow *) (window)))
/* local function prototypes */
@ -263,6 +261,7 @@ static void gimp_image_window_update_tab_labels (GimpImageWindow *win
G_DEFINE_TYPE_WITH_CODE (GimpImageWindow, gimp_image_window, GIMP_TYPE_WINDOW,
G_ADD_PRIVATE (GimpImageWindow)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_DOCK_CONTAINER,
gimp_image_window_dock_container_iface_init)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_SESSION_MANAGED,
@ -312,8 +311,6 @@ gimp_image_window_class_init (GimpImageWindowClass *klass)
GDK_TYPE_MONITOR,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_type_class_add_private (klass, sizeof (GimpImageWindowPrivate));
}
static void

9
app/display/gimptoolcompass.c
View File

@ -169,7 +169,8 @@ static void gimp_tool_compass_update_angle (GimpToolCompass *compa
gboolean flip);
G_DEFINE_TYPE (GimpToolCompass, gimp_tool_compass, GIMP_TYPE_TOOL_WIDGET)
G_DEFINE_TYPE_WITH_PRIVATE (GimpToolCompass, gimp_tool_compass,
GIMP_TYPE_TOOL_WIDGET)
#define parent_class gimp_tool_compass_parent_class
@ -273,16 +274,12 @@ gimp_tool_compass_class_init (GimpToolCompassClass *klass)
g_param_spec_double ("unit-angle", NULL, NULL,
-G_PI, G_PI, 0.0,
GIMP_PARAM_READABLE));
g_type_class_add_private (klass, sizeof (GimpToolCompassPrivate));
}
static void
gimp_tool_compass_init (GimpToolCompass *compass)
{
compass->private = G_TYPE_INSTANCE_GET_PRIVATE (compass,
GIMP_TYPE_TOOL_COMPASS,
GimpToolCompassPrivate);
compass->private = gimp_tool_compass_get_instance_private (compass);
compass->private->point = -1;
}

9
app/display/gimptooldialog.c
View File

@ -43,9 +43,7 @@ struct _GimpToolDialogPrivate
GimpDisplayShell *shell;
};
#define GET_PRIVATE(dialog) G_TYPE_INSTANCE_GET_PRIVATE (dialog, \
GIMP_TYPE_TOOL_DIALOG, \
GimpToolDialogPrivate)
#define GET_PRIVATE(dialog) ((GimpToolDialogPrivate *) gimp_tool_dialog_get_instance_private ((GimpToolDialog *) (dialog)))
static void gimp_tool_dialog_dispose (GObject *object);
@ -54,7 +52,8 @@ static void gimp_tool_dialog_shell_unmap (GimpDisplayShell *shell,
GimpToolDialog *dialog);
G_DEFINE_TYPE (GimpToolDialog, gimp_tool_dialog, GIMP_TYPE_VIEWABLE_DIALOG)
G_DEFINE_TYPE_WITH_PRIVATE (GimpToolDialog, gimp_tool_dialog,
GIMP_TYPE_VIEWABLE_DIALOG)
static void
@ -65,8 +64,6 @@ gimp_tool_dialog_class_init (GimpToolDialogClass *klass)
object_class->dispose = gimp_tool_dialog_dispose;
gtk_widget_class_set_css_name (GTK_WIDGET_CLASS (klass), "GimpToolDialog");
g_type_class_add_private (klass, sizeof (GimpToolDialogPrivate));
}
static void

8
app/display/gimptoolgui.c
View File

@ -81,9 +81,7 @@ struct _GimpToolGuiPrivate
GtkWidget *vbox;
};
#define GET_PRIVATE(gui) G_TYPE_INSTANCE_GET_PRIVATE (gui, \
GIMP_TYPE_TOOL_GUI, \
GimpToolGuiPrivate)
#define GET_PRIVATE(gui) ((GimpToolGuiPrivate *) gimp_tool_gui_get_instance_private ((GimpToolGui *) (gui)))
static void gimp_tool_gui_dispose (GObject *object);
@ -109,7 +107,7 @@ static ResponseEntry * response_entry_find (GList *entries,
gint response_id);
G_DEFINE_TYPE (GimpToolGui, gimp_tool_gui, GIMP_TYPE_OBJECT)
G_DEFINE_TYPE_WITH_PRIVATE (GimpToolGui, gimp_tool_gui, GIMP_TYPE_OBJECT)
static guint signals[LAST_SIGNAL] = { 0, };
@ -133,8 +131,6 @@ gimp_tool_gui_class_init (GimpToolGuiClass *klass)
gimp_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
g_type_class_add_private (klass, sizeof (GimpToolGuiPrivate));
}
static void

9
app/display/gimptoolgyroscope.c
View File

@ -160,7 +160,8 @@ static void gimp_tool_gyroscope_rotate_vector (GimpVector3 *v
const GimpVector3 *axis);
G_DEFINE_TYPE (GimpToolGyroscope, gimp_tool_gyroscope, GIMP_TYPE_TOOL_WIDGET)
G_DEFINE_TYPE_WITH_PRIVATE (GimpToolGyroscope, gimp_tool_gyroscope,
GIMP_TYPE_TOOL_WIDGET)
#define parent_class gimp_tool_gyroscope_parent_class
@ -244,16 +245,12 @@ gimp_tool_gyroscope_class_init (GimpToolGyroscopeClass *klass)
0.0,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_type_class_add_private (klass, sizeof (GimpToolGyroscopePrivate));
}
static void
gimp_tool_gyroscope_init (GimpToolGyroscope *gyroscope)
{
gyroscope->private = G_TYPE_INSTANCE_GET_PRIVATE (gyroscope,
GIMP_TYPE_TOOL_GYROSCOPE,
GimpToolGyroscopePrivate);
gyroscope->private = gimp_tool_gyroscope_get_instance_private (gyroscope);
}
static void

10
app/display/gimptoolhandlegrid.c
View File

@ -155,8 +155,8 @@ static inline gdouble calc_lineintersect_ratio (gdouble p1x,
gdouble q2y);
G_DEFINE_TYPE (GimpToolHandleGrid, gimp_tool_handle_grid,
GIMP_TYPE_TOOL_TRANSFORM_GRID)
G_DEFINE_TYPE_WITH_PRIVATE (GimpToolHandleGrid, gimp_tool_handle_grid,
GIMP_TYPE_TOOL_TRANSFORM_GRID)
#define parent_class gimp_tool_handle_grid_parent_class
@ -338,16 +338,12 @@ gimp_tool_handle_grid_class_init (GimpToolHandleGridClass *klass)
0.0,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_type_class_add_private (klass, sizeof (GimpToolHandleGridPrivate));
}
static void
gimp_tool_handle_grid_init (GimpToolHandleGrid *grid)
{
grid->private = G_TYPE_INSTANCE_GET_PRIVATE (grid,
GIMP_TYPE_TOOL_HANDLE_GRID,
GimpToolHandleGridPrivate);
grid->private = gimp_tool_handle_grid_get_instance_private (grid);
}
static void

8
app/display/gimptoolline.c
View File

@ -208,7 +208,7 @@ static gboolean gimp_tool_line_handle_hit (GimpCanvasItem *handle,
gdouble *min_dist);
G_DEFINE_TYPE (GimpToolLine, gimp_tool_line, GIMP_TYPE_TOOL_WIDGET)
G_DEFINE_TYPE_WITH_PRIVATE (GimpToolLine, gimp_tool_line, GIMP_TYPE_TOOL_WIDGET)
#define parent_class gimp_tool_line_parent_class
@ -347,8 +347,6 @@ gimp_tool_line_class_init (GimpToolLineClass *klass)
_("Line: "),
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_type_class_add_private (klass, sizeof (GimpToolLinePrivate));
}
static void
@ -356,9 +354,7 @@ gimp_tool_line_init (GimpToolLine *line)
{
GimpToolLinePrivate *private;
private = line->private = G_TYPE_INSTANCE_GET_PRIVATE (line,
GIMP_TYPE_TOOL_LINE,
GimpToolLinePrivate);
private = line->private = gimp_tool_line_get_instance_private (line);
private->sliders = g_array_new (FALSE, FALSE, sizeof (GimpControllerSlider));

8
app/display/gimptoolpath.c
View File

@ -198,7 +198,7 @@ static void gimp_tool_path_delete_selected_anchors
(GimpToolPath *path);
G_DEFINE_TYPE (GimpToolPath, gimp_tool_path, GIMP_TYPE_TOOL_WIDGET)
G_DEFINE_TYPE_WITH_PRIVATE (GimpToolPath, gimp_tool_path, GIMP_TYPE_TOOL_WIDGET)
#define parent_class gimp_tool_path_parent_class
@ -278,16 +278,12 @@ gimp_tool_path_class_init (GimpToolPathClass *klass)
FALSE,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_type_class_add_private (klass, sizeof (GimpToolPathPrivate));
}
static void
gimp_tool_path_init (GimpToolPath *path)
{
path->private = G_TYPE_INSTANCE_GET_PRIVATE (path,
GIMP_TYPE_TOOL_PATH,
GimpToolPathPrivate);
path->private = gimp_tool_path_get_instance_private (path);
}
static void

9
app/display/gimptoolpolygon.c
View File

@ -192,7 +192,8 @@ static gint gimp_tool_polygon_get_segment_index (GimpToolPolygon *polygo
const GimpCoords *coords);
G_DEFINE_TYPE (GimpToolPolygon, gimp_tool_polygon, GIMP_TYPE_TOOL_WIDGET)
G_DEFINE_TYPE_WITH_PRIVATE (GimpToolPolygon, gimp_tool_polygon,
GIMP_TYPE_TOOL_WIDGET)
#define parent_class gimp_tool_polygon_parent_class
@ -221,16 +222,12 @@ gimp_tool_polygon_class_init (GimpToolPolygonClass *klass)
widget_class->motion_modifier = gimp_tool_polygon_motion_modifier;
widget_class->hover_modifier = gimp_tool_polygon_hover_modifier;
widget_class->get_cursor = gimp_tool_polygon_get_cursor;
g_type_class_add_private (klass, sizeof (GimpToolPolygonPrivate));
}
static void
gimp_tool_polygon_init (GimpToolPolygon *polygon)
{
polygon->private = G_TYPE_INSTANCE_GET_PRIVATE (polygon,
GIMP_TYPE_TOOL_POLYGON,
GimpToolPolygonPrivate);
polygon->private = gimp_tool_polygon_get_instance_private (polygon);
polygon->private->grabbed_segment_index = INVALID_INDEX;
polygon->private->last_click_time = NO_CLICK_TIME_AVAILABLE;

10
app/display/gimptoolrectangle.c
View File

@ -433,8 +433,8 @@ static void gimp_tool_rectangle_adjust_coord (GimpToolRectangle *rect
gdouble *coord_y_output);
G_DEFINE_TYPE (GimpToolRectangle, gimp_tool_rectangle,
GIMP_TYPE_TOOL_WIDGET)
G_DEFINE_TYPE_WITH_PRIVATE (GimpToolRectangle, gimp_tool_rectangle,
GIMP_TYPE_TOOL_WIDGET)
#define parent_class gimp_tool_rectangle_parent_class
@ -694,16 +694,12 @@ gimp_tool_rectangle_class_init (GimpToolRectangleClass *klass)
FALSE,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_type_class_add_private (klass, sizeof (GimpToolRectanglePrivate));
}
static void
gimp_tool_rectangle_init (GimpToolRectangle *rectangle)
{
rectangle->private = G_TYPE_INSTANCE_GET_PRIVATE (rectangle,
GIMP_TYPE_TOOL_RECTANGLE,
GimpToolRectanglePrivate);
rectangle->private = gimp_tool_rectangle_get_instance_private (rectangle);
rectangle->private->function = GIMP_TOOL_RECTANGLE_CREATING;
rectangle->private->is_first = TRUE;

10
app/display/gimptoolrotategrid.c
View File

@ -77,8 +77,8 @@ static void gimp_tool_rotate_grid_motion (GimpToolWidget *widget,
GdkModifierType state);
G_DEFINE_TYPE (GimpToolRotateGrid, gimp_tool_rotate_grid,
GIMP_TYPE_TOOL_TRANSFORM_GRID)
G_DEFINE_TYPE_WITH_PRIVATE (GimpToolRotateGrid, gimp_tool_rotate_grid,
GIMP_TYPE_TOOL_TRANSFORM_GRID)
#define parent_class gimp_tool_rotate_grid_parent_class
@ -103,16 +103,12 @@ gimp_tool_rotate_grid_class_init (GimpToolRotateGridClass *klass)
0.0,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_type_class_add_private (klass, sizeof (GimpToolRotateGridPrivate));
}
static void
gimp_tool_rotate_grid_init (GimpToolRotateGrid *grid)
{
grid->private = G_TYPE_INSTANCE_GET_PRIVATE (grid,
GIMP_TYPE_TOOL_ROTATE_GRID,
GimpToolRotateGridPrivate);
grid->private = gimp_tool_rotate_grid_get_instance_private (grid);
}
static void

10
app/display/gimptoolsheargrid.c
View File

@ -79,8 +79,8 @@ static void gimp_tool_shear_grid_motion (GimpToolWidget *widget,
GdkModifierType state);
G_DEFINE_TYPE (GimpToolShearGrid, gimp_tool_shear_grid,
GIMP_TYPE_TOOL_TRANSFORM_GRID)
G_DEFINE_TYPE_WITH_PRIVATE (GimpToolShearGrid, gimp_tool_shear_grid,
GIMP_TYPE_TOOL_TRANSFORM_GRID)
#define parent_class gimp_tool_shear_grid_parent_class
@ -122,16 +122,12 @@ gimp_tool_shear_grid_class_init (GimpToolShearGridClass *klass)
0.0,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_type_class_add_private (klass, sizeof (GimpToolShearGridPrivate));
}
static void
gimp_tool_shear_grid_init (GimpToolShearGrid *grid)
{
grid->private = G_TYPE_INSTANCE_GET_PRIVATE (grid,
GIMP_TYPE_TOOL_SHEAR_GRID,
GimpToolShearGridPrivate);
grid->private = gimp_tool_shear_grid_get_instance_private (grid);
g_object_set (grid,
"inside-function", GIMP_TRANSFORM_FUNCTION_SHEAR,

10
app/display/gimptooltransformgrid.c
View File

@ -204,8 +204,8 @@ static void gimp_tool_transform_grid_calc_handles (GimpToolTransformGrid *
gint *handle_h);
G_DEFINE_TYPE (GimpToolTransformGrid, gimp_tool_transform_grid,
GIMP_TYPE_TOOL_WIDGET)
G_DEFINE_TYPE_WITH_PRIVATE (GimpToolTransformGrid, gimp_tool_transform_grid,
GIMP_TYPE_TOOL_WIDGET)
#define parent_class gimp_tool_transform_grid_parent_class
@ -443,16 +443,12 @@ gimp_tool_transform_grid_class_init (GimpToolTransformGridClass *klass)
FALSE,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_type_class_add_private (klass, sizeof (GimpToolTransformGridPrivate));
}
static void
gimp_tool_transform_grid_init (GimpToolTransformGrid *grid)
{
grid->private = G_TYPE_INSTANCE_GET_PRIVATE (grid,
GIMP_TYPE_TOOL_TRANSFORM_GRID,
GimpToolTransformGridPrivate);
grid->private = gimp_tool_transform_grid_get_instance_private (grid);
}
static void

8
app/display/gimptoolwidget.c
View File

@ -96,7 +96,7 @@ static gboolean gimp_tool_widget_real_key_press (GimpToolWidget *widget,
GdkEventKey *kevent);
G_DEFINE_TYPE (GimpToolWidget, gimp_tool_widget, GIMP_TYPE_OBJECT)
G_DEFINE_TYPE_WITH_PRIVATE (GimpToolWidget, gimp_tool_widget, GIMP_TYPE_OBJECT)
#define parent_class gimp_tool_widget_parent_class
@ -194,16 +194,12 @@ gimp_tool_widget_class_init (GimpToolWidgetClass *klass)
NULL, NULL,
GIMP_TYPE_CANVAS_ITEM,
GIMP_PARAM_READABLE));
g_type_class_add_private (klass, sizeof (GimpToolWidgetPrivate));
}
static void
gimp_tool_widget_init (GimpToolWidget *widget)
{
widget->private = G_TYPE_INSTANCE_GET_PRIVATE (widget,
GIMP_TYPE_TOOL_WIDGET,
GimpToolWidgetPrivate);
widget->private = gimp_tool_widget_get_instance_private (widget);
}
static void

9
app/display/gimptoolwidgetgroup.c
View File

@ -133,7 +133,8 @@ static GimpToolWidget * gimp_tool_widget_group_get_hover_widget (GimpToolWidg
GimpHit *hit);
G_DEFINE_TYPE (GimpToolWidgetGroup, gimp_tool_widget_group, GIMP_TYPE_TOOL_WIDGET)
G_DEFINE_TYPE_WITH_PRIVATE (GimpToolWidgetGroup, gimp_tool_widget_group,
GIMP_TYPE_TOOL_WIDGET)
#define parent_class gimp_tool_widget_group_parent_class
@ -161,8 +162,6 @@ gimp_tool_widget_group_class_init (GimpToolWidgetGroupClass *klass)
widget_class->motion_modifier = gimp_tool_widget_group_motion_modifier;
widget_class->hover_modifier = gimp_tool_widget_group_hover_modifier;
widget_class->get_cursor = gimp_tool_widget_group_get_cursor;
g_type_class_add_private (klass, sizeof (GimpToolWidgetGroupPrivate));
}
static void
@ -170,9 +169,7 @@ gimp_tool_widget_group_init (GimpToolWidgetGroup *group)
{
GimpToolWidgetGroupPrivate *priv;
priv = group->priv = G_TYPE_INSTANCE_GET_PRIVATE (group,
GIMP_TYPE_TOOL_WIDGET_GROUP,
GimpToolWidgetGroupPrivate);
priv = group->priv = gimp_tool_widget_group_get_instance_private (group);
priv->children = g_object_new (GIMP_TYPE_LIST,
"children-type", GIMP_TYPE_TOOL_WIDGET,

9
app/gui/gimpuiconfigurer.c
View File

@ -84,7 +84,8 @@ static void gimp_ui_configurer_configure_for_multi_window (GimpUIC
static GimpImageWindow * gimp_ui_configurer_get_uber_window (GimpUIConfigurer *ui_configurer);
G_DEFINE_TYPE (GimpUIConfigurer, gimp_ui_configurer, GIMP_TYPE_OBJECT)
G_DEFINE_TYPE_WITH_PRIVATE (GimpUIConfigurer, gimp_ui_configurer,
GIMP_TYPE_OBJECT)
#define parent_class gimp_ui_configurer_parent_class
@ -102,16 +103,12 @@ gimp_ui_configurer_class_init (GimpUIConfigurerClass *klass)
GIMP_TYPE_GIMP,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_type_class_add_private (klass,
sizeof (GimpUIConfigurerPrivate));
}
static void
gimp_ui_configurer_init (GimpUIConfigurer *ui_configurer)
{
ui_configurer->p = G_TYPE_INSTANCE_GET_PRIVATE (ui_configurer,
GIMP_TYPE_UI_CONFIGURER,
GimpUIConfigurerPrivate);
ui_configurer->p = gimp_ui_configurer_get_instance_private (ui_configurer);
}
static void

9
app/paint/gimpmybrushcore.c
View File

@ -87,7 +87,8 @@ static void gimp_mybrush_core_create_brushes (GimpMybrushCore *mybrush,
GimpSymmetry *sym);
G_DEFINE_TYPE (GimpMybrushCore, gimp_mybrush_core, GIMP_TYPE_PAINT_CORE)
G_DEFINE_TYPE_WITH_PRIVATE (GimpMybrushCore, gimp_mybrush_core,
GIMP_TYPE_PAINT_CORE)
#define parent_class gimp_mybrush_core_parent_class
@ -115,16 +116,12 @@ gimp_mybrush_core_class_init (GimpMybrushCoreClass *klass)
paint_core_class->start = gimp_mybrush_core_start;
paint_core_class->paint = gimp_mybrush_core_paint;
paint_core_class->interpolate = gimp_mybrush_core_interpolate;
g_type_class_add_private (klass, sizeof (GimpMybrushCorePrivate));
}
static void
gimp_mybrush_core_init (GimpMybrushCore *mybrush)
{
mybrush->private = G_TYPE_INSTANCE_GET_PRIVATE (mybrush,
GIMP_TYPE_MYBRUSH_CORE,
GimpMybrushCorePrivate);
mybrush->private = gimp_mybrush_core_get_instance_private (mybrush);
}
static void

9
app/text/gimpfontfactory.c
View File

@ -96,7 +96,8 @@ static void gimp_font_factory_load_names (GimpContainer *container,
PangoContext *context);
G_DEFINE_TYPE (GimpFontFactory, gimp_font_factory, GIMP_TYPE_DATA_FACTORY)
G_DEFINE_TYPE_WITH_PRIVATE (GimpFontFactory, gimp_font_factory,
GIMP_TYPE_DATA_FACTORY)
#define parent_class gimp_font_factory_parent_class
@ -114,16 +115,12 @@ gimp_font_factory_class_init (GimpFontFactoryClass *klass)
factory_class->data_save = gimp_font_factory_data_save;
factory_class->data_duplicate = gimp_font_factory_data_duplicate;
factory_class->data_delete = gimp_font_factory_data_delete;
g_type_class_add_private (klass, sizeof (GimpFontFactoryPrivate));
}
static void
gimp_font_factory_init (GimpFontFactory *factory)
{
factory->priv = G_TYPE_INSTANCE_GET_PRIVATE (factory,
GIMP_TYPE_FONT_FACTORY,
GimpFontFactoryPrivate);
factory->priv = gimp_font_factory_get_instance_private (factory);
}
static void

8
app/text/gimptextlayer.c
View File

@ -121,7 +121,7 @@ static void gimp_text_layer_render_layout (GimpTextLayer *layer,
GimpTextLayout *layout);
G_DEFINE_TYPE (GimpTextLayer, gimp_text_layer, GIMP_TYPE_LAYER)
G_DEFINE_TYPE_WITH_PRIVATE (GimpTextLayer, gimp_text_layer, GIMP_TYPE_LAYER)
#define parent_class gimp_text_layer_parent_class
@ -185,8 +185,6 @@ gimp_text_layer_class_init (GimpTextLayerClass *klass)
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
g_type_class_add_private (klass, sizeof (GimpTextLayerPrivate));
}
static void
@ -194,9 +192,7 @@ gimp_text_layer_init (GimpTextLayer *layer)
{
layer->text = NULL;
layer->text_parasite = NULL;
layer->private = G_TYPE_INSTANCE_GET_PRIVATE (layer,
GIMP_TYPE_TEXT_LAYER,
GimpTextLayerPrivate);
layer->private = gimp_text_layer_get_instance_private (layer);
}
static void

10
app/tools/gimpfreeselecttool.c
View File

@ -110,8 +110,8 @@ static void gimp_free_select_tool_polygon_response (GimpToolWidget
GimpFreeSelectTool *fst);
G_DEFINE_TYPE (GimpFreeSelectTool, gimp_free_select_tool,
GIMP_TYPE_SELECTION_TOOL);
G_DEFINE_TYPE_WITH_PRIVATE (GimpFreeSelectTool, gimp_free_select_tool,
GIMP_TYPE_SELECTION_TOOL)
#define parent_class gimp_free_select_tool_parent_class
@ -167,8 +167,6 @@ gimp_free_select_tool_class_init (GimpFreeSelectToolClass *klass)
tool_class->active_modifier_key = gimp_free_select_tool_active_modifier_key;
klass->select = gimp_free_select_tool_real_select;
g_type_class_add_private (klass, sizeof (GimpFreeSelectToolPrivate));
}
static void
@ -176,9 +174,7 @@ gimp_free_select_tool_init (GimpFreeSelectTool *fst)
{
GimpTool *tool = GIMP_TOOL (fst);
fst->private = G_TYPE_INSTANCE_GET_PRIVATE (fst,
GIMP_TYPE_FREE_SELECT_TOOL,
GimpFreeSelectToolPrivate);
fst->private = gimp_free_select_tool_get_instance_private (fst);
gimp_tool_control_set_motion_mode (tool->control,
GIMP_MOTION_MODE_EXACT);

10
app/tools/gimprectangleselecttool.c
View File

@ -133,8 +133,8 @@ static void gimp_rectangle_select_tool_update_option_defaults
static void gimp_rectangle_select_tool_auto_shrink (GimpRectangleSelectTool *rect_tool);
G_DEFINE_TYPE (GimpRectangleSelectTool, gimp_rectangle_select_tool,
GIMP_TYPE_SELECTION_TOOL)
G_DEFINE_TYPE_WITH_PRIVATE (GimpRectangleSelectTool, gimp_rectangle_select_tool,
GIMP_TYPE_SELECTION_TOOL)
#define parent_class gimp_rectangle_select_tool_parent_class
@ -170,8 +170,6 @@ gimp_rectangle_select_tool_class_init (GimpRectangleSelectToolClass *klass)
tool_class->cursor_update = gimp_rectangle_select_tool_cursor_update;
klass->select = gimp_rectangle_select_tool_real_select;
g_type_class_add_private (klass, sizeof (GimpRectangleSelectToolPrivate));
}
static void
@ -180,9 +178,7 @@ gimp_rectangle_select_tool_init (GimpRectangleSelectTool *rect_tool)
GimpTool *tool = GIMP_TOOL (rect_tool);
rect_tool->private =
G_TYPE_INSTANCE_GET_PRIVATE (rect_tool,
GIMP_TYPE_RECTANGLE_SELECT_TOOL,
GimpRectangleSelectToolPrivate);
gimp_rectangle_select_tool_get_instance_private (rect_tool);
gimp_tool_control_set_wants_click (tool->control, TRUE);
gimp_tool_control_set_active_modifiers (tool->control,

10
app/widgets/gimpbuffersourcebox.c
View File

@ -80,8 +80,8 @@ static void gimp_buffer_source_box_enable_toggled (GtkToggleButton *butto
GimpBufferSourceBox *box);
G_DEFINE_TYPE (GimpBufferSourceBox, gimp_buffer_source_box,
GTK_TYPE_BOX)
G_DEFINE_TYPE_WITH_PRIVATE (GimpBufferSourceBox, gimp_buffer_source_box,
GTK_TYPE_BOX)
#define parent_class gimp_buffer_source_box_parent_class
@ -125,16 +125,12 @@ gimp_buffer_source_box_class_init (GimpBufferSourceBoxClass *klass)
TRUE,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_type_class_add_private (klass, sizeof (GimpBufferSourceBoxPrivate));
}
static void
gimp_buffer_source_box_init (GimpBufferSourceBox *box)
{
box->priv = G_TYPE_INSTANCE_GET_PRIVATE (box,
GIMP_TYPE_BUFFER_SOURCE_BOX,
GimpBufferSourceBoxPrivate);
box->priv = gimp_buffer_source_box_get_instance_private (box);
gtk_orientable_set_orientation (GTK_ORIENTABLE (box),
GTK_ORIENTATION_HORIZONTAL);

9
app/widgets/gimpchanneltreeview.c
View File

@ -49,7 +49,7 @@
#include "gimp-intl.h"
struct _GimpChannelTreeViewPriv
struct _GimpChannelTreeViewPrivate
{
GtkWidget *component_editor;
@ -81,6 +81,7 @@ static void gimp_channel_tree_view_set_view_size (GimpContainerView *
G_DEFINE_TYPE_WITH_CODE (GimpChannelTreeView, gimp_channel_tree_view,
GIMP_TYPE_DRAWABLE_TREE_VIEW,
G_ADD_PRIVATE (GimpChannelTreeView)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONTAINER_VIEW,
gimp_channel_tree_view_view_iface_init))
@ -125,8 +126,6 @@ gimp_channel_tree_view_class_init (GimpChannelTreeViewClass *klass)
iv_class->delete_action = "channels-delete";
iv_class->lock_content_help_id = GIMP_HELP_CHANNEL_LOCK_PIXELS;
iv_class->lock_position_help_id = GIMP_HELP_CHANNEL_LOCK_POSITION;
g_type_class_add_private (klass, sizeof (GimpChannelTreeViewPriv));
}
static void
@ -141,9 +140,7 @@ gimp_channel_tree_view_view_iface_init (GimpContainerViewInterface *view_iface)
static void
gimp_channel_tree_view_init (GimpChannelTreeView *view)
{
view->priv = G_TYPE_INSTANCE_GET_PRIVATE (view,
GIMP_TYPE_CHANNEL_TREE_VIEW,
GimpChannelTreeViewPriv);
view->priv = gimp_channel_tree_view_get_instance_private (view);
view->priv->component_editor = NULL;
view->priv->toselection_button = NULL;

8
app/widgets/gimpchanneltreeview.h
View File

@ -33,14 +33,14 @@
#define GIMP_CHANNEL_TREE_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_CHANNEL_TREE_VIEW, GimpChannelTreeViewClass))
typedef struct _GimpChannelTreeViewClass GimpChannelTreeViewClass;
typedef struct _GimpChannelTreeViewPriv GimpChannelTreeViewPriv;
typedef struct _GimpChannelTreeViewClass GimpChannelTreeViewClass;
typedef struct _GimpChannelTreeViewPrivate GimpChannelTreeViewPrivate;
struct _GimpChannelTreeView
{
GimpDrawableTreeView parent_instance;
GimpDrawableTreeView parent_instance;
GimpChannelTreeViewPriv *priv;
GimpChannelTreeViewPrivate *priv;
};
struct _GimpChannelTreeViewClass

8
app/widgets/gimpcircle.c
View File

@ -103,7 +103,7 @@ static void gimp_circle_draw_background (GimpCircle *circl
GimpCircleBackground background);
G_DEFINE_TYPE (GimpCircle, gimp_circle, GTK_TYPE_WIDGET)
G_DEFINE_TYPE_WITH_PRIVATE (GimpCircle, gimp_circle, GTK_TYPE_WIDGET)
#define parent_class gimp_circle_parent_class
@ -154,16 +154,12 @@ gimp_circle_class_init (GimpCircleClass *klass)
GIMP_CIRCLE_BACKGROUND_HSV,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_type_class_add_private (klass, sizeof (GimpCirclePrivate));
}
static void
gimp_circle_init (GimpCircle *circle)
{
circle->priv = G_TYPE_INSTANCE_GET_PRIVATE (circle,
GIMP_TYPE_CIRCLE,
GimpCirclePrivate);
circle->priv = gimp_circle_get_instance_private (circle);
gtk_widget_set_has_window (GTK_WIDGET (circle), FALSE);
gtk_widget_add_events (GTK_WIDGET (circle),

7
app/widgets/gimpcontainereditor.c
View File

@ -116,6 +116,7 @@ static gboolean gimp_container_editor_get_show_button_bar (GimpDocked *docked);
G_DEFINE_TYPE_WITH_CODE (GimpContainerEditor, gimp_container_editor,
GTK_TYPE_BOX,
G_ADD_PRIVATE (GimpContainerEditor)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_DOCKED,
gimp_container_editor_docked_iface_init))
@ -195,8 +196,6 @@ gimp_container_editor_class_init (GimpContainerEditorClass *klass)
NULL,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_type_class_add_private (klass, sizeof (GimpContainerEditorPrivate));
}
static void
@ -216,9 +215,7 @@ gimp_container_editor_init (GimpContainerEditor *editor)
gtk_orientable_set_orientation (GTK_ORIENTABLE (editor),
GTK_ORIENTATION_VERTICAL);
editor->priv = G_TYPE_INSTANCE_GET_PRIVATE (editor,
GIMP_TYPE_CONTAINER_EDITOR,
GimpContainerEditorPrivate);
editor->priv = gimp_container_editor_get_instance_private (editor);
}
static void

9
app/widgets/gimpcontainericonview.c
View File

@ -42,7 +42,7 @@
#include "gimpwidgets-utils.h"
struct _GimpContainerIconViewPriv
struct _GimpContainerIconViewPrivate
{
GimpViewRenderer *dnd_renderer;
};
@ -111,6 +111,7 @@ static gint gimp_container_icon_view_get_selected (GimpContainer
G_DEFINE_TYPE_WITH_CODE (GimpContainerIconView, gimp_container_icon_view,
GIMP_TYPE_CONTAINER_BOX,
G_ADD_PRIVATE (GimpContainerIconView)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONTAINER_VIEW,
gimp_container_icon_view_view_iface_init))
@ -130,8 +131,6 @@ gimp_container_icon_view_class_init (GimpContainerIconViewClass *klass)
widget_class->unmap = gimp_container_icon_view_unmap;
widget_class->popup_menu = gimp_container_icon_view_popup_menu;
g_type_class_add_private (klass, sizeof (GimpContainerIconViewPriv));
}
static void
@ -162,9 +161,7 @@ gimp_container_icon_view_init (GimpContainerIconView *icon_view)
{
GimpContainerBox *box = GIMP_CONTAINER_BOX (icon_view);
icon_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (icon_view,
GIMP_TYPE_CONTAINER_ICON_VIEW,
GimpContainerIconViewPriv);
icon_view->priv = gimp_container_icon_view_get_instance_private (icon_view);
gimp_container_tree_store_columns_init (icon_view->model_columns,
&icon_view->n_model_columns);

20
app/widgets/gimpcontainericonview.h
View File

@ -33,24 +33,24 @@
#define GIMP_CONTAINER_ICON_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_CONTAINER_ICON_VIEW, GimpContainerIconViewClass))
typedef struct _GimpContainerIconViewClass GimpContainerIconViewClass;
typedef struct _GimpContainerIconViewPriv GimpContainerIconViewPriv;
typedef struct _GimpContainerIconViewClass GimpContainerIconViewClass;
typedef struct _GimpContainerIconViewPrivate GimpContainerIconViewPrivate;
struct _GimpContainerIconView
{
GimpContainerBox parent_instance;
GimpContainerBox parent_instance;
GtkTreeModel *model;
gint n_model_columns;
GType model_columns[16];
GtkTreeModel *model;
gint n_model_columns;
GType model_columns[16];
GtkIconView *view;
GtkIconView *view;
GtkCellRenderer *renderer_cell;
GtkCellRenderer *renderer_cell;
Gimp *dnd_gimp; /* eek */
Gimp *dnd_gimp; /* eek */
GimpContainerIconViewPriv *priv;
GimpContainerIconViewPrivate *priv;
};
struct _GimpContainerIconViewClass

10
app/widgets/gimpcontainertreestore.c
View File

@ -54,9 +54,7 @@ struct _GimpContainerTreeStorePrivate
};
#define GET_PRIVATE(store) \
G_TYPE_INSTANCE_GET_PRIVATE (store, \
GIMP_TYPE_CONTAINER_TREE_STORE, \
GimpContainerTreeStorePrivate)
((GimpContainerTreeStorePrivate *) gimp_container_tree_store_get_instance_private ((GimpContainerTreeStore *) (store)))
static void gimp_container_tree_store_constructed (GObject *object);
@ -77,8 +75,8 @@ static void gimp_container_tree_store_renderer_update (GimpViewRenderer
GimpContainerTreeStore *store);
G_DEFINE_TYPE (GimpContainerTreeStore, gimp_container_tree_store,
GTK_TYPE_TREE_STORE)
G_DEFINE_TYPE_WITH_PRIVATE (GimpContainerTreeStore, gimp_container_tree_store,
GTK_TYPE_TREE_STORE)
#define parent_class gimp_container_tree_store_parent_class
@ -105,8 +103,6 @@ gimp_container_tree_store_class_init (GimpContainerTreeStoreClass *klass)
NULL, NULL,
FALSE,
GIMP_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GimpContainerTreeStorePrivate));
}
static void

2
app/widgets/gimpcontainertreeview-private.h
View File

@ -22,7 +22,7 @@
#define __GIMP_CONTAINER_TREE_VIEW_PRIVATE_H__
struct _GimpContainerTreeViewPriv
struct _GimpContainerTreeViewPrivate
{
GtkTreeSelection *selection;

7
app/widgets/gimpcontainertreeview.c
View File

@ -140,6 +140,7 @@ static void gimp_container_tree_view_monitor_changed (GimpContainer
G_DEFINE_TYPE_WITH_CODE (GimpContainerTreeView, gimp_container_tree_view,
GIMP_TYPE_CONTAINER_BOX,
G_ADD_PRIVATE (GimpContainerTreeView)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONTAINER_VIEW,
gimp_container_tree_view_view_iface_init))
@ -186,8 +187,6 @@ gimp_container_tree_view_class_init (GimpContainerTreeViewClass *klass)
gtk_binding_entry_add_signal (binding_set, GDK_KEY_F2, 0,
"edit-name", 0);
g_type_class_add_private (klass, sizeof (GimpContainerTreeViewPriv));
}
static void
@ -219,9 +218,7 @@ gimp_container_tree_view_init (GimpContainerTreeView *tree_view)
{
GimpContainerBox *box = GIMP_CONTAINER_BOX (tree_view);
tree_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_view,
GIMP_TYPE_CONTAINER_TREE_VIEW,
GimpContainerTreeViewPriv);
tree_view->priv = gimp_container_tree_view_get_instance_private (tree_view);
gimp_container_tree_store_columns_init (tree_view->model_columns,
&tree_view->n_model_columns);

22
app/widgets/gimpcontainertreeview.h
View File

@ -33,25 +33,25 @@
#define GIMP_CONTAINER_TREE_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_CONTAINER_TREE_VIEW, GimpContainerTreeViewClass))
typedef struct _GimpContainerTreeViewClass GimpContainerTreeViewClass;
typedef struct _GimpContainerTreeViewPriv GimpContainerTreeViewPriv;
typedef struct _GimpContainerTreeViewClass GimpContainerTreeViewClass;
typedef struct _GimpContainerTreeViewPrivate GimpContainerTreeViewPrivate;
struct _GimpContainerTreeView
{
GimpContainerBox parent_instance;
GimpContainerBox parent_instance;
GtkTreeModel *model;
gint n_model_columns;
GType model_columns[16];
GtkTreeModel *model;
gint n_model_columns;
GType model_columns[16];
GtkTreeView *view;
GtkTreeView *view;
GtkTreeViewColumn *main_column;
GtkCellRenderer *renderer_cell;
GtkTreeViewColumn *main_column;
GtkCellRenderer *renderer_cell;
Gimp *dnd_gimp; /* eek */
Gimp *dnd_gimp; /* eek */
GimpContainerTreeViewPriv *priv;
GimpContainerTreeViewPrivate *priv;
};
struct _GimpContainerTreeViewClass

7
app/widgets/gimpdashboard.c
View File

@ -892,6 +892,7 @@ static const GroupInfo groups[] =
G_DEFINE_TYPE_WITH_CODE (GimpDashboard, gimp_dashboard, GIMP_TYPE_EDITOR,
G_ADD_PRIVATE (GimpDashboard)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_DOCKED,
gimp_dashboard_docked_iface_init))
@ -915,8 +916,6 @@ gimp_dashboard_class_init (GimpDashboardClass *klass)
widget_class->map = gimp_dashboard_map;
widget_class->unmap = gimp_dashboard_unmap;
g_type_class_add_private (klass, sizeof (GimpDashboardPrivate));
}
static void
@ -942,9 +941,7 @@ gimp_dashboard_init (GimpDashboard *dashboard)
Group group;
gint field;
priv = dashboard->priv = G_TYPE_INSTANCE_GET_PRIVATE (dashboard,
GIMP_TYPE_DASHBOARD,
GimpDashboardPrivate);
priv = dashboard->priv = gimp_dashboard_get_instance_private (dashboard);
g_mutex_init (&priv->mutex);
g_cond_init (&priv->cond);

19
app/widgets/gimpdatafactoryview.c
View File

@ -63,7 +63,7 @@ enum
};
struct _GimpDataFactoryViewPriv
struct _GimpDataFactoryViewPrivate
{
GimpDataFactory *factory;
gchar *action_group;
@ -114,6 +114,7 @@ static void gimp_data_factory_view_tree_name_edited (GtkCellRendererText *cell,
G_DEFINE_TYPE_WITH_CODE (GimpDataFactoryView, gimp_data_factory_view,
GIMP_TYPE_CONTAINER_EDITOR,
G_ADD_PRIVATE (GimpDataFactoryView)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_DOCKED,
gimp_data_factory_view_docked_iface_init))
@ -150,16 +151,12 @@ gimp_data_factory_view_class_init (GimpDataFactoryViewClass *klass)
NULL,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_type_class_add_private (klass, sizeof (GimpDataFactoryViewPriv));
}
static void
gimp_data_factory_view_init (GimpDataFactoryView *view)
{
view->priv = G_TYPE_INSTANCE_GET_PRIVATE (view,
GIMP_TYPE_DATA_FACTORY_VIEW,
GimpDataFactoryViewPriv);
view->priv = gimp_data_factory_view_get_instance_private (view);
view->priv->tagged_container = NULL;
view->priv->query_tag_entry = NULL;
@ -217,11 +214,11 @@ gimp_data_factory_view_constructor (GType type,
static void
gimp_data_factory_view_constructed (GObject *object)
{
GimpDataFactoryView *factory_view = GIMP_DATA_FACTORY_VIEW (object);
GimpDataFactoryViewPriv *priv = factory_view->priv;
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (object);
GimpUIManager *manager;
gchar *str;
GimpDataFactoryView *factory_view = GIMP_DATA_FACTORY_VIEW (object);
GimpDataFactoryViewPrivate *priv = factory_view->priv;
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (object);
GimpUIManager *manager;
gchar *str;
G_OBJECT_CLASS (parent_class)->constructed (object);

8
app/widgets/gimpdatafactoryview.h
View File

@ -33,14 +33,14 @@
#define GIMP_DATA_FACTORY_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_DATA_FACTORY_VIEW, GimpDataFactoryViewClass))
typedef struct _GimpDataFactoryViewClass GimpDataFactoryViewClass;
typedef struct _GimpDataFactoryViewPriv GimpDataFactoryViewPriv;
typedef struct _GimpDataFactoryViewClass GimpDataFactoryViewClass;
typedef struct _GimpDataFactoryViewPrivate GimpDataFactoryViewPrivate;
struct _GimpDataFactoryView
{
GimpContainerEditor parent_instance;
GimpContainerEditor parent_instance;
GimpDataFactoryViewPriv *priv;
GimpDataFactoryViewPrivate *priv;
};
struct _GimpDataFactoryViewClass

9
app/widgets/gimpdeviceeditor.c
View File

@ -72,9 +72,7 @@ struct _GimpDeviceEditorPrivate
#define GIMP_DEVICE_EDITOR_GET_PRIVATE(editor) \
G_TYPE_INSTANCE_GET_PRIVATE (editor, \
GIMP_TYPE_DEVICE_EDITOR, \
GimpDeviceEditorPrivate)
((GimpDeviceEditorPrivate *) gimp_device_editor_get_instance_private ((GimpDeviceEditor *) (editor)))
static void gimp_device_editor_constructed (GObject *object);
@ -106,7 +104,8 @@ static void gimp_device_editor_delete_clicked (GtkWidget *button,
GimpDeviceEditor *editor);
G_DEFINE_TYPE (GimpDeviceEditor, gimp_device_editor, GTK_TYPE_PANED)
G_DEFINE_TYPE_WITH_PRIVATE (GimpDeviceEditor, gimp_device_editor,
GTK_TYPE_PANED)
#define parent_class gimp_device_editor_parent_class
@ -127,8 +126,6 @@ gimp_device_editor_class_init (GimpDeviceEditorClass *klass)
GIMP_TYPE_GIMP,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_type_class_add_private (object_class, sizeof (GimpDeviceEditorPrivate));
}
static void

9
app/widgets/gimpdeviceinfoeditor.c
View File

@ -90,9 +90,7 @@ struct _GimpDeviceInfoEditorPrivate
};
#define GIMP_DEVICE_INFO_EDITOR_GET_PRIVATE(editor) \
G_TYPE_INSTANCE_GET_PRIVATE (editor, \
GIMP_TYPE_DEVICE_INFO_EDITOR, \
GimpDeviceInfoEditorPrivate)
((GimpDeviceInfoEditorPrivate *) gimp_device_info_editor_get_instance_private ((GimpDeviceInfoEditor *) (editor)))
static void gimp_device_info_editor_constructed (GObject *object);
@ -129,7 +127,8 @@ static void gimp_device_info_editor_curve_reset (GtkWidget *butto
GimpCurve *curve);
G_DEFINE_TYPE (GimpDeviceInfoEditor, gimp_device_info_editor, GTK_TYPE_BOX)
G_DEFINE_TYPE_WITH_PRIVATE (GimpDeviceInfoEditor, gimp_device_info_editor,
GTK_TYPE_BOX)
#define parent_class gimp_device_info_editor_parent_class
@ -171,8 +170,6 @@ gimp_device_info_editor_class_init (GimpDeviceInfoEditorClass *klass)
GIMP_TYPE_DEVICE_INFO,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_type_class_add_private (object_class, sizeof (GimpDeviceInfoEditorPrivate));
}
static void

9
app/widgets/gimpdevicemanager.c
View File

@ -95,7 +95,8 @@ static void gimp_device_manager_connect_tool (GimpDeviceManager *manager);
static void gimp_device_manager_disconnect_tool (GimpDeviceManager *manager);
G_DEFINE_TYPE (GimpDeviceManager, gimp_device_manager, GIMP_TYPE_LIST)
G_DEFINE_TYPE_WITH_PRIVATE (GimpDeviceManager, gimp_device_manager,
GIMP_TYPE_LIST)
#define parent_class gimp_device_manager_parent_class
@ -125,16 +126,12 @@ gimp_device_manager_class_init (GimpDeviceManagerClass *klass)
GIMP_TYPE_DEVICE_INFO,
GIMP_PARAM_STATIC_STRINGS |
G_PARAM_READABLE));
g_type_class_add_private (object_class, sizeof (GimpDeviceManagerPrivate));
}
static void
gimp_device_manager_init (GimpDeviceManager *manager)
{
manager->priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
GIMP_TYPE_DEVICE_MANAGER,
GimpDeviceManagerPrivate);
manager->priv = gimp_device_manager_get_instance_private (manager);
manager->priv->displays = g_hash_table_new_full (g_str_hash,
g_str_equal,

Some files were not shown because too many files have changed in this diff Show More