From 74e7e16ec3349084d04756f1a7e221308db1b975 Mon Sep 17 00:00:00 2001 From: Alx Sa Date: Mon, 29 Jul 2024 01:51:38 +0000 Subject: [PATCH] libgimpwidgets: Convert widgets to final/derived type This patch converts libgimpwidgets with no signals to be final or derived types. The remaining widgets will be converted in a subsequent patch. --- libgimpwidgets/gimpbusybox.c | 16 +- libgimpwidgets/gimpbusybox.h | 36 +- libgimpwidgets/gimpcellrenderercolor.c | 75 +- libgimpwidgets/gimpcellrenderercolor.h | 36 +- .../gimpcolorprofilechooserdialog.c | 31 +- .../gimpcolorprofilechooserdialog.h | 37 +- libgimpwidgets/gimpcolorprofilecombobox.c | 61 +- libgimpwidgets/gimpcolorprofilecombobox.h | 36 +- libgimpwidgets/gimpcolorprofilestore.c | 43 +- libgimpwidgets/gimpcolorprofilestore.h | 35 +- libgimpwidgets/gimpcolorprofileview.c | 14 +- libgimpwidgets/gimpcolorprofileview.h | 36 +- libgimpwidgets/gimpcolorscale.c | 292 ++++---- libgimpwidgets/gimpcolorscale.h | 35 +- libgimpwidgets/gimpenumlabel.c | 35 +- libgimpwidgets/gimpenumlabel.h | 36 +- libgimpwidgets/gimphintbox.c | 26 +- libgimpwidgets/gimphintbox.h | 36 +- libgimpwidgets/gimpintcombobox.c | 49 +- libgimpwidgets/gimpintcombobox.h | 21 +- libgimpwidgets/gimppreviewarea.c | 682 ++++++++---------- libgimpwidgets/gimppreviewarea.h | 36 +- libgimpwidgets/gimpspinbutton.c | 33 +- libgimpwidgets/gimpspinbutton.h | 20 +- libgimpwidgets/gimpspinscale.c | 375 +++++----- libgimpwidgets/gimpspinscale.h | 24 +- libgimpwidgets/gimpstringcombobox.c | 31 +- libgimpwidgets/gimpstringcombobox.h | 21 +- 28 files changed, 866 insertions(+), 1342 deletions(-) diff --git a/libgimpwidgets/gimpbusybox.c b/libgimpwidgets/gimpbusybox.c index fd07311a10..165c0d8c29 100644 --- a/libgimpwidgets/gimpbusybox.c +++ b/libgimpwidgets/gimpbusybox.c @@ -49,8 +49,10 @@ enum }; -struct _GimpBusyBoxPrivate +struct _GimpBusyBox { + GtkBox parent_instance; + GtkLabel *label; }; @@ -67,7 +69,7 @@ static void gimp_busy_box_get_property (GObject *object, GParamSpec *pspec); -G_DEFINE_TYPE_WITH_PRIVATE (GimpBusyBox, gimp_busy_box, GTK_TYPE_BOX) +G_DEFINE_TYPE (GimpBusyBox, gimp_busy_box, GTK_TYPE_BOX) #define parent_class gimp_busy_box_parent_class @@ -105,8 +107,6 @@ gimp_busy_box_init (GimpBusyBox *box) GtkWidget *spinner; GtkWidget *label; - 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); gtk_box_set_spacing (GTK_BOX (box), 8); @@ -119,7 +119,7 @@ gimp_busy_box_init (GimpBusyBox *box) /* the label */ label = gtk_label_new (NULL); - box->priv->label = GTK_LABEL (label); + box->label = GTK_LABEL (label); gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, -1); @@ -138,7 +138,7 @@ gimp_busy_box_set_property (GObject *object, switch (property_id) { case PROP_MESSAGE: - gtk_label_set_text (box->priv->label, g_value_get_string (value)); + gtk_label_set_text (box->label, g_value_get_string (value)); break; default: @@ -158,7 +158,7 @@ gimp_busy_box_get_property (GObject *object, switch (property_id) { case PROP_MESSAGE: - g_value_set_string (value, gtk_label_get_text (box->priv->label)); + g_value_set_string (value, gtk_label_get_text (box->label)); break; default: @@ -228,5 +228,5 @@ gimp_busy_box_get_message (GimpBusyBox *box) { g_return_val_if_fail (GIMP_IS_BUSY_BOX (box), NULL); - return gtk_label_get_text (box->priv->label); + return gtk_label_get_text (box->label); } diff --git a/libgimpwidgets/gimpbusybox.h b/libgimpwidgets/gimpbusybox.h index cf2002855f..814f360372 100644 --- a/libgimpwidgets/gimpbusybox.h +++ b/libgimpwidgets/gimpbusybox.h @@ -28,42 +28,10 @@ G_BEGIN_DECLS -#define GIMP_TYPE_BUSY_BOX (gimp_busy_box_get_type ()) -#define GIMP_BUSY_BOX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_BUSY_BOX, GimpBusyBox)) -#define GIMP_BUSY_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_BUSY_BOX, GimpBusyBoxClass)) -#define GIMP_IS_BUSY_BOX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_BUSY_BOX)) -#define GIMP_IS_BUSY_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_BUSY_BOX)) -#define GIMP_BUSY_BOX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_BUSY_BOX, GimpBusyBoxClass)) +#define GIMP_TYPE_BUSY_BOX (gimp_busy_box_get_type ()) +G_DECLARE_FINAL_TYPE (GimpBusyBox, gimp_busy_box, GIMP, BUSY_BOX, GtkBox) -typedef struct _GimpBusyBoxPrivate GimpBusyBoxPrivate; -typedef struct _GimpBusyBoxClass GimpBusyBoxClass; - -struct _GimpBusyBox -{ - GtkBox parent_instance; - - GimpBusyBoxPrivate *priv; -}; - -struct _GimpBusyBoxClass -{ - GtkBoxClass parent_class; - - /* Padding for future expansion */ - void (* _gimp_reserved1) (void); - void (* _gimp_reserved2) (void); - void (* _gimp_reserved3) (void); - void (* _gimp_reserved4) (void); - void (* _gimp_reserved5) (void); - void (* _gimp_reserved6) (void); - void (* _gimp_reserved7) (void); - void (* _gimp_reserved8) (void); -}; - - -GType gimp_busy_box_get_type (void) G_GNUC_CONST; - GtkWidget * gimp_busy_box_new (const gchar *message); void gimp_busy_box_set_message (GimpBusyBox *box, diff --git a/libgimpwidgets/gimpcellrenderercolor.c b/libgimpwidgets/gimpcellrenderercolor.c index 29369795a0..70867f0e32 100644 --- a/libgimpwidgets/gimpcellrenderercolor.c +++ b/libgimpwidgets/gimpcellrenderercolor.c @@ -54,15 +54,15 @@ enum }; -struct _GimpCellRendererColorPrivate +struct _GimpCellRendererColor { - GeglColor *color; - gboolean opaque; - GtkIconSize size; - gint border; -}; + GtkCellRenderer parent_instance; -#define GET_PRIVATE(obj) (((GimpCellRendererColor *) (obj))->priv) + GeglColor *color; + gboolean opaque; + GtkIconSize size; + gint border; +}; static void gimp_cell_renderer_color_finalize (GObject *object); @@ -90,8 +90,7 @@ static void gimp_cell_renderer_color_render (GtkCellRenderer *cell, -G_DEFINE_TYPE_WITH_PRIVATE (GimpCellRendererColor, gimp_cell_renderer_color, - GTK_TYPE_CELL_RENDERER) +G_DEFINE_TYPE (GimpCellRendererColor, gimp_cell_renderer_color, GTK_TYPE_CELL_RENDERER) #define parent_class gimp_cell_renderer_color_parent_class @@ -138,17 +137,15 @@ gimp_cell_renderer_color_class_init (GimpCellRendererColorClass *klass) static void gimp_cell_renderer_color_init (GimpCellRendererColor *cell) { - cell->priv = gimp_cell_renderer_color_get_instance_private (cell); - - cell->priv->color = gegl_color_new ("black"); + cell->color = gegl_color_new ("black"); } static void gimp_cell_renderer_color_finalize (GObject *object) { - GimpCellRendererColorPrivate *private = GET_PRIVATE (object); + GimpCellRendererColor *renderer = GIMP_CELL_RENDERER_COLOR (object); - g_clear_object (&private->color); + g_clear_object (&renderer->color); G_OBJECT_CLASS (parent_class)->finalize (object); } @@ -159,19 +156,19 @@ gimp_cell_renderer_color_get_property (GObject *object, GValue *value, GParamSpec *pspec) { - GimpCellRendererColorPrivate *private = GET_PRIVATE (object); + GimpCellRendererColor *renderer = GIMP_CELL_RENDERER_COLOR (object); switch (param_id) { case PROP_COLOR: - g_clear_object (&private->color); - private->color = gegl_color_duplicate (g_value_get_object (value)); + g_clear_object (&renderer->color); + renderer->color = gegl_color_duplicate (g_value_get_object (value)); break; case PROP_OPAQUE: - g_value_set_boolean (value, private->opaque); + g_value_set_boolean (value, renderer->opaque); break; case PROP_SIZE: - g_value_set_int (value, private->size); + g_value_set_int (value, renderer->size); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); @@ -185,18 +182,18 @@ gimp_cell_renderer_color_set_property (GObject *object, const GValue *value, GParamSpec *pspec) { - GimpCellRendererColorPrivate *private = GET_PRIVATE (object); + GimpCellRendererColor *renderer = GIMP_CELL_RENDERER_COLOR (object); switch (param_id) { case PROP_COLOR: - g_set_object (&private->color, g_value_get_object (value)); + g_set_object (&renderer->color, g_value_get_object (value)); break; case PROP_OPAQUE: - private->opaque = g_value_get_boolean (value); + renderer->opaque = g_value_get_boolean (value); break; case PROP_SIZE: - private->size = g_value_get_int (value); + renderer->size = g_value_get_int (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); @@ -213,15 +210,15 @@ gimp_cell_renderer_color_get_size (GtkCellRenderer *cell, gint *width, gint *height) { - GimpCellRendererColorPrivate *private = GET_PRIVATE (cell); - gint calc_width; - gint calc_height; - gfloat xalign; - gfloat yalign; - gint xpad; - gint ypad; + GimpCellRendererColor *renderer = GIMP_CELL_RENDERER_COLOR (cell); + gint calc_width; + gint calc_height; + gfloat xalign; + gfloat yalign; + gint xpad; + gint ypad; - gtk_icon_size_lookup (private->size, &calc_width, &calc_height); + gtk_icon_size_lookup (renderer->size, &calc_width, &calc_height); gtk_cell_renderer_get_alignment (cell, &xalign, &yalign); gtk_cell_renderer_get_padding (cell, &xpad, &ypad); @@ -262,10 +259,10 @@ gimp_cell_renderer_color_render (GtkCellRenderer *cell, const GdkRectangle *cell_area, GtkCellRendererState flags) { - GimpCellRendererColorPrivate *private = GET_PRIVATE (cell); - GdkRectangle rect; - gint xpad; - gint ypad; + GimpCellRendererColor *renderer = GIMP_CELL_RENDERER_COLOR (cell); + GdkRectangle rect; + gint xpad; + gint ypad; gimp_cell_renderer_color_get_size (cell, widget, cell_area, &rect.x, @@ -291,12 +288,12 @@ gimp_cell_renderer_color_render (GtkCellRenderer *cell, rect.x + 1, rect.y + 1, rect.width - 2, rect.height - 2); - gimp_cairo_set_source_color (cr, private->color, NULL, FALSE, + gimp_cairo_set_source_color (cr, renderer->color, NULL, FALSE, widget); cairo_fill (cr); - gegl_color_get_pixel (private->color, babl_format ("R'G'B'A double"), rgba); - if (! private->opaque && rgba[3] < 1.0) + gegl_color_get_pixel (renderer->color, babl_format ("R'G'B'A double"), rgba); + if (! renderer->opaque && rgba[3] < 1.0) { cairo_pattern_t *pattern; @@ -313,7 +310,7 @@ gimp_cell_renderer_color_render (GtkCellRenderer *cell, cairo_fill_preserve (cr); - gimp_cairo_set_source_color (cr, private->color, NULL, FALSE, + gimp_cairo_set_source_color (cr, renderer->color, NULL, FALSE, widget); cairo_fill (cr); } diff --git a/libgimpwidgets/gimpcellrenderercolor.h b/libgimpwidgets/gimpcellrenderercolor.h index e22b69ad8f..46b44d92e8 100644 --- a/libgimpwidgets/gimpcellrenderercolor.h +++ b/libgimpwidgets/gimpcellrenderercolor.h @@ -29,42 +29,10 @@ G_BEGIN_DECLS -#define GIMP_TYPE_CELL_RENDERER_COLOR (gimp_cell_renderer_color_get_type ()) -#define GIMP_CELL_RENDERER_COLOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_CELL_RENDERER_COLOR, GimpCellRendererColor)) -#define GIMP_CELL_RENDERER_COLOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CELL_RENDERER_COLOR, GimpCellRendererColorClass)) -#define GIMP_IS_CELL_RENDERER_COLOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_CELL_RENDERER_COLOR)) -#define GIMP_IS_CELL_RENDERER_COLOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CELL_RENDERER_COLOR)) -#define GIMP_CELL_RENDERER_COLOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_CELL_RENDERER_COLOR, GimpCellRendererColorClass)) +#define GIMP_TYPE_CELL_RENDERER_COLOR (gimp_cell_renderer_color_get_type ()) +G_DECLARE_FINAL_TYPE (GimpCellRendererColor, gimp_cell_renderer_color, GIMP, CELL_RENDERER_COLOR, GtkCellRenderer) -typedef struct _GimpCellRendererColorPrivate GimpCellRendererColorPrivate; -typedef struct _GimpCellRendererColorClass GimpCellRendererColorClass; - -struct _GimpCellRendererColor -{ - GtkCellRenderer parent_instance; - - GimpCellRendererColorPrivate *priv; -}; - -struct _GimpCellRendererColorClass -{ - GtkCellRendererClass parent_class; - - /* Padding for future expansion */ - void (* _gimp_reserved1) (void); - void (* _gimp_reserved2) (void); - void (* _gimp_reserved3) (void); - void (* _gimp_reserved4) (void); - void (* _gimp_reserved5) (void); - void (* _gimp_reserved6) (void); - void (* _gimp_reserved7) (void); - void (* _gimp_reserved8) (void); -}; - - -GType gimp_cell_renderer_color_get_type (void) G_GNUC_CONST; - GtkCellRenderer * gimp_cell_renderer_color_new (void); diff --git a/libgimpwidgets/gimpcolorprofilechooserdialog.c b/libgimpwidgets/gimpcolorprofilechooserdialog.c index dcb15e10d0..d315dc8051 100644 --- a/libgimpwidgets/gimpcolorprofilechooserdialog.c +++ b/libgimpwidgets/gimpcolorprofilechooserdialog.c @@ -50,8 +50,10 @@ **/ -struct _GimpColorProfileChooserDialogPrivate +struct _GimpColorProfileChooserDialog { + GtkFileChooserDialog parent_instance; + GimpColorProfileView *profile_view; }; @@ -65,9 +67,8 @@ static void gimp_color_profile_chooser_dialog_add_shortcut (GimpColorProfi static void gimp_color_profile_chooser_dialog_update_preview (GimpColorProfileChooserDialog *dialog); -G_DEFINE_TYPE_WITH_PRIVATE (GimpColorProfileChooserDialog, - gimp_color_profile_chooser_dialog, - GTK_TYPE_FILE_CHOOSER_DIALOG) +G_DEFINE_TYPE (GimpColorProfileChooserDialog, gimp_color_profile_chooser_dialog, + GTK_TYPE_FILE_CHOOSER_DIALOG) #define parent_class gimp_color_profile_chooser_dialog_parent_class @@ -86,8 +87,6 @@ gimp_color_profile_chooser_dialog_class_init (GimpColorProfileChooserDialogClass static void gimp_color_profile_chooser_dialog_init (GimpColorProfileChooserDialog *dialog) { - dialog->priv = - gimp_color_profile_chooser_dialog_get_instance_private (dialog); } static void @@ -131,7 +130,7 @@ gimp_color_profile_chooser_dialog_constructed (GObject *object) gtk_container_add (GTK_CONTAINER (scrolled_window), profile_view); gtk_widget_show (profile_view); - dialog->priv->profile_view = GIMP_COLOR_PROFILE_VIEW (profile_view); + dialog->profile_view = GIMP_COLOR_PROFILE_VIEW (profile_view); gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog), scrolled_window); @@ -186,9 +185,9 @@ gimp_color_profile_chooser_dialog_new (const gchar *title, } gimp_dialog_set_alternative_button_order (GTK_DIALOG (dialog), - GTK_RESPONSE_ACCEPT, - GTK_RESPONSE_CANCEL, - -1); + GTK_RESPONSE_ACCEPT, + GTK_RESPONSE_CANCEL, + -1); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT); @@ -210,8 +209,10 @@ add_shortcut (GimpColorProfileChooserDialog *dialog, static void gimp_color_profile_chooser_dialog_add_shortcut (GimpColorProfileChooserDialog *dialog) { +#ifndef G_OS_WIN32 gboolean save = (gtk_file_chooser_get_action (GTK_FILE_CHOOSER (dialog)) == GTK_FILE_CHOOSER_ACTION_SAVE); +#endif #ifdef G_OS_WIN32 { @@ -318,7 +319,7 @@ gimp_color_profile_chooser_dialog_update_preview (GimpColorProfileChooserDialog if (! file) { - gimp_color_profile_view_set_profile (dialog->priv->profile_view, NULL); + gimp_color_profile_view_set_profile (dialog->profile_view, NULL); return; } @@ -329,25 +330,25 @@ gimp_color_profile_chooser_dialog_update_preview (GimpColorProfileChooserDialog if (! profile) { - gimp_color_profile_view_set_error (dialog->priv->profile_view, + gimp_color_profile_view_set_error (dialog->profile_view, error->message); g_clear_error (&error); } else { - gimp_color_profile_view_set_profile (dialog->priv->profile_view, + gimp_color_profile_view_set_profile (dialog->profile_view, profile); g_object_unref (profile); } break; case G_FILE_TYPE_DIRECTORY: - gimp_color_profile_view_set_error (dialog->priv->profile_view, + gimp_color_profile_view_set_error (dialog->profile_view, _("Folder")); break; default: - gimp_color_profile_view_set_error (dialog->priv->profile_view, + gimp_color_profile_view_set_error (dialog->profile_view, _("Not a regular file.")); break; } diff --git a/libgimpwidgets/gimpcolorprofilechooserdialog.h b/libgimpwidgets/gimpcolorprofilechooserdialog.h index e402574ea9..9cb4e6437f 100644 --- a/libgimpwidgets/gimpcolorprofilechooserdialog.h +++ b/libgimpwidgets/gimpcolorprofilechooserdialog.h @@ -25,41 +25,8 @@ G_BEGIN_DECLS -#define GIMP_TYPE_COLOR_PROFILE_CHOOSER_DIALOG (gimp_color_profile_chooser_dialog_get_type ()) -#define GIMP_COLOR_PROFILE_CHOOSER_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_COLOR_PROFILE_CHOOSER_DIALOG, GimpColorProfileChooserDialog)) -#define GIMP_COLOR_PROFILE_CHOOSER_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_COLOR_PROFILE_CHOOSER_DIALOG, GimpColorProfileChooserDialogClass)) -#define GIMP_IS_COLOR_PROFILE_CHOOSER_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_COLOR_PROFILE_CHOOSER_DIALOG)) -#define GIMP_IS_COLOR_PROFILE_CHOOSER_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_COLOR_PROFILE_CHOOSER_DIALOG)) -#define GIMP_COLOR_PROFILE_CHOOSER_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_COLOR_PROFILE_CHOOSER_DIALOG, GimpColorProfileChooserDialogClass)) - - -typedef struct _GimpColorProfileChooserDialogClass GimpColorProfileChooserDialogClass; -typedef struct _GimpColorProfileChooserDialogPrivate GimpColorProfileChooserDialogPrivate; - -struct _GimpColorProfileChooserDialog -{ - GtkFileChooserDialog parent_instance; - - GimpColorProfileChooserDialogPrivate *priv; -}; - -struct _GimpColorProfileChooserDialogClass -{ - GtkFileChooserDialogClass parent_class; - - /* Padding for future expansion */ - void (* _gimp_reserved1) (void); - void (* _gimp_reserved2) (void); - void (* _gimp_reserved3) (void); - void (* _gimp_reserved4) (void); - void (* _gimp_reserved5) (void); - void (* _gimp_reserved6) (void); - void (* _gimp_reserved7) (void); - void (* _gimp_reserved8) (void); -}; - - -GType gimp_color_profile_chooser_dialog_get_type (void) G_GNUC_CONST; +#define GIMP_TYPE_COLOR_PROFILE_CHOOSER_DIALOG (gimp_color_profile_chooser_dialog_get_type ()) +G_DECLARE_FINAL_TYPE (GimpColorProfileChooserDialog, gimp_color_profile_chooser_dialog, GIMP, COLOR_PROFILE_CHOOSER_DIALOG, GtkFileChooserDialog) GtkWidget * gimp_color_profile_chooser_dialog_new (const gchar *title, GtkWindow *parent, diff --git a/libgimpwidgets/gimpcolorprofilecombobox.c b/libgimpwidgets/gimpcolorprofilecombobox.c index dbd82aa7af..05b4dbb8b3 100644 --- a/libgimpwidgets/gimpcolorprofilecombobox.c +++ b/libgimpwidgets/gimpcolorprofilecombobox.c @@ -52,14 +52,14 @@ enum }; -struct _GimpColorProfileComboBoxPrivate +struct _GimpColorProfileComboBox { + GtkComboBox parent_instance; + GtkWidget *dialog; GtkTreePath *last_path; }; -#define GET_PRIVATE(obj) (((GimpColorProfileComboBox *) (obj))->priv) - static void gimp_color_profile_combo_box_finalize (GObject *object); static void gimp_color_profile_combo_box_set_property (GObject *object, @@ -81,8 +81,7 @@ static void gimp_color_profile_combo_dialog_response (GimpColorProfileChooserD GimpColorProfileComboBox *combo); -G_DEFINE_TYPE_WITH_PRIVATE (GimpColorProfileComboBox, - gimp_color_profile_combo_box, GTK_TYPE_COMBO_BOX) +G_DEFINE_TYPE (GimpColorProfileComboBox, gimp_color_profile_combo_box, GTK_TYPE_COMBO_BOX) #define parent_class gimp_color_profile_combo_box_parent_class @@ -138,8 +137,6 @@ gimp_color_profile_combo_box_init (GimpColorProfileComboBox *combo_box) { GtkCellRenderer *cell; - combo_box->priv = gimp_color_profile_combo_box_get_instance_private (combo_box); - cell = gtk_cell_renderer_text_new (); g_object_set (cell, @@ -161,18 +158,18 @@ gimp_color_profile_combo_box_init (GimpColorProfileComboBox *combo_box) static void gimp_color_profile_combo_box_finalize (GObject *object) { - GimpColorProfileComboBoxPrivate *private = GET_PRIVATE (object); + GimpColorProfileComboBox *combo = GIMP_COLOR_PROFILE_COMBO_BOX (object); - if (private->dialog) + if (combo->dialog) { - if (GIMP_IS_COLOR_PROFILE_CHOOSER_DIALOG (private->dialog)) - gtk_widget_destroy (private->dialog); + if (GIMP_IS_COLOR_PROFILE_CHOOSER_DIALOG (combo->dialog)) + gtk_widget_destroy (combo->dialog); - g_object_unref (private->dialog); - private->dialog = NULL; + g_object_unref (combo->dialog); + combo->dialog = NULL; } - g_clear_pointer (&private->last_path, gtk_tree_path_free); + g_clear_pointer (&combo->last_path, gtk_tree_path_free); G_OBJECT_CLASS (parent_class)->finalize (object); } @@ -183,16 +180,16 @@ gimp_color_profile_combo_box_set_property (GObject *object, const GValue *value, GParamSpec *pspec) { - GimpColorProfileComboBoxPrivate *private = GET_PRIVATE (object); + GimpColorProfileComboBox *combo = GIMP_COLOR_PROFILE_COMBO_BOX (object); switch (property_id) { case PROP_DIALOG: - g_return_if_fail (private->dialog == NULL); - private->dialog = g_value_dup_object (value); + g_return_if_fail (combo->dialog == NULL); + combo->dialog = g_value_dup_object (value); - if (GIMP_IS_COLOR_PROFILE_CHOOSER_DIALOG (private->dialog)) - g_signal_connect (private->dialog, "response", + if (GIMP_IS_COLOR_PROFILE_CHOOSER_DIALOG (combo->dialog)) + g_signal_connect (combo->dialog, "response", G_CALLBACK (gimp_color_profile_combo_dialog_response), object); break; @@ -214,12 +211,12 @@ gimp_color_profile_combo_box_get_property (GObject *object, GValue *value, GParamSpec *pspec) { - GimpColorProfileComboBoxPrivate *private = GET_PRIVATE (object); + GimpColorProfileComboBox *combo = GIMP_COLOR_PROFILE_COMBO_BOX (object); switch (property_id) { case PROP_DIALOG: - g_value_set_object (value, private->dialog); + g_value_set_object (value, combo->dialog); break; case PROP_MODEL: @@ -236,10 +233,10 @@ gimp_color_profile_combo_box_get_property (GObject *object, static void gimp_color_profile_combo_box_changed (GtkComboBox *combo) { - GimpColorProfileComboBoxPrivate *priv = GET_PRIVATE (combo); - GtkTreeModel *model = gtk_combo_box_get_model (combo); - GtkTreeIter iter; - gint type; + GimpColorProfileComboBox *color_combo = GIMP_COLOR_PROFILE_COMBO_BOX (combo); + GtkTreeModel *model = gtk_combo_box_get_model (combo); + GtkTreeIter iter; + gint type; if (! gtk_combo_box_get_active_iter (combo, &iter)) return; @@ -255,13 +252,13 @@ gimp_color_profile_combo_box_changed (GtkComboBox *combo) GtkWidget *parent = gtk_widget_get_toplevel (GTK_WIDGET (combo)); if (GTK_IS_WINDOW (parent)) - gtk_window_set_transient_for (GTK_WINDOW (priv->dialog), + gtk_window_set_transient_for (GTK_WINDOW (color_combo->dialog), GTK_WINDOW (parent)); - gtk_window_present (GTK_WINDOW (priv->dialog)); + gtk_window_present (GTK_WINDOW (color_combo->dialog)); - if (priv->last_path && - gtk_tree_model_get_iter (model, &iter, priv->last_path)) + if (color_combo->last_path && + gtk_tree_model_get_iter (model, &iter, color_combo->last_path)) { gtk_combo_box_set_active_iter (combo, &iter); } @@ -269,10 +266,10 @@ gimp_color_profile_combo_box_changed (GtkComboBox *combo) break; case GIMP_COLOR_PROFILE_STORE_ITEM_FILE: - if (priv->last_path) - gtk_tree_path_free (priv->last_path); + if (color_combo->last_path) + gtk_tree_path_free (color_combo->last_path); - priv->last_path = gtk_tree_model_get_path (model, &iter); + color_combo->last_path = gtk_tree_model_get_path (model, &iter); _gimp_color_profile_store_history_reorder (GIMP_COLOR_PROFILE_STORE (model), &iter); diff --git a/libgimpwidgets/gimpcolorprofilecombobox.h b/libgimpwidgets/gimpcolorprofilecombobox.h index 93096c6914..dbc1c1e0a5 100644 --- a/libgimpwidgets/gimpcolorprofilecombobox.h +++ b/libgimpwidgets/gimpcolorprofilecombobox.h @@ -28,42 +28,10 @@ G_BEGIN_DECLS -#define GIMP_TYPE_COLOR_PROFILE_COMBO_BOX (gimp_color_profile_combo_box_get_type ()) -#define GIMP_COLOR_PROFILE_COMBO_BOX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_COLOR_PROFILE_COMBO_BOX, GimpColorProfileComboBox)) -#define GIMP_COLOR_PROFILE_COMBO_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_COLOR_PROFILE_COMBO_BOX, GimpColorProfileComboBoxClass)) -#define GIMP_IS_COLOR_PROFILE_COMBO_BOX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_COLOR_PROFILE_COMBO_BOX)) -#define GIMP_IS_COLOR_PROFILE_COMBO_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_COLOR_PROFILE_COMBO_BOX)) -#define GIMP_COLOR_PROFILE_COMBO_BOX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_COLOR_PROFILE_COMBO_BOX, GimpColorProfileComboBoxClass)) +#define GIMP_TYPE_COLOR_PROFILE_COMBO_BOX (gimp_color_profile_combo_box_get_type ()) +G_DECLARE_FINAL_TYPE (GimpColorProfileComboBox, gimp_color_profile_combo_box, GIMP, COLOR_PROFILE_COMBO_BOX, GtkComboBox) -typedef struct _GimpColorProfileComboBoxPrivate GimpColorProfileComboBoxPrivate; -typedef struct _GimpColorProfileComboBoxClass GimpColorProfileComboBoxClass; - -struct _GimpColorProfileComboBox -{ - GtkComboBox parent_instance; - - GimpColorProfileComboBoxPrivate *priv; -}; - -struct _GimpColorProfileComboBoxClass -{ - GtkComboBoxClass parent_class; - - /* Padding for future expansion */ - void (* _gimp_reserved1) (void); - void (* _gimp_reserved2) (void); - void (* _gimp_reserved3) (void); - void (* _gimp_reserved4) (void); - void (* _gimp_reserved5) (void); - void (* _gimp_reserved6) (void); - void (* _gimp_reserved7) (void); - void (* _gimp_reserved8) (void); -}; - - -GType gimp_color_profile_combo_box_get_type (void) G_GNUC_CONST; - GtkWidget * gimp_color_profile_combo_box_new (GtkWidget *dialog, GFile *history); GtkWidget * gimp_color_profile_combo_box_new_with_model (GtkWidget *dialog, diff --git a/libgimpwidgets/gimpcolorprofilestore.c b/libgimpwidgets/gimpcolorprofilestore.c index e072e21e61..413f338ac6 100644 --- a/libgimpwidgets/gimpcolorprofilestore.c +++ b/libgimpwidgets/gimpcolorprofilestore.c @@ -56,12 +56,12 @@ enum }; -struct _GimpColorProfileStorePrivate +struct _GimpColorProfileStore { - GFile *history; -}; + GtkListStore parent_instance; -#define GET_PRIVATE(obj) (((GimpColorProfileStore *) (obj))->priv) + GFile *history; +}; static void gimp_color_profile_store_constructed (GObject *object); @@ -92,8 +92,7 @@ static gboolean gimp_color_profile_store_load (GimpColorProfileStore GError **error); -G_DEFINE_TYPE_WITH_PRIVATE (GimpColorProfileStore, gimp_color_profile_store, - GTK_TYPE_LIST_STORE) +G_DEFINE_TYPE (GimpColorProfileStore, gimp_color_profile_store, GTK_TYPE_LIST_STORE) #define parent_class gimp_color_profile_store_parent_class @@ -137,8 +136,6 @@ gimp_color_profile_store_init (GimpColorProfileStore *store) G_TYPE_INT /* GIMP_COLOR_PROFILE_STORE_INDEX */ }; - 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); } @@ -146,9 +143,8 @@ gimp_color_profile_store_init (GimpColorProfileStore *store) static void gimp_color_profile_store_constructed (GObject *object) { - GimpColorProfileStore *store = GIMP_COLOR_PROFILE_STORE (object); - GimpColorProfileStorePrivate *private = GET_PRIVATE (store); - GtkTreeIter iter; + GimpColorProfileStore *store = GIMP_COLOR_PROFILE_STORE (object); + GtkTreeIter iter; G_OBJECT_CLASS (parent_class)->constructed (object); @@ -160,18 +156,17 @@ gimp_color_profile_store_constructed (GObject *object) _("Select color profile from disk..."), -1); - if (private->history) - gimp_color_profile_store_load (store, private->history, NULL); + if (store->history) + gimp_color_profile_store_load (store, store->history, NULL); } static void gimp_color_profile_store_dispose (GObject *object) { - GimpColorProfileStore *store = GIMP_COLOR_PROFILE_STORE (object); - GimpColorProfileStorePrivate *private = GET_PRIVATE (store); + GimpColorProfileStore *store = GIMP_COLOR_PROFILE_STORE (object); - if (private->history) - gimp_color_profile_store_save (store, private->history, NULL); + if (store->history) + gimp_color_profile_store_save (store, store->history, NULL); G_OBJECT_CLASS (parent_class)->dispose (object); } @@ -179,9 +174,9 @@ gimp_color_profile_store_dispose (GObject *object) static void gimp_color_profile_store_finalize (GObject *object) { - GimpColorProfileStorePrivate *private = GET_PRIVATE (object); + GimpColorProfileStore *store = GIMP_COLOR_PROFILE_STORE (object); - g_clear_object (&private->history); + g_clear_object (&store->history); G_OBJECT_CLASS (parent_class)->finalize (object); } @@ -192,13 +187,13 @@ gimp_color_profile_store_set_property (GObject *object, const GValue *value, GParamSpec *pspec) { - GimpColorProfileStorePrivate *private = GET_PRIVATE (object); + GimpColorProfileStore *store = GIMP_COLOR_PROFILE_STORE (object); switch (property_id) { case PROP_HISTORY: - g_return_if_fail (private->history == NULL); - private->history = g_value_dup_object (value); + g_return_if_fail (store->history == NULL); + store->history = g_value_dup_object (value); break; default: @@ -213,12 +208,12 @@ gimp_color_profile_store_get_property (GObject *object, GValue *value, GParamSpec *pspec) { - GimpColorProfileStorePrivate *private = GET_PRIVATE (object); + GimpColorProfileStore *store = GIMP_COLOR_PROFILE_STORE (object); switch (property_id) { case PROP_HISTORY: - g_value_set_object (value, private->history); + g_value_set_object (value, store->history); break; default: diff --git a/libgimpwidgets/gimpcolorprofilestore.h b/libgimpwidgets/gimpcolorprofilestore.h index a644684114..a9e8668c07 100644 --- a/libgimpwidgets/gimpcolorprofilestore.h +++ b/libgimpwidgets/gimpcolorprofilestore.h @@ -29,41 +29,10 @@ G_BEGIN_DECLS -#define GIMP_TYPE_COLOR_PROFILE_STORE (gimp_color_profile_store_get_type ()) -#define GIMP_COLOR_PROFILE_STORE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_COLOR_PROFILE_STORE, GimpColorProfileStore)) -#define GIMP_COLOR_PROFILE_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_COLOR_PROFILE_STORE, GimpColorProfileStoreClass)) -#define GIMP_IS_COLOR_PROFILE_STORE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_COLOR_PROFILE_STORE)) -#define GIMP_IS_COLOR_PROFILE_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_COLOR_PROFILE_STORE)) -#define GIMP_COLOR_PROFILE_STORE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_COLOR_PROFILE_STORE, GimpColorProfileStoreClass)) +#define GIMP_TYPE_COLOR_PROFILE_STORE (gimp_color_profile_store_get_type ()) +G_DECLARE_FINAL_TYPE (GimpColorProfileStore, gimp_color_profile_store, GIMP, COLOR_PROFILE_STORE, GtkListStore) -typedef struct _GimpColorProfileStorePrivate GimpColorProfileStorePrivate; -typedef struct _GimpColorProfileStoreClass GimpColorProfileStoreClass; - -struct _GimpColorProfileStore -{ - GtkListStore parent_instance; - - GimpColorProfileStorePrivate *priv; -}; - -struct _GimpColorProfileStoreClass -{ - GtkListStoreClass parent_class; - - void (* _gimp_reserved1) (void); - void (* _gimp_reserved2) (void); - void (* _gimp_reserved3) (void); - void (* _gimp_reserved4) (void); - void (* _gimp_reserved5) (void); - void (* _gimp_reserved6) (void); - void (* _gimp_reserved7) (void); - void (* _gimp_reserved8) (void); -}; - - -GType gimp_color_profile_store_get_type (void) G_GNUC_CONST; - GtkListStore * gimp_color_profile_store_new (GFile *history); void gimp_color_profile_store_add_file (GimpColorProfileStore *store, diff --git a/libgimpwidgets/gimpcolorprofileview.c b/libgimpwidgets/gimpcolorprofileview.c index 558392aff9..6ed66e72ff 100644 --- a/libgimpwidgets/gimpcolorprofileview.c +++ b/libgimpwidgets/gimpcolorprofileview.c @@ -43,8 +43,10 @@ **/ -struct _GimpColorProfileViewPrivate +struct _GimpColorProfileView { + GtkTextView parent_instance; + GimpColorProfile *profile; }; @@ -53,8 +55,7 @@ static void gimp_color_profile_view_constructed (GObject *object); static void gimp_color_profile_view_finalize (GObject *object); -G_DEFINE_TYPE_WITH_PRIVATE (GimpColorProfileView, gimp_color_profile_view, - GTK_TYPE_TEXT_VIEW) +G_DEFINE_TYPE (GimpColorProfileView, gimp_color_profile_view, GTK_TYPE_TEXT_VIEW) #define parent_class gimp_color_profile_view_parent_class @@ -71,7 +72,6 @@ gimp_color_profile_view_class_init (GimpColorProfileViewClass *klass) static void gimp_color_profile_view_init (GimpColorProfileView *view) { - view->priv = gimp_color_profile_view_get_instance_private (view); } static void @@ -109,7 +109,7 @@ gimp_color_profile_view_finalize (GObject *object) { GimpColorProfileView *view = GIMP_COLOR_PROFILE_VIEW (object); - g_clear_object (&view->priv->profile); + g_clear_object (&view->profile); G_OBJECT_CLASS (parent_class)->finalize (object); } @@ -129,14 +129,14 @@ gimp_color_profile_view_set_profile (GimpColorProfileView *view, g_return_if_fail (GIMP_IS_COLOR_PROFILE_VIEW (view)); g_return_if_fail (profile == NULL || GIMP_IS_COLOR_PROFILE (profile)); - if (profile == view->priv->profile) + if (profile == view->profile) return; buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)); gtk_text_buffer_set_text (buffer, "", 0); - if (g_set_object (&view->priv->profile, profile) && profile) + if (g_set_object (&view->profile, profile) && profile) { GtkTextIter iter; const gchar *text; diff --git a/libgimpwidgets/gimpcolorprofileview.h b/libgimpwidgets/gimpcolorprofileview.h index d2e07cb84b..d5cec19de5 100644 --- a/libgimpwidgets/gimpcolorprofileview.h +++ b/libgimpwidgets/gimpcolorprofileview.h @@ -24,42 +24,10 @@ G_BEGIN_DECLS -#define GIMP_TYPE_COLOR_PROFILE_VIEW (gimp_color_profile_view_get_type ()) -#define GIMP_COLOR_PROFILE_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_COLOR_PROFILE_VIEW, GimpColorProfileView)) -#define GIMP_COLOR_PROFILE_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_COLOR_PROFILE_VIEW, GimpColorProfileViewClass)) -#define GIMP_IS_COLOR_PROFILE_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_COLOR_PROFILE_VIEW)) -#define GIMP_IS_COLOR_PROFILE_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_COLOR_PROFILE_VIEW)) -#define GIMP_COLOR_PROFILE_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_COLOR_PROFILE_VIEW, GimpColorProfileViewClass)) +#define GIMP_TYPE_COLOR_PROFILE_VIEW (gimp_color_profile_view_get_type ()) +G_DECLARE_FINAL_TYPE (GimpColorProfileView, gimp_color_profile_view, GIMP, COLOR_PROFILE_VIEW, GtkTextView) -typedef struct _GimpColorProfileViewClass GimpColorProfileViewClass; -typedef struct _GimpColorProfileViewPrivate GimpColorProfileViewPrivate; - -struct _GimpColorProfileView -{ - GtkTextView parent_instance; - - GimpColorProfileViewPrivate *priv; -}; - -struct _GimpColorProfileViewClass -{ - GtkTextViewClass parent_class; - - /* Padding for future expansion */ - void (* _gimp_reserved1) (void); - void (* _gimp_reserved2) (void); - void (* _gimp_reserved3) (void); - void (* _gimp_reserved4) (void); - void (* _gimp_reserved5) (void); - void (* _gimp_reserved6) (void); - void (* _gimp_reserved7) (void); - void (* _gimp_reserved8) (void); -}; - - -GType gimp_color_profile_view_get_type (void) G_GNUC_CONST; - GtkWidget * gimp_color_profile_view_new (void); void gimp_color_profile_view_set_profile (GimpColorProfileView *view, diff --git a/libgimpwidgets/gimpcolorscale.c b/libgimpwidgets/gimpcolorscale.c index ecabad8f23..d90c8087bc 100644 --- a/libgimpwidgets/gimpcolorscale.c +++ b/libgimpwidgets/gimpcolorscale.c @@ -54,16 +54,10 @@ enum }; -typedef struct _GimpLCH GimpLCH; - -struct _GimpLCH +struct _GimpColorScale { - gdouble l, c, h, a; -}; + GtkScale parent_instance; - -struct _GimpColorScalePrivate -{ GimpColorConfig *config; guchar oog_color[3]; const Babl *format; @@ -79,8 +73,6 @@ struct _GimpColorScalePrivate gboolean needs_render; }; -#define GET_PRIVATE(obj) (((GimpColorScale *) (obj))->priv) - static void gimp_color_scale_dispose (GObject *object); static void gimp_color_scale_finalize (GObject *object); @@ -106,7 +98,7 @@ static void gimp_color_scale_notify_config (GimpColorConfig *config, GimpColorScale *scale); -G_DEFINE_TYPE_WITH_PRIVATE (GimpColorScale, gimp_color_scale, GTK_TYPE_SCALE) +G_DEFINE_TYPE (GimpColorScale, gimp_color_scale, GTK_TYPE_SCALE) #define parent_class gimp_color_scale_parent_class @@ -158,13 +150,8 @@ gimp_color_scale_class_init (GimpColorScaleClass *klass) static void gimp_color_scale_init (GimpColorScale *scale) { - GimpColorScalePrivate *priv; - GtkRange *range = GTK_RANGE (scale); - GtkCssProvider *css; - - scale->priv = gimp_color_scale_get_instance_private (scale); - - priv = scale->priv; + GtkRange *range = GTK_RANGE (scale); + GtkCssProvider *css; gtk_widget_set_can_focus (GTK_WIDGET (scale), TRUE); @@ -172,13 +159,13 @@ gimp_color_scale_init (GimpColorScale *scale) gtk_range_set_flippable (GTK_RANGE (scale), TRUE); gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE); - priv->channel = GIMP_COLOR_SELECTOR_VALUE; - priv->needs_render = TRUE; + scale->channel = GIMP_COLOR_SELECTOR_VALUE; + scale->needs_render = TRUE; gtk_orientable_set_orientation (GTK_ORIENTABLE (range), GTK_ORIENTATION_HORIZONTAL); - priv->color = gegl_color_new ("black"); + scale->color = gegl_color_new ("black"); css = gtk_css_provider_new (); gtk_css_provider_load_from_data (css, @@ -216,13 +203,13 @@ gimp_color_scale_dispose (GObject *object) static void gimp_color_scale_finalize (GObject *object) { - GimpColorScalePrivate *priv = GET_PRIVATE (object); + GimpColorScale *scale = GIMP_COLOR_SCALE (object); - g_clear_pointer (&priv->buf, g_free); - priv->width = 0; - priv->height = 0; - priv->rowstride = 0; - g_object_unref (priv->color); + g_clear_pointer (&scale->buf, g_free); + scale->width = 0; + scale->height = 0; + scale->rowstride = 0; + g_object_unref (scale->color); G_OBJECT_CLASS (parent_class)->finalize (object); } @@ -233,12 +220,12 @@ gimp_color_scale_get_property (GObject *object, GValue *value, GParamSpec *pspec) { - GimpColorScalePrivate *priv = GET_PRIVATE (object); + GimpColorScale *scale = GIMP_COLOR_SCALE (object); switch (property_id) { case PROP_CHANNEL: - g_value_set_enum (value, priv->channel); + g_value_set_enum (value, scale->channel); break; default: @@ -271,27 +258,27 @@ static void gimp_color_scale_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { - GimpColorScalePrivate *priv = GET_PRIVATE (widget); - GtkRange *range = GTK_RANGE (widget); - GdkRectangle range_rect; + GimpColorScale *scale = GIMP_COLOR_SCALE (widget); + GtkRange *range = GTK_RANGE (widget); + GdkRectangle range_rect; GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, allocation); gtk_range_get_range_rect (range, &range_rect); - if (range_rect.width != priv->width || - range_rect.height != priv->height) + if (range_rect.width != scale->width || + range_rect.height != scale->height) { - priv->width = range_rect.width; - priv->height = range_rect.height; + scale->width = range_rect.width; + scale->height = range_rect.height; /* TODO: we should move to CAIRO_FORMAT_RGBA128F. */ - priv->rowstride = cairo_format_stride_for_width (CAIRO_FORMAT_RGB24, priv->width); + scale->rowstride = cairo_format_stride_for_width (CAIRO_FORMAT_RGB24, scale->width); - g_free (priv->buf); - priv->buf = g_new (guchar, 3 * priv->width * priv->height); + g_free (scale->buf); + scale->buf = g_new (guchar, 3 * scale->width * scale->height); - priv->needs_render = TRUE; + scale->needs_render = TRUE; } } @@ -299,23 +286,22 @@ static gboolean gimp_color_scale_draw (GtkWidget *widget, cairo_t *cr) { - GimpColorScale *scale = GIMP_COLOR_SCALE (widget); - GimpColorScalePrivate *priv = GET_PRIVATE (widget); - GtkRange *range = GTK_RANGE (widget); - GtkStyleContext *context = gtk_widget_get_style_context (widget); - GdkRectangle range_rect; - GdkRectangle area = { 0, }; - cairo_surface_t *buffer; - guchar *buf = NULL; - guchar *src; - guchar *dest; - gint slider_start; - gint slider_end; - gint slider_mid; - gint slider_size; - const Babl *render_space; + GimpColorScale *scale = GIMP_COLOR_SCALE (widget); + GtkRange *range = GTK_RANGE (widget); + GtkStyleContext *context = gtk_widget_get_style_context (widget); + GdkRectangle range_rect; + GdkRectangle area = { 0, }; + cairo_surface_t *buffer; + guchar *buf = NULL; + guchar *src; + guchar *dest; + gint slider_start; + gint slider_end; + gint slider_mid; + gint slider_size; + const Babl *render_space; - if (! priv->buf) + if (! scale->buf) return FALSE; gtk_range_get_range_rect (range, &range_rect); @@ -324,35 +310,35 @@ gimp_color_scale_draw (GtkWidget *widget, slider_mid = slider_start + (slider_end - slider_start) / 2; slider_size = 6; - if (priv->needs_render) + if (scale->needs_render) { gimp_color_scale_render (scale); - priv->needs_render = FALSE; + scale->needs_render = FALSE; } - render_space = gimp_widget_get_render_space (widget, priv->config); - fish_rgb_to_cairo = babl_fish (babl_format_with_space ("R'G'B' u8", priv->format), + render_space = gimp_widget_get_render_space (widget, scale->config); + fish_rgb_to_cairo = babl_fish (babl_format_with_space ("R'G'B' u8", scale->format), babl_format_with_space ("cairo-RGB24", render_space)), - src = priv->buf; - buf = g_new (guchar, priv->rowstride * priv->height); + src = scale->buf; + buf = g_new (guchar, scale->rowstride * scale->height); dest = buf; /* We convert per line because the cairo rowstride may be bigger than the * real contents. */ - for (gint i = 0; i < priv->height; i++) + for (gint i = 0; i < scale->height; i++) { - babl_process (fish_rgb_to_cairo, src, dest, priv->width); - src += 3 * priv->width; - dest += priv->rowstride; + babl_process (fish_rgb_to_cairo, src, dest, scale->width); + src += 3 * scale->width; + dest += scale->rowstride; } buffer = cairo_image_surface_create_for_data (buf, CAIRO_FORMAT_RGB24, - priv->width, - priv->height, - priv->rowstride); + scale->width, + scale->height, + scale->rowstride); cairo_surface_set_user_data (buffer, NULL, buf, (cairo_destroy_func_t) g_free); switch (gtk_orientable_get_orientation (GTK_ORIENTABLE (range))) @@ -514,14 +500,14 @@ void gimp_color_scale_set_format (GimpColorScale *scale, const Babl *format) { - if (scale->priv->format != format) + if (scale->format != format) { - scale->priv->format = format; + scale->format = format; fish_lch_to_rgb = babl_fish (babl_format ("CIE LCH(ab) double"), babl_format_with_space ("R'G'B' double", format)); fish_hsv_to_rgb = babl_fish (babl_format_with_space ("HSV float", format), babl_format_with_space ("R'G'B' double", format)); - scale->priv->needs_render = TRUE; + scale->needs_render = TRUE; gtk_widget_queue_draw (GTK_WIDGET (scale)); } } @@ -537,17 +523,13 @@ void gimp_color_scale_set_channel (GimpColorScale *scale, GimpColorSelectorChannel channel) { - GimpColorScalePrivate *priv; - g_return_if_fail (GIMP_IS_COLOR_SCALE (scale)); - priv = GET_PRIVATE (scale); - - if (channel != priv->channel) + if (channel != scale->channel) { - priv->channel = channel; + scale->channel = channel; - priv->needs_render = TRUE; + scale->needs_render = TRUE; gtk_widget_queue_draw (GTK_WIDGET (scale)); g_object_notify (G_OBJECT (scale), "channel"); @@ -565,20 +547,17 @@ void gimp_color_scale_set_color (GimpColorScale *scale, GeglColor *color) { - GimpColorScalePrivate *priv; - GeglColor *old_color; + GeglColor *old_color; g_return_if_fail (GIMP_IS_COLOR_SCALE (scale)); g_return_if_fail (GEGL_IS_COLOR (color)); - priv = GET_PRIVATE (scale); + old_color = scale->color; + scale->color = gegl_color_duplicate (color); - old_color = priv->color; - priv->color = gegl_color_duplicate (color); - - if (! gimp_color_is_perceptually_identical (old_color, priv->color)) + if (! gimp_color_is_perceptually_identical (old_color, scale->color)) { - priv->needs_render = TRUE; + scale->needs_render = TRUE; gtk_widget_queue_draw (GTK_WIDGET (scale)); } @@ -598,31 +577,27 @@ void gimp_color_scale_set_color_config (GimpColorScale *scale, GimpColorConfig *config) { - GimpColorScalePrivate *priv; - g_return_if_fail (GIMP_IS_COLOR_SCALE (scale)); g_return_if_fail (config == NULL || GIMP_IS_COLOR_CONFIG (config)); - priv = GET_PRIVATE (scale); - - if (config != priv->config) + if (config != scale->config) { - if (priv->config) + if (scale->config) { - g_signal_handlers_disconnect_by_func (priv->config, + g_signal_handlers_disconnect_by_func (scale->config, gimp_color_scale_notify_config, scale); } - g_set_object (&priv->config, config); + g_set_object (&scale->config, config); - if (priv->config) + if (scale->config) { - g_signal_connect (priv->config, "notify", + g_signal_connect (scale->config, "notify", G_CALLBACK (gimp_color_scale_notify_config), scale); - gimp_color_scale_notify_config (priv->config, NULL, scale); + gimp_color_scale_notify_config (scale->config, NULL, scale); } } } @@ -654,35 +629,34 @@ should_invert (GtkRange *range) static void gimp_color_scale_render (GimpColorScale *scale) { - GimpColorScalePrivate *priv = GET_PRIVATE (scale); - GtkRange *range = GTK_RANGE (scale); - gdouble rgb[4]; - gfloat hsv[3]; - gdouble lch[3]; - gint multiplier = 1; - guint x, y; - gdouble *channel_value = NULL; - gfloat *channel_value_f = NULL; - gboolean from_hsv = FALSE; - gboolean from_lch = FALSE; - gboolean invert; - guchar *buf; - guchar *d; + GtkRange *range = GTK_RANGE (scale); + gdouble rgb[4]; + gfloat hsv[3]; + gdouble lch[3]; + gint multiplier = 1; + guint x, y; + gdouble *channel_value = NULL; + gfloat *channel_value_f = NULL; + gboolean from_hsv = FALSE; + gboolean from_lch = FALSE; + gboolean invert; + guchar *buf; + guchar *d; - if ((buf = priv->buf) == NULL) + if ((buf = scale->buf) == NULL) return; - if (priv->channel == GIMP_COLOR_SELECTOR_ALPHA) + if (scale->channel == GIMP_COLOR_SELECTOR_ALPHA) { gimp_color_scale_render_alpha (scale); return; } - gegl_color_get_pixel (priv->color, babl_format_with_space ("R'G'B'A double", priv->format), rgb); - gegl_color_get_pixel (priv->color, babl_format_with_space ("HSV float", priv->format), hsv); - gegl_color_get_pixel (priv->color, babl_format ("CIE LCH(ab) double"), lch); + gegl_color_get_pixel (scale->color, babl_format_with_space ("R'G'B'A double", scale->format), rgb); + gegl_color_get_pixel (scale->color, babl_format_with_space ("HSV float", scale->format), hsv); + gegl_color_get_pixel (scale->color, babl_format ("CIE LCH(ab) double"), lch); - switch (priv->channel) + switch (scale->channel) { case GIMP_COLOR_SELECTOR_HUE: channel_value_f = &hsv[0]; break; case GIMP_COLOR_SELECTOR_SATURATION: channel_value_f = &hsv[1]; break; @@ -698,7 +672,7 @@ gimp_color_scale_render (GimpColorScale *scale) case GIMP_COLOR_SELECTOR_LCH_HUE: channel_value = &lch[2]; break; } - switch (priv->channel) + switch (scale->channel) { case GIMP_COLOR_SELECTOR_HUE: case GIMP_COLOR_SELECTOR_SATURATION: @@ -728,9 +702,9 @@ gimp_color_scale_render (GimpColorScale *scale) switch (gtk_orientable_get_orientation (GTK_ORIENTABLE (range))) { case GTK_ORIENTATION_HORIZONTAL: - for (x = 0, d = buf; x < priv->width; x++, d += 3) + for (x = 0, d = buf; x < scale->width; x++, d += 3) { - gdouble value = (gdouble) x * multiplier / (gdouble) (priv->width - 1); + gdouble value = (gdouble) x * multiplier / (gdouble) (scale->width - 1); if (invert) value = multiplier - value; @@ -753,9 +727,9 @@ gimp_color_scale_render (GimpColorScale *scale) rgb[1] < 0.0 || rgb[1] > 1.0 || rgb[2] < 0.0 || rgb[2] > 1.0) { - d[0] = priv->oog_color[0]; - d[1] = priv->oog_color[1]; - d[2] = priv->oog_color[2]; + d[0] = scale->oog_color[0]; + d[1] = scale->oog_color[1]; + d[2] = scale->oog_color[2]; } else { @@ -765,18 +739,18 @@ gimp_color_scale_render (GimpColorScale *scale) } } - d = buf + priv->width * 3; - for (y = 1; y < priv->height; y++) + d = buf + scale->width * 3; + for (y = 1; y < scale->height; y++) { - memcpy (d, buf, priv->width * 3); - d += priv->width * 3; + memcpy (d, buf, scale->width * 3); + d += scale->width * 3; } break; case GTK_ORIENTATION_VERTICAL: - for (y = 0; y < priv->height; y++) + for (y = 0; y < scale->height; y++) { - gdouble value = (gdouble) y * multiplier / (gdouble) (priv->height - 1); + gdouble value = (gdouble) y * multiplier / (gdouble) (scale->height - 1); guchar u8rgb[3]; if (invert) @@ -796,9 +770,9 @@ gimp_color_scale_render (GimpColorScale *scale) rgb[1] < 0.0 || rgb[1] > 1.0 || rgb[2] < 0.0 || rgb[2] > 1.0) { - u8rgb[0] = priv->oog_color[0]; - u8rgb[1] = priv->oog_color[1]; - u8rgb[2] = priv->oog_color[2]; + u8rgb[0] = scale->oog_color[0]; + u8rgb[1] = scale->oog_color[1]; + u8rgb[2] = scale->oog_color[2]; } else { @@ -807,14 +781,14 @@ gimp_color_scale_render (GimpColorScale *scale) u8rgb[2] = rgb[2] * 255; } - for (x = 0, d = buf; x < priv->width; x++, d += 3) + for (x = 0, d = buf; x < scale->width; x++, d += 3) { d[0] = u8rgb[0]; d[1] = u8rgb[1]; d[2] = u8rgb[2]; } - buf += priv->width * 3; + buf += scale->width * 3; } break; } @@ -823,19 +797,20 @@ gimp_color_scale_render (GimpColorScale *scale) static void gimp_color_scale_render_alpha (GimpColorScale *scale) { - GimpColorScalePrivate *priv = GET_PRIVATE (scale); - GtkRange *range = GTK_RANGE (scale); - gdouble rgb[3]; - gboolean invert; - gdouble a; - guint x, y; - guchar *buf; - guchar *d, *l; + GtkRange *range = GTK_RANGE (scale); + gdouble rgb[3]; + gboolean invert; + gdouble a; + guint x, y; + guchar *buf; + guchar *d, *l; invert = should_invert (range); - buf = priv->buf; - gegl_color_get_pixel (priv->color, babl_format_with_space ("R'G'B' double", priv->format), rgb); + buf = scale->buf; + gegl_color_get_pixel (scale->color, + babl_format_with_space ("R'G'B' double", scale->format), + rgb); switch (gtk_orientable_get_orientation (GTK_ORIENTABLE (range))) { @@ -846,10 +821,10 @@ gimp_color_scale_render_alpha (GimpColorScale *scale) light = buf; /* this won't work correctly for very thin scales */ - dark = (priv->height > GIMP_CHECK_SIZE_SM ? - buf + GIMP_CHECK_SIZE_SM * 3 * priv->width : light); + dark = (scale->height > GIMP_CHECK_SIZE_SM ? + buf + GIMP_CHECK_SIZE_SM * 3 * scale->width : light); - for (x = 0, d = light, l = dark; x < priv->width; x++) + for (x = 0, d = light, l = dark; x < scale->width; x++) { if ((x % GIMP_CHECK_SIZE_SM) == 0) { @@ -860,7 +835,7 @@ gimp_color_scale_render_alpha (GimpColorScale *scale) l = t; } - a = (gdouble) x / (gdouble) (priv->width - 1); + a = (gdouble) x / (gdouble) (scale->width - 1); if (invert) a = 1.0 - a; @@ -876,15 +851,15 @@ gimp_color_scale_render_alpha (GimpColorScale *scale) d += 3; } - for (y = 0, d = buf; y < priv->height; y++, d += 3 * priv->width) + for (y = 0, d = buf; y < scale->height; y++, d += 3 * scale->width) { if (y == 0 || y == GIMP_CHECK_SIZE_SM) continue; if ((y / GIMP_CHECK_SIZE_SM) & 1) - memcpy (d, dark, 3 * priv->width); + memcpy (d, dark, 3 * scale->width); else - memcpy (d, light, 3 * priv->width); + memcpy (d, light, 3 * scale->width); } } break; @@ -894,9 +869,9 @@ gimp_color_scale_render_alpha (GimpColorScale *scale) guchar light[3] = {0xff, 0xff, 0xff}; guchar dark[3] = {0xff, 0xff, 0xff}; - for (y = 0, d = buf; y < priv->height; y++, d += priv->width * 3) + for (y = 0, d = buf; y < scale->height; y++, d += scale->width * 3) { - a = (gdouble) y / (gdouble) (priv->height - 1); + a = (gdouble) y / (gdouble) (scale->height - 1); if (invert) a = 1.0 - a; @@ -909,7 +884,7 @@ gimp_color_scale_render_alpha (GimpColorScale *scale) dark[1] = (GIMP_CHECK_DARK + (rgb[1] - GIMP_CHECK_DARK) * a) * 255.999; dark[2] = (GIMP_CHECK_DARK + (rgb[2] - GIMP_CHECK_DARK) * a) * 255.999; - for (x = 0, l = d; x < priv->width; x++, l += 3) + for (x = 0, l = d; x < scale->width; x++, l += 3) { if (((x / GIMP_CHECK_SIZE_SM) ^ (y / GIMP_CHECK_SIZE_SM)) & 1) { @@ -935,15 +910,14 @@ gimp_color_scale_notify_config (GimpColorConfig *config, const GParamSpec *pspec, GimpColorScale *scale) { - GimpColorScalePrivate *priv = GET_PRIVATE (scale); - GeglColor *color; + GeglColor *color; color = gimp_color_config_get_out_of_gamut_color (config); /* TODO: shouldn't this be color-managed too, using the target space into * consideration? */ - gegl_color_get_pixel (color, babl_format ("R'G'B' u8"), priv->oog_color); - priv->needs_render = TRUE; + gegl_color_get_pixel (color, babl_format ("R'G'B' u8"), scale->oog_color); + scale->needs_render = TRUE; g_object_unref (color); } diff --git a/libgimpwidgets/gimpcolorscale.h b/libgimpwidgets/gimpcolorscale.h index 7ac2d2bc93..3603009c4c 100644 --- a/libgimpwidgets/gimpcolorscale.h +++ b/libgimpwidgets/gimpcolorscale.h @@ -30,41 +30,10 @@ G_BEGIN_DECLS -#define GIMP_TYPE_COLOR_SCALE (gimp_color_scale_get_type ()) -#define GIMP_COLOR_SCALE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_COLOR_SCALE, GimpColorScale)) -#define GIMP_COLOR_SCALE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_COLOR_SCALE, GimpColorScaleClass)) -#define GIMP_IS_COLOR_SCALE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_COLOR_SCALE)) -#define GIMP_IS_COLOR_SCALE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_COLOR_SCALE)) -#define GIMP_COLOR_SCALE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_COLOR_SCALE, GimpColorScaleClass)) +#define GIMP_TYPE_COLOR_SCALE (gimp_color_scale_get_type ()) +G_DECLARE_FINAL_TYPE (GimpColorScale, gimp_color_scale, GIMP, COLOR_SCALE, GtkScale) -typedef struct _GimpColorScalePrivate GimpColorScalePrivate; -typedef struct _GimpColorScaleClass GimpColorScaleClass; - -struct _GimpColorScale -{ - GtkScale parent_instance; - - GimpColorScalePrivate *priv; -}; - -struct _GimpColorScaleClass -{ - GtkScaleClass parent_class; - - /* Padding for future expansion */ - void (* _gimp_reserved1) (void); - void (* _gimp_reserved2) (void); - void (* _gimp_reserved3) (void); - void (* _gimp_reserved4) (void); - void (* _gimp_reserved5) (void); - void (* _gimp_reserved6) (void); - void (* _gimp_reserved7) (void); - void (* _gimp_reserved8) (void); -}; - - -GType gimp_color_scale_get_type (void) G_GNUC_CONST; GtkWidget * gimp_color_scale_new (GtkOrientation orientation, GimpColorSelectorChannel channel); diff --git a/libgimpwidgets/gimpenumlabel.c b/libgimpwidgets/gimpenumlabel.c index 5a3d603bce..6864d5932f 100644 --- a/libgimpwidgets/gimpenumlabel.c +++ b/libgimpwidgets/gimpenumlabel.c @@ -47,13 +47,13 @@ enum }; -struct _GimpEnumLabelPrivate +struct _GimpEnumLabel { + GtkLabel parent_instance; + GEnumClass *enum_class; }; -#define GET_PRIVATE(obj) (((GimpEnumLabel *) (obj))->priv) - static void gimp_enum_label_finalize (GObject *object); static void gimp_enum_label_get_property (GObject *object, @@ -66,7 +66,7 @@ static void gimp_enum_label_set_property (GObject *object, GParamSpec *pspec); -G_DEFINE_TYPE_WITH_PRIVATE (GimpEnumLabel, gimp_enum_label, GTK_TYPE_LABEL) +G_DEFINE_TYPE (GimpEnumLabel, gimp_enum_label, GTK_TYPE_LABEL) #define parent_class gimp_enum_label_parent_class @@ -114,15 +114,14 @@ gimp_enum_label_class_init (GimpEnumLabelClass *klass) static void gimp_enum_label_init (GimpEnumLabel *enum_label) { - enum_label->priv = gimp_enum_label_get_instance_private (enum_label); } static void gimp_enum_label_finalize (GObject *object) { - GimpEnumLabelPrivate *private = GET_PRIVATE (object); + GimpEnumLabel *label = GIMP_ENUM_LABEL (object); - g_clear_pointer (&private->enum_class, g_type_class_unref); + g_clear_pointer (&label->enum_class, g_type_class_unref); G_OBJECT_CLASS (parent_class)->finalize (object); } @@ -133,13 +132,13 @@ gimp_enum_label_get_property (GObject *object, GValue *value, GParamSpec *pspec) { - GimpEnumLabelPrivate *private = GET_PRIVATE (object); + GimpEnumLabel *label = GIMP_ENUM_LABEL (object); switch (property_id) { case PROP_ENUM_TYPE: - if (private->enum_class) - g_value_set_gtype (value, G_TYPE_FROM_CLASS (private->enum_class)); + if (label->enum_class) + g_value_set_gtype (value, G_TYPE_FROM_CLASS (label->enum_class)); else g_value_set_gtype (value, G_TYPE_NONE); break; @@ -156,13 +155,12 @@ gimp_enum_label_set_property (GObject *object, const GValue *value, GParamSpec *pspec) { - GimpEnumLabel *label = GIMP_ENUM_LABEL (object); - GimpEnumLabelPrivate *private = GET_PRIVATE (label); + GimpEnumLabel *label = GIMP_ENUM_LABEL (object); switch (property_id) { case PROP_ENUM_TYPE: - private->enum_class = g_type_class_ref (g_value_get_gtype (value)); + label->enum_class = g_type_class_ref (g_value_get_gtype (value)); break; case PROP_ENUM_VALUE: @@ -207,20 +205,17 @@ void gimp_enum_label_set_value (GimpEnumLabel *label, gint value) { - GimpEnumLabelPrivate *private; - const gchar *nick; - const gchar *desc; + const gchar *nick; + const gchar *desc; g_return_if_fail (GIMP_IS_ENUM_LABEL (label)); - private = GET_PRIVATE (label); - - if (! gimp_enum_get_value (G_TYPE_FROM_CLASS (private->enum_class), value, + if (! gimp_enum_get_value (G_TYPE_FROM_CLASS (label->enum_class), value, NULL, &nick, &desc, NULL)) { g_warning ("%s: %d is not valid for enum of type '%s'", G_STRLOC, value, - g_type_name (G_TYPE_FROM_CLASS (private->enum_class))); + g_type_name (G_TYPE_FROM_CLASS (label->enum_class))); return; } diff --git a/libgimpwidgets/gimpenumlabel.h b/libgimpwidgets/gimpenumlabel.h index afdbed2354..4057437c47 100644 --- a/libgimpwidgets/gimpenumlabel.h +++ b/libgimpwidgets/gimpenumlabel.h @@ -29,42 +29,10 @@ G_BEGIN_DECLS -#define GIMP_TYPE_ENUM_LABEL (gimp_enum_label_get_type ()) -#define GIMP_ENUM_LABEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_ENUM_LABEL, GimpEnumLabel)) -#define GIMP_ENUM_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_ENUM_LABEL, GimpEnumLabelClass)) -#define GIMP_IS_ENUM_LABEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_ENUM_LABEL)) -#define GIMP_IS_ENUM_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_ENUM_LABEL)) -#define GIMP_ENUM_LABEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_ENUM_LABEL, GimpEnumLabelClass)) +#define GIMP_TYPE_ENUM_LABEL (gimp_enum_label_get_type ()) +G_DECLARE_FINAL_TYPE (GimpEnumLabel, gimp_enum_label, GIMP, ENUM_LABEL, GtkScale) -typedef struct _GimpEnumLabelPrivate GimpEnumLabelPrivate; -typedef struct _GimpEnumLabelClass GimpEnumLabelClass; - -struct _GimpEnumLabel -{ - GtkLabel parent_instance; - - GimpEnumLabelPrivate *priv; -}; - -struct _GimpEnumLabelClass -{ - GtkLabelClass parent_class; - - /* Padding for future expansion */ - void (* _gimp_reserved1) (void); - void (* _gimp_reserved2) (void); - void (* _gimp_reserved3) (void); - void (* _gimp_reserved4) (void); - void (* _gimp_reserved5) (void); - void (* _gimp_reserved6) (void); - void (* _gimp_reserved7) (void); - void (* _gimp_reserved8) (void); -}; - - -GType gimp_enum_label_get_type (void) G_GNUC_CONST; - GtkWidget * gimp_enum_label_new (GType enum_type, gint value); void gimp_enum_label_set_value (GimpEnumLabel *label, diff --git a/libgimpwidgets/gimphintbox.c b/libgimpwidgets/gimphintbox.c index 0cc323944f..b1a46903ad 100644 --- a/libgimpwidgets/gimphintbox.c +++ b/libgimpwidgets/gimphintbox.c @@ -45,8 +45,10 @@ enum PROP_HINT }; -struct _GimpHintBoxPrivate +struct _GimpHintBox { + GtkBox parent_instance; + gchar *icon_name; gchar *hint; }; @@ -64,7 +66,7 @@ static void gimp_hint_box_get_property (GObject *object, GParamSpec *pspec); -G_DEFINE_TYPE_WITH_PRIVATE (GimpHintBox, gimp_hint_box, GTK_TYPE_BOX) +G_DEFINE_TYPE (GimpHintBox, gimp_hint_box, GTK_TYPE_BOX) #define parent_class gimp_hint_box_parent_class @@ -99,8 +101,6 @@ gimp_hint_box_class_init (GimpHintBoxClass *klass) static void gimp_hint_box_init (GimpHintBox *box) { - box->priv = gimp_hint_box_get_instance_private (box); - gtk_orientable_set_orientation (GTK_ORIENTABLE (box), GTK_ORIENTATION_HORIZONTAL); } @@ -116,9 +116,9 @@ gimp_hint_box_constructed (GObject *object) gtk_box_set_spacing (GTK_BOX (box), 12); - if (box->priv->icon_name) + if (box->icon_name) { - image = gtk_image_new_from_icon_name (box->priv->icon_name, + image = gtk_image_new_from_icon_name (box->icon_name, GTK_ICON_SIZE_DIALOG); } @@ -129,7 +129,7 @@ gimp_hint_box_constructed (GObject *object) } label = g_object_new (GTK_TYPE_LABEL, - "label", box->priv->hint, + "label", box->hint, "wrap", TRUE, "justify", GTK_JUSTIFY_LEFT, "xalign", 0.0, @@ -148,8 +148,8 @@ gimp_hint_box_finalize (GObject *object) { GimpHintBox *box = GIMP_HINT_BOX (object); - g_clear_pointer (&box->priv->icon_name, g_free); - g_clear_pointer (&box->priv->hint, g_free); + g_clear_pointer (&box->icon_name, g_free); + g_clear_pointer (&box->hint, g_free); G_OBJECT_CLASS (parent_class)->finalize (object); } @@ -165,11 +165,11 @@ gimp_hint_box_set_property (GObject *object, switch (property_id) { case PROP_ICON_NAME: - box->priv->icon_name = g_value_dup_string (value); + box->icon_name = g_value_dup_string (value); break; case PROP_HINT: - box->priv->hint = g_value_dup_string (value); + box->hint = g_value_dup_string (value); break; default: @@ -189,11 +189,11 @@ gimp_hint_box_get_property (GObject *object, switch (property_id) { case PROP_ICON_NAME: - g_value_set_string (value, box->priv->icon_name); + g_value_set_string (value, box->icon_name); break; case PROP_HINT: - g_value_set_string (value, box->priv->hint); + g_value_set_string (value, box->hint); break; default: diff --git a/libgimpwidgets/gimphintbox.h b/libgimpwidgets/gimphintbox.h index c5c050e0ea..40b2b092af 100644 --- a/libgimpwidgets/gimphintbox.h +++ b/libgimpwidgets/gimphintbox.h @@ -31,42 +31,10 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -#define GIMP_TYPE_HINT_BOX (gimp_hint_box_get_type ()) -#define GIMP_HINT_BOX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_HINT_BOX, GimpHintBox)) -#define GIMP_HINT_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_HINT_BOX, GimpHintBoxClass)) -#define GIMP_IS_HINT_BOX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_HINT_BOX)) -#define GIMP_IS_HINT_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_HINT_BOX)) -#define GIMP_HINT_BOX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_HINT_BOX, GimpHintBoxClass)) +#define GIMP_TYPE_HINT_BOX (gimp_hint_box_get_type ()) +G_DECLARE_FINAL_TYPE (GimpHintBox, gimp_hint_box, GIMP, HINT_BOX, GtkBox) -typedef struct _GimpHintBoxPrivate GimpHintBoxPrivate; -typedef struct _GimpHintBoxClass GimpHintBoxClass; - -struct _GimpHintBox -{ - GtkBox parent_instance; - - GimpHintBoxPrivate *priv; -}; - -struct _GimpHintBoxClass -{ - GtkBoxClass parent_class; - - /* Padding for future expansion */ - void (* _gimp_reserved1) (void); - void (* _gimp_reserved2) (void); - void (* _gimp_reserved3) (void); - void (* _gimp_reserved4) (void); - void (* _gimp_reserved5) (void); - void (* _gimp_reserved6) (void); - void (* _gimp_reserved7) (void); - void (* _gimp_reserved8) (void); -}; - - -GType gimp_hint_box_get_type (void) G_GNUC_CONST; - GtkWidget * gimp_hint_box_new (const gchar *hint); diff --git a/libgimpwidgets/gimpintcombobox.c b/libgimpwidgets/gimpintcombobox.c index 1a818eee3c..2591d12a6d 100644 --- a/libgimpwidgets/gimpintcombobox.c +++ b/libgimpwidgets/gimpintcombobox.c @@ -53,7 +53,7 @@ enum }; -struct _GimpIntComboBoxPrivate +typedef struct _GimpIntComboBoxPrivate { GtkCellRenderer *text_renderer; @@ -64,9 +64,7 @@ struct _GimpIntComboBoxPrivate GimpIntSensitivityFunc sensitivity_func; gpointer sensitivity_data; GDestroyNotify sensitivity_destroy; -}; - -#define GET_PRIVATE(obj) (((GimpIntComboBox *) (obj))->priv) +} GimpIntComboBoxPrivate; static void gimp_int_combo_box_constructed (GObject *object); @@ -175,7 +173,7 @@ gimp_int_combo_box_init (GimpIntComboBox *combo_box) GimpIntComboBoxPrivate *priv; GtkListStore *store; - combo_box->priv = priv = gimp_int_combo_box_get_instance_private (combo_box); + priv = gimp_int_combo_box_get_instance_private (combo_box); store = g_object_new (GIMP_TYPE_INT_STORE, NULL); gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (store)); @@ -199,7 +197,10 @@ gimp_int_combo_box_constructed (GObject *object) static void gimp_int_combo_box_finalize (GObject *object) { - GimpIntComboBoxPrivate *priv = GET_PRIVATE (object); + GimpIntComboBox *combo = GIMP_INT_COMBO_BOX (object); + GimpIntComboBoxPrivate *priv; + + priv = gimp_int_combo_box_get_instance_private (combo); g_clear_pointer (&priv->label, g_free); @@ -220,7 +221,10 @@ gimp_int_combo_box_set_property (GObject *object, const GValue *value, GParamSpec *pspec) { - GimpIntComboBoxPrivate *priv = GET_PRIVATE (object); + GimpIntComboBox *combo = GIMP_INT_COMBO_BOX (object); + GimpIntComboBoxPrivate *priv; + + priv = gimp_int_combo_box_get_instance_private (combo); switch (property_id) { @@ -257,7 +261,10 @@ gimp_int_combo_box_get_property (GObject *object, GValue *value, GParamSpec *pspec) { - GimpIntComboBoxPrivate *priv = GET_PRIVATE (object); + GimpIntComboBox *combo = GIMP_INT_COMBO_BOX (object); + GimpIntComboBoxPrivate *priv; + + priv = gimp_int_combo_box_get_instance_private (combo); switch (property_id) { @@ -520,7 +527,7 @@ gboolean gimp_int_combo_box_get_active (GimpIntComboBox *combo_box, gint *value) { - GtkTreeIter iter; + GtkTreeIter iter; g_return_val_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box), FALSE); g_return_val_if_fail (value != NULL, FALSE); @@ -586,7 +593,7 @@ gboolean gimp_int_combo_box_get_active_user_data (GimpIntComboBox *combo_box, gpointer *user_data) { - GtkTreeIter iter; + GtkTreeIter iter; g_return_val_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box), FALSE); g_return_val_if_fail (user_data != NULL, FALSE); @@ -669,7 +676,7 @@ gimp_int_combo_box_set_label (GimpIntComboBox *combo_box, g_return_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box)); - priv = GET_PRIVATE (combo_box); + priv = gimp_int_combo_box_get_instance_private (combo_box); if (label == priv->label) return; @@ -712,9 +719,13 @@ gimp_int_combo_box_set_label (GimpIntComboBox *combo_box, const gchar * gimp_int_combo_box_get_label (GimpIntComboBox *combo_box) { + GimpIntComboBoxPrivate *priv; + g_return_val_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box), NULL); - return GET_PRIVATE (combo_box)->label; + priv = gimp_int_combo_box_get_instance_private (combo_box); + + return priv->label; } /** @@ -734,7 +745,7 @@ gimp_int_combo_box_set_layout (GimpIntComboBox *combo_box, g_return_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box)); - priv = GET_PRIVATE (combo_box); + priv = gimp_int_combo_box_get_instance_private (combo_box); if (layout == priv->layout) return; @@ -759,10 +770,14 @@ gimp_int_combo_box_set_layout (GimpIntComboBox *combo_box, GimpIntComboBoxLayout gimp_int_combo_box_get_layout (GimpIntComboBox *combo_box) { + GimpIntComboBoxPrivate *priv; + g_return_val_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box), GIMP_INT_COMBO_BOX_LAYOUT_ABBREVIATED); - return GET_PRIVATE (combo_box)->layout; + priv = gimp_int_combo_box_get_instance_private (combo_box); + + return priv->layout; } /** @@ -791,7 +806,7 @@ gimp_int_combo_box_set_sensitivity (GimpIntComboBox *combo_box, g_return_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box)); - priv = GET_PRIVATE (combo_box); + priv = gimp_int_combo_box_get_instance_private (combo_box); if (priv->sensitivity_destroy) { @@ -825,12 +840,14 @@ gimp_int_combo_box_changed (GtkComboBox *combo_box, static void gimp_int_combo_box_create_cells (GimpIntComboBox *combo_box) { - GimpIntComboBoxPrivate *priv = GET_PRIVATE (combo_box); + GimpIntComboBoxPrivate *priv; GtkCellLayout *layout = GTK_CELL_LAYOUT (combo_box); GtkCellRenderer *text_renderer; GtkCellRenderer *pixbuf_renderer; gboolean popup_shown; + priv = gimp_int_combo_box_get_instance_private (combo_box); + g_object_get (combo_box, "popup-shown", &popup_shown, NULL); gtk_cell_layout_clear (layout); diff --git a/libgimpwidgets/gimpintcombobox.h b/libgimpwidgets/gimpintcombobox.h index e05703db4a..a5d3bd8c90 100644 --- a/libgimpwidgets/gimpintcombobox.h +++ b/libgimpwidgets/gimpintcombobox.h @@ -29,24 +29,10 @@ G_BEGIN_DECLS -#define GIMP_TYPE_INT_COMBO_BOX (gimp_int_combo_box_get_type ()) -#define GIMP_INT_COMBO_BOX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_INT_COMBO_BOX, GimpIntComboBox)) -#define GIMP_INT_COMBO_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_INT_COMBO_BOX, GimpIntComboBoxClass)) -#define GIMP_IS_INT_COMBO_BOX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_INT_COMBO_BOX)) -#define GIMP_IS_INT_COMBO_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_INT_COMBO_BOX)) -#define GIMP_INT_COMBO_BOX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_INT_COMBO_BOX, GimpIntComboBoxClass)) +#define GIMP_TYPE_INT_COMBO_BOX (gimp_int_combo_box_get_type ()) +G_DECLARE_DERIVABLE_TYPE (GimpIntComboBox, gimp_int_combo_box, GIMP, INT_COMBO_BOX, GtkComboBox) -typedef struct _GimpIntComboBoxPrivate GimpIntComboBoxPrivate; -typedef struct _GimpIntComboBoxClass GimpIntComboBoxClass; - -struct _GimpIntComboBox -{ - GtkComboBox parent_instance; - - GimpIntComboBoxPrivate *priv; -}; - struct _GimpIntComboBoxClass { GtkComboBoxClass parent_class; @@ -72,9 +58,6 @@ typedef gboolean (* GimpIntSensitivityFunc) (gint value, gpointer data); - -GType gimp_int_combo_box_get_type (void) G_GNUC_CONST; - GtkWidget * gimp_int_combo_box_new (const gchar *first_label, gint first_value, ...) G_GNUC_NULL_TERMINATED; diff --git a/libgimpwidgets/gimppreviewarea.c b/libgimpwidgets/gimppreviewarea.c index f5c0e1e6b6..2347f3b86d 100644 --- a/libgimpwidgets/gimppreviewarea.c +++ b/libgimpwidgets/gimppreviewarea.c @@ -58,21 +58,23 @@ enum #define DEFAULT_CHECK_SIZE GIMP_CHECK_SIZE_MEDIUM_CHECKS #define DEFAULT_CHECK_TYPE GIMP_CHECK_TYPE_GRAY_CHECKS -#define CHECK_R(priv, row, col) \ - (((((priv)->offset_y + (row)) & size) ^ \ - (((priv)->offset_x + (col)) & size)) ? rgb1[0] : rgb2[0]) +#define CHECK_R(are, row, col) \ + (((((area)->offset_y + (row)) & size) ^ \ + (((area)->offset_x + (col)) & size)) ? rgb1[0] : rgb2[0]) -#define CHECK_G(priv, row, col) \ - (((((priv)->offset_y + (row)) & size) ^ \ - (((priv)->offset_x + (col)) & size)) ? rgb1[1] : rgb2[1]) +#define CHECK_G(area, row, col) \ + (((((area)->offset_y + (row)) & size) ^ \ + (((area)->offset_x + (col)) & size)) ? rgb1[1] : rgb2[1]) -#define CHECK_B(priv, row, col) \ - (((((priv)->offset_y + (row)) & size) ^ \ - (((priv)->offset_x + (col)) & size)) ? rgb1[2] : rgb2[2]) +#define CHECK_B(area, row, col) \ + (((((area)->offset_y + (row)) & size) ^ \ + (((area)->offset_x + (col)) & size)) ? rgb1[2] : rgb2[2]) -struct _GimpPreviewAreaPrivate +struct _GimpPreviewArea { + GtkDrawingArea parent_instance; + GimpCheckSize check_size; GimpCheckType check_type; GeglColor *check_custom_color1; @@ -91,8 +93,6 @@ struct _GimpPreviewAreaPrivate GimpColorTransform *transform; }; -#define GET_PRIVATE(obj) (((GimpPreviewArea *) (obj))->priv) - static void gimp_preview_area_dispose (GObject *object); static void gimp_preview_area_finalize (GObject *object); @@ -121,8 +121,7 @@ static void gimp_preview_area_create_transform (GimpPreviewArea *area); static void gimp_preview_area_destroy_transform (GimpPreviewArea *area); -G_DEFINE_TYPE_WITH_PRIVATE (GimpPreviewArea, gimp_preview_area, - GTK_TYPE_DRAWING_AREA) +G_DEFINE_TYPE (GimpPreviewArea, gimp_preview_area, GTK_TYPE_DRAWING_AREA) #define parent_class gimp_preview_area_parent_class @@ -187,20 +186,14 @@ gimp_preview_area_class_init (GimpPreviewAreaClass *klass) static void gimp_preview_area_init (GimpPreviewArea *area) { - GimpPreviewAreaPrivate *priv; - - area->priv = gimp_preview_area_get_instance_private (area); - - priv = area->priv; - - priv->check_size = DEFAULT_CHECK_SIZE; - priv->check_type = DEFAULT_CHECK_TYPE; - priv->check_custom_color1 = gegl_color_new (NULL); - gegl_color_set_pixel (priv->check_custom_color1, babl_format ("R'G'B'A double"), GIMP_CHECKS_CUSTOM_COLOR1); - priv->check_custom_color2 = gegl_color_new (NULL); - gegl_color_set_pixel (priv->check_custom_color2, babl_format ("R'G'B'A double"), GIMP_CHECKS_CUSTOM_COLOR2); - priv->max_width = -1; - priv->max_height = -1; + area->check_size = DEFAULT_CHECK_SIZE; + area->check_type = DEFAULT_CHECK_TYPE; + area->check_custom_color1 = gegl_color_new (NULL); + gegl_color_set_pixel (area->check_custom_color1, babl_format ("R'G'B'A double"), GIMP_CHECKS_CUSTOM_COLOR1); + area->check_custom_color2 = gegl_color_new (NULL); + gegl_color_set_pixel (area->check_custom_color2, babl_format ("R'G'B'A double"), GIMP_CHECKS_CUSTOM_COLOR2); + area->max_width = -1; + area->max_height = -1; gimp_widget_track_monitor (GTK_WIDGET (area), G_CALLBACK (gimp_preview_area_destroy_transform), @@ -220,12 +213,12 @@ gimp_preview_area_dispose (GObject *object) static void gimp_preview_area_finalize (GObject *object) { - GimpPreviewAreaPrivate *priv = GET_PRIVATE (object); + GimpPreviewArea *area = GIMP_PREVIEW_AREA (object); - g_clear_pointer (&priv->buf, g_free); - g_clear_pointer (&priv->colormap, g_free); - g_clear_object (&priv->check_custom_color1); - g_clear_object (&priv->check_custom_color2); + g_clear_pointer (&area->buf, g_free); + g_clear_pointer (&area->colormap, g_free); + g_clear_object (&area->check_custom_color1); + g_clear_object (&area->check_custom_color2); G_OBJECT_CLASS (parent_class)->finalize (object); } @@ -236,23 +229,23 @@ gimp_preview_area_set_property (GObject *object, const GValue *value, GParamSpec *pspec) { - GimpPreviewAreaPrivate *priv = GET_PRIVATE (object); + GimpPreviewArea *area = GIMP_PREVIEW_AREA (object); switch (property_id) { case PROP_CHECK_SIZE: - priv->check_size = g_value_get_enum (value); + area->check_size = g_value_get_enum (value); break; case PROP_CHECK_TYPE: - priv->check_type = g_value_get_enum (value); + area->check_type = g_value_get_enum (value); break; case PROP_CHECK_CUSTOM_COLOR1: - g_clear_object (&priv->check_custom_color1); - priv->check_custom_color1 = gegl_color_duplicate (g_value_get_object (value)); + g_clear_object (&area->check_custom_color1); + area->check_custom_color1 = gegl_color_duplicate (g_value_get_object (value)); break; case PROP_CHECK_CUSTOM_COLOR2: - g_clear_object (&priv->check_custom_color2); - priv->check_custom_color2 = gegl_color_duplicate (g_value_get_object (value)); + g_clear_object (&area->check_custom_color2); + area->check_custom_color2 = gegl_color_duplicate (g_value_get_object (value)); break; default: @@ -267,21 +260,21 @@ gimp_preview_area_get_property (GObject *object, GValue *value, GParamSpec *pspec) { - GimpPreviewAreaPrivate *priv = GET_PRIVATE (object); + GimpPreviewArea *area = GIMP_PREVIEW_AREA (object); switch (property_id) { case PROP_CHECK_SIZE: - g_value_set_enum (value, priv->check_size); + g_value_set_enum (value, area->check_size); break; case PROP_CHECK_TYPE: - g_value_set_enum (value, priv->check_type); + g_value_set_enum (value, area->check_type); break; case PROP_CHECK_CUSTOM_COLOR1: - g_value_set_object (value, priv->check_custom_color1); + g_value_set_object (value, area->check_custom_color1); break; case PROP_CHECK_CUSTOM_COLOR2: - g_value_set_object (value, priv->check_custom_color2); + g_value_set_object (value, area->check_custom_color2); break; default: @@ -294,30 +287,30 @@ static void gimp_preview_area_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { - GimpPreviewAreaPrivate *priv = GET_PRIVATE (widget); - gint width; - gint height; + GimpPreviewArea *area = GIMP_PREVIEW_AREA (widget); + gint width; + gint height; if (GTK_WIDGET_CLASS (parent_class)->size_allocate) GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, allocation); - width = (priv->max_width > 0 ? - MIN (allocation->width, priv->max_width) : allocation->width); - height = (priv->max_height > 0 ? - MIN (allocation->height, priv->max_height) : allocation->height); + width = (area->max_width > 0 ? + MIN (allocation->width, area->max_width) : allocation->width); + height = (area->max_height > 0 ? + MIN (allocation->height, area->max_height) : allocation->height); - if (width != priv->width || height != priv->height) + if (width != area->width || height != area->height) { - if (priv->buf) + if (area->buf) { - g_free (priv->buf); + g_free (area->buf); - priv->buf = NULL; - priv->rowstride = 0; + area->buf = NULL; + area->rowstride = 0; } - priv->width = width; - priv->height = height; + area->width = width; + area->height = height; } } @@ -325,42 +318,41 @@ static gboolean gimp_preview_area_widget_draw (GtkWidget *widget, cairo_t *cr) { - GimpPreviewArea *area = GIMP_PREVIEW_AREA (widget); - GimpPreviewAreaPrivate *priv = GET_PRIVATE (area); - GtkAllocation allocation; - GdkPixbuf *pixbuf; - GdkRectangle rect; + GimpPreviewArea *area = GIMP_PREVIEW_AREA (widget); + GtkAllocation allocation; + GdkPixbuf *pixbuf; + GdkRectangle rect; - if (! priv->buf) + if (! area->buf) return FALSE; gtk_widget_get_allocation (widget, &allocation); - rect.x = (allocation.width - priv->width) / 2; - rect.y = (allocation.height - priv->height) / 2; - rect.width = priv->width; - rect.height = priv->height; + rect.x = (allocation.width - area->width) / 2; + rect.y = (allocation.height - area->height) / 2; + rect.width = area->width; + rect.height = area->height; - if (! priv->transform) + if (! area->transform) gimp_preview_area_create_transform (area); - if (priv->transform) + if (area->transform) { const Babl *format = babl_format ("R'G'B' u8"); - gint rowstride = ((priv->width * 3) + 3) & ~3; - guchar *buf = g_new (guchar, rowstride * priv->height); - guchar *src = priv->buf; + gint rowstride = ((area->width * 3) + 3) & ~3; + guchar *buf = g_new (guchar, rowstride * area->height); + guchar *src = area->buf; guchar *dest = buf; gint i; - for (i = 0; i < priv->height; i++) + for (i = 0; i < area->height; i++) { - gimp_color_transform_process_pixels (priv->transform, + gimp_color_transform_process_pixels (area->transform, format, src, format, dest, - priv->width); + area->width); - src += priv->rowstride; + src += area->rowstride; dest += rowstride; } @@ -375,13 +367,13 @@ gimp_preview_area_widget_draw (GtkWidget *widget, } else { - pixbuf = gdk_pixbuf_new_from_data (priv->buf, + pixbuf = gdk_pixbuf_new_from_data (area->buf, GDK_COLORSPACE_RGB, FALSE, 8, rect.width, rect.height, - priv->rowstride, + area->rowstride, NULL, NULL); } @@ -400,14 +392,13 @@ gimp_preview_area_queue_draw (GimpPreviewArea *area, gint width, gint height) { - GimpPreviewAreaPrivate *priv = GET_PRIVATE (area); - GtkWidget *widget = GTK_WIDGET (area); - GtkAllocation allocation; + GtkWidget *widget = GTK_WIDGET (area); + GtkAllocation allocation; gtk_widget_get_allocation (widget, &allocation); - x += (allocation.width - priv->width) / 2; - y += (allocation.height - priv->height) / 2; + x += (allocation.width - area->width) / 2; + y += (allocation.height - area->height) / 2; gtk_widget_queue_draw_area (widget, x, y, width, height); } @@ -440,9 +431,7 @@ gimp_preview_area_image_type_bytes (GimpImageType type) static void gimp_preview_area_create_transform (GimpPreviewArea *area) { - GimpPreviewAreaPrivate *priv = GET_PRIVATE (area); - - if (priv->config) + if (area->config) { static GimpColorProfile *profile = NULL; @@ -451,8 +440,8 @@ gimp_preview_area_create_transform (GimpPreviewArea *area) if (G_UNLIKELY (! profile)) profile = gimp_color_profile_new_rgb_srgb (); - priv->transform = gimp_widget_get_color_transform (GTK_WIDGET (area), - priv->config, + area->transform = gimp_widget_get_color_transform (GTK_WIDGET (area), + area->config, profile, format, format, @@ -465,12 +454,10 @@ gimp_preview_area_create_transform (GimpPreviewArea *area) static void gimp_preview_area_destroy_transform (GimpPreviewArea *area) { - GimpPreviewAreaPrivate *priv = GET_PRIVATE (area); - - if (priv->transform) + if (area->transform) { - g_object_unref (priv->transform); - priv->transform = NULL; + g_object_unref (area->transform); + area->transform = NULL; } gtk_widget_queue_draw (GTK_WIDGET (area)); @@ -531,32 +518,29 @@ gimp_preview_area_draw (GimpPreviewArea *area, const guchar *buf, gint rowstride) { - GimpPreviewAreaPrivate *priv; - const guchar *src; - guchar *dest; - guint size; - GeglColor *color1; - GeglColor *color2; - guchar rgb1[3]; - guchar rgb2[3]; - gint row; - gint col; + const guchar *src; + guchar *dest; + guint size; + GeglColor *color1; + GeglColor *color2; + guchar rgb1[3]; + guchar rgb2[3]; + gint row; + gint col; g_return_if_fail (GIMP_IS_PREVIEW_AREA (area)); g_return_if_fail (width >= 0 && height >= 0); - priv = GET_PRIVATE (area); - if (width == 0 || height == 0) return; g_return_if_fail (buf != NULL); g_return_if_fail (rowstride > 0); - if (x + width < 0 || x >= priv->width) + if (x + width < 0 || x >= area->width) return; - if (y + height < 0 || y >= priv->height) + if (y + height < 0 || y >= area->height) return; if (x < 0) @@ -569,8 +553,8 @@ gimp_preview_area_draw (GimpPreviewArea *area, x = 0; } - if (x + width > priv->width) - width = priv->width - x; + if (x + width > area->width) + width = area->width - x; if (y < 0) { @@ -580,26 +564,26 @@ gimp_preview_area_draw (GimpPreviewArea *area, y = 0; } - if (y + height > priv->height) - height = priv->height - y; + if (y + height > area->height) + height = area->height - y; - if (! priv->buf) + if (! area->buf) { - priv->rowstride = ((priv->width * 3) + 3) & ~3; - priv->buf = g_new0 (guchar, priv->rowstride * priv->height); + area->rowstride = ((area->width * 3) + 3) & ~3; + area->buf = g_new0 (guchar, area->rowstride * area->height); } - size = 1 << (2 + priv->check_size); - color1 = priv->check_custom_color1; - color2 = priv->check_custom_color2; - gimp_checks_get_colors (priv->check_type, &color1, &color2); + size = 1 << (2 + area->check_size); + color1 = area->check_custom_color1; + color2 = area->check_custom_color2; + gimp_checks_get_colors (area->check_type, &color1, &color2); gegl_color_get_pixel (color1, babl_format ("R'G'B' u8"), rgb1); gegl_color_get_pixel (color2, babl_format ("R'G'B' u8"), rgb2); g_object_unref (color1); g_object_unref (color2); src = buf; - dest = priv->buf + x * 3 + y * priv->rowstride; + dest = area->buf + x * 3 + y * area->rowstride; switch (type) { @@ -609,7 +593,7 @@ gimp_preview_area_draw (GimpPreviewArea *area, memcpy (dest, src, 3 * width); src += rowstride; - dest += priv->rowstride; + dest += area->rowstride; } break; @@ -624,9 +608,9 @@ gimp_preview_area_draw (GimpPreviewArea *area, switch (s[3]) { case 0: - d[0] = CHECK_R (priv, row, col); - d[1] = CHECK_G (priv, row, col); - d[2] = CHECK_B (priv, row, col); + d[0] = CHECK_R (area, row, col); + d[1] = CHECK_G (area, row, col); + d[2] = CHECK_B (area, row, col); break; case 255: @@ -638,9 +622,9 @@ gimp_preview_area_draw (GimpPreviewArea *area, default: { register guint alpha = s[3] + 1; - register guint check_r = CHECK_R (priv, row, col); - register guint check_g = CHECK_G (priv, row, col); - register guint check_b = CHECK_B (priv, row, col); + register guint check_r = CHECK_R (area, row, col); + register guint check_g = CHECK_G (area, row, col); + register guint check_b = CHECK_B (area, row, col); d[0] = ((check_r << 8) + (s[0] - check_r) * alpha) >> 8; d[1] = ((check_g << 8) + (s[1] - check_g) * alpha) >> 8; @@ -651,7 +635,7 @@ gimp_preview_area_draw (GimpPreviewArea *area, } src += rowstride; - dest += priv->rowstride; + dest += area->rowstride; } break; @@ -667,7 +651,7 @@ gimp_preview_area_draw (GimpPreviewArea *area, } src += rowstride; - dest += priv->rowstride; + dest += area->rowstride; } break; @@ -682,9 +666,9 @@ gimp_preview_area_draw (GimpPreviewArea *area, switch (s[1]) { case 0: - d[0] = CHECK_R (priv, row, col); - d[1] = CHECK_G (priv, row, col); - d[2] = CHECK_B (priv, row, col); + d[0] = CHECK_R (area, row, col); + d[1] = CHECK_G (area, row, col); + d[2] = CHECK_B (area, row, col); break; case 255: @@ -694,9 +678,9 @@ gimp_preview_area_draw (GimpPreviewArea *area, default: { register guint alpha = s[1] + 1; - register guint check_r = CHECK_R (priv, row, col); - register guint check_g = CHECK_G (priv, row, col); - register guint check_b = CHECK_B (priv, row, col); + register guint check_r = CHECK_R (area, row, col); + register guint check_g = CHECK_G (area, row, col); + register guint check_b = CHECK_B (area, row, col); d[0] = ((check_r << 8) + (s[0] - check_r) * alpha) >> 8; d[1] = ((check_g << 8) + (s[0] - check_g) * alpha) >> 8; @@ -707,12 +691,12 @@ gimp_preview_area_draw (GimpPreviewArea *area, } src += rowstride; - dest += priv->rowstride; + dest += area->rowstride; } break; case GIMP_INDEXED_IMAGE: - g_return_if_fail (priv->colormap != NULL); + g_return_if_fail (area->colormap != NULL); for (row = 0; row < height; row++) { const guchar *s = src; @@ -720,7 +704,7 @@ gimp_preview_area_draw (GimpPreviewArea *area, for (col = 0; col < width; col++, s++, d += 3) { - const guchar *colormap = priv->colormap + 3 * s[0]; + const guchar *colormap = area->colormap + 3 * s[0]; d[0] = colormap[0]; d[1] = colormap[1]; @@ -728,12 +712,12 @@ gimp_preview_area_draw (GimpPreviewArea *area, } src += rowstride; - dest += priv->rowstride; + dest += area->rowstride; } break; case GIMP_INDEXEDA_IMAGE: - g_return_if_fail (priv->colormap != NULL); + g_return_if_fail (area->colormap != NULL); for (row = y; row < y + height; row++) { const guchar *s = src; @@ -741,14 +725,14 @@ gimp_preview_area_draw (GimpPreviewArea *area, for (col = x; col < x + width; col++, s += 2, d += 3) { - const guchar *colormap = priv->colormap + 3 * s[0]; + const guchar *colormap = area->colormap + 3 * s[0]; switch (s[1]) { case 0: - d[0] = CHECK_R (priv, row, col); - d[1] = CHECK_G (priv, row, col); - d[2] = CHECK_B (priv, row, col); + d[0] = CHECK_R (area, row, col); + d[1] = CHECK_G (area, row, col); + d[2] = CHECK_B (area, row, col); break; case 255: @@ -760,9 +744,9 @@ gimp_preview_area_draw (GimpPreviewArea *area, default: { register guint alpha = s[3] + 1; - register guint check_r = CHECK_R (priv, row, col); - register guint check_g = CHECK_G (priv, row, col); - register guint check_b = CHECK_B (priv, row, col); + register guint check_r = CHECK_R (area, row, col); + register guint check_g = CHECK_G (area, row, col); + register guint check_b = CHECK_B (area, row, col); d[0] = ((check_r << 8) + (colormap[0] - check_r) * alpha) >> 8; d[1] = ((check_g << 8) + (colormap[1] - check_g) * alpha) >> 8; @@ -773,7 +757,7 @@ gimp_preview_area_draw (GimpPreviewArea *area, } src += rowstride; - dest += priv->rowstride; + dest += area->rowstride; } break; } @@ -815,24 +799,21 @@ gimp_preview_area_blend (GimpPreviewArea *area, gint rowstride2, guchar opacity) { - GimpPreviewAreaPrivate *priv; - const guchar *src1; - const guchar *src2; - guchar *dest; - guint size; - GeglColor *color1; - GeglColor *color2; - guchar rgb1[3]; - guchar rgb2[3]; - gint row; - gint col; - gint i; + const guchar *src1; + const guchar *src2; + guchar *dest; + guint size; + GeglColor *color1; + GeglColor *color2; + guchar rgb1[3]; + guchar rgb2[3]; + gint row; + gint col; + gint i; g_return_if_fail (GIMP_IS_PREVIEW_AREA (area)); g_return_if_fail (width >= 0 && height >= 0); - priv = GET_PRIVATE (area); - if (width == 0 || height == 0) return; @@ -857,10 +838,10 @@ gimp_preview_area_blend (GimpPreviewArea *area, break; } - if (x + width < 0 || x >= priv->width) + if (x + width < 0 || x >= area->width) return; - if (y + height < 0 || y >= priv->height) + if (y + height < 0 || y >= area->height) return; if (x < 0) @@ -874,8 +855,8 @@ gimp_preview_area_blend (GimpPreviewArea *area, x = 0; } - if (x + width > priv->width) - width = priv->width - x; + if (x + width > area->width) + width = area->width - x; if (y < 0) { @@ -886,19 +867,19 @@ gimp_preview_area_blend (GimpPreviewArea *area, y = 0; } - if (y + height > priv->height) - height = priv->height - y; + if (y + height > area->height) + height = area->height - y; - if (! priv->buf) + if (! area->buf) { - priv->rowstride = ((priv->width * 3) + 3) & ~3; - priv->buf = g_new0 (guchar, priv->rowstride * priv->height); + area->rowstride = ((area->width * 3) + 3) & ~3; + area->buf = g_new0 (guchar, area->rowstride * area->height); } - size = 1 << (2 + priv->check_size); - color1 = priv->check_custom_color1; - color2 = priv->check_custom_color2; - gimp_checks_get_colors (priv->check_type, &color1, &color2); + size = 1 << (2 + area->check_size); + color1 = area->check_custom_color1; + color2 = area->check_custom_color2; + gimp_checks_get_colors (area->check_type, &color1, &color2); gegl_color_get_pixel (color1, babl_format ("R'G'B' u8"), rgb1); gegl_color_get_pixel (color2, babl_format ("R'G'B' u8"), rgb2); g_object_unref (color1); @@ -906,7 +887,7 @@ gimp_preview_area_blend (GimpPreviewArea *area, src1 = buf1; src2 = buf2; - dest = priv->buf + x * 3 + y * priv->rowstride; + dest = area->buf + x * 3 + y * area->rowstride; switch (type) { @@ -926,7 +907,7 @@ gimp_preview_area_blend (GimpPreviewArea *area, src1 += rowstride1; src2 += rowstride2; - dest += priv->rowstride; + dest += area->rowstride; } break; @@ -968,9 +949,9 @@ gimp_preview_area_blend (GimpPreviewArea *area, switch (inter[3]) { case 0: - d[0] = CHECK_R (priv, row, col); - d[1] = CHECK_G (priv, row, col); - d[2] = CHECK_B (priv, row, col); + d[0] = CHECK_R (area, row, col); + d[1] = CHECK_G (area, row, col); + d[2] = CHECK_B (area, row, col); break; case 255: @@ -982,9 +963,9 @@ gimp_preview_area_blend (GimpPreviewArea *area, default: { register guint alpha = inter[3] + 1; - register guint check_r = CHECK_R (priv, row, col); - register guint check_g = CHECK_G (priv, row, col); - register guint check_b = CHECK_B (priv, row, col); + register guint check_r = CHECK_R (area, row, col); + register guint check_g = CHECK_G (area, row, col); + register guint check_b = CHECK_B (area, row, col); d[0] = ((check_r << 8) + (inter[0] - check_r) * alpha) >> 8; d[1] = ((check_g << 8) + (inter[1] - check_g) * alpha) >> 8; @@ -996,7 +977,7 @@ gimp_preview_area_blend (GimpPreviewArea *area, src1 += rowstride1; src2 += rowstride2; - dest += priv->rowstride; + dest += area->rowstride; } break; @@ -1015,7 +996,7 @@ gimp_preview_area_blend (GimpPreviewArea *area, src1 += rowstride1; src2 += rowstride2; - dest += priv->rowstride; + dest += area->rowstride; } break; @@ -1052,9 +1033,9 @@ gimp_preview_area_blend (GimpPreviewArea *area, switch (inter[1]) { case 0: - d[0] = CHECK_R (priv, row, col); - d[1] = CHECK_G (priv, row, col); - d[2] = CHECK_B (priv, row, col); + d[0] = CHECK_R (area, row, col); + d[1] = CHECK_G (area, row, col); + d[2] = CHECK_B (area, row, col); break; case 255: @@ -1064,9 +1045,9 @@ gimp_preview_area_blend (GimpPreviewArea *area, default: { register guint alpha = inter[1] + 1; - register guint check_r = CHECK_R (priv, row, col); - register guint check_g = CHECK_G (priv, row, col); - register guint check_b = CHECK_B (priv, row, col); + register guint check_r = CHECK_R (area, row, col); + register guint check_g = CHECK_G (area, row, col); + register guint check_b = CHECK_B (area, row, col); d[0] = ((check_r << 8) + (inter[0] - check_r) * alpha) >> 8; d[1] = ((check_g << 8) + (inter[0] - check_g) * alpha) >> 8; @@ -1078,12 +1059,12 @@ gimp_preview_area_blend (GimpPreviewArea *area, src1 += rowstride1; src2 += rowstride2; - dest += priv->rowstride; + dest += area->rowstride; } break; case GIMP_INDEXED_IMAGE: - g_return_if_fail (priv->colormap != NULL); + g_return_if_fail (area->colormap != NULL); for (row = 0; row < height; row++) { const guchar *s1 = src1; @@ -1092,8 +1073,8 @@ gimp_preview_area_blend (GimpPreviewArea *area, for (col = 0; col < width; col++, s1++, s2++, d += 3) { - const guchar *cmap1 = priv->colormap + 3 * s1[0]; - const guchar *cmap2 = priv->colormap + 3 * s2[0]; + const guchar *cmap1 = area->colormap + 3 * s1[0]; + const guchar *cmap2 = area->colormap + 3 * s2[0]; d[0] = ((cmap1[0] << 8) + (cmap2[0] - cmap1[0]) * opacity) >> 8; d[1] = ((cmap1[1] << 8) + (cmap2[1] - cmap1[1]) * opacity) >> 8; @@ -1102,12 +1083,12 @@ gimp_preview_area_blend (GimpPreviewArea *area, src1 += rowstride1; src2 += rowstride2; - dest += priv->rowstride; + dest += area->rowstride; } break; case GIMP_INDEXEDA_IMAGE: - g_return_if_fail (priv->colormap != NULL); + g_return_if_fail (area->colormap != NULL); for (row = y; row < y + height; row++) { const guchar *s1 = src1; @@ -1116,8 +1097,8 @@ gimp_preview_area_blend (GimpPreviewArea *area, for (col = x; col < x + width; col++, s1 += 2, s2 += 2, d += 3) { - const guchar *cmap1 = priv->colormap + 3 * s1[0]; - const guchar *cmap2 = priv->colormap + 3 * s2[0]; + const guchar *cmap1 = area->colormap + 3 * s1[0]; + const guchar *cmap2 = area->colormap + 3 * s2[0]; guchar inter[4]; if (s1[1] == s2[1]) @@ -1150,9 +1131,9 @@ gimp_preview_area_blend (GimpPreviewArea *area, switch (inter[3]) { case 0: - d[0] = CHECK_R (priv, row, col); - d[1] = CHECK_G (priv, row, col); - d[2] = CHECK_B (priv, row, col); + d[0] = CHECK_R (area, row, col); + d[1] = CHECK_G (area, row, col); + d[2] = CHECK_B (area, row, col); break; case 255: @@ -1164,9 +1145,9 @@ gimp_preview_area_blend (GimpPreviewArea *area, default: { register guint alpha = inter[3] + 1; - register guint check_r = CHECK_R (priv, row, col); - register guint check_g = CHECK_G (priv, row, col); - register guint check_b = CHECK_B (priv, row, col); + register guint check_r = CHECK_R (area, row, col); + register guint check_g = CHECK_G (area, row, col); + register guint check_b = CHECK_B (area, row, col); d[0] = ((check_r << 8) + (inter[0] - check_r) * alpha) >> 8; d[1] = ((check_g << 8) + (inter[1] - check_g) * alpha) >> 8; @@ -1178,7 +1159,7 @@ gimp_preview_area_blend (GimpPreviewArea *area, src1 += rowstride1; src2 += rowstride2; - dest += priv->rowstride; + dest += area->rowstride; } break; } @@ -1223,25 +1204,22 @@ gimp_preview_area_mask (GimpPreviewArea *area, const guchar *mask, gint rowstride_mask) { - GimpPreviewAreaPrivate *priv; - const guchar *src1; - const guchar *src2; - const guchar *src_mask; - guchar *dest; - guint size; - GeglColor *color1; - GeglColor *color2; - guchar rgb1[3]; - guchar rgb2[3]; - gint row; - gint col; - gint i; + const guchar *src1; + const guchar *src2; + const guchar *src_mask; + guchar *dest; + guint size; + GeglColor *color1; + GeglColor *color2; + guchar rgb1[3]; + guchar rgb2[3]; + gint row; + gint col; + gint i; g_return_if_fail (GIMP_IS_PREVIEW_AREA (area)); g_return_if_fail (width >= 0 && height >= 0); - priv = GET_PRIVATE (area); - if (width == 0 || height == 0) return; @@ -1252,10 +1230,10 @@ gimp_preview_area_mask (GimpPreviewArea *area, g_return_if_fail (rowstride2 > 0); g_return_if_fail (rowstride_mask > 0); - if (x + width < 0 || x >= priv->width) + if (x + width < 0 || x >= area->width) return; - if (y + height < 0 || y >= priv->height) + if (y + height < 0 || y >= area->height) return; if (x < 0) @@ -1270,8 +1248,8 @@ gimp_preview_area_mask (GimpPreviewArea *area, x = 0; } - if (x + width > priv->width) - width = priv->width - x; + if (x + width > area->width) + width = area->width - x; if (y < 0) { @@ -1283,19 +1261,19 @@ gimp_preview_area_mask (GimpPreviewArea *area, y = 0; } - if (y + height > priv->height) - height = priv->height - y; + if (y + height > area->height) + height = area->height - y; - if (! priv->buf) + if (! area->buf) { - priv->rowstride = ((priv->width * 3) + 3) & ~3; - priv->buf = g_new0 (guchar, priv->rowstride * priv->height); + area->rowstride = ((area->width * 3) + 3) & ~3; + area->buf = g_new0 (guchar, area->rowstride * area->height); } - size = 1 << (2 + priv->check_size); - color1 = priv->check_custom_color1; - color2 = priv->check_custom_color2; - gimp_checks_get_colors (priv->check_type, &color1, &color2); + size = 1 << (2 + area->check_size); + color1 = area->check_custom_color1; + color2 = area->check_custom_color2; + gimp_checks_get_colors (area->check_type, &color1, &color2); gegl_color_get_pixel (color1, babl_format ("R'G'B' u8"), rgb1); gegl_color_get_pixel (color2, babl_format ("R'G'B' u8"), rgb2); g_object_unref (color1); @@ -1304,7 +1282,7 @@ gimp_preview_area_mask (GimpPreviewArea *area, src1 = buf1; src2 = buf2; src_mask = mask; - dest = priv->buf + x * 3 + y * priv->rowstride; + dest = area->buf + x * 3 + y * area->rowstride; switch (type) { @@ -1326,7 +1304,7 @@ gimp_preview_area_mask (GimpPreviewArea *area, src1 += rowstride1; src2 += rowstride2; src_mask += rowstride_mask; - dest += priv->rowstride; + dest += area->rowstride; } break; @@ -1346,9 +1324,9 @@ gimp_preview_area_mask (GimpPreviewArea *area, switch (s1[3]) { case 0: - d[0] = CHECK_R (priv, row, col); - d[1] = CHECK_G (priv, row, col); - d[2] = CHECK_B (priv, row, col); + d[0] = CHECK_R (area, row, col); + d[1] = CHECK_G (area, row, col); + d[2] = CHECK_B (area, row, col); break; case 255: @@ -1360,9 +1338,9 @@ gimp_preview_area_mask (GimpPreviewArea *area, default: { register guint alpha = s1[3] + 1; - register guint check_r = CHECK_R (priv, row, col); - register guint check_g = CHECK_G (priv, row, col); - register guint check_b = CHECK_B (priv, row, col); + register guint check_r = CHECK_R (area, row, col); + register guint check_g = CHECK_G (area, row, col); + register guint check_b = CHECK_B (area, row, col); d[0] = ((check_r << 8) + (s1[0] - check_r) * alpha) >> 8; d[1] = ((check_g << 8) + (s1[1] - check_g) * alpha) >> 8; @@ -1376,9 +1354,9 @@ gimp_preview_area_mask (GimpPreviewArea *area, switch (s2[3]) { case 0: - d[0] = CHECK_R (priv, row, col); - d[1] = CHECK_G (priv, row, col); - d[2] = CHECK_B (priv, row, col); + d[0] = CHECK_R (area, row, col); + d[1] = CHECK_G (area, row, col); + d[2] = CHECK_B (area, row, col); break; case 255: @@ -1390,9 +1368,9 @@ gimp_preview_area_mask (GimpPreviewArea *area, default: { register guint alpha = s2[3] + 1; - register guint check_r = CHECK_R (priv, row, col); - register guint check_g = CHECK_G (priv, row, col); - register guint check_b = CHECK_B (priv, row, col); + register guint check_r = CHECK_R (area, row, col); + register guint check_g = CHECK_G (area, row, col); + register guint check_b = CHECK_B (area, row, col); d[0] = ((check_r << 8) + (s2[0] - check_r) * alpha) >> 8; d[1] = ((check_g << 8) + (s2[1] - check_g) * alpha) >> 8; @@ -1433,9 +1411,9 @@ gimp_preview_area_mask (GimpPreviewArea *area, switch (inter[3]) { case 0: - d[0] = CHECK_R (priv, row, col); - d[1] = CHECK_G (priv, row, col); - d[2] = CHECK_B (priv, row, col); + d[0] = CHECK_R (area, row, col); + d[1] = CHECK_G (area, row, col); + d[2] = CHECK_B (area, row, col); break; case 255: @@ -1447,9 +1425,9 @@ gimp_preview_area_mask (GimpPreviewArea *area, default: { register guint alpha = inter[3] + 1; - register guint check_r = CHECK_R (priv, row, col); - register guint check_g = CHECK_G (priv, row, col); - register guint check_b = CHECK_B (priv, row, col); + register guint check_r = CHECK_R (area, row, col); + register guint check_g = CHECK_G (area, row, col); + register guint check_b = CHECK_B (area, row, col); d[0] = (((check_r << 8) + (inter[0] - check_r) * alpha) >> 8); @@ -1468,7 +1446,7 @@ gimp_preview_area_mask (GimpPreviewArea *area, src1 += rowstride1; src2 += rowstride2; src_mask += rowstride_mask; - dest += priv->rowstride; + dest += area->rowstride; } break; @@ -1486,7 +1464,7 @@ gimp_preview_area_mask (GimpPreviewArea *area, src1 += rowstride1; src2 += rowstride2; src_mask += rowstride_mask; - dest += priv->rowstride; + dest += area->rowstride; } break; @@ -1506,9 +1484,9 @@ gimp_preview_area_mask (GimpPreviewArea *area, switch (s1[1]) { case 0: - d[0] = CHECK_R (priv, row, col); - d[1] = CHECK_G (priv, row, col); - d[2] = CHECK_B (priv, row, col); + d[0] = CHECK_R (area, row, col); + d[1] = CHECK_G (area, row, col); + d[2] = CHECK_B (area, row, col); break; case 255: @@ -1518,9 +1496,9 @@ gimp_preview_area_mask (GimpPreviewArea *area, default: { register guint alpha = s1[1] + 1; - register guint check_r = CHECK_R (priv, row, col); - register guint check_g = CHECK_G (priv, row, col); - register guint check_b = CHECK_B (priv, row, col); + register guint check_r = CHECK_R (area, row, col); + register guint check_g = CHECK_G (area, row, col); + register guint check_b = CHECK_B (area, row, col); d[0] = ((check_r << 8) + (s1[0] - check_r) * alpha) >> 8; d[1] = ((check_g << 8) + (s1[0] - check_g) * alpha) >> 8; @@ -1534,9 +1512,9 @@ gimp_preview_area_mask (GimpPreviewArea *area, switch (s2[1]) { case 0: - d[0] = CHECK_R (priv, row, col); - d[1] = CHECK_G (priv, row, col); - d[2] = CHECK_B (priv, row, col); + d[0] = CHECK_R (area, row, col); + d[1] = CHECK_G (area, row, col); + d[2] = CHECK_B (area, row, col); break; case 255: @@ -1546,9 +1524,9 @@ gimp_preview_area_mask (GimpPreviewArea *area, default: { register guint alpha = s2[1] + 1; - register guint check_r = CHECK_R (priv, row, col); - register guint check_g = CHECK_G (priv, row, col); - register guint check_b = CHECK_B (priv, row, col); + register guint check_r = CHECK_R (area, row, col); + register guint check_g = CHECK_G (area, row, col); + register guint check_b = CHECK_B (area, row, col); d[0] = ((check_r << 8) + (s2[0] - check_r) * alpha) >> 8; d[1] = ((check_g << 8) + (s2[0] - check_g) * alpha) >> 8; @@ -1584,9 +1562,9 @@ gimp_preview_area_mask (GimpPreviewArea *area, switch (inter[1]) { case 0: - d[0] = CHECK_R (priv, row, col); - d[1] = CHECK_G (priv, row, col); - d[2] = CHECK_B (priv, row, col); + d[0] = CHECK_R (area, row, col); + d[1] = CHECK_G (area, row, col); + d[2] = CHECK_B (area, row, col); break; case 255: @@ -1596,9 +1574,9 @@ gimp_preview_area_mask (GimpPreviewArea *area, default: { register guint alpha = inter[1] + 1; - register guint check_r = CHECK_R (priv, row, col); - register guint check_g = CHECK_G (priv, row, col); - register guint check_b = CHECK_B (priv, row, col); + register guint check_r = CHECK_R (area, row, col); + register guint check_g = CHECK_G (area, row, col); + register guint check_b = CHECK_B (area, row, col); d[0] = ((check_r << 8) + (inter[0] - check_r) * alpha) >> 8; d[1] = ((check_g << 8) + (inter[0] - check_g) * alpha) >> 8; @@ -1614,12 +1592,12 @@ gimp_preview_area_mask (GimpPreviewArea *area, src1 += rowstride1; src2 += rowstride2; src_mask += rowstride_mask; - dest += priv->rowstride; + dest += area->rowstride; } break; case GIMP_INDEXED_IMAGE: - g_return_if_fail (priv->colormap != NULL); + g_return_if_fail (area->colormap != NULL); for (row = 0; row < height; row++) { const guchar *s1 = src1; @@ -1629,8 +1607,8 @@ gimp_preview_area_mask (GimpPreviewArea *area, for (col = 0; col < width; col++, s1++, s2++, m++, d += 3) { - const guchar *cmap1 = priv->colormap + 3 * s1[0]; - const guchar *cmap2 = priv->colormap + 3 * s2[0]; + const guchar *cmap1 = area->colormap + 3 * s1[0]; + const guchar *cmap2 = area->colormap + 3 * s2[0]; d[0] = ((cmap1[0] << 8) + (cmap2[0] - cmap1[0]) * m[0]) >> 8; d[1] = ((cmap1[1] << 8) + (cmap2[1] - cmap1[1]) * m[0]) >> 8; @@ -1640,12 +1618,12 @@ gimp_preview_area_mask (GimpPreviewArea *area, src1 += rowstride1; src2 += rowstride2; src_mask += rowstride_mask; - dest += priv->rowstride; + dest += area->rowstride; } break; case GIMP_INDEXEDA_IMAGE: - g_return_if_fail (priv->colormap != NULL); + g_return_if_fail (area->colormap != NULL); for (row = y; row < y + height; row++) { const guchar *s1 = src1; @@ -1655,8 +1633,8 @@ gimp_preview_area_mask (GimpPreviewArea *area, for (col = x; col < x + width; col++, s1 += 2, s2 += 2, m++, d += 3) { - const guchar *cmap1 = priv->colormap + 3 * s1[0]; - const guchar *cmap2 = priv->colormap + 3 * s2[0]; + const guchar *cmap1 = area->colormap + 3 * s1[0]; + const guchar *cmap2 = area->colormap + 3 * s2[0]; switch (m[0]) { @@ -1664,9 +1642,9 @@ gimp_preview_area_mask (GimpPreviewArea *area, switch (s1[1]) { case 0: - d[0] = CHECK_R (priv, row, col); - d[1] = CHECK_G (priv, row, col); - d[2] = CHECK_B (priv, row, col); + d[0] = CHECK_R (area, row, col); + d[1] = CHECK_G (area, row, col); + d[2] = CHECK_B (area, row, col); break; case 255: @@ -1678,9 +1656,9 @@ gimp_preview_area_mask (GimpPreviewArea *area, default: { register guint alpha = s1[1] + 1; - register guint check_r = CHECK_R (priv, row, col); - register guint check_g = CHECK_G (priv, row, col); - register guint check_b = CHECK_B (priv, row, col); + register guint check_r = CHECK_R (area, row, col); + register guint check_g = CHECK_G (area, row, col); + register guint check_b = CHECK_B (area, row, col); d[0] = ((check_r << 8) + (cmap1[0] - check_r) * alpha) >> 8; d[1] = ((check_g << 8) + (cmap1[1] - check_g) * alpha) >> 8; @@ -1694,9 +1672,9 @@ gimp_preview_area_mask (GimpPreviewArea *area, switch (s2[1]) { case 0: - d[0] = CHECK_R (priv, row, col); - d[1] = CHECK_G (priv, row, col); - d[2] = CHECK_B (priv, row, col); + d[0] = CHECK_R (area, row, col); + d[1] = CHECK_G (area, row, col); + d[2] = CHECK_B (area, row, col); break; case 255: @@ -1708,9 +1686,9 @@ gimp_preview_area_mask (GimpPreviewArea *area, default: { register guint alpha = s2[1] + 1; - register guint check_r = CHECK_R (priv, row, col); - register guint check_g = CHECK_G (priv, row, col); - register guint check_b = CHECK_B (priv, row, col); + register guint check_r = CHECK_R (area, row, col); + register guint check_g = CHECK_G (area, row, col); + register guint check_b = CHECK_B (area, row, col); d[0] = ((check_r << 8) + (cmap2[0] - check_r) * alpha) >> 8; d[1] = ((check_g << 8) + (cmap2[1] - check_g) * alpha) >> 8; @@ -1754,9 +1732,9 @@ gimp_preview_area_mask (GimpPreviewArea *area, switch (inter[3]) { case 0: - d[0] = CHECK_R (priv, row, col); - d[1] = CHECK_G (priv, row, col); - d[2] = CHECK_B (priv, row, col); + d[0] = CHECK_R (area, row, col); + d[1] = CHECK_G (area, row, col); + d[2] = CHECK_B (area, row, col); break; case 255: @@ -1768,9 +1746,9 @@ gimp_preview_area_mask (GimpPreviewArea *area, default: { register guint alpha = inter[3] + 1; - register guint check_r = CHECK_R (priv, row, col); - register guint check_g = CHECK_G (priv, row, col); - register guint check_b = CHECK_B (priv, row, col); + register guint check_r = CHECK_R (area, row, col); + register guint check_g = CHECK_G (area, row, col); + register guint check_b = CHECK_B (area, row, col); d[0] = ((check_r << 8) + (inter[0] - check_r) * alpha) >> 8; @@ -1789,7 +1767,7 @@ gimp_preview_area_mask (GimpPreviewArea *area, src1 += rowstride1; src2 += rowstride2; src_mask += rowstride_mask; - dest += priv->rowstride; + dest += area->rowstride; } break; } @@ -1823,24 +1801,21 @@ gimp_preview_area_fill (GimpPreviewArea *area, guchar green, guchar blue) { - GimpPreviewAreaPrivate *priv; - guchar *dest; - guchar *d; - gint row; - gint col; + guchar *dest; + guchar *d; + gint row; + gint col; g_return_if_fail (GIMP_IS_PREVIEW_AREA (area)); g_return_if_fail (width >= 0 && height >= 0); - priv = GET_PRIVATE (area); - if (width == 0 || height == 0) return; - if (x + width < 0 || x >= priv->width) + if (x + width < 0 || x >= area->width) return; - if (y + height < 0 || y >= priv->height) + if (y + height < 0 || y >= area->height) return; if (x < 0) @@ -1849,8 +1824,8 @@ gimp_preview_area_fill (GimpPreviewArea *area, x = 0; } - if (x + width > priv->width) - width = priv->width - x; + if (x + width > area->width) + width = area->width - x; if (y < 0) { @@ -1858,16 +1833,16 @@ gimp_preview_area_fill (GimpPreviewArea *area, y = 0; } - if (y + height > priv->height) - height = priv->height - y; + if (y + height > area->height) + height = area->height - y; - if (! priv->buf) + if (! area->buf) { - priv->rowstride = ((priv->width * 3) + 3) & ~3; - priv->buf = g_new0 (guchar, priv->rowstride * priv->height); + area->rowstride = ((area->width * 3) + 3) & ~3; + area->buf = g_new0 (guchar, area->rowstride * area->height); } - dest = priv->buf + x * 3 + y * priv->rowstride; + dest = area->buf + x * 3 + y * area->rowstride; /* colorize first row */ for (col = 0, d = dest; col < width; col++, d+= 3) @@ -1880,7 +1855,7 @@ gimp_preview_area_fill (GimpPreviewArea *area, /* copy first row to remaining rows */ for (row = 1, d = dest; row < height; row++) { - d += priv->rowstride; + d += area->rowstride; memcpy (d, dest, width * 3); } @@ -1898,15 +1873,14 @@ gimp_preview_area_fill (GimpPreviewArea *area, void gimp_preview_area_reset (GimpPreviewArea *area) { - GimpPreviewAreaPrivate *priv = GET_PRIVATE (area); - GtkAllocation allocation; + GtkAllocation allocation; - if (priv->buf) + if (area->buf) { - g_free (priv->buf); + g_free (area->buf); - priv->buf = NULL; - priv->rowstride = 0; + area->buf = NULL; + area->rowstride = 0; } gtk_widget_get_allocation (GTK_WIDGET (area), &allocation); @@ -1929,14 +1903,10 @@ gimp_preview_area_set_offsets (GimpPreviewArea *area, gint x, gint y) { - GimpPreviewAreaPrivate *priv; - g_return_if_fail (GIMP_IS_PREVIEW_AREA (area)); - priv = GET_PRIVATE (area); - - priv->offset_x = x; - priv->offset_y = y; + area->offset_x = x; + area->offset_y = y; } /** @@ -1956,27 +1926,23 @@ gimp_preview_area_set_colormap (GimpPreviewArea *area, const guchar *colormap, gint num_colors) { - GimpPreviewAreaPrivate *priv; - g_return_if_fail (GIMP_IS_PREVIEW_AREA (area)); g_return_if_fail (colormap != NULL || num_colors == 0); g_return_if_fail (num_colors >= 0 && num_colors <= 256); - priv = GET_PRIVATE (area); - if (num_colors > 0) { - if (priv->colormap) - memset (priv->colormap, 0, 3 * 256); + if (area->colormap) + memset (area->colormap, 0, 3 * 256); else - priv->colormap = g_new0 (guchar, 3 * 256); + area->colormap = g_new0 (guchar, 3 * 256); - memcpy (priv->colormap, colormap, 3 * num_colors); + memcpy (area->colormap, colormap, 3 * num_colors); } else { - g_free (priv->colormap); - priv->colormap = NULL; + g_free (area->colormap); + area->colormap = NULL; } } @@ -1993,29 +1959,25 @@ void gimp_preview_area_set_color_config (GimpPreviewArea *area, GimpColorConfig *config) { - GimpPreviewAreaPrivate *priv; - g_return_if_fail (GIMP_IS_PREVIEW_AREA (area)); g_return_if_fail (config == NULL || GIMP_IS_COLOR_CONFIG (config)); - priv = GET_PRIVATE (area); - - if (config != priv->config) + if (config != area->config) { - if (priv->config) + if (area->config) { - g_signal_handlers_disconnect_by_func (priv->config, + g_signal_handlers_disconnect_by_func (area->config, gimp_preview_area_destroy_transform, area); gimp_preview_area_destroy_transform (area); } - g_set_object (&priv->config, config); + g_set_object (&area->config, config); - if (priv->config) + if (area->config) { - g_signal_connect_swapped (priv->config, "notify", + g_signal_connect_swapped (area->config, "notify", G_CALLBACK (gimp_preview_area_destroy_transform), area); } @@ -2035,14 +1997,10 @@ gimp_preview_area_get_size (GimpPreviewArea *area, gint *width, gint *height) { - GimpPreviewAreaPrivate *priv; - g_return_if_fail (GIMP_IS_PREVIEW_AREA (area)); - priv = GET_PRIVATE (area); - - if (width) *width = priv->width; - if (height) *height = priv->height; + if (width) *width = area->width; + if (height) *height = area->height; } /** @@ -2063,14 +2021,10 @@ gimp_preview_area_set_max_size (GimpPreviewArea *area, gint width, gint height) { - GimpPreviewAreaPrivate *priv; - g_return_if_fail (GIMP_IS_PREVIEW_AREA (area)); - priv = GET_PRIVATE (area); - - priv->max_width = width; - priv->max_height = height; + area->max_width = width; + area->max_height = height; } diff --git a/libgimpwidgets/gimppreviewarea.h b/libgimpwidgets/gimppreviewarea.h index dbd93164b5..c7f5027d7c 100644 --- a/libgimpwidgets/gimppreviewarea.h +++ b/libgimpwidgets/gimppreviewarea.h @@ -26,42 +26,10 @@ G_BEGIN_DECLS -#define GIMP_TYPE_PREVIEW_AREA (gimp_preview_area_get_type ()) -#define GIMP_PREVIEW_AREA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PREVIEW_AREA, GimpPreviewArea)) -#define GIMP_PREVIEW_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PREVIEW_AREA, GimpPreviewAreaClass)) -#define GIMP_IS_PREVIEW_AREA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_PREVIEW_AREA)) -#define GIMP_IS_PREVIEW_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PREVIEW_AREA)) -#define GIMP_PREVIEW_AREA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PREVIEW_AREA, GimpPreviewArea)) +#define GIMP_TYPE_PREVIEW_AREA (gimp_preview_area_get_type ()) +G_DECLARE_FINAL_TYPE (GimpPreviewArea, gimp_preview_area, GIMP, PREVIEW_AREA, GtkDrawingArea) -typedef struct _GimpPreviewAreaPrivate GimpPreviewAreaPrivate; -typedef struct _GimpPreviewAreaClass GimpPreviewAreaClass; - -struct _GimpPreviewArea -{ - GtkDrawingArea parent_instance; - - GimpPreviewAreaPrivate *priv; -}; - -struct _GimpPreviewAreaClass -{ - GtkDrawingAreaClass parent_class; - - /* Padding for future expansion */ - void (* _gimp_reserved1) (void); - void (* _gimp_reserved2) (void); - void (* _gimp_reserved3) (void); - void (* _gimp_reserved4) (void); - void (* _gimp_reserved5) (void); - void (* _gimp_reserved6) (void); - void (* _gimp_reserved7) (void); - void (* _gimp_reserved8) (void); -}; - - -GType gimp_preview_area_get_type (void) G_GNUC_CONST; - GtkWidget * gimp_preview_area_new (void); void gimp_preview_area_draw (GimpPreviewArea *area, diff --git a/libgimpwidgets/gimpspinbutton.c b/libgimpwidgets/gimpspinbutton.c index 7abd79a62e..e559c38bb1 100644 --- a/libgimpwidgets/gimpspinbutton.c +++ b/libgimpwidgets/gimpspinbutton.c @@ -55,10 +55,10 @@ #define MAX_DIGITS 20 -struct _GimpSpinButtonPrivate +typedef struct _GimpSpinButtonPrivate { gboolean changed; -}; +} GimpSpinButtonPrivate; /* local function prototypes */ @@ -105,8 +105,6 @@ gimp_spin_button_class_init (GimpSpinButtonClass *klass) static void gimp_spin_button_init (GimpSpinButton *spin_button) { - spin_button->priv = gimp_spin_button_get_instance_private (spin_button); - g_signal_connect (spin_button, "changed", G_CALLBACK (gimp_spin_button_changed), NULL); @@ -208,9 +206,12 @@ static gboolean gimp_spin_button_focus_in (GtkWidget *widget, GdkEventFocus *event) { - GimpSpinButton *spin_button = GIMP_SPIN_BUTTON (widget); + GimpSpinButton *spin_button = GIMP_SPIN_BUTTON (widget); + GimpSpinButtonPrivate *priv; - spin_button->priv->changed = FALSE; + priv = gimp_spin_button_get_instance_private (spin_button); + + priv->changed = FALSE; return GTK_WIDGET_CLASS (parent_class)->focus_in_event (widget, event); } @@ -219,18 +220,21 @@ static gboolean gimp_spin_button_focus_out (GtkWidget *widget, GdkEventFocus *event) { - GimpSpinButton *spin_button = GIMP_SPIN_BUTTON (widget); - gboolean editable; - gboolean result; + GimpSpinButton *spin_button = GIMP_SPIN_BUTTON (widget); + GimpSpinButtonPrivate *priv; + gboolean editable; + gboolean result; + + priv = gimp_spin_button_get_instance_private (spin_button); editable = gtk_editable_get_editable (GTK_EDITABLE (widget)); - if (! spin_button->priv->changed) + if (! priv->changed) gtk_editable_set_editable (GTK_EDITABLE (widget), FALSE); result = GTK_WIDGET_CLASS (parent_class)->focus_out_event (widget, event); - if (! spin_button->priv->changed) + if (! priv->changed) gtk_editable_set_editable (GTK_EDITABLE (widget), editable); return result; @@ -285,9 +289,12 @@ static void gimp_spin_button_changed (GtkEditable *editable, gpointer data) { - GimpSpinButton *spin_button = GIMP_SPIN_BUTTON (editable); + GimpSpinButton *spin_button = GIMP_SPIN_BUTTON (editable); + GimpSpinButtonPrivate *priv; - spin_button->priv->changed = TRUE; + priv = gimp_spin_button_get_instance_private (spin_button); + + priv->changed = TRUE; } diff --git a/libgimpwidgets/gimpspinbutton.h b/libgimpwidgets/gimpspinbutton.h index 7abe6de412..2edd39cf72 100644 --- a/libgimpwidgets/gimpspinbutton.h +++ b/libgimpwidgets/gimpspinbutton.h @@ -31,24 +31,10 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -#define GIMP_TYPE_SPIN_BUTTON (gimp_spin_button_get_type ()) -#define GIMP_SPIN_BUTTON(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_SPIN_BUTTON, GimpSpinButton)) -#define GIMP_SPIN_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_SPIN_BUTTON, GimpSpinButtonClass)) -#define GIMP_IS_SPIN_BUTTON(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_SPIN_BUTTON)) -#define GIMP_IS_SPIN_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_SPIN_BUTTON)) -#define GIMP_SPIN_BUTTON_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_SPIN_BUTTON, GimpSpinButtonClass)) +#define GIMP_TYPE_SPIN_BUTTON (gimp_spin_button_get_type ()) +G_DECLARE_DERIVABLE_TYPE (GimpSpinButton, gimp_spin_button, GIMP, SPIN_BUTTON, GtkSpinButton) -typedef struct _GimpSpinButtonPrivate GimpSpinButtonPrivate; -typedef struct _GimpSpinButtonClass GimpSpinButtonClass; - -struct _GimpSpinButton -{ - GtkSpinButton parent_instance; - - GimpSpinButtonPrivate *priv; -}; - struct _GimpSpinButtonClass { GtkSpinButtonClass parent_class; @@ -61,8 +47,6 @@ struct _GimpSpinButtonClass }; -GType gimp_spin_button_get_type (void) G_GNUC_CONST; - GtkWidget * gimp_spin_button_new (GtkAdjustment *adjustment, gdouble climb_rate, guint digits); diff --git a/libgimpwidgets/gimpspinscale.c b/libgimpwidgets/gimpspinscale.c index 264eacd8da..3404625ad8 100644 --- a/libgimpwidgets/gimpspinscale.c +++ b/libgimpwidgets/gimpspinscale.c @@ -54,10 +54,10 @@ typedef enum } SpinScaleTarget; -typedef struct _GimpSpinScalePrivate GimpSpinScalePrivate; - -struct _GimpSpinScalePrivate +struct _GimpSpinScale { + GimpSpinButton parent_instance; + gchar *label; gchar *label_text; gchar *label_pattern; @@ -87,8 +87,6 @@ struct _GimpSpinScalePrivate gint pointer_warp_start_x; }; -#define GET_PRIVATE(obj) ((GimpSpinScalePrivate *) gimp_spin_scale_get_instance_private ((GimpSpinScale *) (obj))) - static void gimp_spin_scale_dispose (GObject *object); static void gimp_spin_scale_finalize (GObject *object); @@ -137,8 +135,7 @@ static gdouble odd_pow (gdouble x, gdouble y); -G_DEFINE_TYPE_WITH_PRIVATE (GimpSpinScale, gimp_spin_scale, - GIMP_TYPE_SPIN_BUTTON) +G_DEFINE_TYPE (GimpSpinScale, gimp_spin_scale, GIMP_TYPE_SPIN_BUTTON) #define parent_class gimp_spin_scale_parent_class @@ -179,8 +176,6 @@ gimp_spin_scale_class_init (GimpSpinScaleClass *klass) static void gimp_spin_scale_init (GimpSpinScale *scale) { - GimpSpinScalePrivate *private = GET_PRIVATE (scale); - gtk_widget_add_events (GTK_WIDGET (scale), GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | @@ -191,22 +186,22 @@ gimp_spin_scale_init (GimpSpinScale *scale) gtk_entry_set_alignment (GTK_ENTRY (scale), 1.0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (scale), TRUE); - private->mnemonic_keyval = GDK_KEY_VoidSymbol; - private->gamma = 1.0; + scale->mnemonic_keyval = GDK_KEY_VoidSymbol; + scale->gamma = 1.0; } static void gimp_spin_scale_dispose (GObject *object) { - GimpSpinScalePrivate *private = GET_PRIVATE (object); - guint keyval; + GimpSpinScale *scale = GIMP_SPIN_SCALE (object); + guint keyval; - keyval = private->mnemonic_keyval; - private->mnemonic_keyval = GDK_KEY_VoidSymbol; + keyval = scale->mnemonic_keyval; + scale->mnemonic_keyval = GDK_KEY_VoidSymbol; gimp_spin_scale_setup_mnemonic (GIMP_SPIN_SCALE (object), keyval); - g_clear_object (&private->layout); + g_clear_object (&scale->layout); G_OBJECT_CLASS (parent_class)->dispose (object); } @@ -214,11 +209,11 @@ gimp_spin_scale_dispose (GObject *object) static void gimp_spin_scale_finalize (GObject *object) { - GimpSpinScalePrivate *private = GET_PRIVATE (object); + GimpSpinScale *scale = GIMP_SPIN_SCALE (object); - g_clear_pointer (&private->label, g_free); - g_clear_pointer (&private->label_text, g_free); - g_clear_pointer (&private->label_pattern, g_free); + g_clear_pointer (&scale->label, g_free); + g_clear_pointer (&scale->label_text, g_free); + g_clear_pointer (&scale->label_pattern, g_free); G_OBJECT_CLASS (parent_class)->finalize (object); } @@ -268,9 +263,9 @@ gimp_spin_scale_get_preferred_width (GtkWidget *widget, gint *minimum_width, gint *natural_width) { - GimpSpinScalePrivate *private = GET_PRIVATE (widget); - PangoContext *context = gtk_widget_get_pango_context (widget); - PangoFontMetrics *metrics; + GimpSpinScale *scale = GIMP_SPIN_SCALE (widget); + PangoContext *context = gtk_widget_get_pango_context (widget); + PangoFontMetrics *metrics; GTK_WIDGET_CLASS (parent_class)->get_preferred_width (widget, minimum_width, @@ -280,7 +275,7 @@ gimp_spin_scale_get_preferred_width (GtkWidget *widget, pango_context_get_font_description (context), pango_context_get_language (context)); - if (private->label) + if (scale->label) { gint char_width; gint digit_width; @@ -311,11 +306,11 @@ gimp_spin_scale_get_preferred_height (GtkWidget *widget, static void gimp_spin_scale_style_updated (GtkWidget *widget) { - GimpSpinScalePrivate *private = GET_PRIVATE (widget); + GimpSpinScale *scale = GIMP_SPIN_SCALE (widget); GTK_WIDGET_CLASS (parent_class)->style_updated (widget); - g_clear_object (&private->layout); + g_clear_object (&scale->layout); } static PangoAttrList * @@ -361,13 +356,13 @@ static gboolean gimp_spin_scale_draw (GtkWidget *widget, cairo_t *cr) { - GimpSpinScalePrivate *private = GET_PRIVATE (widget); + GimpSpinScale *scale = GIMP_SPIN_SCALE (widget); cairo_save (cr); GTK_WIDGET_CLASS (parent_class)->draw (widget, cr); cairo_restore (cr); - if (private->label) + if (scale->label) { GtkStyleContext *style = gtk_widget_get_style_context (widget); GtkAllocation allocation; @@ -396,36 +391,36 @@ gimp_spin_scale_draw (GtkWidget *widget, &minimum_width, &natural_width); - if (! private->layout) + if (! scale->layout) { - private->layout = gtk_widget_create_pango_layout (widget, - private->label_text); - pango_layout_set_ellipsize (private->layout, PANGO_ELLIPSIZE_END); + scale->layout = gtk_widget_create_pango_layout (widget, + scale->label_text); + pango_layout_set_ellipsize (scale->layout, PANGO_ELLIPSIZE_END); /* Needing to force right-to-left layout when the widget is * set so, even when the text is not RTL text. Without this, * such case is broken because on the left side, we'd have * both the value and the label texts. */ - pango_layout_set_auto_dir (private->layout, FALSE); + pango_layout_set_auto_dir (scale->layout, FALSE); - if (private->mnemonics_visible) + if (scale->mnemonics_visible) { PangoAttrList *attrs; - attrs = pattern_to_attrs (private->label_text, - private->label_pattern); + attrs = pattern_to_attrs (scale->label_text, + scale->label_pattern); if (attrs) { - pango_layout_set_attributes (private->layout, attrs); + pango_layout_set_attributes (scale->layout, attrs); pango_attr_list_unref (attrs); } } } - pango_layout_set_width (private->layout, + pango_layout_set_width (scale->layout, PANGO_SCALE * (allocation.width - minimum_width)); - pango_layout_get_pixel_extents (private->layout, &ink, NULL); + pango_layout_get_pixel_extents (scale->layout, &ink, NULL); gtk_entry_get_layout_offsets (GTK_ENTRY (widget), NULL, &layout_offset_y); @@ -471,7 +466,7 @@ gimp_spin_scale_draw (GtkWidget *widget, cairo_move_to (cr, layout_offset_x, text_area.y - ink.y + text_area.height / 2 - ink.height / 2); gdk_cairo_set_source_rgba (cr, &text_color); - pango_cairo_show_layout (cr, private->layout); + pango_cairo_show_layout (cr, scale->layout); cairo_restore (cr); @@ -482,7 +477,7 @@ gimp_spin_scale_draw (GtkWidget *widget, cairo_move_to (cr, layout_offset_x, text_area.y - ink.y + text_area.height / 2 - ink.height / 2); gdk_cairo_set_source_rgba (cr, &bar_text_color); - pango_cairo_show_layout (cr, private->layout); + pango_cairo_show_layout (cr, scale->layout); } return FALSE; @@ -637,11 +632,11 @@ static void gimp_spin_scale_update_cursor (GtkWidget *widget, GdkWindow *window) { - GimpSpinScalePrivate *private = GET_PRIVATE (widget); - GdkDisplay *display = gtk_widget_get_display (widget); - GdkCursor *cursor = NULL; + GimpSpinScale *scale = GIMP_SPIN_SCALE (widget); + GdkDisplay *display = gtk_widget_get_display (widget); + GdkCursor *cursor = NULL; - switch (private->target) + switch (scale->target) { case TARGET_NUMBER: cursor = gdk_cursor_new_from_name (display, "text"); @@ -675,14 +670,14 @@ gimp_spin_scale_update_target (GtkWidget *widget, gdouble y, GdkEvent *event) { - GimpSpinScalePrivate *private = GET_PRIVATE (widget); - SpinScaleTarget target; + GimpSpinScale *scale = GIMP_SPIN_SCALE (widget); + SpinScaleTarget target; target = gimp_spin_scale_get_target (widget, x, y, (GdkEvent *) event); - if (target != private->target) + if (target != scale->target) { - private->target = target; + scale->target = target; gimp_spin_scale_update_cursor (widget, window); } @@ -692,11 +687,11 @@ static void gimp_spin_scale_clear_target (GtkWidget *widget, GdkWindow *window) { - GimpSpinScalePrivate *private = GET_PRIVATE (widget); + GimpSpinScale *scale = GIMP_SPIN_SCALE (widget); - if (private->target != TARGET_NONE) + if (scale->target != TARGET_NONE) { - private->target = TARGET_NONE; + scale->target = TARGET_NONE; gimp_spin_scale_update_cursor (widget, window); } @@ -707,12 +702,10 @@ gimp_spin_scale_get_limits (GimpSpinScale *scale, gdouble *lower, gdouble *upper) { - GimpSpinScalePrivate *private = GET_PRIVATE (scale); - - if (private->scale_limits_set) + if (scale->scale_limits_set) { - *lower = private->scale_lower; - *upper = private->scale_upper; + *lower = scale->scale_lower; + *upper = scale->scale_upper; } else { @@ -729,15 +722,15 @@ gimp_spin_scale_change_value (GtkWidget *widget, gdouble x, guint state) { - GimpSpinScalePrivate *private = GET_PRIVATE (widget); - GtkSpinButton *spin_button = GTK_SPIN_BUTTON (widget); - GtkAdjustment *adjustment = gtk_spin_button_get_adjustment (spin_button); - GdkRectangle text_area; - gdouble lower; - gdouble upper; - gdouble value; - gint digits; - gint power = 1; + GimpSpinScale *scale = GIMP_SPIN_SCALE (widget); + GtkSpinButton *spin_button = GTK_SPIN_BUTTON (widget); + GtkAdjustment *adjustment = gtk_spin_button_get_adjustment (spin_button); + GdkRectangle text_area; + gdouble lower; + gdouble upper; + gdouble value; + gint digits; + gint power = 1; gtk_entry_get_text_area (GTK_ENTRY (widget), &text_area); @@ -746,16 +739,16 @@ gimp_spin_scale_change_value (GtkWidget *widget, if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) x = text_area.width - x; - if (private->relative_change) + if (scale->relative_change) { gdouble step; step = (upper - lower) / text_area.width * RELATIVE_CHANGE_SPEED; if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) - step *= x - (text_area.width - private->start_x); + step *= x - (text_area.width - scale->start_x); else - step *= x - private->start_x; + step *= x - scale->start_x; if (state & GDK_CONTROL_MASK) { @@ -764,20 +757,20 @@ gimp_spin_scale_change_value (GtkWidget *widget, step = RINT (step / page_inc) * page_inc; } - value = private->start_value + step; + value = scale->start_value + step; } else { gdouble x0, x1; gdouble fraction; - x0 = odd_pow (lower, 1.0 / private->gamma); - x1 = odd_pow (upper, 1.0 / private->gamma); + x0 = odd_pow (lower, 1.0 / scale->gamma); + x1 = odd_pow (upper, 1.0 / scale->gamma); fraction = x / (gdouble) text_area.width; value = fraction * (x1 - x0) + x0; - value = odd_pow (value, private->gamma); + value = odd_pow (value, scale->gamma); if (state & GDK_CONTROL_MASK) { @@ -799,7 +792,7 @@ gimp_spin_scale_change_value (GtkWidget *widget, value = RINT (value); value /= power; - if (private->constrain_drag) + if (scale->constrain_drag) value = rint (value); gtk_adjustment_set_value (adjustment, value); @@ -809,12 +802,12 @@ static gboolean gimp_spin_scale_button_press (GtkWidget *widget, GdkEventButton *event) { - GimpSpinScalePrivate *private = GET_PRIVATE (widget); - gdouble x, y; + GimpSpinScale *scale = GIMP_SPIN_SCALE (widget); + gdouble x, y; - private->changing_value = FALSE; - private->relative_change = FALSE; - private->pointer_warp = FALSE; + scale->changing_value = FALSE; + scale->relative_change = FALSE; + scale->pointer_warp = FALSE; gimp_spin_scale_event_to_widget_coords (widget, event->window, event->x, event->y, @@ -822,11 +815,11 @@ gimp_spin_scale_button_press (GtkWidget *widget, gimp_spin_scale_update_target (widget, event->window, x, y, (GdkEvent *) event); - switch (private->target) + switch (scale->target) { case TARGET_GRAB: case TARGET_GRABBING: - private->changing_value = TRUE; + scale->changing_value = TRUE; gtk_widget_grab_focus (widget); @@ -837,16 +830,16 @@ gimp_spin_scale_button_press (GtkWidget *widget, return TRUE; case TARGET_RELATIVE: - private->changing_value = TRUE; + scale->changing_value = TRUE; gtk_widget_grab_focus (widget); - private->relative_change = TRUE; - private->start_x = x; - private->start_value = gtk_adjustment_get_value (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget))); + scale->relative_change = TRUE; + scale->start_x = x; + scale->start_value = gtk_adjustment_get_value (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget))); - private->start_pointer_x = floor (event->x_root); - private->start_pointer_y = floor (event->y_root); + scale->start_pointer_x = floor (event->x_root); + scale->start_pointer_y = floor (event->y_root); gimp_spin_scale_update_cursor (widget, event->window); @@ -867,33 +860,33 @@ static gboolean gimp_spin_scale_button_release (GtkWidget *widget, GdkEventButton *event) { - GimpSpinScalePrivate *private = GET_PRIVATE (widget); - gdouble x, y; + GimpSpinScale *scale = GIMP_SPIN_SCALE (widget); + gdouble x, y; gimp_spin_scale_event_to_widget_coords (widget, event->window, event->x, event->y, &x, &y); - if (private->changing_value) + if (scale->changing_value) { - private->changing_value = FALSE; + scale->changing_value = FALSE; /* don't change the value if we're in the middle of a pointer warp, since * we didn't adjust start_x yet. see the comment in * gimp_spin_scale_motion_notify(). */ - if (! private->pointer_warp) + if (! scale->pointer_warp) gimp_spin_scale_change_value (widget, x, event->state); - if (private->relative_change) + if (scale->relative_change) { gdk_device_warp (gdk_event_get_device ((GdkEvent *) event), gdk_event_get_screen ((GdkEvent *) event), - private->start_pointer_x, - private->start_pointer_y); + scale->start_pointer_x, + scale->start_pointer_y); } - if (private->hover) + if (scale->hover) { gimp_spin_scale_update_target (widget, event->window, 0.0, 0.0, NULL); @@ -915,8 +908,8 @@ static gboolean gimp_spin_scale_motion_notify (GtkWidget *widget, GdkEventMotion *event) { - GimpSpinScalePrivate *private = GET_PRIVATE (widget); - gdouble x, y; + GimpSpinScale *scale = GIMP_SPIN_SCALE (widget); + gdouble x, y; gimp_spin_scale_event_to_widget_coords (widget, event->window, event->x, event->y, @@ -924,9 +917,9 @@ gimp_spin_scale_motion_notify (GtkWidget *widget, gdk_event_request_motions (event); - private->hover = TRUE; + scale->hover = TRUE; - if (private->changing_value) + if (scale->changing_value) { GdkScreen *screen; GdkDisplay *display; @@ -971,20 +964,20 @@ gimp_spin_scale_motion_notify (GtkWidget *widget, * across half the screen.) yes, this is an ugly ugly hack :) */ - if (private->pointer_warp) + if (scale->pointer_warp) { - if (pointer_x == private->pointer_warp_x) + if (pointer_x == scale->pointer_warp_x) return TRUE; - private->pointer_warp = FALSE; + scale->pointer_warp = FALSE; - if (ABS (pointer_x - private->pointer_warp_x) < monitor_geometry.width / 2) - private->start_x = private->pointer_warp_start_x; + if (ABS (pointer_x - scale->pointer_warp_x) < monitor_geometry.width / 2) + scale->start_x = scale->pointer_warp_start_x; } gimp_spin_scale_change_value (widget, x, event->state); - if (private->relative_change) + if (scale->relative_change) { GtkAdjustment *adjustment; gdouble value; @@ -1011,23 +1004,23 @@ gimp_spin_scale_motion_notify (GtkWidget *widget, if (pointer_x <= monitor_geometry.x && value > lower) { - private->pointer_warp = TRUE; - private->pointer_warp_x = (monitor_geometry.width - 1) + pointer_x - 1; - private->pointer_warp_start_x = private->start_x + (monitor_geometry.width - 2); + scale->pointer_warp = TRUE; + scale->pointer_warp_x = (monitor_geometry.width - 1) + pointer_x - 1; + scale->pointer_warp_start_x = scale->start_x + (monitor_geometry.width - 2); } else if (pointer_x >= monitor_geometry.x + (monitor_geometry.width - 1) && value < upper) { - private->pointer_warp = TRUE; - private->pointer_warp_x = pointer_x - (monitor_geometry.width - 1) + 1; - private->pointer_warp_start_x = private->start_x - (monitor_geometry.width - 2); + scale->pointer_warp = TRUE; + scale->pointer_warp_x = pointer_x - (monitor_geometry.width - 1) + 1; + scale->pointer_warp_start_x = scale->start_x - (monitor_geometry.width - 2); } - if (private->pointer_warp) + if (scale->pointer_warp) { gdk_device_warp (gdk_event_get_device ((GdkEvent *) event), screen, - private->pointer_warp_x, + scale->pointer_warp_x, pointer_y); } } @@ -1039,7 +1032,7 @@ gimp_spin_scale_motion_notify (GtkWidget *widget, if (! (event->state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK)) && - private->hover) + scale->hover) { gimp_spin_scale_update_target (widget, event->window, x, y, (GdkEvent *) event); @@ -1052,9 +1045,9 @@ static gboolean gimp_spin_scale_leave_notify (GtkWidget *widget, GdkEventCrossing *event) { - GimpSpinScalePrivate *private = GET_PRIVATE (widget); + GimpSpinScale *scale = GIMP_SPIN_SCALE (widget); - private->hover = FALSE; + scale->hover = FALSE; if (! (event->state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK))) @@ -1069,21 +1062,20 @@ static void gimp_spin_scale_hierarchy_changed (GtkWidget *widget, GtkWidget *old_toplevel) { - GimpSpinScalePrivate *private = GET_PRIVATE (widget); + GimpSpinScale *scale = GIMP_SPIN_SCALE (widget); gimp_spin_scale_setup_mnemonic (GIMP_SPIN_SCALE (widget), - private->mnemonic_keyval); + scale->mnemonic_keyval); } static void gimp_spin_scale_screen_changed (GtkWidget *widget, GdkScreen *old_screen) { - GimpSpinScale *scale = GIMP_SPIN_SCALE (widget); - GimpSpinScalePrivate *private = GET_PRIVATE (scale); - GtkSettings *settings; + GimpSpinScale *scale = GIMP_SPIN_SCALE (widget); + GtkSettings *settings; - g_clear_object (&private->layout); + g_clear_object (&scale->layout); if (old_screen) { @@ -1112,21 +1104,21 @@ gimp_spin_scale_screen_changed (GtkWidget *widget, static void gimp_spin_scale_value_changed (GtkSpinButton *spin_button) { - GimpSpinScalePrivate *private = GET_PRIVATE (spin_button); - GtkAdjustment *adjustment = gtk_spin_button_get_adjustment (spin_button); - gdouble lower; - gdouble upper; - gdouble value; - gdouble x0, x1; - gdouble x; + GimpSpinScale *scale = GIMP_SPIN_SCALE (spin_button); + GtkAdjustment *adjustment = gtk_spin_button_get_adjustment (spin_button); + gdouble lower; + gdouble upper; + gdouble value; + gdouble x0, x1; + gdouble x; gimp_spin_scale_get_limits (GIMP_SPIN_SCALE (spin_button), &lower, &upper); value = CLAMP (gtk_adjustment_get_value (adjustment), lower, upper); - x0 = odd_pow (lower, 1.0 / private->gamma); - x1 = odd_pow (upper, 1.0 / private->gamma); - x = odd_pow (value, 1.0 / private->gamma); + x0 = odd_pow (lower, 1.0 / scale->gamma); + x1 = odd_pow (upper, 1.0 / scale->gamma); + x = odd_pow (value, 1.0 / scale->gamma); gtk_entry_set_progress_fraction (GTK_ENTRY (spin_button), (x - x0) / (x1 - x0)); @@ -1148,10 +1140,9 @@ gimp_spin_scale_mnemonics_notify (GtkWindow *window, const GParamSpec *pspec, GimpSpinScale *scale) { - GimpSpinScalePrivate *private = GET_PRIVATE (scale); - gboolean mnemonics_visible = FALSE; - gboolean enable_mnemonics; - gboolean auto_mnemonics; + gboolean mnemonics_visible = FALSE; + gboolean enable_mnemonics; + gboolean auto_mnemonics; g_object_get (gtk_widget_get_settings (GTK_WIDGET (scale)), "gtk-enable-mnemonics", &enable_mnemonics, @@ -1167,11 +1158,11 @@ gimp_spin_scale_mnemonics_notify (GtkWindow *window, NULL); } - if (private->mnemonics_visible != mnemonics_visible) + if (scale->mnemonics_visible != mnemonics_visible) { - private->mnemonics_visible = mnemonics_visible; + scale->mnemonics_visible = mnemonics_visible; - g_clear_object (&private->layout); + g_clear_object (&scale->layout); gtk_widget_queue_draw (GTK_WIDGET (scale)); } @@ -1181,31 +1172,30 @@ static void gimp_spin_scale_setup_mnemonic (GimpSpinScale *scale, guint previous_keyval) { - GimpSpinScalePrivate *private = GET_PRIVATE (scale); - GtkWidget *widget = GTK_WIDGET (scale); - GtkWidget *toplevel; + GtkWidget *widget = GTK_WIDGET (scale); + GtkWidget *toplevel; - if (private->mnemonic_window) + if (scale->mnemonic_window) { - g_signal_handlers_disconnect_by_func (private->mnemonic_window, + g_signal_handlers_disconnect_by_func (scale->mnemonic_window, gimp_spin_scale_mnemonics_notify, scale); - gtk_window_remove_mnemonic (private->mnemonic_window, + gtk_window_remove_mnemonic (scale->mnemonic_window, previous_keyval, widget); - private->mnemonic_window = NULL; + scale->mnemonic_window = NULL; } toplevel = gtk_widget_get_toplevel (widget); if (gtk_widget_is_toplevel (toplevel) && - private->mnemonic_keyval != GDK_KEY_VoidSymbol) + scale->mnemonic_keyval != GDK_KEY_VoidSymbol) { gtk_window_add_mnemonic (GTK_WINDOW (toplevel), - private->mnemonic_keyval, + scale->mnemonic_keyval, widget); - private->mnemonic_window = GTK_WINDOW (toplevel); + scale->mnemonic_window = GTK_WINDOW (toplevel); g_signal_connect (toplevel, "notify::mnemonics-visible", G_CALLBACK (gimp_spin_scale_mnemonics_notify), @@ -1320,40 +1310,37 @@ void gimp_spin_scale_set_label (GimpSpinScale *scale, const gchar *label) { - GimpSpinScalePrivate *private; - guint accel_key = GDK_KEY_VoidSymbol; - gchar *text = NULL; - gchar *pattern = NULL; + guint accel_key = GDK_KEY_VoidSymbol; + gchar *text = NULL; + gchar *pattern = NULL; g_return_if_fail (GIMP_IS_SPIN_SCALE (scale)); - private = GET_PRIVATE (scale); - - if (label == private->label) + if (label == scale->label) return; if (label && ! separate_uline_pattern (label, &accel_key, &text, &pattern)) return; - g_free (private->label); - private->label = g_strdup (label); + g_free (scale->label); + scale->label = g_strdup (label); - g_free (private->label_text); - private->label_text = text; /* don't dup */ + g_free (scale->label_text); + scale->label_text = text; /* don't dup */ - g_free (private->label_pattern); - private->label_pattern = pattern; /* don't dup */ + g_free (scale->label_pattern); + scale->label_pattern = pattern; /* don't dup */ - if (private->mnemonic_keyval != accel_key) + if (scale->mnemonic_keyval != accel_key) { - guint previous = private->mnemonic_keyval; + guint previous = scale->mnemonic_keyval; - private->mnemonic_keyval = accel_key; + scale->mnemonic_keyval = accel_key; gimp_spin_scale_setup_mnemonic (scale, previous); } - g_clear_object (&private->layout); + g_clear_object (&scale->layout); gtk_widget_queue_resize (GTK_WIDGET (scale)); @@ -1365,7 +1352,7 @@ gimp_spin_scale_get_label (GimpSpinScale *scale) { g_return_val_if_fail (GIMP_IS_SPIN_SCALE (scale), NULL); - return GET_PRIVATE (scale)->label; + return scale->label; } void @@ -1373,23 +1360,21 @@ gimp_spin_scale_set_scale_limits (GimpSpinScale *scale, gdouble lower, gdouble upper) { - GimpSpinScalePrivate *private; - GtkSpinButton *spin_button; - GtkAdjustment *adjustment; + GtkSpinButton *spin_button; + GtkAdjustment *adjustment; g_return_if_fail (GIMP_IS_SPIN_SCALE (scale)); - private = GET_PRIVATE (scale); spin_button = GTK_SPIN_BUTTON (scale); adjustment = gtk_spin_button_get_adjustment (spin_button); g_return_if_fail (lower >= gtk_adjustment_get_lower (adjustment)); g_return_if_fail (upper <= gtk_adjustment_get_upper (adjustment)); - private->scale_limits_set = TRUE; - private->scale_lower = lower; - private->scale_upper = upper; - private->gamma = 1.0; + scale->scale_limits_set = TRUE; + scale->scale_lower = lower; + scale->scale_upper = upper; + scale->gamma = 1.0; gimp_spin_scale_value_changed (spin_button); } @@ -1397,15 +1382,11 @@ gimp_spin_scale_set_scale_limits (GimpSpinScale *scale, void gimp_spin_scale_unset_scale_limits (GimpSpinScale *scale) { - GimpSpinScalePrivate *private; - g_return_if_fail (GIMP_IS_SPIN_SCALE (scale)); - private = GET_PRIVATE (scale); - - private->scale_limits_set = FALSE; - private->scale_lower = 0.0; - private->scale_upper = 0.0; + scale->scale_limits_set = FALSE; + scale->scale_lower = 0.0; + scale->scale_upper = 0.0; gimp_spin_scale_value_changed (GTK_SPIN_BUTTON (scale)); } @@ -1415,32 +1396,24 @@ gimp_spin_scale_get_scale_limits (GimpSpinScale *scale, gdouble *lower, gdouble *upper) { - GimpSpinScalePrivate *private; - g_return_val_if_fail (GIMP_IS_SPIN_SCALE (scale), FALSE); - private = GET_PRIVATE (scale); - if (lower) - *lower = private->scale_lower; + *lower = scale->scale_lower; if (upper) - *upper = private->scale_upper; + *upper = scale->scale_upper; - return private->scale_limits_set; + return scale->scale_limits_set; } void gimp_spin_scale_set_gamma (GimpSpinScale *scale, gdouble gamma) { - GimpSpinScalePrivate *private; - g_return_if_fail (GIMP_IS_SPIN_SCALE (scale)); - private = GET_PRIVATE (scale); - - private->gamma = gamma; + scale->gamma = gamma; gimp_spin_scale_value_changed (GTK_SPIN_BUTTON (scale)); } @@ -1450,7 +1423,7 @@ gimp_spin_scale_get_gamma (GimpSpinScale *scale) { g_return_val_if_fail (GIMP_IS_SPIN_SCALE (scale), 1.0); - return GET_PRIVATE (scale)->gamma; + return scale->gamma; } /** @@ -1468,13 +1441,9 @@ void gimp_spin_scale_set_constrain_drag (GimpSpinScale *scale, gboolean constrain) { - GimpSpinScalePrivate *private; - g_return_if_fail (GIMP_IS_SPIN_SCALE (scale)); - private = GET_PRIVATE (scale); - - private->constrain_drag = constrain; + scale->constrain_drag = constrain; } gboolean @@ -1482,7 +1451,7 @@ gimp_spin_scale_get_constrain_drag (GimpSpinScale *scale) { g_return_val_if_fail (GIMP_IS_SPIN_SCALE (scale), 1.0); - return GET_PRIVATE (scale)->constrain_drag; + return scale->constrain_drag; } /** @@ -1499,5 +1468,5 @@ gimp_spin_scale_get_mnemonic_keyval (GimpSpinScale *scale) { g_return_val_if_fail (GIMP_IS_SPIN_SCALE (scale), GDK_KEY_VoidSymbol); - return GET_PRIVATE (scale)->mnemonic_keyval; + return scale->mnemonic_keyval; } diff --git a/libgimpwidgets/gimpspinscale.h b/libgimpwidgets/gimpspinscale.h index b0190cf15a..01ba919e70 100644 --- a/libgimpwidgets/gimpspinscale.h +++ b/libgimpwidgets/gimpspinscale.h @@ -30,30 +30,10 @@ G_BEGIN_DECLS -#define GIMP_TYPE_SPIN_SCALE (gimp_spin_scale_get_type ()) -#define GIMP_SPIN_SCALE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_SPIN_SCALE, GimpSpinScale)) -#define GIMP_SPIN_SCALE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_SPIN_SCALE, GimpSpinScaleClass)) -#define GIMP_IS_SPIN_SCALE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_SPIN_SCALE)) -#define GIMP_IS_SPIN_SCALE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_SPIN_SCALE)) -#define GIMP_SPIN_SCALE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_SPIN_SCALE, GimpSpinScaleClass)) +#define GIMP_TYPE_SPIN_SCALE (gimp_spin_scale_get_type ()) +G_DECLARE_FINAL_TYPE (GimpSpinScale, gimp_spin_scale, GIMP, SPIN_SCALE, GimpSpinButton) -typedef struct _GimpSpinScale GimpSpinScale; -typedef struct _GimpSpinScaleClass GimpSpinScaleClass; - -struct _GimpSpinScale -{ - GimpSpinButton parent_instance; -}; - -struct _GimpSpinScaleClass -{ - GimpSpinButtonClass parent_class; -}; - - -GType gimp_spin_scale_get_type (void) G_GNUC_CONST; - GtkWidget * gimp_spin_scale_new (GtkAdjustment *adjustment, const gchar *label, gint digits); diff --git a/libgimpwidgets/gimpstringcombobox.c b/libgimpwidgets/gimpstringcombobox.c index 0af5b862be..1ac2778b2e 100644 --- a/libgimpwidgets/gimpstringcombobox.c +++ b/libgimpwidgets/gimpstringcombobox.c @@ -51,7 +51,7 @@ enum }; -struct _GimpStringComboBoxPrivate +typedef struct _GimpStringComboBoxPrivate { gint id_column; gint label_column; @@ -60,9 +60,7 @@ struct _GimpStringComboBoxPrivate GimpStringSensitivityFunc sensitivity_func; gpointer sensitivity_data; GDestroyNotify sensitivity_destroy; -}; - -#define GET_PRIVATE(obj) (((GimpStringComboBox *) (obj))->priv) +} GimpStringComboBoxPrivate; static void gimp_string_combo_box_constructed (GObject *object); @@ -170,13 +168,13 @@ gimp_string_combo_box_class_init (GimpStringComboBoxClass *klass) static void gimp_string_combo_box_init (GimpStringComboBox *combo_box) { - combo_box->priv = gimp_string_combo_box_get_instance_private (combo_box); } static void gimp_string_combo_box_constructed (GObject *object) { - GimpStringComboBoxPrivate *priv = GET_PRIVATE (object); + GimpStringComboBox *combo = GIMP_STRING_COMBO_BOX (object); + GimpStringComboBoxPrivate *priv = gimp_string_combo_box_get_instance_private (combo); GtkCellRenderer *cell; G_OBJECT_CLASS (parent_class)->constructed (object); @@ -205,7 +203,8 @@ gimp_string_combo_box_set_property (GObject *object, const GValue *value, GParamSpec *pspec) { - GimpStringComboBoxPrivate *priv = GET_PRIVATE (object); + GimpStringComboBox *combo = GIMP_STRING_COMBO_BOX (object); + GimpStringComboBoxPrivate *priv = gimp_string_combo_box_get_instance_private (combo); switch (property_id) { @@ -238,7 +237,8 @@ gimp_string_combo_box_get_property (GObject *object, GValue *value, GParamSpec *pspec) { - GimpStringComboBoxPrivate *priv = GET_PRIVATE (object); + GimpStringComboBox *combo = GIMP_STRING_COMBO_BOX (object); + GimpStringComboBoxPrivate *priv = gimp_string_combo_box_get_instance_private (combo); switch (property_id) { @@ -351,8 +351,12 @@ gboolean gimp_string_combo_box_set_active (GimpStringComboBox *combo_box, const gchar *id) { + GimpStringComboBoxPrivate *priv; + g_return_val_if_fail (GIMP_IS_STRING_COMBO_BOX (combo_box), FALSE); + priv = gimp_string_combo_box_get_instance_private (combo_box); + if (id) { GtkTreeModel *model; @@ -361,7 +365,7 @@ gimp_string_combo_box_set_active (GimpStringComboBox *combo_box, model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box)); - column = GET_PRIVATE (combo_box)->id_column; + column = priv->id_column; if (gimp_string_model_lookup (model, column, id, &iter)) { @@ -394,17 +398,20 @@ gimp_string_combo_box_set_active (GimpStringComboBox *combo_box, gchar * gimp_string_combo_box_get_active (GimpStringComboBox *combo_box) { - GtkTreeIter iter; + GtkTreeIter iter; + GimpStringComboBoxPrivate *priv; g_return_val_if_fail (GIMP_IS_STRING_COMBO_BOX (combo_box), NULL); + priv = gimp_string_combo_box_get_instance_private (combo_box); + if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo_box), &iter)) { GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box)); gchar *value; gint column; - column = GET_PRIVATE (combo_box)->id_column; + column = priv->id_column; gtk_tree_model_get (model, &iter, column, &value, @@ -442,7 +449,7 @@ gimp_string_combo_box_set_sensitivity (GimpStringComboBox *combo_box, g_return_if_fail (GIMP_IS_STRING_COMBO_BOX (combo_box)); - priv = GET_PRIVATE (combo_box); + priv = gimp_string_combo_box_get_instance_private (combo_box); if (priv->sensitivity_destroy) { diff --git a/libgimpwidgets/gimpstringcombobox.h b/libgimpwidgets/gimpstringcombobox.h index c25fb24995..5b65b8b195 100644 --- a/libgimpwidgets/gimpstringcombobox.h +++ b/libgimpwidgets/gimpstringcombobox.h @@ -38,23 +38,8 @@ typedef gboolean (* GimpStringSensitivityFunc) (const gchar *id, gpointer data); -#define GIMP_TYPE_STRING_COMBO_BOX (gimp_string_combo_box_get_type ()) -#define GIMP_STRING_COMBO_BOX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_STRING_COMBO_BOX, GimpStringComboBox)) -#define GIMP_STRING_COMBO_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_STRING_COMBO_BOX, GimpStringComboBoxClass)) -#define GIMP_IS_STRING_COMBO_BOX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_STRING_COMBO_BOX)) -#define GIMP_IS_STRING_COMBO_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_STRING_COMBO_BOX)) -#define GIMP_STRING_COMBO_BOX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_STRING_COMBO_BOX, GimpStringComboBoxClass)) - - -typedef struct _GimpStringComboBoxPrivate GimpStringComboBoxPrivate; -typedef struct _GimpStringComboBoxClass GimpStringComboBoxClass; - -struct _GimpStringComboBox -{ - GtkComboBox parent_instance; - - GimpStringComboBoxPrivate *priv; -}; +#define GIMP_TYPE_STRING_COMBO_BOX (gimp_string_combo_box_get_type ()) +G_DECLARE_DERIVABLE_TYPE (GimpStringComboBox, gimp_string_combo_box, GIMP, STRING_COMBO_BOX, GtkComboBox) struct _GimpStringComboBoxClass { @@ -72,8 +57,6 @@ struct _GimpStringComboBoxClass }; -GType gimp_string_combo_box_get_type (void) G_GNUC_CONST; - GtkWidget * gimp_string_combo_box_new (GtkTreeModel *model, gint id_column, gint label_column);