From 3b0040c04345de07d8338789d94b1fd9dbf4bd76 Mon Sep 17 00:00:00 2001 From: Ell Date: Tue, 18 Sep 2018 12:09:39 -0400 Subject: [PATCH] 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. --- app/config/gimpdialogconfig.c | 9 +++----- app/core/gimpasync.c | 7 ++---- app/core/gimpasyncset.c | 7 ++---- app/core/gimpauxitem.c | 8 ++----- app/core/gimpbrush.c | 7 ++---- app/core/gimpcontainer.c | 9 +++----- app/core/gimpcontainer.h | 8 +++---- app/core/gimpdatafactory.c | 9 +++----- app/core/gimpdataloaderfactory.c | 10 +++------ app/core/gimpdrawable.c | 7 ++---- app/core/gimpdynamics.c | 9 ++------ app/core/gimpdynamicsoutput.c | 7 ++---- app/core/gimpextension.c | 8 ++----- app/core/gimpextensionmanager.c | 10 ++++----- app/core/gimpfilloptions.c | 7 ++---- app/core/gimpfilter.c | 8 ++----- app/core/gimpgrouplayer.c | 7 ++---- app/core/gimpguide.c | 7 ++---- app/core/gimphistogram.c | 8 ++----- app/core/gimpidtable.c | 16 +++++--------- app/core/gimpidtable.h | 8 +++---- app/core/gimpimage-private.h | 7 +----- app/core/gimpimage.c | 7 +++--- app/core/gimpimage.h | 9 +++++--- app/core/gimpimagefile.c | 8 ++----- app/core/gimpitem.c | 8 ++----- app/core/gimpitemtree.c | 8 ++----- app/core/gimpmybrush.c | 7 ++---- app/core/gimpprojection.c | 7 ++---- app/core/gimpsamplepoint.c | 9 +++----- app/core/gimpstrokeoptions.c | 7 ++---- app/core/gimptagcache.c | 16 +++++--------- app/core/gimptagcache.h | 8 +++---- app/core/gimptemplate.c | 7 ++---- app/core/gimpviewable.c | 7 ++---- app/display/gimpcanvasarc.c | 10 +++------ app/display/gimpcanvasboundary.c | 10 +++------ app/display/gimpcanvasbufferpreview.c | 10 +++------ app/display/gimpcanvascorner.c | 10 +++------ app/display/gimpcanvascursor.c | 10 +++------ app/display/gimpcanvasgrid.c | 9 +++----- app/display/gimpcanvasgroup.c | 9 +++----- app/display/gimpcanvasguide.c | 9 +++----- app/display/gimpcanvashandle.c | 10 +++------ app/display/gimpcanvasitem.c | 9 ++------ app/display/gimpcanvaslayerboundary.c | 10 +++------ app/display/gimpcanvasline.c | 9 +++----- app/display/gimpcanvaspassepartout.c | 10 +++------ app/display/gimpcanvaspath.c | 10 +++------ app/display/gimpcanvaspen.c | 10 +++------ app/display/gimpcanvaspolygon.c | 10 +++------ app/display/gimpcanvasprogress.c | 7 ++---- app/display/gimpcanvasproxygroup.c | 10 +++------ app/display/gimpcanvasrectangle.c | 10 +++------ app/display/gimpcanvasrectangleguides.c | 10 +++------ app/display/gimpcanvassamplepoint.c | 10 +++------ app/display/gimpcanvastextcursor.c | 10 +++------ app/display/gimpcanvastransformguides.c | 10 +++------ app/display/gimpcanvastransformpreview.c | 11 ++++------ app/display/gimpcursorview.c | 9 +++----- app/display/gimpcursorview.h | 8 +++---- app/display/gimpdisplay.c | 7 ++---- app/display/gimpimagewindow.c | 7 ++---- app/display/gimptoolcompass.c | 9 +++----- app/display/gimptooldialog.c | 9 +++----- app/display/gimptoolgui.c | 8 ++----- app/display/gimptoolgyroscope.c | 9 +++----- app/display/gimptoolhandlegrid.c | 10 +++------ app/display/gimptoolline.c | 8 ++----- app/display/gimptoolpath.c | 8 ++----- app/display/gimptoolpolygon.c | 9 +++----- app/display/gimptoolrectangle.c | 10 +++------ app/display/gimptoolrotategrid.c | 10 +++------ app/display/gimptoolsheargrid.c | 10 +++------ app/display/gimptooltransformgrid.c | 10 +++------ app/display/gimptoolwidget.c | 8 ++----- app/display/gimptoolwidgetgroup.c | 9 +++----- app/gui/gimpuiconfigurer.c | 9 +++----- app/paint/gimpmybrushcore.c | 9 +++----- app/text/gimpfontfactory.c | 9 +++----- app/text/gimptextlayer.c | 8 ++----- app/tools/gimpfreeselecttool.c | 10 +++------ app/tools/gimprectangleselecttool.c | 10 +++------ app/widgets/gimpbuffersourcebox.c | 10 +++------ app/widgets/gimpchanneltreeview.c | 9 +++----- app/widgets/gimpchanneltreeview.h | 8 +++---- app/widgets/gimpcircle.c | 8 ++----- app/widgets/gimpcontainereditor.c | 7 ++---- app/widgets/gimpcontainericonview.c | 9 +++----- app/widgets/gimpcontainericonview.h | 20 ++++++++--------- app/widgets/gimpcontainertreestore.c | 10 +++------ app/widgets/gimpcontainertreeview-private.h | 2 +- app/widgets/gimpcontainertreeview.c | 7 ++---- app/widgets/gimpcontainertreeview.h | 22 +++++++++---------- app/widgets/gimpdashboard.c | 7 ++---- app/widgets/gimpdatafactoryview.c | 19 +++++++--------- app/widgets/gimpdatafactoryview.h | 8 +++---- app/widgets/gimpdeviceeditor.c | 9 +++----- app/widgets/gimpdeviceinfoeditor.c | 9 +++----- app/widgets/gimpdevicemanager.c | 9 +++----- app/widgets/gimpdial.c | 8 ++----- app/widgets/gimpdialogfactory.c | 9 +++----- app/widgets/gimpdock.c | 8 ++----- app/widgets/gimpdockable.c | 7 ++---- app/widgets/gimpdockbook.c | 8 ++----- app/widgets/gimpdockcolumns.c | 8 ++----- app/widgets/gimpdockwindow.c | 7 ++---- app/widgets/gimpdynamicsoutputeditor.c | 11 +++------- app/widgets/gimpeditor.c | 7 ++---- app/widgets/gimpextensiondetails.c | 8 +++---- app/widgets/gimpextensionlist.c | 9 +++----- app/widgets/gimpiconpicker.c | 8 ++----- app/widgets/gimpitemtreeview.c | 9 +++----- app/widgets/gimpitemtreeview.h | 8 +++---- app/widgets/gimplayermodebox.c | 9 ++------ app/widgets/gimplayermodecombobox.c | 10 +++------ app/widgets/gimplayertreeview.c | 9 +++----- app/widgets/gimplayertreeview.h | 8 +++---- app/widgets/gimpmenudock.c | 4 +--- app/widgets/gimpmenufactory.c | 9 +++----- app/widgets/gimpmeter.c | 8 ++----- app/widgets/gimppanedbox.c | 8 ++----- app/widgets/gimppickablebutton.c | 9 +++----- app/widgets/gimppickablepopup.c | 9 +++----- app/widgets/gimppolar.c | 8 ++----- app/widgets/gimpprefsbox.c | 8 ++----- app/widgets/gimpsearchpopup.c | 8 ++----- app/widgets/gimpsessioninfo.c | 7 ++---- app/widgets/gimpsettingsbox.c | 8 ++----- app/widgets/gimpsettingseditor.c | 9 +++----- app/widgets/gimpsizebox.c | 7 ++---- app/widgets/gimpspinscale.c | 9 +++----- app/widgets/gimpsymmetryeditor.c | 10 +++------ app/widgets/gimptemplateeditor.c | 9 +++----- app/widgets/gimptoolbox.c | 8 ++----- app/widgets/gimptooleditor.c | 9 +++----- app/widgets/gimptooloptionseditor.c | 7 ++---- app/widgets/gimptoolpalette.c | 9 +++----- app/widgets/gimptoolpreseteditor.c | 7 ++---- app/widgets/gimpviewrenderer.c | 8 ++----- app/widgets/gimpviewrendererdrawable.c | 11 ++++------ app/widgets/gimpwindow.c | 8 ++----- libgimp/gimpaspectpreview.c | 9 +++----- libgimp/gimpbrushselectbutton.c | 11 +++------- libgimp/gimpdrawablepreview.c | 10 +++------ libgimp/gimpfontselectbutton.c | 11 +++------- libgimp/gimpgradientselectbutton.c | 12 ++++------ libgimp/gimppaletteselectbutton.c | 9 +++----- libgimp/gimppatternselectbutton.c | 9 +++----- libgimp/gimpprocbrowserdialog.c | 10 +++------ libgimp/gimptilebackendplugin.c | 10 +++------ libgimp/gimpzoompreview.c | 9 +++----- libgimpcolor/gimpcolorprofile.c | 9 ++------ libgimpcolor/gimpcolortransform.c | 10 +++------ libgimpconfig/gimpcolorconfig.c | 7 ++---- libgimpmodule/gimpmoduledb.c | 8 ++----- libgimpwidgets/gimpbrowser.c | 8 ++----- libgimpwidgets/gimpbusybox.c | 8 ++----- libgimpwidgets/gimpbutton.c | 9 ++------ libgimpwidgets/gimpcellrenderercolor.c | 10 +++------ libgimpwidgets/gimpcellrenderertoggle.c | 10 +++------ libgimpwidgets/gimpchainbutton.c | 8 ++----- libgimpwidgets/gimpcolorarea.c | 9 +++----- libgimpwidgets/gimpcolordisplay.c | 8 +++---- libgimpwidgets/gimpcolordisplaystack.c | 9 +++----- libgimpwidgets/gimpcolorhexentry.c | 9 +++----- libgimpwidgets/gimpcolornotebook.c | 11 +++------- .../gimpcolorprofilechooserdialog.c | 11 ++++------ libgimpwidgets/gimpcolorprofilecombobox.c | 11 +++------- libgimpwidgets/gimpcolorprofilestore.c | 10 +++------ libgimpwidgets/gimpcolorprofileview.c | 10 +++------ libgimpwidgets/gimpcolorscale.c | 8 ++----- libgimpwidgets/gimpcolorselection.c | 9 +++----- libgimpwidgets/gimpcolorselector.c | 9 +++----- libgimpwidgets/gimpdialog.c | 8 ++----- libgimpwidgets/gimpenumlabel.c | 8 ++----- libgimpwidgets/gimpenumstore.c | 8 ++----- libgimpwidgets/gimpintcombobox.c | 9 +++----- libgimpwidgets/gimpintstore.c | 7 ++---- libgimpwidgets/gimpmemsizeentry.c | 12 +++------- libgimpwidgets/gimpnumberpairentry.c | 9 +++----- libgimpwidgets/gimpoffsetarea.c | 10 +++------ libgimpwidgets/gimppageselector.c | 8 ++----- libgimpwidgets/gimppickbutton.c | 8 ++----- libgimpwidgets/gimppreview.c | 8 ++----- libgimpwidgets/gimppreviewarea.c | 9 +++----- libgimpwidgets/gimpruler.c | 8 ++----- libgimpwidgets/gimpscrolledpreview.c | 10 +++------ libgimpwidgets/gimpsizeentry.c | 8 ++----- libgimpwidgets/gimpstringcombobox.c | 9 +++----- libgimpwidgets/gimpunitstore.c | 7 ++---- libgimpwidgets/gimpzoommodel.c | 8 ++----- modules/gimpcolorwheel.c | 11 ++++------ 193 files changed, 540 insertions(+), 1184 deletions(-) diff --git a/app/config/gimpdialogconfig.c b/app/config/gimpdialogconfig.c index b470da07bb..766d1d18f4 100644 --- a/app/config/gimpdialogconfig.c +++ b/app/config/gimpdialogconfig.c @@ -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 diff --git a/app/core/gimpasync.c b/app/core/gimpasync.c index 647ffd9f05..77ecd947f1 100644 --- a/app/core/gimpasync.c +++ b/app/core/gimpasync.c @@ -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); diff --git a/app/core/gimpasyncset.c b/app/core/gimpasyncset.c index 91aab579d5..f1b611e6ee 100644 --- a/app/core/gimpasyncset.c +++ b/app/core/gimpasyncset.c @@ -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); } diff --git a/app/core/gimpauxitem.c b/app/core/gimpauxitem.c index 42225b4a55..cc9614934b 100644 --- a/app/core/gimpauxitem.c +++ b/app/core/gimpauxitem.c @@ -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 diff --git a/app/core/gimpbrush.c b/app/core/gimpbrush.c index 1e77263942..b4791b70c4 100644 --- a/app/core/gimpbrush.c +++ b/app/core/gimpbrush.c @@ -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; diff --git a/app/core/gimpcontainer.c b/app/core/gimpcontainer.c index ec11b28406..3c2be3d440 100644 --- a/app/core/gimpcontainer.c +++ b/app/core/gimpcontainer.c @@ -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; diff --git a/app/core/gimpcontainer.h b/app/core/gimpcontainer.h index 76bec4c8bc..8b428599fa 100644 --- a/app/core/gimpcontainer.h +++ b/app/core/gimpcontainer.h @@ -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 diff --git a/app/core/gimpdatafactory.c b/app/core/gimpdatafactory.c index a3162263fa..6f99551373 100644 --- a/app/core/gimpdatafactory.c +++ b/app/core/gimpdatafactory.c @@ -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 (); } diff --git a/app/core/gimpdataloaderfactory.c b/app/core/gimpdataloaderfactory.c index 6809aed028..18728ba6b0 100644 --- a/app/core/gimpdataloaderfactory.c +++ b/app/core/gimpdataloaderfactory.c @@ -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 diff --git a/app/core/gimpdrawable.c b/app/core/gimpdrawable.c index cc6176cfb4..91b0cad1e7 100644 --- a/app/core/gimpdrawable.c +++ b/app/core/gimpdrawable.c @@ -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); } diff --git a/app/core/gimpdynamics.c b/app/core/gimpdynamics.c index 5056c35d2c..a1fb0efc2c 100644 --- a/app/core/gimpdynamics.c +++ b/app/core/gimpdynamics.c @@ -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 diff --git a/app/core/gimpdynamicsoutput.c b/app/core/gimpdynamicsoutput.c index d3a5dac027..7a4f309a7e 100644 --- a/app/core/gimpdynamicsoutput.c +++ b/app/core/gimpdynamicsoutput.c @@ -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 diff --git a/app/core/gimpextension.c b/app/core/gimpextension.c index 1732ca4092..4618f2e03b 100644 --- a/app/core/gimpextension.c +++ b/app/core/gimpextension.c @@ -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 diff --git a/app/core/gimpextensionmanager.c b/app/core/gimpextensionmanager.c index 087584bfc7..5b5de7c290 100644 --- a/app/core/gimpextensionmanager.c +++ b/app/core/gimpextensionmanager.c @@ -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; } diff --git a/app/core/gimpfilloptions.c b/app/core/gimpfilloptions.c index 7e86ffe0c4..3da41e94d4 100644 --- a/app/core/gimpfilloptions.c +++ b/app/core/gimpfilloptions.c @@ -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 diff --git a/app/core/gimpfilter.c b/app/core/gimpfilter.c index d88458bfb8..f565d499a0 100644 --- a/app/core/gimpfilter.c +++ b/app/core/gimpfilter.c @@ -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 diff --git a/app/core/gimpgrouplayer.c b/app/core/gimpgrouplayer.c index 7d251fcb1a..295fba66c0 100644 --- a/app/core/gimpgrouplayer.c +++ b/app/core/gimpgrouplayer.c @@ -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; } diff --git a/app/core/gimpguide.c b/app/core/gimpguide.c index 87da7f7f74..14389587da 100644 --- a/app/core/gimpguide.c +++ b/app/core/gimpguide.c @@ -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 diff --git a/app/core/gimphistogram.c b/app/core/gimphistogram.c index 4188e5ce05..d6de248e86 100644 --- a/app/core/gimphistogram.c +++ b/app/core/gimphistogram.c @@ -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; } diff --git a/app/core/gimpidtable.c b/app/core/gimpidtable.c index 193c8cd35f..b69a13d053 100644 --- a/app/core/gimpidtable.c +++ b/app/core/gimpidtable.c @@ -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; diff --git a/app/core/gimpidtable.h b/app/core/gimpidtable.h index 0311d17b80..88097fd4c1 100644 --- a/app/core/gimpidtable.h +++ b/app/core/gimpidtable.h @@ -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 diff --git a/app/core/gimpimage-private.h b/app/core/gimpimage-private.h index 3a1604974b..c1d35805ca 100644 --- a/app/core/gimpimage-private.h +++ b/app/core/gimpimage-private.h @@ -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); diff --git a/app/core/gimpimage.c b/app/core/gimpimage.c index 23dae7bb41..343f1f6a6f 100644 --- a/app/core/gimpimage.c +++ b/app/core/gimpimage.c @@ -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; diff --git a/app/core/gimpimage.h b/app/core/gimpimage.h index ac6523f3a7..fd404404d7 100644 --- a/app/core/gimpimage.h +++ b/app/core/gimpimage.h @@ -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 diff --git a/app/core/gimpimagefile.c b/app/core/gimpimagefile.c index fb10d34945..cf079d848c 100644 --- a/app/core/gimpimagefile.c +++ b/app/core/gimpimagefile.c @@ -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 diff --git a/app/core/gimpitem.c b/app/core/gimpitem.c index 363ee52eec..d7856ef071 100644 --- a/app/core/gimpitem.c +++ b/app/core/gimpitem.c @@ -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 diff --git a/app/core/gimpitemtree.c b/app/core/gimpitemtree.c index 839a3b8cba..247f3b8648 100644 --- a/app/core/gimpitemtree.c +++ b/app/core/gimpitemtree.c @@ -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 diff --git a/app/core/gimpmybrush.c b/app/core/gimpmybrush.c index 53199524a5..b140b13abc 100644 --- a/app/core/gimpmybrush.c +++ b/app/core/gimpmybrush.c @@ -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; diff --git a/app/core/gimpprojection.c b/app/core/gimpprojection.c index 502ef1e218..8e97972955 100644 --- a/app/core/gimpprojection.c +++ b/app/core/gimpprojection.c @@ -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 diff --git a/app/core/gimpsamplepoint.c b/app/core/gimpsamplepoint.c index 60870594b6..f0fe3778cd 100644 --- a/app/core/gimpsamplepoint.c +++ b/app/core/gimpsamplepoint.c @@ -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 diff --git a/app/core/gimpstrokeoptions.c b/app/core/gimpstrokeoptions.c index 8315792ddb..3bb5c92115 100644 --- a/app/core/gimpstrokeoptions.c +++ b/app/core/gimpstrokeoptions.c @@ -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 diff --git a/app/core/gimptagcache.c b/app/core/gimptagcache.c index e43c1145a7..ab508c0243 100644 --- a/app/core/gimptagcache.c +++ b/app/core/gimptagcache.c @@ -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)); diff --git a/app/core/gimptagcache.h b/app/core/gimptagcache.h index 21dc536ed6..4c3a465926 100644 --- a/app/core/gimptagcache.h +++ b/app/core/gimptagcache.h @@ -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 diff --git a/app/core/gimptemplate.c b/app/core/gimptemplate.c index 5240917f2d..f903bb5b87 100644 --- a/app/core/gimptemplate.c +++ b/app/core/gimptemplate.c @@ -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 diff --git a/app/core/gimpviewable.c b/app/core/gimpviewable.c index fdb925bd53..4fcc2df36b 100644 --- a/app/core/gimpviewable.c +++ b/app/core/gimpviewable.c @@ -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 diff --git a/app/display/gimpcanvasarc.c b/app/display/gimpcanvasarc.c index 5fde91b76a..a4041b2930 100644 --- a/app/display/gimpcanvasarc.c +++ b/app/display/gimpcanvasarc.c @@ -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 diff --git a/app/display/gimpcanvasboundary.c b/app/display/gimpcanvasboundary.c index 68448ad357..b2e445fd2c 100644 --- a/app/display/gimpcanvasboundary.c +++ b/app/display/gimpcanvasboundary.c @@ -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 diff --git a/app/display/gimpcanvasbufferpreview.c b/app/display/gimpcanvasbufferpreview.c index 2221b0ac3a..6aad7f2ed1 100644 --- a/app/display/gimpcanvasbufferpreview.c +++ b/app/display/gimpcanvasbufferpreview.c @@ -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 diff --git a/app/display/gimpcanvascorner.c b/app/display/gimpcanvascorner.c index 2cc59f3e06..50aebfb4f0 100644 --- a/app/display/gimpcanvascorner.c +++ b/app/display/gimpcanvascorner.c @@ -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 diff --git a/app/display/gimpcanvascursor.c b/app/display/gimpcanvascursor.c index ff171d36ad..581fa76c90 100644 --- a/app/display/gimpcanvascursor.c +++ b/app/display/gimpcanvascursor.c @@ -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 diff --git a/app/display/gimpcanvasgrid.c b/app/display/gimpcanvasgrid.c index 4f9f138370..f55c202c38 100644 --- a/app/display/gimpcanvasgrid.c +++ b/app/display/gimpcanvasgrid.c @@ -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 diff --git a/app/display/gimpcanvasgroup.c b/app/display/gimpcanvasgroup.c index a28029e3ec..13d00ff94f 100644 --- a/app/display/gimpcanvasgroup.c +++ b/app/display/gimpcanvasgroup.c @@ -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 (); } diff --git a/app/display/gimpcanvasguide.c b/app/display/gimpcanvasguide.c index 2547e9dae6..5712633448 100644 --- a/app/display/gimpcanvasguide.c +++ b/app/display/gimpcanvasguide.c @@ -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 diff --git a/app/display/gimpcanvashandle.c b/app/display/gimpcanvashandle.c index 36b0307513..4291affc7c 100644 --- a/app/display/gimpcanvashandle.c +++ b/app/display/gimpcanvashandle.c @@ -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 diff --git a/app/display/gimpcanvasitem.c b/app/display/gimpcanvasitem.c index 5d505b3f8f..3c90237183 100644 --- a/app/display/gimpcanvasitem.c +++ b/app/display/gimpcanvasitem.c @@ -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; diff --git a/app/display/gimpcanvaslayerboundary.c b/app/display/gimpcanvaslayerboundary.c index cc23476216..0e4b43be32 100644 --- a/app/display/gimpcanvaslayerboundary.c +++ b/app/display/gimpcanvaslayerboundary.c @@ -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 diff --git a/app/display/gimpcanvasline.c b/app/display/gimpcanvasline.c index d22b97bab8..38a00c8d01 100644 --- a/app/display/gimpcanvasline.c +++ b/app/display/gimpcanvasline.c @@ -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 diff --git a/app/display/gimpcanvaspassepartout.c b/app/display/gimpcanvaspassepartout.c index b7a11c695b..06b26e703e 100644 --- a/app/display/gimpcanvaspassepartout.c +++ b/app/display/gimpcanvaspassepartout.c @@ -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 diff --git a/app/display/gimpcanvaspath.c b/app/display/gimpcanvaspath.c index 7721789bf6..098a8859c5 100644 --- a/app/display/gimpcanvaspath.c +++ b/app/display/gimpcanvaspath.c @@ -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 diff --git a/app/display/gimpcanvaspen.c b/app/display/gimpcanvaspen.c index 45a9453d2d..d0d01f914d 100644 --- a/app/display/gimpcanvaspen.c +++ b/app/display/gimpcanvaspen.c @@ -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 diff --git a/app/display/gimpcanvaspolygon.c b/app/display/gimpcanvaspolygon.c index 3667da102c..b4bf5f6183 100644 --- a/app/display/gimpcanvaspolygon.c +++ b/app/display/gimpcanvaspolygon.c @@ -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 diff --git a/app/display/gimpcanvasprogress.c b/app/display/gimpcanvasprogress.c index 0d83c78fb9..8995d40e6c 100644 --- a/app/display/gimpcanvasprogress.c +++ b/app/display/gimpcanvasprogress.c @@ -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 diff --git a/app/display/gimpcanvasproxygroup.c b/app/display/gimpcanvasproxygroup.c index 8fced481b1..a979f24cf8 100644 --- a/app/display/gimpcanvasproxygroup.c +++ b/app/display/gimpcanvasproxygroup.c @@ -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 diff --git a/app/display/gimpcanvasrectangle.c b/app/display/gimpcanvasrectangle.c index f0690933a7..7ef7351ee1 100644 --- a/app/display/gimpcanvasrectangle.c +++ b/app/display/gimpcanvasrectangle.c @@ -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 diff --git a/app/display/gimpcanvasrectangleguides.c b/app/display/gimpcanvasrectangleguides.c index 0f9ebf1029..b7cc07dd29 100644 --- a/app/display/gimpcanvasrectangleguides.c +++ b/app/display/gimpcanvasrectangleguides.c @@ -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 diff --git a/app/display/gimpcanvassamplepoint.c b/app/display/gimpcanvassamplepoint.c index c4c299d890..913a5b7ca1 100644 --- a/app/display/gimpcanvassamplepoint.c +++ b/app/display/gimpcanvassamplepoint.c @@ -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 diff --git a/app/display/gimpcanvastextcursor.c b/app/display/gimpcanvastextcursor.c index 0e2780d723..aaa8c5fb50 100644 --- a/app/display/gimpcanvastextcursor.c +++ b/app/display/gimpcanvastextcursor.c @@ -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 diff --git a/app/display/gimpcanvastransformguides.c b/app/display/gimpcanvastransformguides.c index 3110c5e852..ba6c4cb455 100644 --- a/app/display/gimpcanvastransformguides.c +++ b/app/display/gimpcanvastransformguides.c @@ -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 diff --git a/app/display/gimpcanvastransformpreview.c b/app/display/gimpcanvastransformpreview.c index 66352b6272..392d8b9d41 100644 --- a/app/display/gimpcanvastransformpreview.c +++ b/app/display/gimpcanvastransformpreview.c @@ -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 diff --git a/app/display/gimpcursorview.c b/app/display/gimpcursorview.c index 8375da4fbc..9324f36e2f 100644 --- a/app/display/gimpcursorview.c +++ b/app/display/gimpcursorview.c @@ -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; diff --git a/app/display/gimpcursorview.h b/app/display/gimpcursorview.h index 7d5beefe79..f5380410d0 100644 --- a/app/display/gimpcursorview.h +++ b/app/display/gimpcursorview.h @@ -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 diff --git a/app/display/gimpdisplay.c b/app/display/gimpdisplay.c index ee4838b86f..38a5026197 100644 --- a/app/display/gimpdisplay.c +++ b/app/display/gimpdisplay.c @@ -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 diff --git a/app/display/gimpimagewindow.c b/app/display/gimpimagewindow.c index 59d1bf873b..c5a4ee3c71 100644 --- a/app/display/gimpimagewindow.c +++ b/app/display/gimpimagewindow.c @@ -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 diff --git a/app/display/gimptoolcompass.c b/app/display/gimptoolcompass.c index 6328e8123a..626195c148 100644 --- a/app/display/gimptoolcompass.c +++ b/app/display/gimptoolcompass.c @@ -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; } diff --git a/app/display/gimptooldialog.c b/app/display/gimptooldialog.c index b52cbde9df..ccb057f31e 100644 --- a/app/display/gimptooldialog.c +++ b/app/display/gimptooldialog.c @@ -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 diff --git a/app/display/gimptoolgui.c b/app/display/gimptoolgui.c index 646e90e1be..b12755b047 100644 --- a/app/display/gimptoolgui.c +++ b/app/display/gimptoolgui.c @@ -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 diff --git a/app/display/gimptoolgyroscope.c b/app/display/gimptoolgyroscope.c index 41ff43b3bf..4d6b1759c7 100644 --- a/app/display/gimptoolgyroscope.c +++ b/app/display/gimptoolgyroscope.c @@ -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 diff --git a/app/display/gimptoolhandlegrid.c b/app/display/gimptoolhandlegrid.c index 1a074d0f0a..cb5b53d2ac 100644 --- a/app/display/gimptoolhandlegrid.c +++ b/app/display/gimptoolhandlegrid.c @@ -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 diff --git a/app/display/gimptoolline.c b/app/display/gimptoolline.c index ed3dbf3632..271f926617 100644 --- a/app/display/gimptoolline.c +++ b/app/display/gimptoolline.c @@ -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)); diff --git a/app/display/gimptoolpath.c b/app/display/gimptoolpath.c index c452cef401..027ef9486e 100644 --- a/app/display/gimptoolpath.c +++ b/app/display/gimptoolpath.c @@ -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 diff --git a/app/display/gimptoolpolygon.c b/app/display/gimptoolpolygon.c index 52b6917888..7c8174eec8 100644 --- a/app/display/gimptoolpolygon.c +++ b/app/display/gimptoolpolygon.c @@ -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; diff --git a/app/display/gimptoolrectangle.c b/app/display/gimptoolrectangle.c index 17ee0cb368..97c5d058f7 100644 --- a/app/display/gimptoolrectangle.c +++ b/app/display/gimptoolrectangle.c @@ -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; diff --git a/app/display/gimptoolrotategrid.c b/app/display/gimptoolrotategrid.c index 02c2fa1dbc..c58349043a 100644 --- a/app/display/gimptoolrotategrid.c +++ b/app/display/gimptoolrotategrid.c @@ -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 diff --git a/app/display/gimptoolsheargrid.c b/app/display/gimptoolsheargrid.c index e99a420fcd..06183e1552 100644 --- a/app/display/gimptoolsheargrid.c +++ b/app/display/gimptoolsheargrid.c @@ -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, diff --git a/app/display/gimptooltransformgrid.c b/app/display/gimptooltransformgrid.c index 338adbcfc5..6c150b6130 100644 --- a/app/display/gimptooltransformgrid.c +++ b/app/display/gimptooltransformgrid.c @@ -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 diff --git a/app/display/gimptoolwidget.c b/app/display/gimptoolwidget.c index 60859f2c66..d54c5dd2a3 100644 --- a/app/display/gimptoolwidget.c +++ b/app/display/gimptoolwidget.c @@ -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 diff --git a/app/display/gimptoolwidgetgroup.c b/app/display/gimptoolwidgetgroup.c index 804c99be20..f34dea4316 100644 --- a/app/display/gimptoolwidgetgroup.c +++ b/app/display/gimptoolwidgetgroup.c @@ -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, diff --git a/app/gui/gimpuiconfigurer.c b/app/gui/gimpuiconfigurer.c index 83101bfcce..651b1d11d7 100644 --- a/app/gui/gimpuiconfigurer.c +++ b/app/gui/gimpuiconfigurer.c @@ -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 diff --git a/app/paint/gimpmybrushcore.c b/app/paint/gimpmybrushcore.c index a5c0260106..b0771a61af 100644 --- a/app/paint/gimpmybrushcore.c +++ b/app/paint/gimpmybrushcore.c @@ -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 diff --git a/app/text/gimpfontfactory.c b/app/text/gimpfontfactory.c index a68f178cf9..8bb96cc967 100644 --- a/app/text/gimpfontfactory.c +++ b/app/text/gimpfontfactory.c @@ -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 diff --git a/app/text/gimptextlayer.c b/app/text/gimptextlayer.c index 7dd50ff1be..a3468d99d5 100644 --- a/app/text/gimptextlayer.c +++ b/app/text/gimptextlayer.c @@ -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 diff --git a/app/tools/gimpfreeselecttool.c b/app/tools/gimpfreeselecttool.c index 18ce5e2f68..5509a26392 100644 --- a/app/tools/gimpfreeselecttool.c +++ b/app/tools/gimpfreeselecttool.c @@ -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); diff --git a/app/tools/gimprectangleselecttool.c b/app/tools/gimprectangleselecttool.c index 5f9e2757da..007e81b269 100644 --- a/app/tools/gimprectangleselecttool.c +++ b/app/tools/gimprectangleselecttool.c @@ -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, diff --git a/app/widgets/gimpbuffersourcebox.c b/app/widgets/gimpbuffersourcebox.c index 967a009f55..e40b4a6aa3 100644 --- a/app/widgets/gimpbuffersourcebox.c +++ b/app/widgets/gimpbuffersourcebox.c @@ -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); diff --git a/app/widgets/gimpchanneltreeview.c b/app/widgets/gimpchanneltreeview.c index 9644d4094f..5b77aa4a70 100644 --- a/app/widgets/gimpchanneltreeview.c +++ b/app/widgets/gimpchanneltreeview.c @@ -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; diff --git a/app/widgets/gimpchanneltreeview.h b/app/widgets/gimpchanneltreeview.h index a6e6d54874..933dcddd7c 100644 --- a/app/widgets/gimpchanneltreeview.h +++ b/app/widgets/gimpchanneltreeview.h @@ -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 diff --git a/app/widgets/gimpcircle.c b/app/widgets/gimpcircle.c index dbaecfbeef..75c1f9f39d 100644 --- a/app/widgets/gimpcircle.c +++ b/app/widgets/gimpcircle.c @@ -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), diff --git a/app/widgets/gimpcontainereditor.c b/app/widgets/gimpcontainereditor.c index 45848f87b9..f21bcfbe49 100644 --- a/app/widgets/gimpcontainereditor.c +++ b/app/widgets/gimpcontainereditor.c @@ -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 diff --git a/app/widgets/gimpcontainericonview.c b/app/widgets/gimpcontainericonview.c index 2def8a33bd..d5bcbcf038 100644 --- a/app/widgets/gimpcontainericonview.c +++ b/app/widgets/gimpcontainericonview.c @@ -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); diff --git a/app/widgets/gimpcontainericonview.h b/app/widgets/gimpcontainericonview.h index e1ccb8b75d..c7d15cdb51 100644 --- a/app/widgets/gimpcontainericonview.h +++ b/app/widgets/gimpcontainericonview.h @@ -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 diff --git a/app/widgets/gimpcontainertreestore.c b/app/widgets/gimpcontainertreestore.c index ef20d3a95a..643368df2d 100644 --- a/app/widgets/gimpcontainertreestore.c +++ b/app/widgets/gimpcontainertreestore.c @@ -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 diff --git a/app/widgets/gimpcontainertreeview-private.h b/app/widgets/gimpcontainertreeview-private.h index 3765afd96a..66c21f4b29 100644 --- a/app/widgets/gimpcontainertreeview-private.h +++ b/app/widgets/gimpcontainertreeview-private.h @@ -22,7 +22,7 @@ #define __GIMP_CONTAINER_TREE_VIEW_PRIVATE_H__ -struct _GimpContainerTreeViewPriv +struct _GimpContainerTreeViewPrivate { GtkTreeSelection *selection; diff --git a/app/widgets/gimpcontainertreeview.c b/app/widgets/gimpcontainertreeview.c index 495e93eb2e..585b23e48b 100644 --- a/app/widgets/gimpcontainertreeview.c +++ b/app/widgets/gimpcontainertreeview.c @@ -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); diff --git a/app/widgets/gimpcontainertreeview.h b/app/widgets/gimpcontainertreeview.h index 4ed9bc8e76..b31d24f3ec 100644 --- a/app/widgets/gimpcontainertreeview.h +++ b/app/widgets/gimpcontainertreeview.h @@ -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 diff --git a/app/widgets/gimpdashboard.c b/app/widgets/gimpdashboard.c index bb56e99bda..c34cdb8ab8 100644 --- a/app/widgets/gimpdashboard.c +++ b/app/widgets/gimpdashboard.c @@ -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); diff --git a/app/widgets/gimpdatafactoryview.c b/app/widgets/gimpdatafactoryview.c index 9cf81eb4a7..35c8eb1ce0 100644 --- a/app/widgets/gimpdatafactoryview.c +++ b/app/widgets/gimpdatafactoryview.c @@ -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); diff --git a/app/widgets/gimpdatafactoryview.h b/app/widgets/gimpdatafactoryview.h index 25c7cc0aca..347029514c 100644 --- a/app/widgets/gimpdatafactoryview.h +++ b/app/widgets/gimpdatafactoryview.h @@ -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 diff --git a/app/widgets/gimpdeviceeditor.c b/app/widgets/gimpdeviceeditor.c index feb55e155d..fb836fc914 100644 --- a/app/widgets/gimpdeviceeditor.c +++ b/app/widgets/gimpdeviceeditor.c @@ -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 diff --git a/app/widgets/gimpdeviceinfoeditor.c b/app/widgets/gimpdeviceinfoeditor.c index fcefd16019..0422192533 100644 --- a/app/widgets/gimpdeviceinfoeditor.c +++ b/app/widgets/gimpdeviceinfoeditor.c @@ -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 diff --git a/app/widgets/gimpdevicemanager.c b/app/widgets/gimpdevicemanager.c index 42dcfb6d13..7eb0d0ff54 100644 --- a/app/widgets/gimpdevicemanager.c +++ b/app/widgets/gimpdevicemanager.c @@ -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, diff --git a/app/widgets/gimpdial.c b/app/widgets/gimpdial.c index 10ffe48945..b147c39fa8 100644 --- a/app/widgets/gimpdial.c +++ b/app/widgets/gimpdial.c @@ -107,7 +107,7 @@ static gdouble gimp_dial_get_angle_distance (gdouble alpha, gdouble beta); -G_DEFINE_TYPE (GimpDial, gimp_dial, GIMP_TYPE_CIRCLE) +G_DEFINE_TYPE_WITH_PRIVATE (GimpDial, gimp_dial, GIMP_TYPE_CIRCLE) #define parent_class gimp_dial_parent_class @@ -162,16 +162,12 @@ gimp_dial_class_init (GimpDialClass *klass) TRUE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); - - g_type_class_add_private (klass, sizeof (GimpDialPrivate)); } static void gimp_dial_init (GimpDial *dial) { - dial->priv = G_TYPE_INSTANCE_GET_PRIVATE (dial, - GIMP_TYPE_DIAL, - GimpDialPrivate); + dial->priv = gimp_dial_get_instance_private (dial); } static void diff --git a/app/widgets/gimpdialogfactory.c b/app/widgets/gimpdialogfactory.c index f1022625d5..3c28fabf6b 100644 --- a/app/widgets/gimpdialogfactory.c +++ b/app/widgets/gimpdialogfactory.c @@ -97,7 +97,8 @@ static void gimp_dialog_factory_hide (GimpDialogFactory static void gimp_dialog_factory_show (GimpDialogFactory *factory); -G_DEFINE_TYPE (GimpDialogFactory, gimp_dialog_factory, GIMP_TYPE_OBJECT) +G_DEFINE_TYPE_WITH_PRIVATE (GimpDialogFactory, gimp_dialog_factory, + GIMP_TYPE_OBJECT) #define parent_class gimp_dialog_factory_parent_class @@ -139,16 +140,12 @@ gimp_dialog_factory_class_init (GimpDialogFactoryClass *klass) gimp_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GIMP_TYPE_DOCK_WINDOW); - - g_type_class_add_private (klass, sizeof (GimpDialogFactoryPrivate)); } static void gimp_dialog_factory_init (GimpDialogFactory *factory) { - factory->p = G_TYPE_INSTANCE_GET_PRIVATE (factory, - GIMP_TYPE_DIALOG_FACTORY, - GimpDialogFactoryPrivate); + factory->p = gimp_dialog_factory_get_instance_private (factory); factory->p->dialog_state = GIMP_DIALOGS_SHOWN; } diff --git a/app/widgets/gimpdock.c b/app/widgets/gimpdock.c index 1d5121c1d5..dcfbda6ab1 100644 --- a/app/widgets/gimpdock.c +++ b/app/widgets/gimpdock.c @@ -81,7 +81,7 @@ static gboolean gimp_dock_dropped_cb (GtkWidget *notebook, gpointer data); -G_DEFINE_TYPE (GimpDock, gimp_dock, GTK_TYPE_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpDock, gimp_dock, GTK_TYPE_BOX) #define parent_class gimp_dock_parent_class @@ -142,8 +142,6 @@ gimp_dock_class_init (GimpDockClass *klass) klass->geometry_invalidated = NULL; gtk_widget_class_set_css_name (widget_class, "GimpDock"); - - g_type_class_add_private (klass, sizeof (GimpDockPrivate)); } static void @@ -155,9 +153,7 @@ gimp_dock_init (GimpDock *dock) gtk_orientable_set_orientation (GTK_ORIENTABLE (dock), GTK_ORIENTATION_VERTICAL); - dock->p = G_TYPE_INSTANCE_GET_PRIVATE (dock, - GIMP_TYPE_DOCK, - GimpDockPrivate); + dock->p = gimp_dock_get_instance_private (dock); dock->p->ID = dock_ID++; name = g_strdup_printf ("gimp-internal-dock-%d", dock->p->ID); diff --git a/app/widgets/gimpdockable.c b/app/widgets/gimpdockable.c index 3641a27ab4..890b989ddf 100644 --- a/app/widgets/gimpdockable.c +++ b/app/widgets/gimpdockable.c @@ -94,6 +94,7 @@ static void gimp_dockable_set_aux_info (GimpSessionManaged *managed, G_DEFINE_TYPE_WITH_CODE (GimpDockable, gimp_dockable, GTK_TYPE_BIN, + G_ADD_PRIVATE (GimpDockable) G_IMPLEMENT_INTERFACE (GIMP_TYPE_SESSION_MANAGED, gimp_dockable_session_managed_iface_init)) @@ -132,16 +133,12 @@ gimp_dockable_class_init (GimpDockableClass *klass) G_MAXINT, 0, GIMP_PARAM_READABLE)); - - g_type_class_add_private (klass, sizeof (GimpDockablePrivate)); } static void gimp_dockable_init (GimpDockable *dockable) { - dockable->p = G_TYPE_INSTANCE_GET_PRIVATE (dockable, - GIMP_TYPE_DOCKABLE, - GimpDockablePrivate); + dockable->p = gimp_dockable_get_instance_private (dockable); dockable->p->tab_style = GIMP_TAB_STYLE_PREVIEW; diff --git a/app/widgets/gimpdockbook.c b/app/widgets/gimpdockbook.c index 9b4d72f5a2..326b27fe80 100644 --- a/app/widgets/gimpdockbook.c +++ b/app/widgets/gimpdockbook.c @@ -126,7 +126,7 @@ static void gimp_dockbook_help_func (const gchar *help_id, gpointer help_data); -G_DEFINE_TYPE (GimpDockbook, gimp_dockbook, GTK_TYPE_NOTEBOOK) +G_DEFINE_TYPE_WITH_PRIVATE (GimpDockbook, gimp_dockbook, GTK_TYPE_NOTEBOOK) #define parent_class gimp_dockbook_parent_class @@ -193,8 +193,6 @@ gimp_dockbook_class_init (GimpDockbookClass *klass) GTK_TYPE_ICON_SIZE, DEFAULT_TAB_ICON_SIZE, GIMP_PARAM_READABLE)); - - g_type_class_add_private (klass, sizeof (GimpDockbookPrivate)); } static void @@ -203,9 +201,7 @@ gimp_dockbook_init (GimpDockbook *dockbook) GtkNotebook *notebook = GTK_NOTEBOOK (dockbook); GtkWidget *image; - dockbook->p = G_TYPE_INSTANCE_GET_PRIVATE (dockbook, - GIMP_TYPE_DOCKBOOK, - GimpDockbookPrivate); + dockbook->p = gimp_dockbook_get_instance_private (dockbook); /* Various init */ gtk_notebook_popup_enable (notebook); diff --git a/app/widgets/gimpdockcolumns.c b/app/widgets/gimpdockcolumns.c index 0329494f43..1b9cadad41 100644 --- a/app/widgets/gimpdockcolumns.c +++ b/app/widgets/gimpdockcolumns.c @@ -92,7 +92,7 @@ static void gimp_dock_columns_dock_book_removed (GimpDockColumns *dock_colu GimpDock *dock); -G_DEFINE_TYPE (GimpDockColumns, gimp_dock_columns, GTK_TYPE_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpDockColumns, gimp_dock_columns, GTK_TYPE_BOX) #define parent_class gimp_dock_columns_parent_class @@ -151,8 +151,6 @@ gimp_dock_columns_class_init (GimpDockColumnsClass *klass) gimp_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GIMP_TYPE_DOCK); - - g_type_class_add_private (klass, sizeof (GimpDockColumnsPrivate)); } static void @@ -161,9 +159,7 @@ gimp_dock_columns_init (GimpDockColumns *dock_columns) gtk_orientable_set_orientation (GTK_ORIENTABLE (dock_columns), GTK_ORIENTATION_HORIZONTAL); - dock_columns->p = G_TYPE_INSTANCE_GET_PRIVATE (dock_columns, - GIMP_TYPE_DOCK_COLUMNS, - GimpDockColumnsPrivate); + dock_columns->p = gimp_dock_columns_get_instance_private (dock_columns); dock_columns->p->paned_hbox = gimp_paned_box_new (FALSE, 0, GTK_ORIENTATION_HORIZONTAL); diff --git a/app/widgets/gimpdockwindow.c b/app/widgets/gimpdockwindow.c index 9417d8e87d..1f93b409ae 100644 --- a/app/widgets/gimpdockwindow.c +++ b/app/widgets/gimpdockwindow.c @@ -164,6 +164,7 @@ static void gimp_dock_window_auto_clicked (GtkWidget G_DEFINE_TYPE_WITH_CODE (GimpDockWindow, gimp_dock_window, GIMP_TYPE_WINDOW, + G_ADD_PRIVATE (GimpDockWindow) G_IMPLEMENT_INTERFACE (GIMP_TYPE_DOCK_CONTAINER, gimp_dock_window_dock_container_iface_init) G_IMPLEMENT_INTERFACE (GIMP_TYPE_SESSION_MANAGED, @@ -242,8 +243,6 @@ gimp_dock_window_class_init (GimpDockWindowClass *klass) GTK_TYPE_ICON_SIZE, DEFAULT_MENU_VIEW_SIZE, GIMP_PARAM_READABLE)); - - g_type_class_add_private (klass, sizeof (GimpDockWindowPrivate)); } static void @@ -252,9 +251,7 @@ gimp_dock_window_init (GimpDockWindow *dock_window) static gint dock_window_ID = 1; gchar *name = NULL; - dock_window->p = G_TYPE_INSTANCE_GET_PRIVATE (dock_window, - GIMP_TYPE_DOCK_WINDOW, - GimpDockWindowPrivate); + dock_window->p = gimp_dock_window_get_instance_private (dock_window); dock_window->p->ID = dock_window_ID++; dock_window->p->auto_follow_active = TRUE; diff --git a/app/widgets/gimpdynamicsoutputeditor.c b/app/widgets/gimpdynamicsoutputeditor.c index 2fbad0e1de..7dacf23b55 100644 --- a/app/widgets/gimpdynamicsoutputeditor.c +++ b/app/widgets/gimpdynamicsoutputeditor.c @@ -95,9 +95,7 @@ struct _GimpDynamicsOutputEditorPrivate }; #define GET_PRIVATE(editor) \ - G_TYPE_INSTANCE_GET_PRIVATE (editor, \ - GIMP_TYPE_DYNAMICS_OUTPUT_EDITOR, \ - GimpDynamicsOutputEditorPrivate) + ((GimpDynamicsOutputEditorPrivate *) gimp_dynamics_output_editor_get_instance_private ((GimpDynamicsOutputEditor *) (editor))) static void gimp_dynamics_output_editor_constructed (GObject *object); @@ -129,8 +127,8 @@ static void gimp_dynamics_output_editor_notify_output (GimpDynamicsOutput GimpDynamicsOutputEditor *editor); -G_DEFINE_TYPE (GimpDynamicsOutputEditor, gimp_dynamics_output_editor, - GTK_TYPE_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpDynamicsOutputEditor, + gimp_dynamics_output_editor, GTK_TYPE_BOX) #define parent_class gimp_dynamics_output_editor_parent_class @@ -151,9 +149,6 @@ gimp_dynamics_output_editor_class_init (GimpDynamicsOutputEditorClass *klass) GIMP_TYPE_DYNAMICS_OUTPUT, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); - - g_type_class_add_private (object_class, - sizeof (GimpDynamicsOutputEditorPrivate)); } static void diff --git a/app/widgets/gimpeditor.c b/app/widgets/gimpeditor.c index 4ba7424c9e..2534ebb03d 100644 --- a/app/widgets/gimpeditor.c +++ b/app/widgets/gimpeditor.c @@ -101,6 +101,7 @@ static GtkIconSize gimp_editor_ensure_button_box (GimpEditor *editor, G_DEFINE_TYPE_WITH_CODE (GimpEditor, gimp_editor, GTK_TYPE_BOX, + G_ADD_PRIVATE (GimpEditor) G_IMPLEMENT_INTERFACE (GIMP_TYPE_DOCKED, gimp_editor_docked_iface_init)) @@ -189,8 +190,6 @@ gimp_editor_class_init (GimpEditorClass *klass) GTK_TYPE_RELIEF_STYLE, DEFAULT_BUTTON_RELIEF, GIMP_PARAM_READABLE)); - - g_type_class_add_private (klass, sizeof (GimpEditorPrivate)); } static void @@ -208,9 +207,7 @@ gimp_editor_init (GimpEditor *editor) gtk_orientable_set_orientation (GTK_ORIENTABLE (editor), GTK_ORIENTATION_VERTICAL); - editor->priv = G_TYPE_INSTANCE_GET_PRIVATE (editor, - GIMP_TYPE_EDITOR, - GimpEditorPrivate); + editor->priv = gimp_editor_get_instance_private (editor); editor->priv->popup_data = editor; editor->priv->show_button_bar = TRUE; diff --git a/app/widgets/gimpextensiondetails.c b/app/widgets/gimpextensiondetails.c index 23767d308a..cc7c442aaa 100644 --- a/app/widgets/gimpextensiondetails.c +++ b/app/widgets/gimpextensiondetails.c @@ -39,7 +39,8 @@ struct _GimpExtensionDetailsPrivate GimpExtension *extension; }; -G_DEFINE_TYPE (GimpExtensionDetails, gimp_extension_details, GTK_TYPE_FRAME) +G_DEFINE_TYPE_WITH_PRIVATE (GimpExtensionDetails, gimp_extension_details, + GTK_TYPE_FRAME) #define parent_class gimp_extension_details_parent_class @@ -47,16 +48,13 @@ G_DEFINE_TYPE (GimpExtensionDetails, gimp_extension_details, GTK_TYPE_FRAME) static void gimp_extension_details_class_init (GimpExtensionDetailsClass *klass) { - g_type_class_add_private (klass, sizeof (GimpExtensionDetailsPrivate)); } static void gimp_extension_details_init (GimpExtensionDetails *details) { gtk_frame_set_label_align (GTK_FRAME (details), 0.5, 1.0); - details->p = G_TYPE_INSTANCE_GET_PRIVATE (details, - GIMP_TYPE_EXTENSION_DETAILS, - GimpExtensionDetailsPrivate); + details->p = gimp_extension_details_get_instance_private (details); } GtkWidget * diff --git a/app/widgets/gimpextensionlist.c b/app/widgets/gimpextensionlist.c index 224853b040..fef768f898 100644 --- a/app/widgets/gimpextensionlist.c +++ b/app/widgets/gimpextensionlist.c @@ -56,7 +56,8 @@ static void gimp_extension_row_activated (GtkListBox *box, GtkListBoxRow *row, gpointer user_data); -G_DEFINE_TYPE (GimpExtensionList, gimp_extension_list, GTK_TYPE_LIST_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpExtensionList, gimp_extension_list, + GTK_TYPE_LIST_BOX) #define parent_class gimp_extension_list_parent_class @@ -74,8 +75,6 @@ gimp_extension_list_class_init (GimpExtensionListClass *klass) gimp_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GIMP_TYPE_OBJECT); - - g_type_class_add_private (klass, sizeof (GimpExtensionListPrivate)); } static void @@ -85,9 +84,7 @@ gimp_extension_list_init (GimpExtensionList *list) GTK_SELECTION_SINGLE); gtk_list_box_set_activate_on_single_click (GTK_LIST_BOX (list), FALSE); - list->p = G_TYPE_INSTANCE_GET_PRIVATE (list, - GIMP_TYPE_EXTENSION_LIST, - GimpExtensionListPrivate); + list->p = gimp_extension_list_get_instance_private (list); } GtkWidget * diff --git a/app/widgets/gimpiconpicker.c b/app/widgets/gimpiconpicker.c index 475a7c39ef..730360c752 100644 --- a/app/widgets/gimpiconpicker.c +++ b/app/widgets/gimpiconpicker.c @@ -73,9 +73,7 @@ struct _GimpIconPickerPrivate }; #define GET_PRIVATE(picker) \ - G_TYPE_INSTANCE_GET_PRIVATE (picker, \ - GIMP_TYPE_ICON_PICKER, \ - GimpIconPickerPrivate) + ((GimpIconPickerPrivate *) gimp_icon_picker_get_instance_private ((GimpIconPicker *) (picker))) static void gimp_icon_picker_constructed (GObject *object); @@ -110,7 +108,7 @@ static void gimp_icon_picker_menu_copy (GtkWidget *widget, gpointer data); -G_DEFINE_TYPE (GimpIconPicker, gimp_icon_picker, GTK_TYPE_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpIconPicker, gimp_icon_picker, GTK_TYPE_BOX) #define parent_class gimp_icon_picker_parent_class @@ -141,8 +139,6 @@ gimp_icon_picker_class_init (GimpIconPickerClass *klass) g_param_spec_object ("icon-pixbuf", NULL, NULL, GDK_TYPE_PIXBUF, GIMP_PARAM_READWRITE)); - - g_type_class_add_private (object_class, sizeof (GimpIconPickerPrivate)); } static void diff --git a/app/widgets/gimpitemtreeview.c b/app/widgets/gimpitemtreeview.c index dbdbf5f38b..a69e68c6e5 100644 --- a/app/widgets/gimpitemtreeview.c +++ b/app/widgets/gimpitemtreeview.c @@ -65,7 +65,7 @@ enum }; -struct _GimpItemTreeViewPriv +struct _GimpItemTreeViewPrivate { GimpImage *image; @@ -213,6 +213,7 @@ static void gimp_item_tree_view_row_expanded (GtkTreeView *tree_vie G_DEFINE_TYPE_WITH_CODE (GimpItemTreeView, gimp_item_tree_view, GIMP_TYPE_CONTAINER_TREE_VIEW, + G_ADD_PRIVATE (GimpItemTreeView) G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONTAINER_VIEW, gimp_item_tree_view_view_iface_init) G_IMPLEMENT_INTERFACE (GIMP_TYPE_DOCKED, @@ -281,8 +282,6 @@ gimp_item_tree_view_class_init (GimpItemTreeViewClass *klass) klass->lock_position_icon_name = NULL; klass->lock_position_tooltip = NULL; klass->lock_position_help_id = NULL; - - g_type_class_add_private (klass, sizeof (GimpItemTreeViewPriv)); } static void @@ -310,9 +309,7 @@ gimp_item_tree_view_init (GimpItemTreeView *view) { GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view); - view->priv = G_TYPE_INSTANCE_GET_PRIVATE (view, - GIMP_TYPE_ITEM_TREE_VIEW, - GimpItemTreeViewPriv); + view->priv = gimp_item_tree_view_get_instance_private (view); view->priv->model_column_visible = gimp_container_tree_store_columns_add (tree_view->model_columns, diff --git a/app/widgets/gimpitemtreeview.h b/app/widgets/gimpitemtreeview.h index 845e130e2d..891eca9a41 100644 --- a/app/widgets/gimpitemtreeview.h +++ b/app/widgets/gimpitemtreeview.h @@ -49,14 +49,14 @@ typedef GimpItem * (* GimpNewItemFunc) (GimpImage *image); #define GIMP_ITEM_TREE_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_ITEM_TREE_VIEW, GimpItemTreeViewClass)) -typedef struct _GimpItemTreeViewClass GimpItemTreeViewClass; -typedef struct _GimpItemTreeViewPriv GimpItemTreeViewPriv; +typedef struct _GimpItemTreeViewClass GimpItemTreeViewClass; +typedef struct _GimpItemTreeViewPrivate GimpItemTreeViewPrivate; struct _GimpItemTreeView { - GimpContainerTreeView parent_instance; + GimpContainerTreeView parent_instance; - GimpItemTreeViewPriv *priv; + GimpItemTreeViewPrivate *priv; }; struct _GimpItemTreeViewClass diff --git a/app/widgets/gimplayermodebox.c b/app/widgets/gimplayermodebox.c index ca18c489ae..aa35f8f5eb 100644 --- a/app/widgets/gimplayermodebox.c +++ b/app/widgets/gimplayermodebox.c @@ -74,8 +74,7 @@ static void gimp_layer_mode_box_get_property (GObject *object, GParamSpec *pspec); -G_DEFINE_TYPE (GimpLayerModeBox, gimp_layer_mode_box, - GTK_TYPE_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpLayerModeBox, gimp_layer_mode_box, GTK_TYPE_BOX) #define parent_class gimp_layer_mode_box_parent_class @@ -104,16 +103,12 @@ gimp_layer_mode_box_class_init (GimpLayerModeBoxClass *klass) GIMP_LAYER_MODE_NORMAL, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); - - g_type_class_add_private (klass, sizeof (GimpLayerModeBoxPrivate)); } static void gimp_layer_mode_box_init (GimpLayerModeBox *box) { - box->priv = G_TYPE_INSTANCE_GET_PRIVATE (box, - GIMP_TYPE_LAYER_MODE_BOX, - GimpLayerModeBoxPrivate); + box->priv = gimp_layer_mode_box_get_instance_private (box); gtk_orientable_set_orientation (GTK_ORIENTABLE (box), GTK_ORIENTATION_HORIZONTAL); diff --git a/app/widgets/gimplayermodecombobox.c b/app/widgets/gimplayermodecombobox.c index dd03a18c7a..2062486d19 100644 --- a/app/widgets/gimplayermodecombobox.c +++ b/app/widgets/gimplayermodecombobox.c @@ -78,8 +78,8 @@ static gboolean gimp_layer_mode_combo_box_separator_func (GtkTreeModel gpointer data); -G_DEFINE_TYPE (GimpLayerModeComboBox, gimp_layer_mode_combo_box, - GIMP_TYPE_ENUM_COMBO_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpLayerModeComboBox, gimp_layer_mode_combo_box, + GIMP_TYPE_ENUM_COMBO_BOX) #define parent_class gimp_layer_mode_combo_box_parent_class @@ -119,16 +119,12 @@ gimp_layer_mode_combo_box_class_init (GimpLayerModeComboBoxClass *klass) GIMP_LAYER_MODE_GROUP_DEFAULT, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); - - g_type_class_add_private (klass, sizeof (GimpLayerModeComboBoxPrivate)); } static void gimp_layer_mode_combo_box_init (GimpLayerModeComboBox *combo) { - combo->priv = G_TYPE_INSTANCE_GET_PRIVATE (combo, - GIMP_TYPE_LAYER_MODE_COMBO_BOX, - GimpLayerModeComboBoxPrivate); + combo->priv = gimp_layer_mode_combo_box_get_instance_private (combo); gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combo), gimp_layer_mode_combo_box_separator_func, diff --git a/app/widgets/gimplayertreeview.c b/app/widgets/gimplayertreeview.c index 7733e32ef0..0c16395bad 100644 --- a/app/widgets/gimplayertreeview.c +++ b/app/widgets/gimplayertreeview.c @@ -63,7 +63,7 @@ #include "gimp-intl.h" -struct _GimpLayerTreeViewPriv +struct _GimpLayerTreeViewPrivate { GtkWidget *layer_mode_box; GtkAdjustment *opacity_adjustment; @@ -175,6 +175,7 @@ static void gimp_layer_tree_view_alpha_changed (GimpLayer G_DEFINE_TYPE_WITH_CODE (GimpLayerTreeView, gimp_layer_tree_view, GIMP_TYPE_DRAWABLE_TREE_VIEW, + G_ADD_PRIVATE (GimpLayerTreeView) G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONTAINER_VIEW, gimp_layer_tree_view_view_iface_init)) @@ -225,8 +226,6 @@ gimp_layer_tree_view_class_init (GimpLayerTreeViewClass *klass) item_view_class->delete_action = "layers-delete"; item_view_class->lock_content_help_id = GIMP_HELP_LAYER_LOCK_PIXELS; item_view_class->lock_position_help_id = GIMP_HELP_LAYER_LOCK_POSITION; - - g_type_class_add_private (klass, sizeof (GimpLayerTreeViewPriv)); } static void @@ -253,9 +252,7 @@ gimp_layer_tree_view_init (GimpLayerTreeView *view) GtkIconSize icon_size; PangoAttribute *attr; - view->priv = G_TYPE_INSTANCE_GET_PRIVATE (view, - GIMP_TYPE_LAYER_TREE_VIEW, - GimpLayerTreeViewPriv); + view->priv = gimp_layer_tree_view_get_instance_private (view); view->priv->model_column_mask = gimp_container_tree_store_columns_add (tree_view->model_columns, diff --git a/app/widgets/gimplayertreeview.h b/app/widgets/gimplayertreeview.h index 3f09810026..1a89b2d4e9 100644 --- a/app/widgets/gimplayertreeview.h +++ b/app/widgets/gimplayertreeview.h @@ -33,14 +33,14 @@ #define GIMP_LAYER_TREE_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_LAYER_TREE_VIEW, GimpLayerTreeViewClass)) -typedef struct _GimpLayerTreeViewClass GimpLayerTreeViewClass; -typedef struct _GimpLayerTreeViewPriv GimpLayerTreeViewPriv; +typedef struct _GimpLayerTreeViewClass GimpLayerTreeViewClass; +typedef struct _GimpLayerTreeViewPrivate GimpLayerTreeViewPrivate; struct _GimpLayerTreeView { - GimpDrawableTreeView parent_instance; + GimpDrawableTreeView parent_instance; - GimpLayerTreeViewPriv *priv; + GimpLayerTreeViewPrivate *priv; }; struct _GimpLayerTreeViewClass diff --git a/app/widgets/gimpmenudock.c b/app/widgets/gimpmenudock.c index 91ec036366..bae706a99e 100644 --- a/app/widgets/gimpmenudock.c +++ b/app/widgets/gimpmenudock.c @@ -55,7 +55,7 @@ struct _GimpMenuDockPrivate static void gimp_menu_dock_style_updated (GtkWidget *widget); -G_DEFINE_TYPE (GimpMenuDock, gimp_menu_dock, GIMP_TYPE_DOCK) +G_DEFINE_TYPE_WITH_PRIVATE (GimpMenuDock, gimp_menu_dock, GIMP_TYPE_DOCK) #define parent_class gimp_menu_dock_parent_class @@ -74,8 +74,6 @@ gimp_menu_dock_class_init (GimpMenuDockClass *klass) G_MAXINT, DEFAULT_MINIMAL_WIDTH, GIMP_PARAM_READABLE)); - - g_type_class_add_private (klass, sizeof (GimpMenuDockPrivate)); } static void diff --git a/app/widgets/gimpmenufactory.c b/app/widgets/gimpmenufactory.c index ff6122c58f..a879503aaf 100644 --- a/app/widgets/gimpmenufactory.c +++ b/app/widgets/gimpmenufactory.c @@ -47,7 +47,8 @@ struct _GimpMenuFactoryPrivate static void gimp_menu_factory_finalize (GObject *object); -G_DEFINE_TYPE (GimpMenuFactory, gimp_menu_factory, GIMP_TYPE_OBJECT) +G_DEFINE_TYPE_WITH_PRIVATE (GimpMenuFactory, gimp_menu_factory, + GIMP_TYPE_OBJECT) #define parent_class gimp_menu_factory_parent_class @@ -58,16 +59,12 @@ gimp_menu_factory_class_init (GimpMenuFactoryClass *klass) GObjectClass *object_class = G_OBJECT_CLASS (klass); object_class->finalize = gimp_menu_factory_finalize; - - g_type_class_add_private (klass, sizeof (GimpMenuFactoryPrivate)); } static void gimp_menu_factory_init (GimpMenuFactory *factory) { - factory->p = G_TYPE_INSTANCE_GET_PRIVATE (factory, - GIMP_TYPE_MENU_FACTORY, - GimpMenuFactoryPrivate); + factory->p = gimp_menu_factory_get_instance_private (factory); } static void diff --git a/app/widgets/gimpmeter.c b/app/widgets/gimpmeter.c index 5cd2e070d7..0fd90c0182 100644 --- a/app/widgets/gimpmeter.c +++ b/app/widgets/gimpmeter.c @@ -132,7 +132,7 @@ static void gimp_meter_mask_sample (GimpMeter *meter, gdouble *result); -G_DEFINE_TYPE (GimpMeter, gimp_meter, GTK_TYPE_WIDGET) +G_DEFINE_TYPE_WITH_PRIVATE (GimpMeter, gimp_meter, GTK_TYPE_WIDGET) #define parent_class gimp_meter_parent_class @@ -227,16 +227,12 @@ gimp_meter_class_init (GimpMeterClass *klass) TRUE, &(GimpRGB) {}, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); - - g_type_class_add_private (klass, sizeof (GimpMeterPrivate)); } static void gimp_meter_init (GimpMeter *meter) { - meter->priv = G_TYPE_INSTANCE_GET_PRIVATE (meter, - GIMP_TYPE_METER, - GimpMeterPrivate); + meter->priv = gimp_meter_get_instance_private (meter); g_mutex_init (&meter->priv->mutex); diff --git a/app/widgets/gimppanedbox.c b/app/widgets/gimppanedbox.c index c69c2d794f..d26a6c1251 100644 --- a/app/widgets/gimppanedbox.c +++ b/app/widgets/gimppanedbox.c @@ -111,7 +111,7 @@ static gint gimp_paned_box_get_drop_area_size (GimpPanedBox *paned_b static void gimp_paned_box_hide_drop_indicator (GimpPanedBox *paned_box); -G_DEFINE_TYPE (GimpPanedBox, gimp_paned_box, GTK_TYPE_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpPanedBox, gimp_paned_box, GTK_TYPE_BOX) #define parent_class gimp_paned_box_parent_class @@ -130,16 +130,12 @@ gimp_paned_box_class_init (GimpPanedBoxClass *klass) widget_class->drag_motion = gimp_paned_box_drag_motion; widget_class->drag_drop = gimp_paned_box_drag_drop; widget_class->drag_data_received = gimp_paned_box_drag_data_received; - - g_type_class_add_private (klass, sizeof (GimpPanedBoxPrivate)); } static void gimp_paned_box_init (GimpPanedBox *paned_box) { - paned_box->p = G_TYPE_INSTANCE_GET_PRIVATE (paned_box, - GIMP_TYPE_PANED_BOX, - GimpPanedBoxPrivate); + paned_box->p = gimp_paned_box_get_instance_private (paned_box); /* Instructions label * diff --git a/app/widgets/gimppickablebutton.c b/app/widgets/gimppickablebutton.c index fc8100fcb9..e8454c2729 100644 --- a/app/widgets/gimppickablebutton.c +++ b/app/widgets/gimppickablebutton.c @@ -85,7 +85,8 @@ static void gimp_pickable_button_notify_buffer (GimpPickable *pickable GimpPickableButton *button); -G_DEFINE_TYPE (GimpPickableButton, gimp_pickable_button, GIMP_TYPE_BUTTON) +G_DEFINE_TYPE_WITH_PRIVATE (GimpPickableButton, gimp_pickable_button, + GIMP_TYPE_BUTTON) #define parent_class gimp_pickable_button_parent_class @@ -116,16 +117,12 @@ gimp_pickable_button_class_init (GimpPickableButtonClass *klass) NULL, NULL, GIMP_TYPE_PICKABLE, GIMP_PARAM_READWRITE)); - - g_type_class_add_private (klass, sizeof (GimpPickableButtonPrivate)); } static void gimp_pickable_button_init (GimpPickableButton *button) { - button->private = G_TYPE_INSTANCE_GET_PRIVATE (button, - GIMP_TYPE_PICKABLE_BUTTON, - GimpPickableButtonPrivate); + button->private = gimp_pickable_button_get_instance_private (button); button->private->view_size = GIMP_VIEW_SIZE_LARGE; button->private->view_border_width = 1; diff --git a/app/widgets/gimppickablepopup.c b/app/widgets/gimppickablepopup.c index dbee51d9f8..c0e0161af5 100644 --- a/app/widgets/gimppickablepopup.c +++ b/app/widgets/gimppickablepopup.c @@ -86,7 +86,8 @@ static void gimp_pickable_popup_item_activate (GimpContainerView *view, GimpPickablePopup *popup); -G_DEFINE_TYPE (GimpPickablePopup, gimp_pickable_popup, GIMP_TYPE_POPUP) +G_DEFINE_TYPE_WITH_PRIVATE (GimpPickablePopup, gimp_pickable_popup, + GIMP_TYPE_POPUP) #define parent_class gimp_pickable_popup_parent_class @@ -130,16 +131,12 @@ gimp_pickable_popup_class_init (GimpPickablePopupClass *klass) 1, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); - - g_type_class_add_private (klass, sizeof (GimpPickablePopupPrivate)); } static void gimp_pickable_popup_init (GimpPickablePopup *popup) { - popup->priv = G_TYPE_INSTANCE_GET_PRIVATE (popup, - GIMP_TYPE_PICKABLE_POPUP, - GimpPickablePopupPrivate); + popup->priv = gimp_pickable_popup_get_instance_private (popup); popup->priv->view_size = GIMP_VIEW_SIZE_SMALL; popup->priv->view_border_width = 1; diff --git a/app/widgets/gimppolar.c b/app/widgets/gimppolar.c index 66cfabb2a0..20578f2a45 100644 --- a/app/widgets/gimppolar.c +++ b/app/widgets/gimppolar.c @@ -93,7 +93,7 @@ static gdouble gimp_polar_get_angle_distance (gdouble alpha, gdouble beta); -G_DEFINE_TYPE (GimpPolar, gimp_polar, GIMP_TYPE_CIRCLE) +G_DEFINE_TYPE_WITH_PRIVATE (GimpPolar, gimp_polar, GIMP_TYPE_CIRCLE) #define parent_class gimp_polar_parent_class @@ -127,16 +127,12 @@ gimp_polar_class_init (GimpPolarClass *klass) 0.0, 1.0, 0.0, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); - - g_type_class_add_private (klass, sizeof (GimpPolarPrivate)); } static void gimp_polar_init (GimpPolar *polar) { - polar->priv = G_TYPE_INSTANCE_GET_PRIVATE (polar, - GIMP_TYPE_POLAR, - GimpPolarPrivate); + polar->priv = gimp_polar_get_instance_private (polar); } static void diff --git a/app/widgets/gimpprefsbox.c b/app/widgets/gimpprefsbox.c index 948fe30fef..f845d4048a 100644 --- a/app/widgets/gimpprefsbox.c +++ b/app/widgets/gimpprefsbox.c @@ -69,7 +69,7 @@ static void gimp_prefs_box_tree_select_callback (GtkTreeSelection *sel, GimpPrefsBox *box); -G_DEFINE_TYPE (GimpPrefsBox, gimp_prefs_box, GTK_TYPE_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpPrefsBox, gimp_prefs_box, GTK_TYPE_BOX) #define parent_class gimp_prefs_box_parent_class @@ -80,8 +80,6 @@ gimp_prefs_box_class_init (GimpPrefsBoxClass *klass) GObjectClass *object_class = G_OBJECT_CLASS (klass); object_class->finalize = gimp_prefs_box_finalize; - - g_type_class_add_private (klass, sizeof (GimpPrefsBoxPrivate)); } static void @@ -96,9 +94,7 @@ gimp_prefs_box_init (GimpPrefsBox *box) GtkWidget *ebox; GtkWidget *vbox; - box->priv = G_TYPE_INSTANCE_GET_PRIVATE (box, - GIMP_TYPE_PREFS_BOX, - GimpPrefsBoxPrivate); + box->priv = gimp_prefs_box_get_instance_private (box); private = box->priv; diff --git a/app/widgets/gimpsearchpopup.c b/app/widgets/gimpsearchpopup.c index b81057faa7..18a81362e6 100644 --- a/app/widgets/gimpsearchpopup.c +++ b/app/widgets/gimpsearchpopup.c @@ -115,7 +115,7 @@ static gboolean gimp_search_popup_view_accel_find_func (GtkAccelKey *key gpointer data); -G_DEFINE_TYPE (GimpSearchPopup, gimp_search_popup, GIMP_TYPE_POPUP) +G_DEFINE_TYPE_WITH_PRIVATE (GimpSearchPopup, gimp_search_popup, GIMP_TYPE_POPUP) #define parent_class gimp_search_popup_parent_class @@ -166,16 +166,12 @@ gimp_search_popup_class_init (GimpSearchPopupClass *klass) g_param_spec_pointer ("callback-data", NULL, NULL, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); - - g_type_class_add_private (klass, sizeof (GimpSearchPopupPrivate)); } static void gimp_search_popup_init (GimpSearchPopup *search_popup) { - search_popup->priv = G_TYPE_INSTANCE_GET_PRIVATE (search_popup, - GIMP_TYPE_SEARCH_POPUP, - GimpSearchPopupPrivate); + search_popup->priv = gimp_search_popup_get_instance_private (search_popup); } /************ Public Functions ****************/ diff --git a/app/widgets/gimpsessioninfo.c b/app/widgets/gimpsessioninfo.c index acd0df6cee..dfaf78cebc 100644 --- a/app/widgets/gimpsessioninfo.c +++ b/app/widgets/gimpsessioninfo.c @@ -93,6 +93,7 @@ static gboolean gimp_session_info_restore_docks (GimpRestoreDocksData *dat G_DEFINE_TYPE_WITH_CODE (GimpSessionInfo, gimp_session_info, GIMP_TYPE_OBJECT, + G_ADD_PRIVATE (GimpSessionInfo) G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONFIG, gimp_session_info_config_iface_init)) @@ -108,16 +109,12 @@ gimp_session_info_class_init (GimpSessionInfoClass *klass) object_class->finalize = gimp_session_info_finalize; gimp_object_class->get_memsize = gimp_session_info_get_memsize; - - g_type_class_add_private (klass, sizeof (GimpSessionInfoPrivate)); } static void gimp_session_info_init (GimpSessionInfo *info) { - info->p = G_TYPE_INSTANCE_GET_PRIVATE (info, - GIMP_TYPE_SESSION_INFO, - GimpSessionInfoPrivate); + info->p = gimp_session_info_get_instance_private (info); info->p->monitor = DEFAULT_MONITOR; } diff --git a/app/widgets/gimpsettingsbox.c b/app/widgets/gimpsettingsbox.c index febae6509b..521e7f4fbe 100644 --- a/app/widgets/gimpsettingsbox.c +++ b/app/widgets/gimpsettingsbox.c @@ -88,9 +88,7 @@ struct _GimpSettingsBoxPrivate GFile *last_file; }; -#define GET_PRIVATE(item) G_TYPE_INSTANCE_GET_PRIVATE (item, \ - GIMP_TYPE_SETTINGS_BOX, \ - GimpSettingsBoxPrivate) +#define GET_PRIVATE(item) ((GimpSettingsBoxPrivate *) gimp_settings_box_get_instance_private ((GimpSettingsBox *) (item))) static void gimp_settings_box_constructed (GObject *object); @@ -143,7 +141,7 @@ static void gimp_settings_box_truncate_list (GimpSettingsBox *box, gint max_recent); -G_DEFINE_TYPE (GimpSettingsBox, gimp_settings_box, GTK_TYPE_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpSettingsBox, gimp_settings_box, GTK_TYPE_BOX) #define parent_class gimp_settings_box_parent_class @@ -261,8 +259,6 @@ gimp_settings_box_class_init (GimpSettingsBoxClass *klass) G_TYPE_FILE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); - - g_type_class_add_private (klass, sizeof (GimpSettingsBoxPrivate)); } static void diff --git a/app/widgets/gimpsettingseditor.c b/app/widgets/gimpsettingseditor.c index 5f883bcd91..b86f4100e2 100644 --- a/app/widgets/gimpsettingseditor.c +++ b/app/widgets/gimpsettingseditor.c @@ -71,9 +71,7 @@ struct _GimpSettingsEditorPrivate GtkWidget *delete_button; }; -#define GET_PRIVATE(item) G_TYPE_INSTANCE_GET_PRIVATE (item, \ - GIMP_TYPE_SETTINGS_EDITOR, \ - GimpSettingsEditorPrivate) +#define GET_PRIVATE(item) ((GimpSettingsEditorPrivate *) gimp_settings_editor_get_instance_private ((GimpSettingsEditor *) (item))) static void gimp_settings_editor_constructed (GObject *object); @@ -107,7 +105,8 @@ static void gimp_settings_editor_name_edited (GtkCellRendererText *cell, GimpSettingsEditor *editor); -G_DEFINE_TYPE (GimpSettingsEditor, gimp_settings_editor, GTK_TYPE_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpSettingsEditor, gimp_settings_editor, + GTK_TYPE_BOX) #define parent_class gimp_settings_editor_parent_class @@ -142,8 +141,6 @@ gimp_settings_editor_class_init (GimpSettingsEditorClass *klass) GIMP_TYPE_CONTAINER, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); - - g_type_class_add_private (klass, sizeof (GimpSettingsEditorPrivate)); } static void diff --git a/app/widgets/gimpsizebox.c b/app/widgets/gimpsizebox.c index 1bf9ae5855..8efe457ce5 100644 --- a/app/widgets/gimpsizebox.c +++ b/app/widgets/gimpsizebox.c @@ -53,8 +53,7 @@ enum }; -#define GIMP_SIZE_BOX_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \ - GIMP_TYPE_SIZE_BOX, GimpSizeBoxPrivate)) +#define GIMP_SIZE_BOX_GET_PRIVATE(obj) ((GimpSizeBoxPrivate *) gimp_size_box_get_instance_private ((GimpSizeBox *) (obj))) typedef struct _GimpSizeBoxPrivate GimpSizeBoxPrivate; @@ -84,7 +83,7 @@ static void gimp_size_box_chain_toggled (GimpChainButton *button, GimpSizeBox *box); -G_DEFINE_TYPE (GimpSizeBox, gimp_size_box, GTK_TYPE_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpSizeBox, gimp_size_box, GTK_TYPE_BOX) #define parent_class gimp_size_box_parent_class @@ -99,8 +98,6 @@ gimp_size_box_class_init (GimpSizeBoxClass *klass) object_class->set_property = gimp_size_box_set_property; object_class->get_property = gimp_size_box_get_property; - g_type_class_add_private (object_class, sizeof (GimpSizeBoxPrivate)); - g_object_class_install_property (object_class, PROP_WIDTH, g_param_spec_int ("width", NULL, NULL, GIMP_MIN_IMAGE_SIZE, diff --git a/app/widgets/gimpspinscale.c b/app/widgets/gimpspinscale.c index b2c790c044..17eff281f4 100644 --- a/app/widgets/gimpspinscale.c +++ b/app/widgets/gimpspinscale.c @@ -81,9 +81,7 @@ struct _GimpSpinScalePrivate gint pointer_warp_start_x; }; -#define GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \ - GIMP_TYPE_SPIN_SCALE, \ - GimpSpinScalePrivate)) +#define GET_PRIVATE(obj) ((GimpSpinScalePrivate *) gimp_spin_scale_get_instance_private ((GimpSpinScale *) (obj))) static void gimp_spin_scale_dispose (GObject *object); @@ -130,7 +128,8 @@ static void gimp_spin_scale_setup_mnemonic (GimpSpinScale *scale, guint previous_keyval); -G_DEFINE_TYPE (GimpSpinScale, gimp_spin_scale, GTK_TYPE_SPIN_BUTTON); +G_DEFINE_TYPE_WITH_PRIVATE (GimpSpinScale, gimp_spin_scale, + GTK_TYPE_SPIN_BUTTON) #define parent_class gimp_spin_scale_parent_class @@ -165,8 +164,6 @@ gimp_spin_scale_class_init (GimpSpinScaleClass *klass) NULL, GIMP_PARAM_READWRITE)); - g_type_class_add_private (klass, sizeof (GimpSpinScalePrivate)); - gtk_widget_class_set_css_name (widget_class, "spinbutton"); } diff --git a/app/widgets/gimpsymmetryeditor.c b/app/widgets/gimpsymmetryeditor.c index a712cbfa19..64c90f6857 100644 --- a/app/widgets/gimpsymmetryeditor.c +++ b/app/widgets/gimpsymmetryeditor.c @@ -66,8 +66,8 @@ static void gimp_symmetry_editor_set_options (GimpSymmetryEditor *editor, GimpSymmetry *symmetry); -G_DEFINE_TYPE (GimpSymmetryEditor, gimp_symmetry_editor, - GIMP_TYPE_IMAGE_EDITOR) +G_DEFINE_TYPE_WITH_PRIVATE (GimpSymmetryEditor, gimp_symmetry_editor, + GIMP_TYPE_IMAGE_EDITOR) #define parent_class gimp_symmetry_editor_parent_class @@ -78,8 +78,6 @@ gimp_symmetry_editor_class_init (GimpSymmetryEditorClass *klass) GimpImageEditorClass *image_editor_class = GIMP_IMAGE_EDITOR_CLASS (klass); image_editor_class->set_image = gimp_symmetry_editor_set_image; - - g_type_class_add_private (klass, sizeof (GimpSymmetryEditorPrivate)); } static void @@ -88,9 +86,7 @@ gimp_symmetry_editor_init (GimpSymmetryEditor *editor) GtkWidget *scrolled_window; GtkWidget *viewport; - editor->p = G_TYPE_INSTANCE_GET_PRIVATE (editor, - GIMP_TYPE_SYMMETRY_EDITOR, - GimpSymmetryEditorPrivate); + editor->p = gimp_symmetry_editor_get_instance_private (editor); gtk_widget_set_size_request (GTK_WIDGET (editor), -1, 200); diff --git a/app/widgets/gimptemplateeditor.c b/app/widgets/gimptemplateeditor.c index 0a5b1805f3..e0c67d4559 100644 --- a/app/widgets/gimptemplateeditor.c +++ b/app/widgets/gimptemplateeditor.c @@ -75,9 +75,7 @@ struct _GimpTemplateEditorPrivate }; #define GET_PRIVATE(editor) \ - G_TYPE_INSTANCE_GET_PRIVATE (editor, \ - GIMP_TYPE_TEMPLATE_EDITOR, \ - GimpTemplateEditorPrivate) + ((GimpTemplateEditorPrivate *) gimp_template_editor_get_instance_private ((GimpTemplateEditor *) (editor))) static void gimp_template_editor_constructed (GObject *object); @@ -100,7 +98,8 @@ static void gimp_template_editor_template_notify (GimpTemplate *template GimpTemplateEditor *editor); -G_DEFINE_TYPE (GimpTemplateEditor, gimp_template_editor, GTK_TYPE_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpTemplateEditor, gimp_template_editor, + GTK_TYPE_BOX) #define parent_class gimp_template_editor_parent_class @@ -126,8 +125,6 @@ gimp_template_editor_class_init (GimpTemplateEditorClass *klass) GIMP_TYPE_TEMPLATE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); - - g_type_class_add_private (object_class, sizeof (GimpTemplateEditorPrivate)); } static void diff --git a/app/widgets/gimptoolbox.c b/app/widgets/gimptoolbox.c index 8af21a85aa..b91de27363 100644 --- a/app/widgets/gimptoolbox.c +++ b/app/widgets/gimptoolbox.c @@ -135,7 +135,7 @@ static void toolbox_paste_received (GtkClipboard *clipboa gpointer data); -G_DEFINE_TYPE (GimpToolbox, gimp_toolbox, GIMP_TYPE_DOCK) +G_DEFINE_TYPE_WITH_PRIVATE (GimpToolbox, gimp_toolbox, GIMP_TYPE_DOCK) #define parent_class gimp_toolbox_parent_class @@ -165,16 +165,12 @@ gimp_toolbox_class_init (GimpToolboxClass *klass) GIMP_TYPE_CONTEXT, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); - - g_type_class_add_private (klass, sizeof (GimpToolboxPrivate)); } static void gimp_toolbox_init (GimpToolbox *toolbox) { - toolbox->p = G_TYPE_INSTANCE_GET_PRIVATE (toolbox, - GIMP_TYPE_TOOLBOX, - GimpToolboxPrivate); + toolbox->p = gimp_toolbox_get_instance_private (toolbox); gimp_help_connect (GTK_WIDGET (toolbox), gimp_standard_help_func, GIMP_HELP_TOOLBOX, NULL); diff --git a/app/widgets/gimptooleditor.c b/app/widgets/gimptooleditor.c index 042570e5c1..1ad4693604 100644 --- a/app/widgets/gimptooleditor.c +++ b/app/widgets/gimptooleditor.c @@ -105,13 +105,12 @@ static void gimp_tool_editor_reset_clicked GimpToolEditor *tool_editor); -G_DEFINE_TYPE (GimpToolEditor, gimp_tool_editor, GIMP_TYPE_CONTAINER_TREE_VIEW) +G_DEFINE_TYPE_WITH_PRIVATE (GimpToolEditor, gimp_tool_editor, + GIMP_TYPE_CONTAINER_TREE_VIEW) #define parent_class gimp_tool_editor_parent_class -#define GIMP_TOOL_EDITOR_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \ - GIMP_TYPE_TOOL_EDITOR, \ - GimpToolEditorPrivate)) +#define GIMP_TOOL_EDITOR_GET_PRIVATE(obj) ((GimpToolEditorPrivate *) gimp_tool_editor_get_instance_private ((GimpToolEditor *) (obj))) static void @@ -121,8 +120,6 @@ gimp_tool_editor_class_init (GimpToolEditorClass *klass) object_class->dispose = gimp_tool_editor_dispose; object_class->finalize = gimp_tool_editor_finalize; - - g_type_class_add_private (klass, sizeof (GimpToolEditorPrivate)); } static void diff --git a/app/widgets/gimptooloptionseditor.c b/app/widgets/gimptooloptionseditor.c index ecf75d3366..a1ffee75fc 100644 --- a/app/widgets/gimptooloptionseditor.c +++ b/app/widgets/gimptooloptionseditor.c @@ -105,6 +105,7 @@ static void gimp_tool_options_editor_presets_update (GimpToolOptionsEd G_DEFINE_TYPE_WITH_CODE (GimpToolOptionsEditor, gimp_tool_options_editor, GIMP_TYPE_EDITOR, + G_ADD_PRIVATE (GimpToolOptionsEditor) G_IMPLEMENT_INTERFACE (GIMP_TYPE_DOCKED, gimp_tool_options_editor_docked_iface_init)) @@ -127,8 +128,6 @@ gimp_tool_options_editor_class_init (GimpToolOptionsEditorClass *klass) GIMP_TYPE_GIMP, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); - - g_type_class_add_private (klass, sizeof (GimpToolOptionsEditorPrivate)); } static void @@ -144,9 +143,7 @@ gimp_tool_options_editor_init (GimpToolOptionsEditor *editor) { GtkScrolledWindow *scrolled_window; - editor->p = G_TYPE_INSTANCE_GET_PRIVATE (editor, - GIMP_TYPE_TOOL_OPTIONS_EDITOR, - GimpToolOptionsEditorPrivate); + editor->p = gimp_tool_options_editor_get_instance_private (editor); gtk_widget_set_size_request (GTK_WIDGET (editor), -1, 200); diff --git a/app/widgets/gimptoolpalette.c b/app/widgets/gimptoolpalette.c index 38d0cb0c56..aa3b4ea28e 100644 --- a/app/widgets/gimptoolpalette.c +++ b/app/widgets/gimptoolpalette.c @@ -56,9 +56,7 @@ struct _GimpToolPalettePrivate GimpToolbox *toolbox; }; -#define GET_PRIVATE(p) G_TYPE_INSTANCE_GET_PRIVATE (p, \ - GIMP_TYPE_TOOL_PALETTE, \ - GimpToolPalettePrivate) +#define GET_PRIVATE(p) ((GimpToolPalettePrivate *) gimp_tool_palette_get_instance_private ((GimpToolPalette *) (p))) static GtkSizeRequestMode @@ -91,7 +89,8 @@ static gboolean gimp_tool_palette_tool_button_press (GtkWidget *widget, GimpToolPalette *palette); -G_DEFINE_TYPE (GimpToolPalette, gimp_tool_palette, GTK_TYPE_TOOL_PALETTE) +G_DEFINE_TYPE_WITH_PRIVATE (GimpToolPalette, gimp_tool_palette, + GTK_TYPE_TOOL_PALETTE) #define parent_class gimp_tool_palette_parent_class @@ -121,8 +120,6 @@ gimp_tool_palette_class_init (GimpToolPaletteClass *klass) GTK_TYPE_RELIEF_STYLE, DEFAULT_BUTTON_RELIEF, GIMP_PARAM_READABLE)); - - g_type_class_add_private (klass, sizeof (GimpToolPalettePrivate)); } static void diff --git a/app/widgets/gimptoolpreseteditor.c b/app/widgets/gimptoolpreseteditor.c index 5176376f70..6f84a63cea 100644 --- a/app/widgets/gimptoolpreseteditor.c +++ b/app/widgets/gimptoolpreseteditor.c @@ -76,6 +76,7 @@ static void gimp_tool_preset_editor_notify_data (GimpToolPreset *option G_DEFINE_TYPE_WITH_CODE (GimpToolPresetEditor, gimp_tool_preset_editor, GIMP_TYPE_DATA_EDITOR, + G_ADD_PRIVATE (GimpToolPresetEditor) G_IMPLEMENT_INTERFACE (GIMP_TYPE_DOCKED, NULL)) #define parent_class gimp_tool_preset_editor_parent_class @@ -92,16 +93,12 @@ gimp_tool_preset_editor_class_init (GimpToolPresetEditorClass *klass) editor_class->set_data = gimp_tool_preset_editor_set_data; editor_class->title = _("Tool Preset Editor"); - - g_type_class_add_private (klass, sizeof (GimpToolPresetEditorPrivate)); } static void gimp_tool_preset_editor_init (GimpToolPresetEditor *editor) { - editor->priv = G_TYPE_INSTANCE_GET_PRIVATE (editor, - GIMP_TYPE_TOOL_PRESET_EDITOR, - GimpToolPresetEditorPrivate); + editor->priv = gimp_tool_preset_editor_get_instance_private (editor); } static void diff --git a/app/widgets/gimpviewrenderer.c b/app/widgets/gimpviewrenderer.c index bdad3ca884..ee3fc059bf 100644 --- a/app/widgets/gimpviewrenderer.c +++ b/app/widgets/gimpviewrenderer.c @@ -114,7 +114,7 @@ static cairo_pattern_t * GtkWidget *widget); -G_DEFINE_TYPE (GimpViewRenderer, gimp_view_renderer, G_TYPE_OBJECT) +G_DEFINE_TYPE_WITH_PRIVATE (GimpViewRenderer, gimp_view_renderer, G_TYPE_OBJECT) #define parent_class gimp_view_renderer_parent_class @@ -159,16 +159,12 @@ gimp_view_renderer_class_init (GimpViewRendererClass *klass) gimp_rgba_set (&white_color, 1.0, 1.0, 1.0, GIMP_OPACITY_OPAQUE); gimp_rgba_set (&green_color, 0.0, 0.94, 0.0, GIMP_OPACITY_OPAQUE); gimp_rgba_set (&red_color, 1.0, 0.0, 0.0, GIMP_OPACITY_OPAQUE); - - g_type_class_add_private (klass, sizeof (GimpViewRendererPrivate)); } static void gimp_view_renderer_init (GimpViewRenderer *renderer) { - renderer->priv = G_TYPE_INSTANCE_GET_PRIVATE (renderer, - GIMP_TYPE_VIEW_RENDERER, - GimpViewRendererPrivate); + renderer->priv = gimp_view_renderer_get_instance_private (renderer); renderer->viewable = NULL; diff --git a/app/widgets/gimpviewrendererdrawable.c b/app/widgets/gimpviewrendererdrawable.c index f3ee8c10c1..d2e7013ae0 100644 --- a/app/widgets/gimpviewrendererdrawable.c +++ b/app/widgets/gimpviewrendererdrawable.c @@ -65,8 +65,9 @@ static void gimp_view_renderer_drawable_render (GimpViewRenderer static void gimp_view_renderer_drawable_cancel_render (GimpViewRendererDrawable *renderdrawable); -G_DEFINE_TYPE (GimpViewRendererDrawable, gimp_view_renderer_drawable, - GIMP_TYPE_VIEW_RENDERER) +G_DEFINE_TYPE_WITH_PRIVATE (GimpViewRendererDrawable, + gimp_view_renderer_drawable, + GIMP_TYPE_VIEW_RENDERER) #define parent_class gimp_view_renderer_drawable_parent_class @@ -84,17 +85,13 @@ gimp_view_renderer_drawable_class_init (GimpViewRendererDrawableClass *klass) renderer_class->invalidate = gimp_view_renderer_drawable_invalidate; renderer_class->render = gimp_view_renderer_drawable_render; - - g_type_class_add_private (klass, sizeof (GimpViewRendererDrawablePrivate)); } static void gimp_view_renderer_drawable_init (GimpViewRendererDrawable *renderdrawable) { renderdrawable->priv = - G_TYPE_INSTANCE_GET_PRIVATE (renderdrawable, - GIMP_TYPE_VIEW_RENDERER_DRAWABLE, - GimpViewRendererDrawablePrivate); + gimp_view_renderer_drawable_get_instance_private (renderdrawable); } static void diff --git a/app/widgets/gimpwindow.c b/app/widgets/gimpwindow.c index 8bbd585d2e..c0a0f1ba5f 100644 --- a/app/widgets/gimpwindow.c +++ b/app/widgets/gimpwindow.c @@ -61,7 +61,7 @@ static gboolean gimp_window_key_press_event (GtkWidget *widget, GdkEventKey *kevent); -G_DEFINE_TYPE (GimpWindow, gimp_window, GTK_TYPE_WINDOW) +G_DEFINE_TYPE_WITH_PRIVATE (GimpWindow, gimp_window, GTK_TYPE_WINDOW) #define parent_class gimp_window_parent_class @@ -89,16 +89,12 @@ gimp_window_class_init (GimpWindowClass *klass) widget_class->screen_changed = gimp_window_screen_changed; widget_class->configure_event = gimp_window_configure_event; widget_class->key_press_event = gimp_window_key_press_event; - - g_type_class_add_private (klass, sizeof (GimpWindowPrivate)); } static void gimp_window_init (GimpWindow *window) { - window->private = G_TYPE_INSTANCE_GET_PRIVATE (window, - GIMP_TYPE_WINDOW, - GimpWindowPrivate); + window->private = gimp_window_get_instance_private (window); } static void diff --git a/libgimp/gimpaspectpreview.c b/libgimp/gimpaspectpreview.c index d973153f0f..378af78f09 100644 --- a/libgimp/gimpaspectpreview.c +++ b/libgimp/gimpaspectpreview.c @@ -94,7 +94,8 @@ static void gimp_aspect_preview_set_drawable_id gint32 drawable_ID); -G_DEFINE_TYPE (GimpAspectPreview, gimp_aspect_preview, GIMP_TYPE_PREVIEW) +G_DEFINE_TYPE_WITH_PRIVATE (GimpAspectPreview, gimp_aspect_preview, + GIMP_TYPE_PREVIEW) #define parent_class gimp_aspect_preview_parent_class @@ -120,8 +121,6 @@ gimp_aspect_preview_class_init (GimpAspectPreviewClass *klass) preview_class->transform = gimp_aspect_preview_transform; preview_class->untransform = gimp_aspect_preview_untransform; - g_type_class_add_private (object_class, sizeof (GimpAspectPreviewPrivate)); - /** * GimpAspectPreview:drawable-id: * @@ -141,9 +140,7 @@ gimp_aspect_preview_class_init (GimpAspectPreviewClass *klass) static void gimp_aspect_preview_init (GimpAspectPreview *preview) { - preview->priv = G_TYPE_INSTANCE_GET_PRIVATE (preview, - GIMP_TYPE_ASPECT_PREVIEW, - GimpAspectPreviewPrivate); + preview->priv = gimp_aspect_preview_get_instance_private (preview); g_object_set (gimp_preview_get_area (GIMP_PREVIEW (preview)), "check-size", gimp_check_size (), diff --git a/libgimp/gimpbrushselectbutton.c b/libgimp/gimpbrushselectbutton.c index 68b6b5a34d..bd14d00632 100644 --- a/libgimp/gimpbrushselectbutton.c +++ b/libgimp/gimpbrushselectbutton.c @@ -146,8 +146,8 @@ static const GtkTargetEntry target = { "application/x-gimp-brush-name", 0 }; static guint brush_button_signals[LAST_SIGNAL] = { 0 }; -G_DEFINE_TYPE (GimpBrushSelectButton, gimp_brush_select_button, - GIMP_TYPE_SELECT_BUTTON) +G_DEFINE_TYPE_WITH_PRIVATE (GimpBrushSelectButton, gimp_brush_select_button, + GIMP_TYPE_SELECT_BUTTON) static void @@ -268,9 +268,6 @@ gimp_brush_select_button_class_init (GimpBrushSelectButtonClass *klass) G_TYPE_INT, G_TYPE_POINTER, G_TYPE_BOOLEAN); - - g_type_class_add_private (object_class, - sizeof (GimpBrushSelectButtonPrivate)); } static void @@ -283,9 +280,7 @@ gimp_brush_select_button_init (GimpBrushSelectButton *button) gint color_data_size; guint8 *color_data; - button->priv = G_TYPE_INSTANCE_GET_PRIVATE (button, - GIMP_TYPE_BRUSH_SELECT_BUTTON, - GimpBrushSelectButtonPrivate); + button->priv = gimp_brush_select_button_get_instance_private (button); priv = GET_PRIVATE (button); diff --git a/libgimp/gimpdrawablepreview.c b/libgimp/gimpdrawablepreview.c index 812b9e6b4b..b77e1abaff 100644 --- a/libgimp/gimpdrawablepreview.c +++ b/libgimp/gimpdrawablepreview.c @@ -92,8 +92,8 @@ static void gimp_drawable_preview_set_drawable_id gint32 drawable_ID); -G_DEFINE_TYPE (GimpDrawablePreview, gimp_drawable_preview, - GIMP_TYPE_SCROLLED_PREVIEW) +G_DEFINE_TYPE_WITH_PRIVATE (GimpDrawablePreview, gimp_drawable_preview, + GIMP_TYPE_SCROLLED_PREVIEW) #define parent_class gimp_drawable_preview_parent_class @@ -118,8 +118,6 @@ gimp_drawable_preview_class_init (GimpDrawablePreviewClass *klass) preview_class->draw_thumb = gimp_drawable_preview_draw_thumb; preview_class->draw_buffer = gimp_drawable_preview_draw_buffer; - g_type_class_add_private (object_class, sizeof (GimpDrawablePreviewPrivate)); - /** * GimpDrawablePreview:drawable-id: * @@ -140,9 +138,7 @@ gimp_drawable_preview_class_init (GimpDrawablePreviewClass *klass) static void gimp_drawable_preview_init (GimpDrawablePreview *preview) { - preview->priv = G_TYPE_INSTANCE_GET_PRIVATE (preview, - GIMP_TYPE_DRAWABLE_PREVIEW, - GimpDrawablePreviewPrivate); + preview->priv = gimp_drawable_preview_get_instance_private (preview); g_object_set (gimp_preview_get_area (GIMP_PREVIEW (preview)), "check-size", gimp_check_size (), diff --git a/libgimp/gimpfontselectbutton.c b/libgimp/gimpfontselectbutton.c index ed877181d7..1e2b2dffab 100644 --- a/libgimp/gimpfontselectbutton.c +++ b/libgimp/gimpfontselectbutton.c @@ -106,8 +106,8 @@ static const GtkTargetEntry target = { "application/x-gimp-font-name", 0 }; static guint font_button_signals[LAST_SIGNAL] = { 0 }; -G_DEFINE_TYPE (GimpFontSelectButton, gimp_font_select_button, - GIMP_TYPE_SELECT_BUTTON) +G_DEFINE_TYPE_WITH_PRIVATE (GimpFontSelectButton, gimp_font_select_button, + GIMP_TYPE_SELECT_BUTTON) static void @@ -173,9 +173,6 @@ gimp_font_select_button_class_init (GimpFontSelectButtonClass *klass) G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_BOOLEAN); - - g_type_class_add_private (object_class, - sizeof (GimpFontSelectButtonPrivate)); } static void @@ -183,9 +180,7 @@ gimp_font_select_button_init (GimpFontSelectButton *button) { GimpFontSelectButtonPrivate *priv; - button->priv = G_TYPE_INSTANCE_GET_PRIVATE (button, - GIMP_TYPE_FONT_SELECT_BUTTON, - GimpFontSelectButtonPrivate); + button->priv = gimp_font_select_button_get_instance_private (button); priv = GET_PRIVATE (button); diff --git a/libgimp/gimpgradientselectbutton.c b/libgimp/gimpgradientselectbutton.c index 9da89a3e96..b5eb14c4df 100644 --- a/libgimp/gimpgradientselectbutton.c +++ b/libgimp/gimpgradientselectbutton.c @@ -123,8 +123,9 @@ static const GtkTargetEntry target = { "application/x-gimp-gradient-name", 0 }; static guint gradient_button_signals[LAST_SIGNAL] = { 0 }; -G_DEFINE_TYPE (GimpGradientSelectButton, gimp_gradient_select_button, - GIMP_TYPE_SELECT_BUTTON) +G_DEFINE_TYPE_WITH_PRIVATE (GimpGradientSelectButton, + gimp_gradient_select_button, + GIMP_TYPE_SELECT_BUTTON) static void @@ -194,9 +195,6 @@ gimp_gradient_select_button_class_init (GimpGradientSelectButtonClass *klass) G_TYPE_INT, G_TYPE_POINTER, G_TYPE_BOOLEAN); - - g_type_class_add_private (object_class, - sizeof (GimpGradientSelectButtonPrivate)); } static void @@ -204,9 +202,7 @@ gimp_gradient_select_button_init (GimpGradientSelectButton *button) { GimpGradientSelectButtonPrivate *priv; - button->priv = G_TYPE_INSTANCE_GET_PRIVATE (button, - GIMP_TYPE_GRADIENT_SELECT_BUTTON, - GimpGradientSelectButtonPrivate); + button->priv = gimp_gradient_select_button_get_instance_private (button); priv = GET_PRIVATE (button); diff --git a/libgimp/gimppaletteselectbutton.c b/libgimp/gimppaletteselectbutton.c index 95de751cfd..774d3a0122 100644 --- a/libgimp/gimppaletteselectbutton.c +++ b/libgimp/gimppaletteselectbutton.c @@ -44,7 +44,7 @@ **/ -#define GIMP_PALETTE_SELECT_BUTTON_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GIMP_TYPE_PALETTE_SELECT_BUTTON, GimpPaletteSelectButtonPrivate)) +#define GIMP_PALETTE_SELECT_BUTTON_GET_PRIVATE(obj) ((GimpPaletteSelectButtonPrivate *) gimp_palette_select_button_get_instance_private ((GimpPaletteSelectButton *) (obj))) typedef struct _GimpPaletteSelectButtonPrivate GimpPaletteSelectButtonPrivate; @@ -107,8 +107,8 @@ static const GtkTargetEntry target = { "application/x-gimp-palette-name", 0 }; static guint palette_button_signals[LAST_SIGNAL] = { 0 }; -G_DEFINE_TYPE (GimpPaletteSelectButton, gimp_palette_select_button, - GIMP_TYPE_SELECT_BUTTON) +G_DEFINE_TYPE_WITH_PRIVATE (GimpPaletteSelectButton, gimp_palette_select_button, + GIMP_TYPE_SELECT_BUTTON) static void @@ -174,9 +174,6 @@ gimp_palette_select_button_class_init (GimpPaletteSelectButtonClass *klass) G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_BOOLEAN); - - g_type_class_add_private (object_class, - sizeof (GimpPaletteSelectButtonPrivate)); } static void diff --git a/libgimp/gimppatternselectbutton.c b/libgimp/gimppatternselectbutton.c index 4d4385baef..c07dfd4df0 100644 --- a/libgimp/gimppatternselectbutton.c +++ b/libgimp/gimppatternselectbutton.c @@ -47,7 +47,7 @@ #define CELL_SIZE 20 -#define GIMP_PATTERN_SELECT_BUTTON_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GIMP_TYPE_PATTERN_SELECT_BUTTON, GimpPatternSelectButtonPrivate)) +#define GIMP_PATTERN_SELECT_BUTTON_GET_PRIVATE(obj) ((GimpPatternSelectButtonPrivate *) gimp_pattern_select_button_get_instance_private ((GimpPatternSelectButton *) (obj))) typedef struct _GimpPatternSelectButtonPrivate GimpPatternSelectButtonPrivate; @@ -134,8 +134,8 @@ static const GtkTargetEntry target = { "application/x-gimp-pattern-name", 0 }; static guint pattern_button_signals[LAST_SIGNAL] = { 0 }; -G_DEFINE_TYPE (GimpPatternSelectButton, gimp_pattern_select_button, - GIMP_TYPE_SELECT_BUTTON) +G_DEFINE_TYPE_WITH_PRIVATE (GimpPatternSelectButton, gimp_pattern_select_button, + GIMP_TYPE_SELECT_BUTTON) static void gimp_pattern_select_button_class_init (GimpPatternSelectButtonClass *klass) @@ -208,9 +208,6 @@ gimp_pattern_select_button_class_init (GimpPatternSelectButtonClass *klass) G_TYPE_INT, G_TYPE_POINTER, G_TYPE_BOOLEAN); - - g_type_class_add_private (object_class, - sizeof (GimpPatternSelectButtonPrivate)); } static void diff --git a/libgimp/gimpprocbrowserdialog.c b/libgimp/gimpprocbrowserdialog.c index 5a6ab47304..979195e9de 100644 --- a/libgimp/gimpprocbrowserdialog.c +++ b/libgimp/gimpprocbrowserdialog.c @@ -101,8 +101,8 @@ static void browser_search (GimpBrowser *browser, GimpProcBrowserDialog *dialog); -G_DEFINE_TYPE (GimpProcBrowserDialog, gimp_proc_browser_dialog, - GIMP_TYPE_DIALOG) +G_DEFINE_TYPE_WITH_PRIVATE (GimpProcBrowserDialog, gimp_proc_browser_dialog, + GIMP_TYPE_DIALOG) #define parent_class gimp_proc_browser_dialog_parent_class @@ -146,8 +146,6 @@ gimp_proc_browser_dialog_class_init (GimpProcBrowserDialogClass *klass) klass->selection_changed = NULL; klass->row_activated = NULL; - - g_type_class_add_private (klass, sizeof (GimpProcBrowserDialogPrivate)); } static void @@ -159,9 +157,7 @@ gimp_proc_browser_dialog_init (GimpProcBrowserDialog *dialog) GtkTreeSelection *selection; GtkWidget *parent; - dialog->priv = G_TYPE_INSTANCE_GET_PRIVATE (dialog, - GIMP_TYPE_PROC_BROWSER_DIALOG, - GimpProcBrowserDialogPrivate); + dialog->priv = gimp_proc_browser_dialog_get_instance_private (dialog); priv = GET_PRIVATE (dialog); diff --git a/libgimp/gimptilebackendplugin.c b/libgimp/gimptilebackendplugin.c index 6c37371f0e..900e934df0 100644 --- a/libgimp/gimptilebackendplugin.c +++ b/libgimp/gimptilebackendplugin.c @@ -78,8 +78,8 @@ static GeglTile * gimp_tile_read_mul (GimpTileBackendPlugin *backend_plugin, gint y); -G_DEFINE_TYPE (GimpTileBackendPlugin, _gimp_tile_backend_plugin, - GEGL_TYPE_TILE_BACKEND) +G_DEFINE_TYPE_WITH_PRIVATE (GimpTileBackendPlugin, _gimp_tile_backend_plugin, + GEGL_TYPE_TILE_BACKEND) #define parent_class _gimp_tile_backend_plugin_parent_class @@ -94,8 +94,6 @@ _gimp_tile_backend_plugin_class_init (GimpTileBackendPluginClass *klass) object_class->finalize = gimp_tile_backend_plugin_finalize; - g_type_class_add_private (klass, sizeof (GimpTileBackendPluginPrivate)); - gimp_tile_cache_ntiles (64); } @@ -104,9 +102,7 @@ _gimp_tile_backend_plugin_init (GimpTileBackendPlugin *backend) { GeglTileSource *source = GEGL_TILE_SOURCE (backend); - backend->priv = G_TYPE_INSTANCE_GET_PRIVATE (backend, - GIMP_TYPE_TILE_BACKEND_PLUGIN, - GimpTileBackendPluginPrivate); + backend->priv = _gimp_tile_backend_plugin_get_instance_private (backend); source->command = gimp_tile_backend_plugin_command; } diff --git a/libgimp/gimpzoompreview.c b/libgimp/gimpzoompreview.c index 2fd199a981..638b32fb6e 100644 --- a/libgimp/gimpzoompreview.c +++ b/libgimp/gimpzoompreview.c @@ -120,7 +120,8 @@ static void gimp_zoom_preview_get_source_area (GimpPreview *preview, gint *h); -G_DEFINE_TYPE (GimpZoomPreview, gimp_zoom_preview, GIMP_TYPE_SCROLLED_PREVIEW) +G_DEFINE_TYPE_WITH_PRIVATE (GimpZoomPreview, gimp_zoom_preview, + GIMP_TYPE_SCROLLED_PREVIEW) #define parent_class gimp_zoom_preview_parent_class @@ -149,8 +150,6 @@ gimp_zoom_preview_class_init (GimpZoomPreviewClass *klass) preview_class->transform = gimp_zoom_preview_transform; preview_class->untransform = gimp_zoom_preview_untransform; - g_type_class_add_private (object_class, sizeof (GimpZoomPreviewPrivate)); - /** * GimpZoomPreview:drawable-id: * @@ -187,9 +186,7 @@ gimp_zoom_preview_init (GimpZoomPreview *preview) { GtkWidget *area = gimp_preview_get_area (GIMP_PREVIEW (preview)); - preview->priv = G_TYPE_INSTANCE_GET_PRIVATE (preview, - GIMP_TYPE_ZOOM_PREVIEW, - GimpZoomPreviewPrivate); + preview->priv = gimp_zoom_preview_get_instance_private (preview); g_signal_connect (area, "size-allocate", G_CALLBACK (gimp_zoom_preview_size_allocate), diff --git a/libgimpcolor/gimpcolorprofile.c b/libgimpcolor/gimpcolorprofile.c index 9d64e8f1dd..805f0cfc42 100644 --- a/libgimpcolor/gimpcolorprofile.c +++ b/libgimpcolor/gimpcolorprofile.c @@ -107,8 +107,7 @@ struct _GimpColorProfilePrivate static void gimp_color_profile_finalize (GObject *object); -G_DEFINE_TYPE (GimpColorProfile, gimp_color_profile, - G_TYPE_OBJECT); +G_DEFINE_TYPE_WITH_PRIVATE (GimpColorProfile, gimp_color_profile, G_TYPE_OBJECT) #define parent_class gimp_color_profile_parent_class @@ -132,16 +131,12 @@ gimp_color_profile_class_init (GimpColorProfileClass *klass) GObjectClass *object_class = G_OBJECT_CLASS (klass); object_class->finalize = gimp_color_profile_finalize; - - g_type_class_add_private (klass, sizeof (GimpColorProfilePrivate)); } static void gimp_color_profile_init (GimpColorProfile *profile) { - profile->priv = G_TYPE_INSTANCE_GET_PRIVATE (profile, - GIMP_TYPE_COLOR_PROFILE, - GimpColorProfilePrivate); + profile->priv = gimp_color_profile_get_instance_private (profile); } static void diff --git a/libgimpcolor/gimpcolortransform.c b/libgimpcolor/gimpcolortransform.c index b99c1f6e52..f761a93683 100644 --- a/libgimpcolor/gimpcolortransform.c +++ b/libgimpcolor/gimpcolortransform.c @@ -82,8 +82,8 @@ struct _GimpColorTransformPrivate static void gimp_color_transform_finalize (GObject *object); -G_DEFINE_TYPE (GimpColorTransform, gimp_color_transform, - G_TYPE_OBJECT); +G_DEFINE_TYPE_WITH_PRIVATE (GimpColorTransform, gimp_color_transform, + G_TYPE_OBJECT) #define parent_class gimp_color_transform_parent_class @@ -130,17 +130,13 @@ gimp_color_transform_class_init (GimpColorTransformClass *klass) G_TYPE_NONE, 1, G_TYPE_DOUBLE); - g_type_class_add_private (klass, sizeof (GimpColorTransformPrivate)); - cmsSetLogErrorHandler (lcms_error_handler); } static void gimp_color_transform_init (GimpColorTransform *transform) { - transform->priv = G_TYPE_INSTANCE_GET_PRIVATE (transform, - GIMP_TYPE_COLOR_TRANSFORM, - GimpColorTransformPrivate); + transform->priv = gimp_color_transform_get_instance_private (transform); } static void diff --git a/libgimpconfig/gimpcolorconfig.c b/libgimpconfig/gimpcolorconfig.c index 53c6e02e2e..8e89a6f31a 100644 --- a/libgimpconfig/gimpcolorconfig.c +++ b/libgimpconfig/gimpcolorconfig.c @@ -185,6 +185,7 @@ static void gimp_color_config_set_simulation_profile (GimpColorConfig *config, G_DEFINE_TYPE_WITH_CODE (GimpColorConfig, gimp_color_config, G_TYPE_OBJECT, + G_ADD_PRIVATE (GimpColorConfig) G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONFIG, NULL) gimp_type_set_translation_domain (g_define_type_id, GETTEXT_PACKAGE "-libgimp")) @@ -312,16 +313,12 @@ gimp_color_config_class_init (GimpColorConfigClass *klass) OUT_OF_GAMUT_COLOR_BLURB, FALSE, &color, GIMP_PARAM_STATIC_STRINGS); - - g_type_class_add_private (object_class, sizeof (GimpColorConfigPrivate)); } static void gimp_color_config_init (GimpColorConfig *config) { - config->priv = G_TYPE_INSTANCE_GET_PRIVATE (config, - GIMP_TYPE_COLOR_CONFIG, - GimpColorConfigPrivate); + config->priv = gimp_color_config_get_instance_private (config); } static void diff --git a/libgimpmodule/gimpmoduledb.c b/libgimpmodule/gimpmoduledb.c index 66025d7ce4..d3f65f8faa 100644 --- a/libgimpmodule/gimpmoduledb.c +++ b/libgimpmodule/gimpmoduledb.c @@ -84,7 +84,7 @@ static void gimp_module_db_module_modified (GimpModule *module, GimpModuleDB *db); -G_DEFINE_TYPE (GimpModuleDB, gimp_module_db, G_TYPE_OBJECT) +G_DEFINE_TYPE_WITH_PRIVATE (GimpModuleDB, gimp_module_db, G_TYPE_OBJECT) #define parent_class gimp_module_db_parent_class @@ -130,16 +130,12 @@ gimp_module_db_class_init (GimpModuleDBClass *klass) klass->add = NULL; klass->remove = NULL; - - g_type_class_add_private (klass, sizeof (GimpModuleDBPrivate)); } static void gimp_module_db_init (GimpModuleDB *db) { - db->priv = G_TYPE_INSTANCE_GET_PRIVATE (db, - GIMP_TYPE_MODULE_DB, - GimpModuleDBPrivate); + db->priv = gimp_module_db_get_instance_private (db); db->priv->modules = NULL; db->priv->load_inhibit = NULL; diff --git a/libgimpwidgets/gimpbrowser.c b/libgimpwidgets/gimpbrowser.c index 2e427f95e5..d024f4a903 100644 --- a/libgimpwidgets/gimpbrowser.c +++ b/libgimpwidgets/gimpbrowser.c @@ -82,7 +82,7 @@ static void gimp_browser_entry_icon_press (GtkEntry *entry, static gboolean gimp_browser_search_timeout (gpointer data); -G_DEFINE_TYPE (GimpBrowser, gimp_browser, GTK_TYPE_PANED) +G_DEFINE_TYPE_WITH_PRIVATE (GimpBrowser, gimp_browser, GTK_TYPE_PANED) #define parent_class gimp_browser_parent_class @@ -108,8 +108,6 @@ gimp_browser_class_init (GimpBrowserClass *klass) object_class->dispose = gimp_browser_dispose; klass->search = NULL; - - g_type_class_add_private (object_class, sizeof (GimpBrowserPrivate)); } static void @@ -121,9 +119,7 @@ gimp_browser_init (GimpBrowser *browser) GtkWidget *scrolled_window; GtkWidget *viewport; - browser->priv = G_TYPE_INSTANCE_GET_PRIVATE (browser, - GIMP_TYPE_BROWSER, - GimpBrowserPrivate); + browser->priv = gimp_browser_get_instance_private (browser); priv = GET_PRIVATE (browser); diff --git a/libgimpwidgets/gimpbusybox.c b/libgimpwidgets/gimpbusybox.c index 112f5f8fee..d469755715 100644 --- a/libgimpwidgets/gimpbusybox.c +++ b/libgimpwidgets/gimpbusybox.c @@ -65,7 +65,7 @@ static void gimp_busy_box_get_property (GObject *object, GParamSpec *pspec); -G_DEFINE_TYPE (GimpBusyBox, gimp_busy_box, GTK_TYPE_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpBusyBox, gimp_busy_box, GTK_TYPE_BOX) #define parent_class gimp_busy_box_parent_class @@ -94,8 +94,6 @@ gimp_busy_box_class_init (GimpBusyBoxClass *klass) NULL, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); - - g_type_class_add_private (klass, sizeof (GimpBusyBoxPrivate)); } static void @@ -104,9 +102,7 @@ gimp_busy_box_init (GimpBusyBox *box) GtkWidget *spinner; GtkWidget *label; - box->priv = G_TYPE_INSTANCE_GET_PRIVATE (box, - GIMP_TYPE_BUSY_BOX, - GimpBusyBoxPrivate); + box->priv = gimp_busy_box_get_instance_private (box); gtk_widget_set_halign (GTK_WIDGET (box), GTK_ALIGN_CENTER); gtk_widget_set_valign (GTK_WIDGET (box), GTK_ALIGN_CENTER); diff --git a/libgimpwidgets/gimpbutton.c b/libgimpwidgets/gimpbutton.c index b08a48112b..6cc8f84d74 100644 --- a/libgimpwidgets/gimpbutton.c +++ b/libgimpwidgets/gimpbutton.c @@ -59,7 +59,7 @@ static gboolean gimp_button_button_press (GtkWidget *widget, static void gimp_button_clicked (GtkButton *button); -G_DEFINE_TYPE (GimpButton, gimp_button, GTK_TYPE_BUTTON) +G_DEFINE_TYPE_WITH_PRIVATE (GimpButton, gimp_button, GTK_TYPE_BUTTON) #define parent_class gimp_button_parent_class @@ -69,7 +69,6 @@ static guint button_signals[LAST_SIGNAL] = { 0 }; static void gimp_button_class_init (GimpButtonClass *klass) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); GtkButtonClass *button_class = GTK_BUTTON_CLASS (klass); @@ -94,16 +93,12 @@ gimp_button_class_init (GimpButtonClass *klass) widget_class->button_press_event = gimp_button_button_press; button_class->clicked = gimp_button_clicked; - - g_type_class_add_private (object_class, sizeof (GimpButtonPrivate)); } static void gimp_button_init (GimpButton *button) { - button->priv = G_TYPE_INSTANCE_GET_PRIVATE (button, - GIMP_TYPE_BUTTON, - GimpButtonPrivate); + button->priv = gimp_button_get_instance_private (button); } /** diff --git a/libgimpwidgets/gimpcellrenderercolor.c b/libgimpwidgets/gimpcellrenderercolor.c index ee96e1f64b..b644779394 100644 --- a/libgimpwidgets/gimpcellrenderercolor.c +++ b/libgimpwidgets/gimpcellrenderercolor.c @@ -89,8 +89,8 @@ static void gimp_cell_renderer_color_render (GtkCellRenderer *cell, -G_DEFINE_TYPE (GimpCellRendererColor, gimp_cell_renderer_color, - GTK_TYPE_CELL_RENDERER) +G_DEFINE_TYPE_WITH_PRIVATE (GimpCellRendererColor, gimp_cell_renderer_color, + GTK_TYPE_CELL_RENDERER) #define parent_class gimp_cell_renderer_color_parent_class @@ -130,16 +130,12 @@ gimp_cell_renderer_color_class_init (GimpCellRendererColorClass *klass) DEFAULT_ICON_SIZE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); - - g_type_class_add_private (object_class, sizeof (GimpCellRendererColorPrivate)); } static void gimp_cell_renderer_color_init (GimpCellRendererColor *cell) { - cell->priv = G_TYPE_INSTANCE_GET_PRIVATE (cell, - GIMP_TYPE_CELL_RENDERER_COLOR, - GimpCellRendererColorPrivate); + cell->priv = gimp_cell_renderer_color_get_instance_private (cell); gimp_rgba_set (&cell->priv->color, 0.0, 0.0, 0.0, 1.0); } diff --git a/libgimpwidgets/gimpcellrenderertoggle.c b/libgimpwidgets/gimpcellrenderertoggle.c index 21febd6b8e..21032adeca 100644 --- a/libgimpwidgets/gimpcellrenderertoggle.c +++ b/libgimpwidgets/gimpcellrenderertoggle.c @@ -102,8 +102,8 @@ static void gimp_cell_renderer_toggle_create_pixbuf (GimpCellRendererToggle *tog GtkWidget *widget); -G_DEFINE_TYPE (GimpCellRendererToggle, gimp_cell_renderer_toggle, - GTK_TYPE_CELL_RENDERER_TOGGLE) +G_DEFINE_TYPE_WITH_PRIVATE (GimpCellRendererToggle, gimp_cell_renderer_toggle, + GTK_TYPE_CELL_RENDERER_TOGGLE) #define parent_class gimp_cell_renderer_toggle_parent_class @@ -159,16 +159,12 @@ gimp_cell_renderer_toggle_class_init (GimpCellRendererToggleClass *klass) FALSE, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); - - g_type_class_add_private (object_class, sizeof (GimpCellRendererTogglePrivate)); } static void gimp_cell_renderer_toggle_init (GimpCellRendererToggle *toggle) { - toggle->priv = G_TYPE_INSTANCE_GET_PRIVATE (toggle, - GIMP_TYPE_CELL_RENDERER_TOGGLE, - GimpCellRendererTogglePrivate); + toggle->priv = gimp_cell_renderer_toggle_get_instance_private (toggle); } static void diff --git a/libgimpwidgets/gimpchainbutton.c b/libgimpwidgets/gimpchainbutton.c index 1b00fd3f73..09adc239cd 100644 --- a/libgimpwidgets/gimpchainbutton.c +++ b/libgimpwidgets/gimpchainbutton.c @@ -96,7 +96,7 @@ static GtkWidget * gimp_chain_line_new (GimpChainPosition position, gint which); -G_DEFINE_TYPE (GimpChainButton, gimp_chain_button, GTK_TYPE_GRID) +G_DEFINE_TYPE_WITH_PRIVATE (GimpChainButton, gimp_chain_button, GTK_TYPE_GRID) #define parent_class gimp_chain_button_parent_class @@ -146,8 +146,6 @@ gimp_chain_button_class_init (GimpChainButtonClass *klass) GIMP_CHAIN_TOP, G_PARAM_CONSTRUCT_ONLY | GIMP_PARAM_READWRITE)); - - g_type_class_add_private (object_class, sizeof (GimpChainButtonPrivate)); } static void @@ -155,9 +153,7 @@ gimp_chain_button_init (GimpChainButton *button) { GimpChainButtonPrivate *private = GET_PRIVATE (button); - button->priv = G_TYPE_INSTANCE_GET_PRIVATE (button, - GIMP_TYPE_CHAIN_BUTTON, - GimpChainButtonPrivate); + button->priv = gimp_chain_button_get_instance_private (button); private = GET_PRIVATE (button); diff --git a/libgimpwidgets/gimpcolorarea.c b/libgimpwidgets/gimpcolorarea.c index 003049673d..062be74f0c 100644 --- a/libgimpwidgets/gimpcolorarea.c +++ b/libgimpwidgets/gimpcolorarea.c @@ -129,7 +129,8 @@ static void gimp_color_area_create_transform (GimpColorArea *area); static void gimp_color_area_destroy_transform (GimpColorArea *area); -G_DEFINE_TYPE (GimpColorArea, gimp_color_area, GTK_TYPE_DRAWING_AREA) +G_DEFINE_TYPE_WITH_PRIVATE (GimpColorArea, gimp_color_area, + GTK_TYPE_DRAWING_AREA) #define parent_class gimp_color_area_parent_class @@ -228,8 +229,6 @@ gimp_color_area_class_init (GimpColorAreaClass *klass) "Whether to draw a thin border in the foreground color around the area", FALSE, GIMP_PARAM_READWRITE)); - - g_type_class_add_private (object_class, sizeof (GimpColorAreaPrivate)); } static void @@ -237,9 +236,7 @@ gimp_color_area_init (GimpColorArea *area) { GimpColorAreaPrivate *priv; - area->priv = G_TYPE_INSTANCE_GET_PRIVATE (area, - GIMP_TYPE_COLOR_AREA, - GimpColorAreaPrivate); + area->priv = gimp_color_area_get_instance_private (area); priv = GET_PRIVATE (area); diff --git a/libgimpwidgets/gimpcolordisplay.c b/libgimpwidgets/gimpcolordisplay.c index fd40a2544f..9e11eef77c 100644 --- a/libgimpwidgets/gimpcolordisplay.c +++ b/libgimpwidgets/gimpcolordisplay.c @@ -91,6 +91,8 @@ static void gimp_color_display_set_color_managed (GimpColorDisplay *display, G_DEFINE_TYPE_WITH_CODE (GimpColorDisplay, gimp_color_display, G_TYPE_OBJECT, + G_ADD_PRIVATE (GimpColorDisplay) + G_ADD_PRIVATE (GimpColorDisplay) G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONFIG, NULL)) #define parent_class gimp_color_display_parent_class @@ -149,16 +151,12 @@ gimp_color_display_class_init (GimpColorDisplayClass *klass) klass->configure = NULL; klass->changed = NULL; - - g_type_class_add_private (object_class, sizeof (GimpColorDisplayPrivate)); } static void gimp_color_display_init (GimpColorDisplay *display) { - display->priv = G_TYPE_INSTANCE_GET_PRIVATE (display, - GIMP_TYPE_COLOR_DISPLAY, - GimpColorDisplayPrivate); + display->priv = gimp_color_display_get_instance_private (display); } static void diff --git a/libgimpwidgets/gimpcolordisplaystack.c b/libgimpwidgets/gimpcolordisplaystack.c index 9372a1e600..d50bdfdbab 100644 --- a/libgimpwidgets/gimpcolordisplaystack.c +++ b/libgimpwidgets/gimpcolordisplaystack.c @@ -72,7 +72,8 @@ static void gimp_color_display_stack_disconnect (GimpColorDisplayStack *s GimpColorDisplay *display); -G_DEFINE_TYPE (GimpColorDisplayStack, gimp_color_display_stack, G_TYPE_OBJECT) +G_DEFINE_TYPE_WITH_PRIVATE (GimpColorDisplayStack, gimp_color_display_stack, + G_TYPE_OBJECT) #define parent_class gimp_color_display_stack_parent_class @@ -131,16 +132,12 @@ gimp_color_display_stack_class_init (GimpColorDisplayStackClass *klass) klass->added = NULL; klass->removed = NULL; klass->reordered = NULL; - - g_type_class_add_private (object_class, sizeof (GimpColorDisplayStackPrivate)); } static void gimp_color_display_stack_init (GimpColorDisplayStack *stack) { - stack->priv = G_TYPE_INSTANCE_GET_PRIVATE (stack, - GIMP_TYPE_COLOR_DISPLAY_STACK, - GimpColorDisplayStackPrivate); + stack->priv = gimp_color_display_stack_get_instance_private (stack); } static void diff --git a/libgimpwidgets/gimpcolorhexentry.c b/libgimpwidgets/gimpcolorhexentry.c index 7e07d90bb4..c4621d0e7c 100644 --- a/libgimpwidgets/gimpcolorhexentry.c +++ b/libgimpwidgets/gimpcolorhexentry.c @@ -83,7 +83,8 @@ static gboolean gimp_color_hex_entry_matched (GtkEntryCompletion *completio GimpColorHexEntry *entry); -G_DEFINE_TYPE (GimpColorHexEntry, gimp_color_hex_entry, GTK_TYPE_ENTRY) +G_DEFINE_TYPE_WITH_PRIVATE (GimpColorHexEntry, gimp_color_hex_entry, + GTK_TYPE_ENTRY) #define parent_class gimp_color_hex_entry_parent_class @@ -107,8 +108,6 @@ gimp_color_hex_entry_class_init (GimpColorHexEntryClass *klass) object_class->constructed = gimp_color_hex_entry_constructed; klass->color_changed = NULL; - - g_type_class_add_private (object_class, sizeof (GimpColorHexEntryPrivate)); } static void @@ -123,9 +122,7 @@ gimp_color_hex_entry_init (GimpColorHexEntry *entry) gint num_colors; gint i; - entry->priv = G_TYPE_INSTANCE_GET_PRIVATE (entry, - GIMP_TYPE_COLOR_HEX_ENTRY, - GimpColorHexEntryPrivate); + entry->priv = gimp_color_hex_entry_get_instance_private (entry); private = GET_PRIVATE (entry); diff --git a/libgimpwidgets/gimpcolornotebook.c b/libgimpwidgets/gimpcolornotebook.c index 1d9b99b00b..d6f08105ca 100644 --- a/libgimpwidgets/gimpcolornotebook.c +++ b/libgimpwidgets/gimpcolornotebook.c @@ -110,8 +110,8 @@ static void gimp_color_notebook_remove_selector (GtkContainer *container, GimpColorNotebook *notebook); -G_DEFINE_TYPE (GimpColorNotebook, gimp_color_notebook, - GIMP_TYPE_COLOR_SELECTOR) +G_DEFINE_TYPE_WITH_PRIVATE (GimpColorNotebook, gimp_color_notebook, + GIMP_TYPE_COLOR_SELECTOR) #define parent_class gimp_color_notebook_parent_class @@ -119,7 +119,6 @@ G_DEFINE_TYPE (GimpColorNotebook, gimp_color_notebook, static void gimp_color_notebook_class_init (GimpColorNotebookClass *klass) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); GimpColorSelectorClass *selector_class = GIMP_COLOR_SELECTOR_CLASS (klass); @@ -144,8 +143,6 @@ gimp_color_notebook_class_init (GimpColorNotebookClass *klass) G_PARAM_READABLE)); gtk_widget_class_set_css_name (widget_class, "GimpColorNotebook"); - - g_type_class_add_private (object_class, sizeof (GimpColorNotebookPrivate)); } static void @@ -156,9 +153,7 @@ gimp_color_notebook_init (GimpColorNotebook *notebook) guint n_selector_types; guint i; - notebook->priv = G_TYPE_INSTANCE_GET_PRIVATE (notebook, - GIMP_TYPE_COLOR_NOTEBOOK, - GimpColorNotebookPrivate); + notebook->priv = gimp_color_notebook_get_instance_private (notebook); private = notebook->priv; diff --git a/libgimpwidgets/gimpcolorprofilechooserdialog.c b/libgimpwidgets/gimpcolorprofilechooserdialog.c index d238d2c3fa..1794e7f9e4 100644 --- a/libgimpwidgets/gimpcolorprofilechooserdialog.c +++ b/libgimpwidgets/gimpcolorprofilechooserdialog.c @@ -56,8 +56,9 @@ static void gimp_color_profile_chooser_dialog_add_shortcut (GimpColorProfi static void gimp_color_profile_chooser_dialog_update_preview (GimpColorProfileChooserDialog *dialog); -G_DEFINE_TYPE (GimpColorProfileChooserDialog, gimp_color_profile_chooser_dialog, - GTK_TYPE_FILE_CHOOSER_DIALOG); +G_DEFINE_TYPE_WITH_PRIVATE (GimpColorProfileChooserDialog, + gimp_color_profile_chooser_dialog, + GTK_TYPE_FILE_CHOOSER_DIALOG) #define parent_class gimp_color_profile_chooser_dialog_parent_class @@ -71,17 +72,13 @@ gimp_color_profile_chooser_dialog_class_init (GimpColorProfileChooserDialogClass object_class->constructed = gimp_color_profile_chooser_dialog_constructed; widget_class->delete_event = gimp_color_profile_chooser_dialog_delete_event; - - g_type_class_add_private (klass, sizeof (GimpColorProfileChooserDialogPrivate)); } static void gimp_color_profile_chooser_dialog_init (GimpColorProfileChooserDialog *dialog) { dialog->priv = - G_TYPE_INSTANCE_GET_PRIVATE (dialog, - GIMP_TYPE_COLOR_PROFILE_CHOOSER_DIALOG, - GimpColorProfileChooserDialogPrivate); + gimp_color_profile_chooser_dialog_get_instance_private (dialog); } static void diff --git a/libgimpwidgets/gimpcolorprofilecombobox.c b/libgimpwidgets/gimpcolorprofilecombobox.c index 68ac6a5c02..fa6de162f8 100644 --- a/libgimpwidgets/gimpcolorprofilecombobox.c +++ b/libgimpwidgets/gimpcolorprofilecombobox.c @@ -80,8 +80,8 @@ static void gimp_color_profile_combo_dialog_response (GimpColorProfileChooserD GimpColorProfileComboBox *combo); -G_DEFINE_TYPE (GimpColorProfileComboBox, - gimp_color_profile_combo_box, GTK_TYPE_COMBO_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpColorProfileComboBox, + gimp_color_profile_combo_box, GTK_TYPE_COMBO_BOX) #define parent_class gimp_color_profile_combo_box_parent_class @@ -130,9 +130,6 @@ gimp_color_profile_combo_box_class_init (GimpColorProfileComboBoxClass *klass) "The profile store used for this combo box", GIMP_TYPE_COLOR_PROFILE_STORE, GIMP_PARAM_READWRITE)); - - g_type_class_add_private (object_class, - sizeof (GimpColorProfileComboBoxPrivate)); } static void @@ -140,9 +137,7 @@ gimp_color_profile_combo_box_init (GimpColorProfileComboBox *combo_box) { GtkCellRenderer *cell; - combo_box->priv = G_TYPE_INSTANCE_GET_PRIVATE (combo_box, - GIMP_TYPE_COLOR_PROFILE_COMBO_BOX, - GimpColorProfileComboBoxPrivate); + combo_box->priv = gimp_color_profile_combo_box_get_instance_private (combo_box); cell = gtk_cell_renderer_text_new (); diff --git a/libgimpwidgets/gimpcolorprofilestore.c b/libgimpwidgets/gimpcolorprofilestore.c index 4aa65b6f6e..af33b21d38 100644 --- a/libgimpwidgets/gimpcolorprofilestore.c +++ b/libgimpwidgets/gimpcolorprofilestore.c @@ -90,8 +90,8 @@ static gboolean gimp_color_profile_store_load (GimpColorProfileStore GError **error); -G_DEFINE_TYPE (GimpColorProfileStore, - gimp_color_profile_store, GTK_TYPE_LIST_STORE) +G_DEFINE_TYPE_WITH_PRIVATE (GimpColorProfileStore, gimp_color_profile_store, + GTK_TYPE_LIST_STORE) #define parent_class gimp_color_profile_store_parent_class @@ -122,8 +122,6 @@ gimp_color_profile_store_class_init (GimpColorProfileStoreClass *klass) NULL, G_PARAM_CONSTRUCT_ONLY | GIMP_PARAM_READWRITE)); - - g_type_class_add_private (object_class, sizeof (GimpColorProfileStorePrivate)); } static void @@ -137,9 +135,7 @@ gimp_color_profile_store_init (GimpColorProfileStore *store) G_TYPE_INT /* GIMP_COLOR_PROFILE_STORE_INDEX */ }; - store->priv = G_TYPE_INSTANCE_GET_PRIVATE (store, - GIMP_TYPE_COLOR_PROFILE_STORE, - GimpColorProfileStorePrivate); + store->priv = gimp_color_profile_store_get_instance_private (store); gtk_list_store_set_column_types (GTK_LIST_STORE (store), G_N_ELEMENTS (types), types); diff --git a/libgimpwidgets/gimpcolorprofileview.c b/libgimpwidgets/gimpcolorprofileview.c index 979b515590..8ee2308cf7 100644 --- a/libgimpwidgets/gimpcolorprofileview.c +++ b/libgimpwidgets/gimpcolorprofileview.c @@ -44,8 +44,8 @@ static void gimp_color_profile_view_constructed (GObject *object); static void gimp_color_profile_view_finalize (GObject *object); -G_DEFINE_TYPE (GimpColorProfileView, gimp_color_profile_view, - GTK_TYPE_TEXT_VIEW); +G_DEFINE_TYPE_WITH_PRIVATE (GimpColorProfileView, gimp_color_profile_view, + GTK_TYPE_TEXT_VIEW) #define parent_class gimp_color_profile_view_parent_class @@ -57,16 +57,12 @@ gimp_color_profile_view_class_init (GimpColorProfileViewClass *klass) object_class->constructed = gimp_color_profile_view_constructed; object_class->finalize = gimp_color_profile_view_finalize; - - g_type_class_add_private (klass, sizeof (GimpColorProfileViewPrivate)); } static void gimp_color_profile_view_init (GimpColorProfileView *view) { - view->priv = G_TYPE_INSTANCE_GET_PRIVATE (view, - GIMP_TYPE_COLOR_PROFILE_VIEW, - GimpColorProfileViewPrivate); + view->priv = gimp_color_profile_view_get_instance_private (view); } static void diff --git a/libgimpwidgets/gimpcolorscale.c b/libgimpwidgets/gimpcolorscale.c index 3404056f0b..7bcd09e54b 100644 --- a/libgimpwidgets/gimpcolorscale.c +++ b/libgimpwidgets/gimpcolorscale.c @@ -109,7 +109,7 @@ static void gimp_color_scale_notify_config (GimpColorConfig *config, GimpColorScale *scale); -G_DEFINE_TYPE (GimpColorScale, gimp_color_scale, GTK_TYPE_SCALE) +G_DEFINE_TYPE_WITH_PRIVATE (GimpColorScale, gimp_color_scale, GTK_TYPE_SCALE) #define parent_class gimp_color_scale_parent_class @@ -149,8 +149,6 @@ gimp_color_scale_class_init (GimpColorScaleClass *klass) gtk_widget_class_set_css_name (widget_class, "GimpColorScale"); - g_type_class_add_private (object_class, sizeof (GimpColorScalePrivate)); - fish_rgb_to_lch = babl_fish (babl_format ("R'G'B'A double"), babl_format ("CIE LCH(ab) double")); fish_lch_to_rgb = babl_fish (babl_format ("CIE LCH(ab) double"), @@ -164,9 +162,7 @@ gimp_color_scale_init (GimpColorScale *scale) GtkRange *range = GTK_RANGE (scale); GtkCssProvider *css; - scale->priv = G_TYPE_INSTANCE_GET_PRIVATE (scale, - GIMP_TYPE_COLOR_SCALE, - GimpColorScalePrivate); + scale->priv = gimp_color_scale_get_instance_private (scale); priv = scale->priv; diff --git a/libgimpwidgets/gimpcolorselection.c b/libgimpwidgets/gimpcolorselection.c index e7a2991d03..a6865a7759 100644 --- a/libgimpwidgets/gimpcolorselection.c +++ b/libgimpwidgets/gimpcolorselection.c @@ -135,7 +135,8 @@ static void gimp_color_selection_update (GimpColorSelection *select UpdateType update); -G_DEFINE_TYPE (GimpColorSelection, gimp_color_selection, GTK_TYPE_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpColorSelection, gimp_color_selection, + GTK_TYPE_BOX) #define parent_class gimp_color_selection_parent_class @@ -168,8 +169,6 @@ gimp_color_selection_class_init (GimpColorSelectionClass *klass) G_TYPE_NONE, 0); gtk_widget_class_set_css_name (GTK_WIDGET_CLASS (klass), "GimpColorSelection"); - - g_type_class_add_private (object_class, sizeof (GimpColorSelectionPrivate)); } static void @@ -186,9 +185,7 @@ gimp_color_selection_init (GimpColorSelection *selection) GtkSizeGroup *new_group; GtkSizeGroup *old_group; - selection->priv = G_TYPE_INSTANCE_GET_PRIVATE (selection, - GIMP_TYPE_COLOR_SELECTION, - GimpColorSelectionPrivate); + selection->priv = gimp_color_selection_get_instance_private (selection); priv = selection->priv; diff --git a/libgimpwidgets/gimpcolorselector.c b/libgimpwidgets/gimpcolorselector.c index 8172b9bb87..d107c8d6f7 100644 --- a/libgimpwidgets/gimpcolorselector.c +++ b/libgimpwidgets/gimpcolorselector.c @@ -69,7 +69,8 @@ struct _GimpColorSelectorPrivate static void gimp_color_selector_dispose (GObject *object); -G_DEFINE_TYPE (GimpColorSelector, gimp_color_selector, GTK_TYPE_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpColorSelector, gimp_color_selector, + GTK_TYPE_BOX) #define parent_class gimp_color_selector_parent_class @@ -129,8 +130,6 @@ gimp_color_selector_class_init (GimpColorSelectorClass *klass) klass->channel_changed = NULL; klass->model_visible_changed = NULL; klass->set_config = NULL; - - g_type_class_add_private (object_class, sizeof (GimpColorSelectorPrivate)); } static void @@ -138,9 +137,7 @@ gimp_color_selector_init (GimpColorSelector *selector) { GimpColorSelectorPrivate *priv; - selector->priv = G_TYPE_INSTANCE_GET_PRIVATE (selector, - GIMP_TYPE_COLOR_SELECTOR, - GimpColorSelectorPrivate); + selector->priv = gimp_color_selector_get_instance_private (selector); priv = GET_PRIVATE (selector); diff --git a/libgimpwidgets/gimpdialog.c b/libgimpwidgets/gimpdialog.c index 70c66cab19..c1457d2342 100644 --- a/libgimpwidgets/gimpdialog.c +++ b/libgimpwidgets/gimpdialog.c @@ -83,7 +83,7 @@ static void gimp_dialog_response (GtkDialog *dialog, gint response_id); -G_DEFINE_TYPE (GimpDialog, gimp_dialog, GTK_TYPE_DIALOG) +G_DEFINE_TYPE_WITH_PRIVATE (GimpDialog, gimp_dialog, GTK_TYPE_DIALOG) #define parent_class gimp_dialog_parent_class @@ -145,16 +145,12 @@ gimp_dialog_class_init (GimpDialogClass *klass) GTK_TYPE_WIDGET, GIMP_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY)); - - g_type_class_add_private (klass, sizeof (GimpDialogPrivate)); } static void gimp_dialog_init (GimpDialog *dialog) { - dialog->priv = G_TYPE_INSTANCE_GET_PRIVATE (dialog, - GIMP_TYPE_DIALOG, - GimpDialogPrivate); + dialog->priv = gimp_dialog_get_instance_private (dialog); g_signal_connect (dialog, "response", G_CALLBACK (gimp_dialog_response), diff --git a/libgimpwidgets/gimpenumlabel.c b/libgimpwidgets/gimpenumlabel.c index 979fd97616..332e25a309 100644 --- a/libgimpwidgets/gimpenumlabel.c +++ b/libgimpwidgets/gimpenumlabel.c @@ -66,7 +66,7 @@ static void gimp_enum_label_set_property (GObject *object, GParamSpec *pspec); -G_DEFINE_TYPE (GimpEnumLabel, gimp_enum_label, GTK_TYPE_LABEL) +G_DEFINE_TYPE_WITH_PRIVATE (GimpEnumLabel, gimp_enum_label, GTK_TYPE_LABEL) #define parent_class gimp_enum_label_parent_class @@ -109,16 +109,12 @@ gimp_enum_label_class_init (GimpEnumLabelClass *klass) G_MININT, G_MAXINT, 0, GIMP_PARAM_WRITABLE | G_PARAM_CONSTRUCT)); - - g_type_class_add_private (object_class, sizeof (GimpEnumLabelPrivate)); } static void gimp_enum_label_init (GimpEnumLabel *enum_label) { - enum_label->priv = G_TYPE_INSTANCE_GET_PRIVATE (enum_label, - GIMP_TYPE_ENUM_LABEL, - GimpEnumLabelPrivate); + enum_label->priv = gimp_enum_label_get_instance_private (enum_label); } static void diff --git a/libgimpwidgets/gimpenumstore.c b/libgimpwidgets/gimpenumstore.c index c5b86ff797..8751076872 100644 --- a/libgimpwidgets/gimpenumstore.c +++ b/libgimpwidgets/gimpenumstore.c @@ -68,7 +68,7 @@ static void gimp_enum_store_add_value (GtkListStore *store, GEnumValue *value); -G_DEFINE_TYPE (GimpEnumStore, gimp_enum_store, GIMP_TYPE_INT_STORE) +G_DEFINE_TYPE_WITH_PRIVATE (GimpEnumStore, gimp_enum_store, GIMP_TYPE_INT_STORE) #define parent_class gimp_enum_store_parent_class @@ -97,16 +97,12 @@ gimp_enum_store_class_init (GimpEnumStoreClass *klass) G_TYPE_ENUM, G_PARAM_CONSTRUCT_ONLY | GIMP_PARAM_READWRITE)); - - g_type_class_add_private (klass, sizeof (GimpEnumStorePrivate)); } static void gimp_enum_store_init (GimpEnumStore *store) { - store->priv = G_TYPE_INSTANCE_GET_PRIVATE (store, - GIMP_TYPE_ENUM_STORE, - GimpEnumStorePrivate); + store->priv = gimp_enum_store_get_instance_private (store); } static void diff --git a/libgimpwidgets/gimpintcombobox.c b/libgimpwidgets/gimpintcombobox.c index b93e3593eb..ec80b6be38 100644 --- a/libgimpwidgets/gimpintcombobox.c +++ b/libgimpwidgets/gimpintcombobox.c @@ -85,7 +85,8 @@ static void gimp_int_combo_box_data_func (GtkCellLayout *layout, gpointer data); -G_DEFINE_TYPE (GimpIntComboBox, gimp_int_combo_box, GTK_TYPE_COMBO_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpIntComboBox, gimp_int_combo_box, + GTK_TYPE_COMBO_BOX) #define parent_class gimp_int_combo_box_parent_class @@ -145,8 +146,6 @@ gimp_int_combo_box_class_init (GimpIntComboBoxClass *klass) GIMP_TYPE_INT_COMBO_BOX_LAYOUT, GIMP_INT_COMBO_BOX_LAYOUT_ABBREVIATED, GIMP_PARAM_READWRITE)); - - g_type_class_add_private (object_class, sizeof (GimpIntComboBoxPrivate)); } static void @@ -155,9 +154,7 @@ gimp_int_combo_box_init (GimpIntComboBox *combo_box) GimpIntComboBoxPrivate *priv; GtkListStore *store; - combo_box->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE (combo_box, - GIMP_TYPE_INT_COMBO_BOX, - GimpIntComboBoxPrivate); + combo_box->priv = priv = gimp_int_combo_box_get_instance_private (combo_box); store = gimp_int_store_new (); gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (store)); diff --git a/libgimpwidgets/gimpintstore.c b/libgimpwidgets/gimpintstore.c index a0fcea2b3f..090296592f 100644 --- a/libgimpwidgets/gimpintstore.c +++ b/libgimpwidgets/gimpintstore.c @@ -80,6 +80,7 @@ static void gimp_int_store_add_empty (GimpIntStore *store); G_DEFINE_TYPE_WITH_CODE (GimpIntStore, gimp_int_store, GTK_TYPE_LIST_STORE, + G_ADD_PRIVATE (GimpIntStore) G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL, gimp_int_store_tree_model_init)) @@ -117,8 +118,6 @@ gimp_int_store_class_init (GimpIntStoreClass *klass) G_TYPE_NONE, G_PARAM_CONSTRUCT_ONLY | GIMP_PARAM_READWRITE)); - - g_type_class_add_private (object_class, sizeof (GimpIntStorePrivate)); } static void @@ -133,9 +132,7 @@ gimp_int_store_tree_model_init (GtkTreeModelIface *iface) static void gimp_int_store_init (GimpIntStore *store) { - store->priv = G_TYPE_INSTANCE_GET_PRIVATE (store, - GIMP_TYPE_INT_STORE, - GimpIntStorePrivate); + store->priv = gimp_int_store_get_instance_private (store); } static void diff --git a/libgimpwidgets/gimpmemsizeentry.c b/libgimpwidgets/gimpmemsizeentry.c index edc100d97f..e541ceb048 100644 --- a/libgimpwidgets/gimpmemsizeentry.c +++ b/libgimpwidgets/gimpmemsizeentry.c @@ -74,7 +74,7 @@ static void gimp_memsize_entry_unit_callback (GtkWidget *widget, GimpMemsizeEntry *entry); -G_DEFINE_TYPE (GimpMemsizeEntry, gimp_memsize_entry, GTK_TYPE_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpMemsizeEntry, gimp_memsize_entry, GTK_TYPE_BOX) #define parent_class gimp_memsize_entry_parent_class @@ -84,9 +84,7 @@ static guint gimp_memsize_entry_signals[LAST_SIGNAL] = { 0 }; static void gimp_memsize_entry_class_init (GimpMemsizeEntryClass *klass) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); - - klass->value_changed = NULL; + klass->value_changed = NULL; gimp_memsize_entry_signals[VALUE_CHANGED] = g_signal_new ("value-changed", @@ -96,16 +94,12 @@ gimp_memsize_entry_class_init (GimpMemsizeEntryClass *klass) NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); - - g_type_class_add_private (object_class, sizeof (GimpMemsizeEntryPrivate)); } static void gimp_memsize_entry_init (GimpMemsizeEntry *entry) { - entry->priv = G_TYPE_INSTANCE_GET_PRIVATE (entry, - GIMP_TYPE_MEMSIZE_ENTRY, - GimpMemsizeEntryPrivate); + entry->priv = gimp_memsize_entry_get_instance_private (entry); gtk_orientable_set_orientation (GTK_ORIENTABLE (entry), GTK_ORIENTATION_HORIZONTAL); diff --git a/libgimpwidgets/gimpnumberpairentry.c b/libgimpwidgets/gimpnumberpairentry.c index c75eb5f4e9..7dc6820bff 100644 --- a/libgimpwidgets/gimpnumberpairentry.c +++ b/libgimpwidgets/gimpnumberpairentry.c @@ -161,7 +161,8 @@ static gchar * gimp_number_pair_entry_strdup_number_pair_string -G_DEFINE_TYPE (GimpNumberPairEntry, gimp_number_pair_entry, GTK_TYPE_ENTRY) +G_DEFINE_TYPE_WITH_PRIVATE (GimpNumberPairEntry, gimp_number_pair_entry, + GTK_TYPE_ENTRY) #define parent_class gimp_number_pair_entry_parent_class @@ -297,8 +298,6 @@ gimp_number_pair_entry_class_init (GimpNumberPairEntryClass *klass) GIMP_TYPE_ASPECT_TYPE, GIMP_ASPECT_SQUARE, GIMP_PARAM_READWRITE)); - - g_type_class_add_private (klass, sizeof (GimpNumberPairEntryPrivate)); } static void @@ -306,9 +305,7 @@ gimp_number_pair_entry_init (GimpNumberPairEntry *entry) { GimpNumberPairEntryPrivate *priv; - entry->priv = G_TYPE_INSTANCE_GET_PRIVATE (entry, - GIMP_TYPE_NUMBER_PAIR_ENTRY, - GimpNumberPairEntryPrivate); + entry->priv = gimp_number_pair_entry_get_instance_private (entry); priv = GET_PRIVATE (entry); diff --git a/libgimpwidgets/gimpoffsetarea.c b/libgimpwidgets/gimpoffsetarea.c index cf8330ab10..8a06fb4031 100644 --- a/libgimpwidgets/gimpoffsetarea.c +++ b/libgimpwidgets/gimpoffsetarea.c @@ -74,7 +74,8 @@ static gboolean gimp_offset_area_draw (GtkWidget *widget, cairo_t *cr); -G_DEFINE_TYPE (GimpOffsetArea, gimp_offset_area, GTK_TYPE_DRAWING_AREA) +G_DEFINE_TYPE_WITH_PRIVATE (GimpOffsetArea, gimp_offset_area, + GTK_TYPE_DRAWING_AREA) #define parent_class gimp_offset_area_parent_class @@ -84,7 +85,6 @@ static guint gimp_offset_area_signals[LAST_SIGNAL] = { 0 }; static void gimp_offset_area_class_init (GimpOffsetAreaClass *klass) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); gimp_offset_area_signals[OFFSETS_CHANGED] = @@ -102,8 +102,6 @@ gimp_offset_area_class_init (GimpOffsetAreaClass *klass) widget_class->realize = gimp_offset_area_realize; widget_class->event = gimp_offset_area_event; widget_class->draw = gimp_offset_area_draw; - - g_type_class_add_private (object_class, sizeof (GimpOffsetAreaPrivate)); } static void @@ -111,9 +109,7 @@ gimp_offset_area_init (GimpOffsetArea *area) { GimpOffsetAreaPrivate *private; - area->priv = G_TYPE_INSTANCE_GET_PRIVATE (area, - GIMP_TYPE_OFFSET_AREA, - GimpOffsetAreaPrivate); + area->priv = gimp_offset_area_get_instance_private (area); private = GET_PRIVATE (area); diff --git a/libgimpwidgets/gimppageselector.c b/libgimpwidgets/gimppageselector.c index 1c1a0bd392..37f2ceab07 100644 --- a/libgimpwidgets/gimppageselector.c +++ b/libgimpwidgets/gimppageselector.c @@ -117,7 +117,7 @@ static GdkPixbuf * gimp_page_selector_add_frame (GtkWidget *widget, GdkPixbuf *pixbuf); -G_DEFINE_TYPE (GimpPageSelector, gimp_page_selector, GTK_TYPE_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpPageSelector, gimp_page_selector, GTK_TYPE_BOX) #define parent_class gimp_page_selector_parent_class @@ -201,8 +201,6 @@ gimp_page_selector_class_init (GimpPageSelectorClass *klass) GIMP_TYPE_PAGE_SELECTOR_TARGET, GIMP_PAGE_SELECTOR_TARGET_LAYERS, GIMP_PARAM_READWRITE)); - - g_type_class_add_private (object_class, sizeof (GimpPageSelectorPrivate)); } static void @@ -218,9 +216,7 @@ gimp_page_selector_init (GimpPageSelector *selector) GtkWidget *combo; GtkCellRenderer *renderer; - selector->priv = G_TYPE_INSTANCE_GET_PRIVATE (selector, - GIMP_TYPE_PAGE_SELECTOR, - GimpPageSelectorPrivate); + selector->priv = gimp_page_selector_get_instance_private (selector); priv = GET_PRIVATE (selector); diff --git a/libgimpwidgets/gimppickbutton.c b/libgimpwidgets/gimppickbutton.c index 7b10466f0d..b4bd5a681b 100644 --- a/libgimpwidgets/gimppickbutton.c +++ b/libgimpwidgets/gimppickbutton.c @@ -63,7 +63,7 @@ static void gimp_pick_button_dispose (GObject *object); static void gimp_pick_button_clicked (GtkButton *button); -G_DEFINE_TYPE (GimpPickButton, gimp_pick_button, GTK_TYPE_BUTTON) +G_DEFINE_TYPE_WITH_PRIVATE (GimpPickButton, gimp_pick_button, GTK_TYPE_BUTTON) #define parent_class gimp_pick_button_parent_class @@ -98,8 +98,6 @@ gimp_pick_button_class_init (GimpPickButtonClass* klass) button_class->clicked = gimp_pick_button_clicked; klass->color_picked = NULL; - - g_type_class_add_private (object_class, sizeof (GimpPickButtonPrivate)); } static void @@ -107,9 +105,7 @@ gimp_pick_button_init (GimpPickButton *button) { GtkWidget *image; - button->priv = G_TYPE_INSTANCE_GET_PRIVATE (button, - GIMP_TYPE_PICK_BUTTON, - GimpPickButtonPrivate); + button->priv = gimp_pick_button_get_instance_private (button); image = gtk_image_new_from_icon_name (GIMP_ICON_COLOR_PICK_FROM_SCREEN, GTK_ICON_SIZE_BUTTON); diff --git a/libgimpwidgets/gimppreview.c b/libgimpwidgets/gimppreview.c index 0d13c9ea62..c722525ec8 100644 --- a/libgimpwidgets/gimppreview.c +++ b/libgimpwidgets/gimppreview.c @@ -126,7 +126,7 @@ static void gimp_preview_real_untransform (GimpPreview *preview, gint *dest_y); -G_DEFINE_ABSTRACT_TYPE (GimpPreview, gimp_preview, GTK_TYPE_BOX) +G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GimpPreview, gimp_preview, GTK_TYPE_BOX) #define parent_class gimp_preview_parent_class @@ -164,8 +164,6 @@ gimp_preview_class_init (GimpPreviewClass *klass) klass->transform = gimp_preview_real_transform; klass->untransform = gimp_preview_real_untransform; - g_type_class_add_private (object_class, sizeof (GimpPreviewPrivate)); - g_object_class_install_property (object_class, PROP_UPDATE, g_param_spec_boolean ("update", @@ -191,9 +189,7 @@ gimp_preview_init (GimpPreview *preview) GtkWidget *frame; gdouble xalign = 0.0; - preview->priv = G_TYPE_INSTANCE_GET_PRIVATE (preview, - GIMP_TYPE_PREVIEW, - GimpPreviewPrivate); + preview->priv = gimp_preview_get_instance_private (preview); priv = preview->priv; diff --git a/libgimpwidgets/gimppreviewarea.c b/libgimpwidgets/gimppreviewarea.c index 2e1db2a4d5..9f9f8d0cb8 100644 --- a/libgimpwidgets/gimppreviewarea.c +++ b/libgimpwidgets/gimppreviewarea.c @@ -109,7 +109,8 @@ static void gimp_preview_area_create_transform (GimpPreviewArea *area); static void gimp_preview_area_destroy_transform (GimpPreviewArea *area); -G_DEFINE_TYPE (GimpPreviewArea, gimp_preview_area, GTK_TYPE_DRAWING_AREA) +G_DEFINE_TYPE_WITH_PRIVATE (GimpPreviewArea, gimp_preview_area, + GTK_TYPE_DRAWING_AREA) #define parent_class gimp_preview_area_parent_class @@ -143,8 +144,6 @@ gimp_preview_area_class_init (GimpPreviewAreaClass *klass) GIMP_TYPE_CHECK_TYPE, DEFAULT_CHECK_TYPE, GIMP_PARAM_READWRITE)); - - g_type_class_add_private (object_class, sizeof (GimpPreviewAreaPrivate)); } static void @@ -152,9 +151,7 @@ gimp_preview_area_init (GimpPreviewArea *area) { GimpPreviewAreaPrivate *priv; - area->priv = G_TYPE_INSTANCE_GET_PRIVATE (area, - GIMP_TYPE_PREVIEW_AREA, - GimpPreviewAreaPrivate); + area->priv = gimp_preview_area_get_instance_private (area); priv = area->priv; diff --git a/libgimpwidgets/gimpruler.c b/libgimpwidgets/gimpruler.c index aff7e1c904..1b34f9290b 100644 --- a/libgimpwidgets/gimpruler.c +++ b/libgimpwidgets/gimpruler.c @@ -153,7 +153,7 @@ static const RulerMetric * gimp_ruler_get_metric (GimpUnit unit); -G_DEFINE_TYPE (GimpRuler, gimp_ruler, GTK_TYPE_WIDGET) +G_DEFINE_TYPE_WITH_PRIVATE (GimpRuler, gimp_ruler, GTK_TYPE_WIDGET) #define parent_class gimp_ruler_parent_class @@ -238,8 +238,6 @@ gimp_ruler_class_init (GimpRulerClass *klass) GIMP_PARAM_READWRITE)); gtk_widget_class_set_css_name (widget_class, "GimpRuler"); - - g_type_class_add_private (object_class, sizeof (GimpRulerPrivate)); } static void @@ -247,9 +245,7 @@ gimp_ruler_init (GimpRuler *ruler) { GimpRulerPrivate *priv; - ruler->priv = G_TYPE_INSTANCE_GET_PRIVATE (ruler, - GIMP_TYPE_RULER, - GimpRulerPrivate); + ruler->priv = gimp_ruler_get_instance_private (ruler); priv = ruler->priv; diff --git a/libgimpwidgets/gimpscrolledpreview.c b/libgimpwidgets/gimpscrolledpreview.c index dbfca8baa4..49ead8a1d3 100644 --- a/libgimpwidgets/gimpscrolledpreview.c +++ b/libgimpwidgets/gimpscrolledpreview.c @@ -98,8 +98,8 @@ static gboolean gimp_scrolled_preview_nav_popup_draw (GtkWidget static void gimp_scrolled_preview_set_cursor (GimpPreview *preview); -G_DEFINE_ABSTRACT_TYPE (GimpScrolledPreview, gimp_scrolled_preview, - GIMP_TYPE_PREVIEW) +G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GimpScrolledPreview, gimp_scrolled_preview, + GIMP_TYPE_PREVIEW) #define parent_class gimp_scrolled_preview_parent_class @@ -115,8 +115,6 @@ gimp_scrolled_preview_class_init (GimpScrolledPreviewClass *klass) object_class->dispose = gimp_scrolled_preview_dispose; preview_class->set_cursor = gimp_scrolled_preview_set_cursor; - - g_type_class_add_private (object_class, sizeof (GimpScrolledPreviewPrivate)); } static void @@ -130,9 +128,7 @@ gimp_scrolled_preview_init (GimpScrolledPreview *preview) gint width; gint height; - preview->priv = G_TYPE_INSTANCE_GET_PRIVATE (preview, - GIMP_TYPE_SCROLLED_PREVIEW, - GimpScrolledPreviewPrivate); + preview->priv = gimp_scrolled_preview_get_instance_private (preview); priv = GET_PRIVATE (preview); diff --git a/libgimpwidgets/gimpsizeentry.c b/libgimpwidgets/gimpsizeentry.c index 69801267a1..d82f5f532e 100644 --- a/libgimpwidgets/gimpsizeentry.c +++ b/libgimpwidgets/gimpsizeentry.c @@ -143,7 +143,7 @@ static gboolean gimp_size_entry_eevl_unit_resolver (const gchar *ident, gpointer data); -G_DEFINE_TYPE (GimpSizeEntry, gimp_size_entry, GTK_TYPE_GRID) +G_DEFINE_TYPE_WITH_PRIVATE (GimpSizeEntry, gimp_size_entry, GTK_TYPE_GRID) #define parent_class gimp_size_entry_parent_class @@ -187,8 +187,6 @@ gimp_size_entry_class_init (GimpSizeEntryClass *klass) klass->value_changed = NULL; klass->refval_changed = NULL; klass->unit_changed = NULL; - - g_type_class_add_private (klass, sizeof (GimpSizeEntryPrivate)); } static void @@ -196,9 +194,7 @@ gimp_size_entry_init (GimpSizeEntry *gse) { GimpSizeEntryPrivate *priv; - gse->priv = G_TYPE_INSTANCE_GET_PRIVATE (gse, - GIMP_TYPE_SIZE_ENTRY, - GimpSizeEntryPrivate); + gse->priv = gimp_size_entry_get_instance_private (gse); priv = gse->priv; diff --git a/libgimpwidgets/gimpstringcombobox.c b/libgimpwidgets/gimpstringcombobox.c index cdd07f754d..a25bc194dc 100644 --- a/libgimpwidgets/gimpstringcombobox.c +++ b/libgimpwidgets/gimpstringcombobox.c @@ -69,7 +69,8 @@ static void gimp_string_combo_box_get_property (GObject *object, GParamSpec *pspec); -G_DEFINE_TYPE (GimpStringComboBox, gimp_string_combo_box, GTK_TYPE_COMBO_BOX) +G_DEFINE_TYPE_WITH_PRIVATE (GimpStringComboBox, gimp_string_combo_box, + GTK_TYPE_COMBO_BOX) #define parent_class gimp_string_combo_box_parent_class @@ -135,16 +136,12 @@ gimp_string_combo_box_class_init (GimpStringComboBoxClass *klass) PANGO_TYPE_ELLIPSIZE_MODE, PANGO_ELLIPSIZE_NONE, GIMP_PARAM_READWRITE)); - - g_type_class_add_private (object_class, sizeof (GimpStringComboBoxPrivate)); } static void gimp_string_combo_box_init (GimpStringComboBox *combo_box) { - combo_box->priv = G_TYPE_INSTANCE_GET_PRIVATE (combo_box, - GIMP_TYPE_STRING_COMBO_BOX, - GimpStringComboBoxPrivate); + combo_box->priv = gimp_string_combo_box_get_instance_private (combo_box); } static void diff --git a/libgimpwidgets/gimpunitstore.c b/libgimpwidgets/gimpunitstore.c index 084f806a27..b5be8aa90d 100644 --- a/libgimpwidgets/gimpunitstore.c +++ b/libgimpwidgets/gimpunitstore.c @@ -102,6 +102,7 @@ static gboolean gimp_unit_store_iter_parent (GtkTreeModel *tree_model, G_DEFINE_TYPE_WITH_CODE (GimpUnitStore, gimp_unit_store, G_TYPE_OBJECT, + G_ADD_PRIVATE (GimpUnitStore) G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL, gimp_unit_store_tree_model_init)) @@ -169,8 +170,6 @@ gimp_unit_store_class_init (GimpUnitStoreClass *klass) "Format string for a long label", "%p", GIMP_PARAM_READWRITE)); - - g_type_class_add_private (object_class, sizeof (GimpUnitStorePrivate)); } static void @@ -178,9 +177,7 @@ gimp_unit_store_init (GimpUnitStore *store) { GimpUnitStorePrivate *private; - store->priv = G_TYPE_INSTANCE_GET_PRIVATE (store, - GIMP_TYPE_UNIT_STORE, - GimpUnitStorePrivate); + store->priv = gimp_unit_store_get_instance_private (store); private = store->priv; diff --git a/libgimpwidgets/gimpzoommodel.c b/libgimpwidgets/gimpzoommodel.c index c0c45d3a60..00360815d3 100644 --- a/libgimpwidgets/gimpzoommodel.c +++ b/libgimpwidgets/gimpzoommodel.c @@ -84,7 +84,7 @@ static void gimp_zoom_model_get_property (GObject *object, static guint zoom_model_signals[LAST_SIGNAL] = { 0, }; -G_DEFINE_TYPE (GimpZoomModel, gimp_zoom_model, G_TYPE_OBJECT) +G_DEFINE_TYPE_WITH_PRIVATE (GimpZoomModel, gimp_zoom_model, G_TYPE_OBJECT) #define parent_class gimp_zoom_model_parent_class @@ -175,8 +175,6 @@ gimp_zoom_model_class_init (GimpZoomModelClass *klass) "The zoom factor expressed as a percentage", "100%", GIMP_PARAM_READABLE)); - - g_type_class_add_private (object_class, sizeof (GimpZoomModelPrivate)); } static void @@ -184,9 +182,7 @@ gimp_zoom_model_init (GimpZoomModel *model) { GimpZoomModelPrivate *priv; - model->priv = G_TYPE_INSTANCE_GET_PRIVATE (model, - GIMP_TYPE_ZOOM_MODEL, - GimpZoomModelPrivate); + model->priv = gimp_zoom_model_get_instance_private (model); priv = GET_PRIVATE (model); diff --git a/modules/gimpcolorwheel.c b/modules/gimpcolorwheel.c index 62ec9a3925..af8a8d026c 100644 --- a/modules/gimpcolorwheel.c +++ b/modules/gimpcolorwheel.c @@ -131,7 +131,9 @@ static void gimp_color_wheel_destroy_transform (GimpColorWheel *wheel static guint wheel_signals[LAST_SIGNAL]; -G_DEFINE_DYNAMIC_TYPE (GimpColorWheel, gimp_color_wheel, GTK_TYPE_WIDGET) +G_DEFINE_DYNAMIC_TYPE_EXTENDED (GimpColorWheel, gimp_color_wheel, + GTK_TYPE_WIDGET, 0, + G_ADD_PRIVATE_DYNAMIC (GimpColorWheel)) #define parent_class gimp_color_wheel_parent_class @@ -217,8 +219,6 @@ gimp_color_wheel_class_init (GimpColorWheelClass *class) gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, 0, "move", 1, G_TYPE_ENUM, GTK_DIR_LEFT); - - g_type_class_add_private (object_class, sizeof (GimpColorWheelPrivate)); } static void @@ -229,10 +229,7 @@ gimp_color_wheel_class_finalize (GimpColorWheelClass *klass) static void gimp_color_wheel_init (GimpColorWheel *wheel) { - GimpColorWheelPrivate *priv; - - priv = G_TYPE_INSTANCE_GET_PRIVATE (wheel, GIMP_TYPE_COLOR_WHEEL, - GimpColorWheelPrivate); + GimpColorWheelPrivate *priv = gimp_color_wheel_get_instance_private (wheel); wheel->priv = priv;