procyberian/gimp
2
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-07-04 09:53:25 +00:00
Code Issues 1 Projects 1 Releases Packages Wiki Activity Actions

libgimpwidgets: More widgets are now FINAL types

Browse source
This commit is contained in:
Alx Sa 2024-10-19 02:27:07 +00:00
parent 0b72b028e8
commit bd23d5a926
20 changed files with 835 additions and 1365 deletions
Download patch file Download diff file Expand all files Collapse all files

78
libgimpwidgets/gimplabelcolor.c
View file

@ -56,11 +56,13 @@ enum
static GParamSpec *object_props[N_PROPS] = { NULL, }; static GParamSpec *object_props[N_PROPS] = { NULL, };
typedef struct _GimpLabelColorPrivate struct _GimpLabelColor
{ {
GimpLabeled parent_instance;
GtkWidget *area; GtkWidget *area;
gboolean editable; gboolean editable;
} GimpLabelColorPrivate; };
static void gimp_label_color_constructed (GObject *object); static void gimp_label_color_constructed (GObject *object);
static void gimp_label_color_set_property (GObject *object, static void gimp_label_color_set_property (GObject *object,
@ -79,7 +81,7 @@ static GtkWidget * gimp_label_color_populate (GimpLabeled *color,
gint *height); gint *height);
G_DEFINE_TYPE_WITH_PRIVATE (GimpLabelColor, gimp_label_color, GIMP_TYPE_LABELED) G_DEFINE_TYPE (GimpLabelColor, gimp_label_color, GIMP_TYPE_LABELED)
#define parent_class gimp_label_color_parent_class #define parent_class gimp_label_color_parent_class
@ -95,7 +97,7 @@ gimp_label_color_class_init (GimpLabelColorClass *klass)
g_signal_new ("value-changed", g_signal_new ("value-changed",
G_TYPE_FROM_CLASS (klass), G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpLabelColorClass, value_changed), 0,
NULL, NULL, NULL, NULL, NULL, NULL,
G_TYPE_NONE, 0); G_TYPE_NONE, 0);
@ -139,17 +141,16 @@ gimp_label_color_class_init (GimpLabelColorClass *klass)
static void static void
gimp_label_color_init (GimpLabelColor *color) gimp_label_color_init (GimpLabelColor *color)
{ {
GimpLabelColorPrivate *priv = gimp_label_color_get_instance_private (color);
GeglColor *black = gegl_color_new ("black"); GeglColor *black = gegl_color_new ("black");
priv->editable = FALSE; color->editable = FALSE;
priv->area = gimp_color_area_new (black, GIMP_COLOR_AREA_SMALL_CHECKS, color->area = gimp_color_area_new (black, GIMP_COLOR_AREA_SMALL_CHECKS,
GDK_BUTTON1_MASK | GDK_BUTTON2_MASK); GDK_BUTTON1_MASK | GDK_BUTTON2_MASK);
/* Typically for a labelled color area, a small square next to your /* Typically for a labelled color area, a small square next to your
* label is probably what you want to display. * label is probably what you want to display.
*/ */
gtk_widget_set_size_request (priv->area, 20, 20); gtk_widget_set_size_request (color->area, 20, 20);
g_object_unref (black); g_object_unref (black);
} }
@ -158,7 +159,6 @@ static void
gimp_label_color_constructed (GObject *object) gimp_label_color_constructed (GObject *object)
{ {
GimpLabelColor *color = GIMP_LABEL_COLOR (object); GimpLabelColor *color = GIMP_LABEL_COLOR (object);
GimpLabelColorPrivate *priv = gimp_label_color_get_instance_private (color);
G_OBJECT_CLASS (parent_class)->constructed (object); G_OBJECT_CLASS (parent_class)->constructed (object);
@ -166,7 +166,7 @@ gimp_label_color_constructed (GObject *object)
* will allow config object to bind the "value" property of this * will allow config object to bind the "value" property of this
* widget, and therefore be updated automatically. * widget, and therefore be updated automatically.
*/ */
g_object_bind_property (G_OBJECT (priv->area), "color", g_object_bind_property (G_OBJECT (color->area), "color",
G_OBJECT (color), "value", G_OBJECT (color), "value",
G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
} }
@ -178,7 +178,6 @@ gimp_label_color_set_property (GObject *object,
GParamSpec *pspec) GParamSpec *pspec)
{ {
GimpLabelColor *lcolor = GIMP_LABEL_COLOR (object); GimpLabelColor *lcolor = GIMP_LABEL_COLOR (object);
GimpLabelColorPrivate *priv = gimp_label_color_get_instance_private (lcolor);
switch (property_id) switch (property_id)
{ {
@ -189,7 +188,7 @@ gimp_label_color_set_property (GObject *object,
new_color = g_value_get_object (value); new_color = g_value_get_object (value);
g_object_get (priv->area, g_object_get (lcolor->area,
"color", &color, "color", &color,
NULL); NULL);
@ -198,14 +197,14 @@ gimp_label_color_set_property (GObject *object,
*/ */
if (! gimp_color_is_perceptually_identical (color, new_color)) if (! gimp_color_is_perceptually_identical (color, new_color))
{ {
g_object_set (priv->area, "color", new_color, NULL); g_object_set (lcolor->area, "color", new_color, NULL);
g_signal_emit (object, gimp_label_color_signals[VALUE_CHANGED], 0); g_signal_emit (object, gimp_label_color_signals[VALUE_CHANGED], 0);
} }
g_object_unref (color); g_object_unref (color);
} }
break; break;
case PROP_EDITABLE: case PROP_EDITABLE:
if (priv->editable != g_value_get_boolean (value)) if (lcolor->editable != g_value_get_boolean (value))
{ {
const gchar *dialog_title; const gchar *dialog_title;
GimpLabeled *labeled; GimpLabeled *labeled;
@ -220,34 +219,34 @@ gimp_label_color_set_property (GObject *object,
*/ */
dialog_title = gtk_label_get_text (GTK_LABEL (gimp_labeled_get_label (labeled))); dialog_title = gtk_label_get_text (GTK_LABEL (gimp_labeled_get_label (labeled)));
attached = (gtk_widget_get_parent (priv->area) != NULL); attached = (gtk_widget_get_parent (lcolor->area) != NULL);
g_object_get (priv->area, g_object_get (lcolor->area,
"type", &type, "type", &type,
"color", &color, "color", &color,
NULL); NULL);
gtk_widget_destroy (priv->area); gtk_widget_destroy (lcolor->area);
priv->editable = g_value_get_boolean (value); lcolor->editable = g_value_get_boolean (value);
if (priv->editable) if (lcolor->editable)
priv->area = gimp_color_button_new (dialog_title, lcolor->area = gimp_color_button_new (dialog_title,
20, 20, color, type); 20, 20, color, type);
else else
priv->area = gimp_color_area_new (color, type, lcolor->area = gimp_color_area_new (color, type,
GDK_BUTTON1_MASK | GDK_BUTTON2_MASK); GDK_BUTTON1_MASK | GDK_BUTTON2_MASK);
g_object_unref (color); g_object_unref (color);
gtk_widget_set_size_request (priv->area, 20, 20); gtk_widget_set_size_request (lcolor->area, 20, 20);
g_object_bind_property (G_OBJECT (priv->area), "color", g_object_bind_property (G_OBJECT (lcolor->area), "color",
G_OBJECT (lcolor), "value", G_OBJECT (lcolor), "value",
G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
if (attached) if (attached)
{ {
gtk_grid_attach (GTK_GRID (lcolor), priv->area, 1, 0, 1, 1); gtk_grid_attach (GTK_GRID (lcolor), lcolor->area, 1, 0, 1, 1);
gtk_widget_show (priv->area); gtk_widget_show (lcolor->area);
g_signal_emit_by_name (object, "mnemonic-widget-changed", priv->area); g_signal_emit_by_name (object, "mnemonic-widget-changed", lcolor->area);
} }
} }
break; break;
@ -264,8 +263,7 @@ gimp_label_color_get_property (GObject *object,
GValue *value, GValue *value,
GParamSpec *pspec) GParamSpec *pspec)
{ {
GimpLabelColor *color = GIMP_LABEL_COLOR (object); GimpLabelColor *lcolor = GIMP_LABEL_COLOR (object);
GimpLabelColorPrivate *priv = gimp_label_color_get_instance_private (color);
switch (property_id) switch (property_id)
{ {
@ -273,14 +271,14 @@ gimp_label_color_get_property (GObject *object,
{ {
GeglColor *color; GeglColor *color;
g_object_get (priv->area, g_object_get (lcolor->area,
"color", &color, "color", &color,
NULL); NULL);
g_value_take_object (value, color); g_value_take_object (value, color);
} }
break; break;
case PROP_EDITABLE: case PROP_EDITABLE:
g_value_set_boolean (value, priv->editable); g_value_set_boolean (value, lcolor->editable);
break; break;
@ -298,15 +296,14 @@ gimp_label_color_populate (GimpLabeled *labeled,
gint *height) gint *height)
{ {
GimpLabelColor *color = GIMP_LABEL_COLOR (labeled); GimpLabelColor *color = GIMP_LABEL_COLOR (labeled);
GimpLabelColorPrivate *priv = gimp_label_color_get_instance_private (color);
gtk_grid_attach (GTK_GRID (color), priv->area, 1, 0, 1, 1); gtk_grid_attach (GTK_GRID (color), color->area, 1, 0, 1, 1);
/* Make sure the label and color won't be glued next to each other's. */ /* Make sure the label and color won't be glued next to each other's. */
gtk_grid_set_column_spacing (GTK_GRID (color), gtk_grid_set_column_spacing (GTK_GRID (color),
4 * gtk_widget_get_scale_factor (GTK_WIDGET (color))); 4 * gtk_widget_get_scale_factor (GTK_WIDGET (color)));
gtk_widget_show (priv->area); gtk_widget_show (color->area);
return priv->area; return color->area;
} }
@ -379,13 +376,12 @@ gimp_label_color_set_value (GimpLabelColor *color,
GeglColor * GeglColor *
gimp_label_color_get_value (GimpLabelColor *color) gimp_label_color_get_value (GimpLabelColor *color)
{ {
GimpLabelColorPrivate *priv = gimp_label_color_get_instance_private (color);
GeglColor *value = NULL; GeglColor *value = NULL;
GeglColor *retval; GeglColor *retval;
g_return_val_if_fail (GIMP_IS_LABEL_COLOR (color), NULL); g_return_val_if_fail (GIMP_IS_LABEL_COLOR (color), NULL);
g_object_get (priv->area, g_object_get (color->area,
"color", &value, "color", &value,
NULL); NULL);
retval = gegl_color_duplicate (value); retval = gegl_color_duplicate (value);
@ -421,13 +417,9 @@ gimp_label_color_set_editable (GimpLabelColor *color,
gboolean gboolean
gimp_label_color_is_editable (GimpLabelColor *color) gimp_label_color_is_editable (GimpLabelColor *color)
{ {
GimpLabelColorPrivate *priv = gimp_label_color_get_instance_private (color);
g_return_val_if_fail (GIMP_IS_LABEL_COLOR (color), FALSE); g_return_val_if_fail (GIMP_IS_LABEL_COLOR (color), FALSE);
priv = gimp_label_color_get_instance_private (color); return GIMP_IS_COLOR_SELECT (color->area);
return GIMP_IS_COLOR_SELECT (priv->area);
} }
/** /**
@ -443,9 +435,7 @@ gimp_label_color_is_editable (GimpLabelColor *color)
GtkWidget * GtkWidget *
gimp_label_color_get_color_widget (GimpLabelColor *color) gimp_label_color_get_color_widget (GimpLabelColor *color)
{ {
GimpLabelColorPrivate *priv = gimp_label_color_get_instance_private (color);
g_return_val_if_fail (GIMP_IS_LABEL_COLOR (color), NULL); g_return_val_if_fail (GIMP_IS_LABEL_COLOR (color), NULL);
return priv->area; return color->area;
} }

19
libgimpwidgets/gimplabelcolor.h
View file

@ -31,25 +31,8 @@
G_BEGIN_DECLS G_BEGIN_DECLS
#define GIMP_TYPE_LABEL_COLOR (gimp_label_color_get_type ()) #define GIMP_TYPE_LABEL_COLOR (gimp_label_color_get_type ())
G_DECLARE_DERIVABLE_TYPE (GimpLabelColor, gimp_label_color, GIMP, LABEL_COLOR, GimpLabeled) G_DECLARE_FINAL_TYPE (GimpLabelColor, gimp_label_color, GIMP, LABEL_COLOR, GimpLabeled)
struct _GimpLabelColorClass
{
GimpLabeledClass parent_class;
/* Signals */
void (* value_changed) (GimpLabelColor *color);
/* 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);
};
GtkWidget * gimp_label_color_new (const gchar *label, GtkWidget * gimp_label_color_new (const gchar *label,
GeglColor *color, GeglColor *color,

37
libgimpwidgets/gimplabelentry.c
View file

@ -51,10 +51,12 @@ enum
PROP_VALUE, PROP_VALUE,
}; };
typedef struct _GimpLabelEntryPrivate struct _GimpLabelEntry
{ {
GimpLabeled parent_class;
GtkWidget *entry; GtkWidget *entry;
} GimpLabelEntryPrivate; };
static void gimp_label_entry_constructed (GObject *object); static void gimp_label_entry_constructed (GObject *object);
static void gimp_label_entry_set_property (GObject *object, static void gimp_label_entry_set_property (GObject *object,
@ -72,7 +74,7 @@ static GtkWidget * gimp_label_entry_populate (GimpLabeled *entry,
gint *width, gint *width,
gint *height); gint *height);
G_DEFINE_TYPE_WITH_PRIVATE (GimpLabelEntry, gimp_label_entry, GIMP_TYPE_LABELED) G_DEFINE_TYPE (GimpLabelEntry, gimp_label_entry, GIMP_TYPE_LABELED)
#define parent_class gimp_label_entry_parent_class #define parent_class gimp_label_entry_parent_class
@ -88,7 +90,7 @@ gimp_label_entry_class_init (GimpLabelEntryClass *klass)
g_signal_new ("value-changed", g_signal_new ("value-changed",
G_TYPE_FROM_CLASS (klass), G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpLabelEntryClass, value_changed), 0,
NULL, NULL, NULL, NULL, NULL, NULL,
G_TYPE_NONE, 0); G_TYPE_NONE, 0);
@ -116,17 +118,14 @@ gimp_label_entry_class_init (GimpLabelEntryClass *klass)
static void static void
gimp_label_entry_init (GimpLabelEntry *entry) gimp_label_entry_init (GimpLabelEntry *entry)
{ {
GimpLabelEntryPrivate *priv = gimp_label_entry_get_instance_private (entry); entry->entry = gtk_entry_new ();
priv->entry = gtk_entry_new ();
} }
static void static void
gimp_label_entry_constructed (GObject *object) gimp_label_entry_constructed (GObject *object)
{ {
GimpLabelEntry *entry = GIMP_LABEL_ENTRY (object); GimpLabelEntry *entry = GIMP_LABEL_ENTRY (object);
GimpLabelEntryPrivate *priv = gimp_label_entry_get_instance_private (entry); GtkEntryBuffer *buffer = gtk_entry_get_buffer (GTK_ENTRY (entry->entry));
GtkEntryBuffer *buffer = gtk_entry_get_buffer (GTK_ENTRY (priv->entry));
G_OBJECT_CLASS (parent_class)->constructed (object); G_OBJECT_CLASS (parent_class)->constructed (object);
@ -146,13 +145,12 @@ gimp_label_entry_set_property (GObject *object,
GParamSpec *pspec) GParamSpec *pspec)
{ {
GimpLabelEntry *entry = GIMP_LABEL_ENTRY (object); GimpLabelEntry *entry = GIMP_LABEL_ENTRY (object);
GimpLabelEntryPrivate *priv = gimp_label_entry_get_instance_private (entry);
switch (property_id) switch (property_id)
{ {
case PROP_VALUE: case PROP_VALUE:
{ {
GtkEntryBuffer *buffer = gtk_entry_get_buffer (GTK_ENTRY (priv->entry)); GtkEntryBuffer *buffer = gtk_entry_get_buffer (GTK_ENTRY (entry->entry));
/* Avoid looping forever since we have bound this widget's /* Avoid looping forever since we have bound this widget's
* "value" property with the entry button "value" property. * "value" property with the entry button "value" property.
@ -178,13 +176,12 @@ gimp_label_entry_get_property (GObject *object,
GParamSpec *pspec) GParamSpec *pspec)
{ {
GimpLabelEntry *entry = GIMP_LABEL_ENTRY (object); GimpLabelEntry *entry = GIMP_LABEL_ENTRY (object);
GimpLabelEntryPrivate *priv = gimp_label_entry_get_instance_private (entry);
switch (property_id) switch (property_id)
{ {
case PROP_VALUE: case PROP_VALUE:
{ {
GtkEntryBuffer *buffer = gtk_entry_get_buffer (GTK_ENTRY (priv->entry)); GtkEntryBuffer *buffer = gtk_entry_get_buffer (GTK_ENTRY (entry->entry));
g_value_set_string (value, gtk_entry_buffer_get_text (buffer)); g_value_set_string (value, gtk_entry_buffer_get_text (buffer));
} }
@ -204,15 +201,14 @@ gimp_label_entry_populate (GimpLabeled *labeled,
gint *height) gint *height)
{ {
GimpLabelEntry *entry = GIMP_LABEL_ENTRY (labeled); GimpLabelEntry *entry = GIMP_LABEL_ENTRY (labeled);
GimpLabelEntryPrivate *priv = gimp_label_entry_get_instance_private (entry);
gtk_grid_attach (GTK_GRID (entry), priv->entry, 1, 0, 1, 1); gtk_grid_attach (GTK_GRID (entry), entry->entry, 1, 0, 1, 1);
/* Make sure the label and entry won't be glued next to each other's. */ /* Make sure the label and entry won't be glued next to each other's. */
gtk_grid_set_column_spacing (GTK_GRID (entry), gtk_grid_set_column_spacing (GTK_GRID (entry),
4 * gtk_widget_get_scale_factor (GTK_WIDGET (entry))); 4 * gtk_widget_get_scale_factor (GTK_WIDGET (entry)));
gtk_widget_show (priv->entry); gtk_widget_show (entry->entry);
return priv->entry; return entry->entry;
} }
@ -267,12 +263,11 @@ gimp_label_entry_set_value (GimpLabelEntry *entry,
const gchar * const gchar *
gimp_label_entry_get_value (GimpLabelEntry *entry) gimp_label_entry_get_value (GimpLabelEntry *entry)
{ {
GimpLabelEntryPrivate *priv = gimp_label_entry_get_instance_private (entry);
GtkEntryBuffer *buffer; GtkEntryBuffer *buffer;
g_return_val_if_fail (GIMP_IS_LABEL_ENTRY (entry), NULL); g_return_val_if_fail (GIMP_IS_LABEL_ENTRY (entry), NULL);
buffer = gtk_entry_get_buffer (GTK_ENTRY (priv->entry)); buffer = gtk_entry_get_buffer (GTK_ENTRY (entry->entry));
return gtk_entry_buffer_get_text (buffer); return gtk_entry_buffer_get_text (buffer);
} }
@ -288,9 +283,7 @@ gimp_label_entry_get_value (GimpLabelEntry *entry)
GtkWidget * GtkWidget *
gimp_label_entry_get_entry (GimpLabelEntry *entry) gimp_label_entry_get_entry (GimpLabelEntry *entry)
{ {
GimpLabelEntryPrivate *priv = gimp_label_entry_get_instance_private (entry);
g_return_val_if_fail (GIMP_IS_LABEL_ENTRY (entry), NULL); g_return_val_if_fail (GIMP_IS_LABEL_ENTRY (entry), NULL);
return priv->entry; return entry->entry;
} }

19
libgimpwidgets/gimplabelentry.h
View file

@ -31,25 +31,8 @@
G_BEGIN_DECLS G_BEGIN_DECLS
#define GIMP_TYPE_LABEL_ENTRY (gimp_label_entry_get_type ()) #define GIMP_TYPE_LABEL_ENTRY (gimp_label_entry_get_type ())
G_DECLARE_DERIVABLE_TYPE (GimpLabelEntry, gimp_label_entry, GIMP, LABEL_ENTRY, GimpLabeled) G_DECLARE_FINAL_TYPE (GimpLabelEntry, gimp_label_entry, GIMP, LABEL_ENTRY, GimpLabeled)
struct _GimpLabelEntryClass
{
GimpLabeledClass parent_class;
/* Signals */
void (* value_changed) (GimpLabelEntry *entry);
/* 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);
};
GtkWidget * gimp_label_entry_new (const gchar *label); GtkWidget * gimp_label_entry_new (const gchar *label);

34
libgimpwidgets/gimplabelintwidget.c
View file

@ -53,13 +53,13 @@ enum
PROP_WIDGET, PROP_WIDGET,
}; };
typedef struct _GimpLabelIntWidgetPrivate struct _GimpLabelIntWidget
{ {
GimpLabeled parent_instance; GimpLabeled parent_instance;
GtkWidget *widget; GtkWidget *widget;
gint value; gint value;
} GimpLabelIntWidgetPrivate; };
static void gimp_label_int_widget_constructed (GObject *object); static void gimp_label_int_widget_constructed (GObject *object);
static void gimp_label_int_widget_set_property (GObject *object, static void gimp_label_int_widget_set_property (GObject *object,
@ -77,7 +77,7 @@ static GtkWidget * gimp_label_int_widget_populate (GimpLabeled *widge
gint *width, gint *width,
gint *height); gint *height);
G_DEFINE_TYPE_WITH_PRIVATE (GimpLabelIntWidget, gimp_label_int_widget, GIMP_TYPE_LABELED) G_DEFINE_TYPE (GimpLabelIntWidget, gimp_label_int_widget, GIMP_TYPE_LABELED)
#define parent_class gimp_label_int_widget_parent_class #define parent_class gimp_label_int_widget_parent_class
@ -93,7 +93,7 @@ gimp_label_int_widget_class_init (GimpLabelIntWidgetClass *klass)
g_signal_new ("value-changed", g_signal_new ("value-changed",
G_TYPE_FROM_CLASS (klass), G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpLabelIntWidgetClass, value_changed), 0,
NULL, NULL, NULL, NULL, NULL, NULL,
G_TYPE_NONE, 0); G_TYPE_NONE, 0);
@ -140,7 +140,6 @@ static void
gimp_label_int_widget_constructed (GObject *object) gimp_label_int_widget_constructed (GObject *object)
{ {
GimpLabelIntWidget *widget = GIMP_LABEL_INT_WIDGET (object); GimpLabelIntWidget *widget = GIMP_LABEL_INT_WIDGET (object);
GimpLabelIntWidgetPrivate *priv = gimp_label_int_widget_get_instance_private (widget);
G_OBJECT_CLASS (parent_class)->constructed (object); G_OBJECT_CLASS (parent_class)->constructed (object);
@ -151,7 +150,7 @@ gimp_label_int_widget_constructed (GObject *object)
* will allow config object to bind the "value" property of this * will allow config object to bind the "value" property of this
* widget, and therefore be updated automatically. * widget, and therefore be updated automatically.
*/ */
g_object_bind_property (G_OBJECT (priv->widget), "value", g_object_bind_property (G_OBJECT (widget->widget), "value",
object, "value", object, "value",
G_BINDING_BIDIRECTIONAL | G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE); G_BINDING_SYNC_CREATE);
@ -164,16 +163,15 @@ gimp_label_int_widget_set_property (GObject *object,
GParamSpec *pspec) GParamSpec *pspec)
{ {
GimpLabelIntWidget *widget = GIMP_LABEL_INT_WIDGET (object); GimpLabelIntWidget *widget = GIMP_LABEL_INT_WIDGET (object);
GimpLabelIntWidgetPrivate *priv = gimp_label_int_widget_get_instance_private (widget);
switch (property_id) switch (property_id)
{ {
case PROP_VALUE: case PROP_VALUE:
priv->value = g_value_get_int (value); widget->value = g_value_get_int (value);
g_signal_emit (object, gimp_label_int_widget_signals[VALUE_CHANGED], 0); g_signal_emit (object, gimp_label_int_widget_signals[VALUE_CHANGED], 0);
break; break;
case PROP_WIDGET: case PROP_WIDGET:
priv->widget = g_value_get_object (value); widget->widget = g_value_get_object (value);
break; break;
default: default:
@ -189,15 +187,14 @@ gimp_label_int_widget_get_property (GObject *object,
GParamSpec *pspec) GParamSpec *pspec)
{ {
GimpLabelIntWidget *widget = GIMP_LABEL_INT_WIDGET (object); GimpLabelIntWidget *widget = GIMP_LABEL_INT_WIDGET (object);
GimpLabelIntWidgetPrivate *priv = gimp_label_int_widget_get_instance_private (widget);
switch (property_id) switch (property_id)
{ {
case PROP_VALUE: case PROP_VALUE:
g_value_set_int (value, priv->value); g_value_set_int (value, widget->value);
break; break;
case PROP_WIDGET: case PROP_WIDGET:
g_value_set_object (value, priv->widget); g_value_set_object (value, widget->widget);
break; break;
default: default:
@ -214,12 +211,11 @@ gimp_label_int_widget_populate (GimpLabeled *labeled,
gint *height) gint *height)
{ {
GimpLabelIntWidget *widget = GIMP_LABEL_INT_WIDGET (labeled); GimpLabelIntWidget *widget = GIMP_LABEL_INT_WIDGET (labeled);
GimpLabelIntWidgetPrivate *priv = gimp_label_int_widget_get_instance_private (widget);
gtk_grid_attach (GTK_GRID (widget), priv->widget, 1, 0, 1, 1); gtk_grid_attach (GTK_GRID (widget), widget->widget, 1, 0, 1, 1);
gtk_widget_show (priv->widget); gtk_widget_show (widget->widget);
return priv->widget; return widget->widget;
} }
/* Public Functions */ /* Public Functions */
@ -263,11 +259,7 @@ gimp_label_int_widget_new (const gchar *text,
GtkWidget * GtkWidget *
gimp_label_int_widget_get_widget (GimpLabelIntWidget *widget) gimp_label_int_widget_get_widget (GimpLabelIntWidget *widget)
{ {
GimpLabelIntWidgetPrivate *priv;
g_return_val_if_fail (GIMP_IS_LABEL_INT_WIDGET (widget), NULL); g_return_val_if_fail (GIMP_IS_LABEL_INT_WIDGET (widget), NULL);
priv = gimp_label_int_widget_get_instance_private (widget); return widget->widget;
return priv->widget;
} }

19
libgimpwidgets/gimplabelintwidget.h
View file

@ -31,25 +31,8 @@
G_BEGIN_DECLS G_BEGIN_DECLS
#define GIMP_TYPE_LABEL_INT_WIDGET (gimp_label_int_widget_get_type ()) #define GIMP_TYPE_LABEL_INT_WIDGET (gimp_label_int_widget_get_type ())
G_DECLARE_DERIVABLE_TYPE (GimpLabelIntWidget, gimp_label_int_widget, GIMP, LABEL_INT_WIDGET, GimpLabeled) G_DECLARE_FINAL_TYPE (GimpLabelIntWidget, gimp_label_int_widget, GIMP, LABEL_INT_WIDGET, GimpLabeled)
struct _GimpLabelIntWidgetClass
{
GimpLabeledClass parent_class;
/* Signals */
void (* value_changed) (GtkWidget *int_widget);
/* 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);
};
GtkWidget * gimp_label_int_widget_new (const gchar *text, GtkWidget * gimp_label_int_widget_new (const gchar *text,
GtkWidget *widget); GtkWidget *widget);

41
libgimpwidgets/gimplabelstringwidget.c
View file

@ -53,13 +53,13 @@ enum
PROP_WIDGET, PROP_WIDGET,
}; };
typedef struct _GimpLabelStringWidgetPrivate struct _GimpLabelStringWidget
{ {
GimpLabeled parent_instance; GimpLabeled parent_instance;
GtkWidget *widget; GtkWidget *widget;
gchar *value; gchar *value;
} GimpLabelStringWidgetPrivate; };
static void gimp_label_string_widget_constructed (GObject *object); static void gimp_label_string_widget_constructed (GObject *object);
static void gimp_label_string_widget_finalize (GObject *object); static void gimp_label_string_widget_finalize (GObject *object);
@ -78,7 +78,7 @@ static GtkWidget * gimp_label_string_widget_populate (GimpLabeled *wi
gint *width, gint *width,
gint *height); gint *height);
G_DEFINE_TYPE_WITH_PRIVATE (GimpLabelStringWidget, gimp_label_string_widget, GIMP_TYPE_LABELED) G_DEFINE_TYPE (GimpLabelStringWidget, gimp_label_string_widget, GIMP_TYPE_LABELED)
#define parent_class gimp_label_string_widget_parent_class #define parent_class gimp_label_string_widget_parent_class
@ -94,7 +94,7 @@ gimp_label_string_widget_class_init (GimpLabelStringWidgetClass *klass)
g_signal_new ("value-changed", g_signal_new ("value-changed",
G_TYPE_FROM_CLASS (klass), G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpLabelStringWidgetClass, value_changed), 0,
NULL, NULL, NULL, NULL, NULL, NULL,
G_TYPE_NONE, 0); G_TYPE_NONE, 0);
@ -142,7 +142,6 @@ static void
gimp_label_string_widget_constructed (GObject *object) gimp_label_string_widget_constructed (GObject *object)
{ {
GimpLabelStringWidget *widget = GIMP_LABEL_STRING_WIDGET (object); GimpLabelStringWidget *widget = GIMP_LABEL_STRING_WIDGET (object);
GimpLabelStringWidgetPrivate *priv = gimp_label_string_widget_get_instance_private (widget);
G_OBJECT_CLASS (parent_class)->constructed (object); G_OBJECT_CLASS (parent_class)->constructed (object);
@ -153,7 +152,7 @@ gimp_label_string_widget_constructed (GObject *object)
* will allow config object to bind the "value" property of this * will allow config object to bind the "value" property of this
* widget, and therefore be updated automatically. * widget, and therefore be updated automatically.
*/ */
g_object_bind_property (G_OBJECT (priv->widget), "value", g_object_bind_property (G_OBJECT (widget->widget), "value",
object, "value", object, "value",
G_BINDING_BIDIRECTIONAL | G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE); G_BINDING_SYNC_CREATE);
@ -163,9 +162,8 @@ static void
gimp_label_string_widget_finalize (GObject *object) gimp_label_string_widget_finalize (GObject *object)
{ {
GimpLabelStringWidget *widget = GIMP_LABEL_STRING_WIDGET (object); GimpLabelStringWidget *widget = GIMP_LABEL_STRING_WIDGET (object);
GimpLabelStringWidgetPrivate *priv = gimp_label_string_widget_get_instance_private (widget);
g_free (priv->value); g_free (widget->value);
G_OBJECT_CLASS (parent_class)->finalize (object); G_OBJECT_CLASS (parent_class)->finalize (object);
} }
@ -177,20 +175,19 @@ gimp_label_string_widget_set_property (GObject *object,
GParamSpec *pspec) GParamSpec *pspec)
{ {
GimpLabelStringWidget *widget = GIMP_LABEL_STRING_WIDGET (object); GimpLabelStringWidget *widget = GIMP_LABEL_STRING_WIDGET (object);
GimpLabelStringWidgetPrivate *priv = gimp_label_string_widget_get_instance_private (widget);
switch (property_id) switch (property_id)
{ {
case PROP_VALUE: case PROP_VALUE:
if (g_strcmp0 (priv->value, g_value_get_string (value)) != 0) if (g_strcmp0 (widget->value, g_value_get_string (value)) != 0)
{ {
g_free (priv->value); g_free (widget->value);
priv->value = g_value_dup_string (value); widget->value = g_value_dup_string (value);
g_signal_emit (object, gimp_label_string_widget_signals[VALUE_CHANGED], 0); g_signal_emit (object, gimp_label_string_widget_signals[VALUE_CHANGED], 0);
} }
break; break;
case PROP_WIDGET: case PROP_WIDGET:
priv->widget = g_value_get_object (value); widget->widget = g_value_get_object (value);
break; break;
default: default:
@ -206,15 +203,14 @@ gimp_label_string_widget_get_property (GObject *object,
GParamSpec *pspec) GParamSpec *pspec)
{ {
GimpLabelStringWidget *widget = GIMP_LABEL_STRING_WIDGET (object); GimpLabelStringWidget *widget = GIMP_LABEL_STRING_WIDGET (object);
GimpLabelStringWidgetPrivate *priv = gimp_label_string_widget_get_instance_private (widget);
switch (property_id) switch (property_id)
{ {
case PROP_VALUE: case PROP_VALUE:
g_value_set_string (value, priv->value); g_value_set_string (value, widget->value);
break; break;
case PROP_WIDGET: case PROP_WIDGET:
g_value_set_object (value, priv->widget); g_value_set_object (value, widget->widget);
break; break;
default: default:
@ -231,12 +227,11 @@ gimp_label_string_widget_populate (GimpLabeled *labeled,
gint *height) gint *height)
{ {
GimpLabelStringWidget *widget = GIMP_LABEL_STRING_WIDGET (labeled); GimpLabelStringWidget *widget = GIMP_LABEL_STRING_WIDGET (labeled);
GimpLabelStringWidgetPrivate *priv = gimp_label_string_widget_get_instance_private (widget);
gtk_grid_attach (GTK_GRID (widget), priv->widget, 1, 0, 1, 1); gtk_grid_attach (GTK_GRID (widget), widget->widget, 1, 0, 1, 1);
gtk_widget_show (priv->widget); gtk_widget_show (widget->widget);
return priv->widget; return widget->widget;
} }
/* Public Functions */ /* Public Functions */
@ -281,11 +276,7 @@ gimp_label_string_widget_new (const gchar *text,
GtkWidget * GtkWidget *
gimp_label_string_widget_get_widget (GimpLabelStringWidget *widget) gimp_label_string_widget_get_widget (GimpLabelStringWidget *widget)
{ {
GimpLabelStringWidgetPrivate *priv;
g_return_val_if_fail (GIMP_IS_LABEL_STRING_WIDGET (widget), NULL); g_return_val_if_fail (GIMP_IS_LABEL_STRING_WIDGET (widget), NULL);
priv = gimp_label_string_widget_get_instance_private (widget); return widget->widget;
return priv->widget;
} }

19
libgimpwidgets/gimplabelstringwidget.h
View file

@ -31,25 +31,8 @@
G_BEGIN_DECLS G_BEGIN_DECLS
#define GIMP_TYPE_LABEL_STRING_WIDGET (gimp_label_string_widget_get_type ()) #define GIMP_TYPE_LABEL_STRING_WIDGET (gimp_label_string_widget_get_type ())
G_DECLARE_DERIVABLE_TYPE (GimpLabelStringWidget, gimp_label_string_widget, GIMP, LABEL_STRING_WIDGET, GimpLabeled) G_DECLARE_FINAL_TYPE (GimpLabelStringWidget, gimp_label_string_widget, GIMP, LABEL_STRING_WIDGET, GimpLabeled)
struct _GimpLabelStringWidgetClass
{
GimpLabeledClass parent_class;
/* Signals */
void (* value_changed) (GtkWidget *string_widget);
/* 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);
};
GtkWidget * gimp_label_string_widget_new (const gchar *text, GtkWidget * gimp_label_string_widget_new (const gchar *text,
GtkWidget *widget); GtkWidget *widget);

107
libgimpwidgets/gimpmemsizeentry.c
View file

@ -51,8 +51,10 @@ enum
}; };
typedef struct _GimpMemsizeEntryPrivate struct _GimpMemsizeEntry
{ {
GtkBox parent_instance;
guint64 value; guint64 value;
guint64 lower; guint64 lower;
guint64 upper; guint64 upper;
@ -63,7 +65,7 @@ typedef struct _GimpMemsizeEntryPrivate
GtkAdjustment *adjustment; GtkAdjustment *adjustment;
GtkWidget *spinbutton; GtkWidget *spinbutton;
GtkWidget *menu; GtkWidget *menu;
} GimpMemsizeEntryPrivate; } ;
static void gimp_memsize_entry_adj_callback (GtkAdjustment *adj, static void gimp_memsize_entry_adj_callback (GtkAdjustment *adj,
@ -74,7 +76,7 @@ static void gimp_memsize_entry_unit_callback (GtkWidget *widget,
static guint64 gimp_memsize_entry_get_rounded_value (GimpMemsizeEntry *entry, static guint64 gimp_memsize_entry_get_rounded_value (GimpMemsizeEntry *entry,
guint64 value); guint64 value);
G_DEFINE_TYPE_WITH_PRIVATE (GimpMemsizeEntry, gimp_memsize_entry, GTK_TYPE_BOX) G_DEFINE_TYPE (GimpMemsizeEntry, gimp_memsize_entry, GTK_TYPE_BOX)
#define parent_class gimp_memsize_entry_parent_class #define parent_class gimp_memsize_entry_parent_class
@ -84,13 +86,11 @@ static guint gimp_memsize_entry_signals[LAST_SIGNAL] = { 0 };
static void static void
gimp_memsize_entry_class_init (GimpMemsizeEntryClass *klass) gimp_memsize_entry_class_init (GimpMemsizeEntryClass *klass)
{ {
klass->value_changed = NULL;
gimp_memsize_entry_signals[VALUE_CHANGED] = gimp_memsize_entry_signals[VALUE_CHANGED] =
g_signal_new ("value-changed", g_signal_new ("value-changed",
G_TYPE_FROM_CLASS (klass), G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpMemsizeEntryClass, value_changed), 0,
NULL, NULL, NULL, NULL, NULL, NULL,
G_TYPE_NONE, 0); G_TYPE_NONE, 0);
} }
@ -108,16 +108,13 @@ static void
gimp_memsize_entry_adj_callback (GtkAdjustment *adj, gimp_memsize_entry_adj_callback (GtkAdjustment *adj,
GimpMemsizeEntry *entry) GimpMemsizeEntry *entry)
{ {
GimpMemsizeEntryPrivate *private;
guint64 size = gtk_adjustment_get_value (adj); guint64 size = gtk_adjustment_get_value (adj);
private = gimp_memsize_entry_get_instance_private (entry); if (gimp_memsize_entry_get_rounded_value (entry, entry->value) != size)
if (gimp_memsize_entry_get_rounded_value (entry, private->value) != size)
/* Do not allow losing accuracy if the converted/displayed value /* Do not allow losing accuracy if the converted/displayed value
* stays the same. * stays the same.
*/ */
private->value = size << private->shift; entry->value = size << entry->shift;
g_signal_emit (entry, gimp_memsize_entry_signals[VALUE_CHANGED], 0); g_signal_emit (entry, gimp_memsize_entry_signals[VALUE_CHANGED], 0);
} }
@ -126,11 +123,8 @@ static void
gimp_memsize_entry_unit_callback (GtkWidget *widget, gimp_memsize_entry_unit_callback (GtkWidget *widget,
GimpMemsizeEntry *entry) GimpMemsizeEntry *entry)
{ {
GimpMemsizeEntryPrivate *private;
guint shift; guint shift;
private = gimp_memsize_entry_get_instance_private (entry);
gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), (gint *) &shift); gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), (gint *) &shift);
#if _MSC_VER < 1300 #if _MSC_VER < 1300
@ -139,17 +133,17 @@ gimp_memsize_entry_unit_callback (GtkWidget *widget,
# define CAST # define CAST
#endif #endif
if (shift != private->shift) if (shift != entry->shift)
{ {
private->shift = shift; entry->shift = shift;
gtk_adjustment_configure (private->adjustment, gtk_adjustment_configure (entry->adjustment,
gimp_memsize_entry_get_rounded_value (entry, private->value), gimp_memsize_entry_get_rounded_value (entry, entry->value),
CAST private->lower >> shift, CAST entry->lower >> shift,
CAST private->upper >> shift, CAST entry->upper >> shift,
gtk_adjustment_get_step_increment (private->adjustment), gtk_adjustment_get_step_increment (entry->adjustment),
gtk_adjustment_get_page_increment (private->adjustment), gtk_adjustment_get_page_increment (entry->adjustment),
gtk_adjustment_get_page_size (private->adjustment)); gtk_adjustment_get_page_size (entry->adjustment));
} }
#undef CAST #undef CAST
@ -168,19 +162,16 @@ static guint64
gimp_memsize_entry_get_rounded_value (GimpMemsizeEntry *entry, gimp_memsize_entry_get_rounded_value (GimpMemsizeEntry *entry,
guint64 value) guint64 value)
{ {
GimpMemsizeEntryPrivate *private;
guint64 converted; guint64 converted;
private = gimp_memsize_entry_get_instance_private (entry);
#if _MSC_VER < 1300 #if _MSC_VER < 1300
# define CAST (gint64) # define CAST (gint64)
#else #else
# define CAST # define CAST
#endif #endif
converted = (CAST value >> private->shift) + converted = (CAST value >> entry->shift) +
((CAST private->value >> (private->shift - 1)) & 1); ((CAST entry->value >> (entry->shift - 1)) & 1);
#undef CAST #undef CAST
@ -205,7 +196,6 @@ gimp_memsize_entry_new (guint64 value,
guint64 upper) guint64 upper)
{ {
GimpMemsizeEntry *entry; GimpMemsizeEntry *entry;
GimpMemsizeEntryPrivate *private;
guint shift; guint shift;
#if _MSC_VER < 1300 #if _MSC_VER < 1300
@ -218,8 +208,6 @@ gimp_memsize_entry_new (guint64 value,
entry = g_object_new (GIMP_TYPE_MEMSIZE_ENTRY, NULL); entry = g_object_new (GIMP_TYPE_MEMSIZE_ENTRY, NULL);
private = gimp_memsize_entry_get_instance_private (entry);
for (shift = 30; shift > 10; shift -= 10) for (shift = 30; shift > 10; shift -= 10)
{ {
if (value > (G_GUINT64_CONSTANT (1) << shift) && if (value > (G_GUINT64_CONSTANT (1) << shift) &&
@ -227,43 +215,43 @@ gimp_memsize_entry_new (guint64 value,
break; break;
} }
private->value = value; entry->value = value;
private->lower = lower; entry->lower = lower;
private->upper = upper; entry->upper = upper;
private->shift = shift; entry->shift = shift;
private->adjustment = gtk_adjustment_new (gimp_memsize_entry_get_rounded_value (entry, entry->adjustment = gtk_adjustment_new (gimp_memsize_entry_get_rounded_value (entry,
private->value), entry->value),
CAST (lower >> shift), CAST (lower >> shift),
CAST (upper >> shift), CAST (upper >> shift),
1, 8, 0); 1, 8, 0);
private->spinbutton = gimp_spin_button_new (private->adjustment, 1.0, 0); entry->spinbutton = gimp_spin_button_new (entry->adjustment, 1.0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (private->spinbutton), TRUE); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (entry->spinbutton), TRUE);
#undef CAST #undef CAST
gtk_entry_set_width_chars (GTK_ENTRY (private->spinbutton), 7); gtk_entry_set_width_chars (GTK_ENTRY (entry->spinbutton), 7);
gtk_box_pack_start (GTK_BOX (entry), private->spinbutton, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (entry), entry->spinbutton, FALSE, FALSE, 0);
gtk_widget_show (private->spinbutton); gtk_widget_show (entry->spinbutton);
g_signal_connect (private->adjustment, "value-changed", g_signal_connect (entry->adjustment, "value-changed",
G_CALLBACK (gimp_memsize_entry_adj_callback), G_CALLBACK (gimp_memsize_entry_adj_callback),
entry); entry);
private->menu = gimp_int_combo_box_new (_("Kibibyte"), 10, entry->menu = gimp_int_combo_box_new (_("Kibibyte"), 10,
_("Mebibyte"), 20, _("Mebibyte"), 20,
_("Gibibyte"), 30, _("Gibibyte"), 30,
NULL); NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (private->menu), shift); gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (entry->menu), shift);
g_signal_connect (private->menu, "changed", g_signal_connect (entry->menu, "changed",
G_CALLBACK (gimp_memsize_entry_unit_callback), G_CALLBACK (gimp_memsize_entry_unit_callback),
entry); entry);
gtk_box_pack_start (GTK_BOX (entry), private->menu, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (entry), entry->menu, FALSE, FALSE, 0);
gtk_widget_show (private->menu); gtk_widget_show (entry->menu);
return GTK_WIDGET (entry); return GTK_WIDGET (entry);
} }
@ -280,14 +268,11 @@ void
gimp_memsize_entry_set_value (GimpMemsizeEntry *entry, gimp_memsize_entry_set_value (GimpMemsizeEntry *entry,
guint64 value) guint64 value)
{ {
GimpMemsizeEntryPrivate *private;
guint shift; guint shift;
g_return_if_fail (GIMP_IS_MEMSIZE_ENTRY (entry)); g_return_if_fail (GIMP_IS_MEMSIZE_ENTRY (entry));
private = gimp_memsize_entry_get_instance_private (entry); g_return_if_fail (value >= entry->lower && value <= entry->upper);
g_return_if_fail (value >= private->lower && value <= private->upper);
for (shift = 30; shift > 10; shift -= 10) for (shift = 30; shift > 10; shift -= 10)
{ {
@ -296,10 +281,10 @@ gimp_memsize_entry_set_value (GimpMemsizeEntry *entry,
break; break;
} }
if (shift != private->shift) if (shift != entry->shift)
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (private->menu), shift); gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (entry->menu), shift);
gtk_adjustment_set_value (private->adjustment, gtk_adjustment_set_value (entry->adjustment,
(gdouble) gimp_memsize_entry_get_rounded_value (entry, value)); (gdouble) gimp_memsize_entry_get_rounded_value (entry, value));
#undef CASE #undef CASE
@ -316,13 +301,9 @@ gimp_memsize_entry_set_value (GimpMemsizeEntry *entry,
guint64 guint64
gimp_memsize_entry_get_value (GimpMemsizeEntry *entry) gimp_memsize_entry_get_value (GimpMemsizeEntry *entry)
{ {
GimpMemsizeEntryPrivate *private;
g_return_val_if_fail (GIMP_IS_MEMSIZE_ENTRY (entry), 0); g_return_val_if_fail (GIMP_IS_MEMSIZE_ENTRY (entry), 0);
private = gimp_memsize_entry_get_instance_private (entry); return entry->value;
return private->value;
} }
/** /**
@ -336,11 +317,7 @@ gimp_memsize_entry_get_value (GimpMemsizeEntry *entry)
GtkWidget * GtkWidget *
gimp_memsize_entry_get_spinbutton (GimpMemsizeEntry *entry) gimp_memsize_entry_get_spinbutton (GimpMemsizeEntry *entry)
{ {
GimpMemsizeEntryPrivate *private;
g_return_val_if_fail (GIMP_IS_MEMSIZE_ENTRY (entry), 0); g_return_val_if_fail (GIMP_IS_MEMSIZE_ENTRY (entry), 0);
private = gimp_memsize_entry_get_instance_private (entry); return entry->spinbutton;
return private->spinbutton;
} }

19
libgimpwidgets/gimpmemsizeentry.h
View file

@ -30,24 +30,7 @@ G_BEGIN_DECLS
#define GIMP_TYPE_MEMSIZE_ENTRY (gimp_memsize_entry_get_type ()) #define GIMP_TYPE_MEMSIZE_ENTRY (gimp_memsize_entry_get_type ())
G_DECLARE_DERIVABLE_TYPE (GimpMemsizeEntry, gimp_memsize_entry, GIMP, MEMSIZE_ENTRY, GtkBox) G_DECLARE_FINAL_TYPE (GimpMemsizeEntry, gimp_memsize_entry, GIMP, MEMSIZE_ENTRY, GtkBox)
struct _GimpMemsizeEntryClass
{
GtkBoxClass parent_class;
void (* value_changed) (GimpMemsizeEntry *entry);
/* 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);
};
GtkWidget * gimp_memsize_entry_new (guint64 value, GtkWidget * gimp_memsize_entry_new (guint64 value,

268
libgimpwidgets/gimpnumberpairentry.c
View file

@ -82,8 +82,10 @@ typedef enum
} ParseResult; } ParseResult;
typedef struct _GimpNumberPairEntryPrivate struct _GimpNumberPairEntry
{ {
GtkEntry parent_instance;
/* The current number pair displayed in the widget. */ /* The current number pair displayed in the widget. */
gdouble left_number; gdouble left_number;
gdouble right_number; gdouble right_number;
@ -119,7 +121,7 @@ typedef struct _GimpNumberPairEntryPrivate
/* What range of values considered valid. */ /* What range of values considered valid. */
gdouble min_valid_value; gdouble min_valid_value;
gdouble max_valid_value; gdouble max_valid_value;
} GimpNumberPairEntryPrivate; };
static void gimp_number_pair_entry_finalize (GObject *entry); static void gimp_number_pair_entry_finalize (GObject *entry);
@ -160,8 +162,7 @@ static gchar * gimp_number_pair_entry_strdup_number_pair_string
G_DEFINE_TYPE_WITH_PRIVATE (GimpNumberPairEntry, gimp_number_pair_entry, G_DEFINE_TYPE (GimpNumberPairEntry, gimp_number_pair_entry, GTK_TYPE_ENTRY)
GTK_TYPE_ENTRY)
#define parent_class gimp_number_pair_entry_parent_class #define parent_class gimp_number_pair_entry_parent_class
@ -184,7 +185,7 @@ gimp_number_pair_entry_class_init (GimpNumberPairEntryClass *klass)
g_signal_new ("numbers-changed", g_signal_new ("numbers-changed",
G_TYPE_FROM_CLASS (klass), G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpNumberPairEntryClass, numbers_changed), 0,
NULL, NULL, NULL, NULL, NULL, NULL,
G_TYPE_NONE, 0); G_TYPE_NONE, 0);
@ -192,7 +193,7 @@ gimp_number_pair_entry_class_init (GimpNumberPairEntryClass *klass)
g_signal_new ("ratio-changed", g_signal_new ("ratio-changed",
G_TYPE_FROM_CLASS (klass), G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpNumberPairEntryClass, ratio_changed), 0,
NULL, NULL, NULL, NULL, NULL, NULL,
G_TYPE_NONE, 0); G_TYPE_NONE, 0);
@ -200,9 +201,6 @@ gimp_number_pair_entry_class_init (GimpNumberPairEntryClass *klass)
object_class->get_property = gimp_number_pair_entry_get_property; object_class->get_property = gimp_number_pair_entry_get_property;
object_class->finalize = gimp_number_pair_entry_finalize; object_class->finalize = gimp_number_pair_entry_finalize;
klass->numbers_changed = NULL;
klass->ratio_changed = NULL;
g_object_class_install_property (object_class, PROP_LEFT_NUMBER, g_object_class_install_property (object_class, PROP_LEFT_NUMBER,
g_param_spec_double ("left-number", g_param_spec_double ("left-number",
"Left number", "Left number",
@ -300,22 +298,18 @@ gimp_number_pair_entry_class_init (GimpNumberPairEntryClass *klass)
static void static void
gimp_number_pair_entry_init (GimpNumberPairEntry *entry) gimp_number_pair_entry_init (GimpNumberPairEntry *entry)
{ {
GimpNumberPairEntryPrivate *priv; entry->left_number = 1.0;
entry->right_number = 1.0;
priv = gimp_number_pair_entry_get_instance_private (entry); entry->default_left_number = 1.0;
entry->default_right_number = 1.0;
priv->left_number = 1.0; entry->user_override = FALSE;
priv->right_number = 1.0; entry->font_italic = FALSE;
priv->default_left_number = 1.0; entry->separators = NULL;
priv->default_right_number = 1.0; entry->default_text = NULL;
priv->user_override = FALSE; entry->num_separators = 0;
priv->font_italic = FALSE; entry->allow_simplification = FALSE;
priv->separators = NULL; entry->min_valid_value = G_MINDOUBLE;
priv->default_text = NULL; entry->max_valid_value = G_MAXDOUBLE;
priv->num_separators = 0;
priv->allow_simplification = FALSE;
priv->min_valid_value = G_MINDOUBLE;
priv->max_valid_value = G_MAXDOUBLE;
g_signal_connect (entry, "changed", g_signal_connect (entry, "changed",
G_CALLBACK (gimp_number_pair_entry_changed), G_CALLBACK (gimp_number_pair_entry_changed),
@ -341,14 +335,11 @@ static void
gimp_number_pair_entry_finalize (GObject *object) gimp_number_pair_entry_finalize (GObject *object)
{ {
GimpNumberPairEntry *entry = GIMP_NUMBER_PAIR_ENTRY (object); GimpNumberPairEntry *entry = GIMP_NUMBER_PAIR_ENTRY (object);
GimpNumberPairEntryPrivate *priv;
priv = gimp_number_pair_entry_get_instance_private (entry); g_clear_pointer (&entry->separators, g_free);
entry->num_separators = 0;
g_clear_pointer (&priv->separators, g_free); g_clear_pointer (&entry->default_text, g_free);
priv->num_separators = 0;
g_clear_pointer (&priv->default_text, g_free);
G_OBJECT_CLASS (parent_class)->finalize (object); G_OBJECT_CLASS (parent_class)->finalize (object);
} }
@ -487,13 +478,9 @@ gimp_number_pair_entry_set_ratio (GimpNumberPairEntry *entry,
gdouble gdouble
gimp_number_pair_entry_get_ratio (GimpNumberPairEntry *entry) gimp_number_pair_entry_get_ratio (GimpNumberPairEntry *entry)
{ {
GimpNumberPairEntryPrivate *priv;
g_return_val_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry), 1.0); g_return_val_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry), 1.0);
priv = gimp_number_pair_entry_get_instance_private (entry); return entry->left_number / entry->right_number;
return priv->left_number / priv->right_number;
} }
/** /**
@ -513,7 +500,6 @@ gimp_number_pair_entry_set_values (GimpNumberPairEntry *entry,
gdouble left, gdouble left,
gdouble right) gdouble right)
{ {
GimpNumberPairEntryPrivate *priv;
GimpAspectType old_aspect; GimpAspectType old_aspect;
gdouble old_ratio; gdouble old_ratio;
gdouble old_left_number; gdouble old_left_number;
@ -523,12 +509,10 @@ gimp_number_pair_entry_set_values (GimpNumberPairEntry *entry,
g_return_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry)); g_return_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry));
priv = gimp_number_pair_entry_get_instance_private (entry);
/* Store current values */ /* Store current values */
old_left_number = priv->left_number; old_left_number = entry->left_number;
old_right_number = priv->right_number; old_right_number = entry->right_number;
old_ratio = gimp_number_pair_entry_get_ratio (entry); old_ratio = gimp_number_pair_entry_get_ratio (entry);
old_aspect = gimp_number_pair_entry_get_aspect (entry); old_aspect = gimp_number_pair_entry_get_aspect (entry);
@ -540,8 +524,8 @@ gimp_number_pair_entry_set_values (GimpNumberPairEntry *entry,
/* Set the new numbers and update the entry */ /* Set the new numbers and update the entry */
priv->left_number = left; entry->left_number = left;
priv->right_number = right; entry->right_number = right;
g_object_notify (G_OBJECT (entry), "left-number"); g_object_notify (G_OBJECT (entry), "left-number");
g_object_notify (G_OBJECT (entry), "right-number"); g_object_notify (G_OBJECT (entry), "right-number");
@ -561,8 +545,8 @@ gimp_number_pair_entry_set_values (GimpNumberPairEntry *entry,
g_object_notify (G_OBJECT (entry), "aspect"); g_object_notify (G_OBJECT (entry), "aspect");
} }
if (old_left_number != priv->left_number || if (old_left_number != entry->left_number ||
old_right_number != priv->right_number) old_right_number != entry->right_number)
{ {
numbers_changed = TRUE; numbers_changed = TRUE;
} }
@ -597,17 +581,13 @@ gimp_number_pair_entry_get_values (GimpNumberPairEntry *entry,
gdouble *left, gdouble *left,
gdouble *right) gdouble *right)
{ {
GimpNumberPairEntryPrivate *priv;
g_return_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry)); g_return_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry));
priv = gimp_number_pair_entry_get_instance_private (entry);
if (left != NULL) if (left != NULL)
*left = priv->left_number; *left = entry->left_number;
if (right != NULL) if (right != NULL)
*right = priv->right_number; *right = entry->right_number;
} }
/** /**
@ -629,14 +609,10 @@ void
gimp_number_pair_entry_set_default_text (GimpNumberPairEntry *entry, gimp_number_pair_entry_set_default_text (GimpNumberPairEntry *entry,
const gchar *string) const gchar *string)
{ {
GimpNumberPairEntryPrivate *priv;
g_return_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry)); g_return_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry));
priv = gimp_number_pair_entry_get_instance_private (entry); g_free (entry->default_text);
entry->default_text = g_strdup (string);
g_free (priv->default_text);
priv->default_text = g_strdup (string);
gimp_number_pair_entry_update_text (entry); gimp_number_pair_entry_update_text (entry);
@ -655,13 +631,9 @@ gimp_number_pair_entry_set_default_text (GimpNumberPairEntry *entry,
const gchar * const gchar *
gimp_number_pair_entry_get_default_text (GimpNumberPairEntry *entry) gimp_number_pair_entry_get_default_text (GimpNumberPairEntry *entry)
{ {
GimpNumberPairEntryPrivate *priv;
g_return_val_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry), NULL); g_return_val_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry), NULL);
priv = gimp_number_pair_entry_get_instance_private (entry); return entry->default_text;
return priv->default_text;
} }
/** /**
@ -679,28 +651,24 @@ void
gimp_number_pair_entry_set_aspect (GimpNumberPairEntry *entry, gimp_number_pair_entry_set_aspect (GimpNumberPairEntry *entry,
GimpAspectType aspect) GimpAspectType aspect)
{ {
GimpNumberPairEntryPrivate *priv;
g_return_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry)); g_return_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry));
if (gimp_number_pair_entry_get_aspect (entry) == aspect) if (gimp_number_pair_entry_get_aspect (entry) == aspect)
return; return;
priv = gimp_number_pair_entry_get_instance_private (entry);
switch (aspect) switch (aspect)
{ {
case GIMP_ASPECT_SQUARE: case GIMP_ASPECT_SQUARE:
gimp_number_pair_entry_set_values (entry, gimp_number_pair_entry_set_values (entry,
priv->left_number, entry->left_number,
priv->left_number); entry->left_number);
break; break;
case GIMP_ASPECT_LANDSCAPE: case GIMP_ASPECT_LANDSCAPE:
case GIMP_ASPECT_PORTRAIT: case GIMP_ASPECT_PORTRAIT:
gimp_number_pair_entry_set_values (entry, gimp_number_pair_entry_set_values (entry,
priv->right_number, entry->right_number,
priv->left_number); entry->left_number);
break; break;
} }
} }
@ -718,17 +686,13 @@ gimp_number_pair_entry_set_aspect (GimpNumberPairEntry *entry,
GimpAspectType GimpAspectType
gimp_number_pair_entry_get_aspect (GimpNumberPairEntry *entry) gimp_number_pair_entry_get_aspect (GimpNumberPairEntry *entry)
{ {
GimpNumberPairEntryPrivate *priv;
g_return_val_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry), GIMP_ASPECT_SQUARE); g_return_val_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry), GIMP_ASPECT_SQUARE);
priv = gimp_number_pair_entry_get_instance_private (entry); if (entry->left_number > entry->right_number)
if (priv->left_number > priv->right_number)
{ {
return GIMP_ASPECT_LANDSCAPE; return GIMP_ASPECT_LANDSCAPE;
} }
else if (priv->left_number < priv->right_number) else if (entry->left_number < entry->right_number)
{ {
return GIMP_ASPECT_PORTRAIT; return GIMP_ASPECT_PORTRAIT;
} }
@ -742,12 +706,9 @@ static void
gimp_number_pair_entry_modify_font (GimpNumberPairEntry *entry, gimp_number_pair_entry_modify_font (GimpNumberPairEntry *entry,
gboolean italic) gboolean italic)
{ {
GimpNumberPairEntryPrivate *priv;
GtkStyleContext *style; GtkStyleContext *style;
priv = gimp_number_pair_entry_get_instance_private (entry); if (entry->font_italic == italic)
if (priv->font_italic == italic)
return; return;
style = gtk_widget_get_style_context (GTK_WIDGET (entry)); style = gtk_widget_get_style_context (GTK_WIDGET (entry));
@ -761,7 +722,7 @@ gimp_number_pair_entry_modify_font (GimpNumberPairEntry *entry,
GTK_ENTRY_ICON_SECONDARY, GTK_ENTRY_ICON_SECONDARY,
! italic); ! italic);
priv->font_italic = italic; entry->font_italic = italic;
} }
@ -781,19 +742,15 @@ void
gimp_number_pair_entry_set_user_override (GimpNumberPairEntry *entry, gimp_number_pair_entry_set_user_override (GimpNumberPairEntry *entry,
gboolean user_override) gboolean user_override)
{ {
GimpNumberPairEntryPrivate *priv;
g_return_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry)); g_return_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry));
priv = gimp_number_pair_entry_get_instance_private (entry); entry->user_override = user_override;
priv->user_override = user_override;
if (! user_override) if (! user_override)
{ {
gimp_number_pair_entry_set_default_values (entry, gimp_number_pair_entry_set_default_values (entry,
priv->default_left_number, entry->default_left_number,
priv->default_right_number); entry->default_right_number);
} }
gimp_number_pair_entry_modify_font (entry, ! user_override); gimp_number_pair_entry_modify_font (entry, ! user_override);
@ -812,13 +769,9 @@ gimp_number_pair_entry_set_user_override (GimpNumberPairEntry *entry,
gboolean gboolean
gimp_number_pair_entry_get_user_override (GimpNumberPairEntry *entry) gimp_number_pair_entry_get_user_override (GimpNumberPairEntry *entry)
{ {
GimpNumberPairEntryPrivate *priv;
g_return_val_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry), FALSE); g_return_val_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry), FALSE);
priv = gimp_number_pair_entry_get_instance_private (entry); return entry->user_override;
return priv->user_override;
} }
static void static void
@ -840,10 +793,8 @@ gimp_number_pair_entry_events (GtkWidget *widget,
GdkEvent *event) GdkEvent *event)
{ {
GimpNumberPairEntry *entry = GIMP_NUMBER_PAIR_ENTRY (widget); GimpNumberPairEntry *entry = GIMP_NUMBER_PAIR_ENTRY (widget);
GimpNumberPairEntryPrivate *priv;
gboolean force_user_override; gboolean force_user_override;
priv = gimp_number_pair_entry_get_instance_private (entry);
force_user_override = FALSE; force_user_override = FALSE;
switch (event->type) switch (event->type)
@ -882,8 +833,8 @@ gimp_number_pair_entry_events (GtkWidget *widget,
{ {
case PARSE_VALID: case PARSE_VALID:
{ {
if (priv->left_number != left_value || if (entry->left_number != left_value ||
priv->right_number != right_value || entry->right_number != right_value ||
force_user_override) force_user_override)
{ {
gimp_number_pair_entry_set_values (entry, gimp_number_pair_entry_set_values (entry,
@ -931,14 +882,11 @@ gimp_number_pair_entry_strdup_number_pair_string (GimpNumberPairEntry *entry,
gdouble left_number, gdouble left_number,
gdouble right_number) gdouble right_number)
{ {
GimpNumberPairEntryPrivate *priv;
gchar sep[8]; gchar sep[8];
gint len; gint len;
priv = gimp_number_pair_entry_get_instance_private (entry); if (entry->num_separators > 0)
len = g_unichar_to_utf8 (entry->separators[0], sep);
if (priv->num_separators > 0)
len = g_unichar_to_utf8 (priv->separators[0], sep);
else else
len = g_unichar_to_utf8 (DEFAULT_SEPARATOR, sep); len = g_unichar_to_utf8 (DEFAULT_SEPARATOR, sep);
@ -950,24 +898,21 @@ gimp_number_pair_entry_strdup_number_pair_string (GimpNumberPairEntry *entry,
static void static void
gimp_number_pair_entry_update_text (GimpNumberPairEntry *entry) gimp_number_pair_entry_update_text (GimpNumberPairEntry *entry)
{ {
GimpNumberPairEntryPrivate *priv;
gchar *buffer; gchar *buffer;
priv = gimp_number_pair_entry_get_instance_private (entry); if (! entry->user_override &&
entry->default_text != NULL)
if (! priv->user_override &&
priv->default_text != NULL)
{ {
/* Instead of the numbers, show the string explicitly set by a /* Instead of the numbers, show the string explicitly set by a
* client to show when in automatic mode. * client to show when in automatic mode.
*/ */
buffer = g_strdup (priv->default_text); buffer = g_strdup (entry->default_text);
} }
else else
{ {
buffer = gimp_number_pair_entry_strdup_number_pair_string (entry, buffer = gimp_number_pair_entry_strdup_number_pair_string (entry,
priv->left_number, entry->left_number,
priv->right_number); entry->right_number);
} }
g_signal_handlers_block_by_func (entry, g_signal_handlers_block_by_func (entry,
@ -979,23 +924,19 @@ gimp_number_pair_entry_update_text (GimpNumberPairEntry *entry)
g_signal_handlers_unblock_by_func (entry, g_signal_handlers_unblock_by_func (entry,
gimp_number_pair_entry_changed, NULL); gimp_number_pair_entry_changed, NULL);
gimp_number_pair_entry_modify_font (entry, ! priv->user_override); gimp_number_pair_entry_modify_font (entry, ! entry->user_override);
} }
static gboolean static gboolean
gimp_number_pair_entry_valid_separator (GimpNumberPairEntry *entry, gimp_number_pair_entry_valid_separator (GimpNumberPairEntry *entry,
gunichar candidate) gunichar candidate)
{ {
GimpNumberPairEntryPrivate *priv; if (entry->num_separators > 0)
priv = gimp_number_pair_entry_get_instance_private (entry);
if (priv->num_separators > 0)
{ {
gint i; gint i;
for (i = 0; i < priv->num_separators; i++) for (i = 0; i < entry->num_separators; i++)
if (priv->separators[i] == candidate) if (entry->separators[i] == candidate)
return TRUE; return TRUE;
} }
else if (candidate == DEFAULT_SEPARATOR) else if (candidate == DEFAULT_SEPARATOR)
@ -1012,14 +953,11 @@ gimp_number_pair_entry_parse_text (GimpNumberPairEntry *entry,
gdouble *left_value, gdouble *left_value,
gdouble *right_value) gdouble *right_value)
{ {
GimpNumberPairEntryPrivate *priv;
gdouble new_left_number; gdouble new_left_number;
gdouble new_right_number; gdouble new_right_number;
gboolean simplify = FALSE; gboolean simplify = FALSE;
gchar *end; gchar *end;
priv = gimp_number_pair_entry_get_instance_private (entry);
/* skip over whitespace */ /* skip over whitespace */
while (g_unichar_isspace (g_utf8_get_char (text))) while (g_unichar_isspace (g_utf8_get_char (text)))
text = g_utf8_next_char (text); text = g_utf8_next_char (text);
@ -1061,7 +999,7 @@ gimp_number_pair_entry_parse_text (GimpNumberPairEntry *entry,
/* check for the simplification char */ /* check for the simplification char */
if (g_utf8_get_char (text) == SIMPLIFICATION_CHAR) if (g_utf8_get_char (text) == SIMPLIFICATION_CHAR)
{ {
simplify = priv->allow_simplification; simplify = entry->allow_simplification;
text = g_utf8_next_char (text); text = g_utf8_next_char (text);
} }
@ -1101,30 +1039,27 @@ gimp_number_pair_entry_set_property (GObject *object,
GParamSpec *pspec) GParamSpec *pspec)
{ {
GimpNumberPairEntry *entry = GIMP_NUMBER_PAIR_ENTRY (object); GimpNumberPairEntry *entry = GIMP_NUMBER_PAIR_ENTRY (object);
GimpNumberPairEntryPrivate *priv;
priv = gimp_number_pair_entry_get_instance_private (entry);
switch (property_id) switch (property_id)
{ {
case PROP_LEFT_NUMBER: case PROP_LEFT_NUMBER:
gimp_number_pair_entry_set_values (entry, gimp_number_pair_entry_set_values (entry,
g_value_get_double (value), g_value_get_double (value),
priv->right_number); entry->right_number);
break; break;
case PROP_RIGHT_NUMBER: case PROP_RIGHT_NUMBER:
gimp_number_pair_entry_set_values (entry, gimp_number_pair_entry_set_values (entry,
priv->left_number, entry->left_number,
g_value_get_double (value)); g_value_get_double (value));
break; break;
case PROP_DEFAULT_LEFT_NUMBER: case PROP_DEFAULT_LEFT_NUMBER:
gimp_number_pair_entry_set_default_values (entry, gimp_number_pair_entry_set_default_values (entry,
g_value_get_double (value), g_value_get_double (value),
priv->default_right_number); entry->default_right_number);
break; break;
case PROP_DEFAULT_RIGHT_NUMBER: case PROP_DEFAULT_RIGHT_NUMBER:
gimp_number_pair_entry_set_default_values (entry, gimp_number_pair_entry_set_default_values (entry,
priv->default_left_number, entry->default_left_number,
g_value_get_double (value)); g_value_get_double (value));
break; break;
case PROP_USER_OVERRIDE: case PROP_USER_OVERRIDE:
@ -1132,26 +1067,26 @@ gimp_number_pair_entry_set_property (GObject *object,
g_value_get_boolean (value)); g_value_get_boolean (value));
break; break;
case PROP_SEPARATORS: case PROP_SEPARATORS:
g_free (priv->separators); g_free (entry->separators);
priv->num_separators = 0; entry->num_separators = 0;
if (g_value_get_string (value)) if (g_value_get_string (value))
priv->separators = g_utf8_to_ucs4 (g_value_get_string (value), -1, entry->separators = g_utf8_to_ucs4 (g_value_get_string (value), -1,
NULL, &priv->num_separators, NULL); NULL, &entry->num_separators, NULL);
else else
priv->separators = NULL; entry->separators = NULL;
break; break;
case PROP_DEFAULT_TEXT: case PROP_DEFAULT_TEXT:
gimp_number_pair_entry_set_default_text (entry, gimp_number_pair_entry_set_default_text (entry,
g_value_get_string (value)); g_value_get_string (value));
break; break;
case PROP_ALLOW_SIMPLIFICATION: case PROP_ALLOW_SIMPLIFICATION:
priv->allow_simplification = g_value_get_boolean (value); entry->allow_simplification = g_value_get_boolean (value);
break; break;
case PROP_MIN_VALID_VALUE: case PROP_MIN_VALID_VALUE:
priv->min_valid_value = g_value_get_double (value); entry->min_valid_value = g_value_get_double (value);
break; break;
case PROP_MAX_VALID_VALUE: case PROP_MAX_VALID_VALUE:
priv->max_valid_value = g_value_get_double (value); entry->max_valid_value = g_value_get_double (value);
break; break;
case PROP_RATIO: case PROP_RATIO:
gimp_number_pair_entry_set_ratio (entry, g_value_get_double (value)); gimp_number_pair_entry_set_ratio (entry, g_value_get_double (value));
@ -1172,44 +1107,41 @@ gimp_number_pair_entry_get_property (GObject *object,
GParamSpec *pspec) GParamSpec *pspec)
{ {
GimpNumberPairEntry *entry = GIMP_NUMBER_PAIR_ENTRY (object); GimpNumberPairEntry *entry = GIMP_NUMBER_PAIR_ENTRY (object);
GimpNumberPairEntryPrivate *priv;
priv = gimp_number_pair_entry_get_instance_private (entry);
switch (property_id) switch (property_id)
{ {
case PROP_LEFT_NUMBER: case PROP_LEFT_NUMBER:
g_value_set_double (value, priv->left_number); g_value_set_double (value, entry->left_number);
break; break;
case PROP_RIGHT_NUMBER: case PROP_RIGHT_NUMBER:
g_value_set_double (value, priv->right_number); g_value_set_double (value, entry->right_number);
break; break;
case PROP_DEFAULT_LEFT_NUMBER: case PROP_DEFAULT_LEFT_NUMBER:
g_value_set_double (value, priv->default_left_number); g_value_set_double (value, entry->default_left_number);
break; break;
case PROP_DEFAULT_RIGHT_NUMBER: case PROP_DEFAULT_RIGHT_NUMBER:
g_value_set_double (value, priv->default_right_number); g_value_set_double (value, entry->default_right_number);
break; break;
case PROP_USER_OVERRIDE: case PROP_USER_OVERRIDE:
g_value_set_boolean (value, priv->user_override); g_value_set_boolean (value, entry->user_override);
break; break;
case PROP_SEPARATORS: case PROP_SEPARATORS:
g_value_take_string (value, g_value_take_string (value,
g_ucs4_to_utf8 (priv->separators, g_ucs4_to_utf8 (entry->separators,
priv->num_separators, entry->num_separators,
NULL, NULL, NULL)); NULL, NULL, NULL));
break; break;
case PROP_ALLOW_SIMPLIFICATION: case PROP_ALLOW_SIMPLIFICATION:
g_value_set_boolean (value, priv->allow_simplification); g_value_set_boolean (value, entry->allow_simplification);
break; break;
case PROP_DEFAULT_TEXT: case PROP_DEFAULT_TEXT:
g_value_set_string (value, priv->default_text); g_value_set_string (value, entry->default_text);
break; break;
case PROP_MIN_VALID_VALUE: case PROP_MIN_VALID_VALUE:
g_value_set_double (value, priv->min_valid_value); g_value_set_double (value, entry->min_valid_value);
break; break;
case PROP_MAX_VALID_VALUE: case PROP_MAX_VALID_VALUE:
g_value_set_double (value, priv->max_valid_value); g_value_set_double (value, entry->max_valid_value);
break; break;
case PROP_RATIO: case PROP_RATIO:
g_value_set_double (value, gimp_number_pair_entry_get_ratio (entry)); g_value_set_double (value, gimp_number_pair_entry_get_ratio (entry));
@ -1236,20 +1168,16 @@ gimp_number_pair_entry_set_default_values (GimpNumberPairEntry *entry,
gdouble left, gdouble left,
gdouble right) gdouble right)
{ {
GimpNumberPairEntryPrivate *priv;
g_return_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry)); g_return_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry));
priv = gimp_number_pair_entry_get_instance_private (entry); entry->default_left_number = left;
entry->default_right_number = right;
priv->default_left_number = left; if (! entry->user_override)
priv->default_right_number = right;
if (! priv->user_override)
{ {
gimp_number_pair_entry_set_values (entry, gimp_number_pair_entry_set_values (entry,
priv->default_left_number, entry->default_left_number,
priv->default_right_number); entry->default_right_number);
} }
} }
@ -1266,17 +1194,13 @@ gimp_number_pair_entry_get_default_values (GimpNumberPairEntry *entry,
gdouble *left, gdouble *left,
gdouble *right) gdouble *right)
{ {
GimpNumberPairEntryPrivate *priv;
g_return_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry)); g_return_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry));
priv = gimp_number_pair_entry_get_instance_private (entry);
if (left != NULL) if (left != NULL)
*left = priv->default_left_number; *left = entry->default_left_number;
if (right != NULL) if (right != NULL)
*right = priv->default_right_number; *right = entry->default_right_number;
} }
static gboolean static gboolean
@ -1284,12 +1208,8 @@ gimp_number_pair_entry_numbers_in_range (GimpNumberPairEntry *entry,
gdouble left_number, gdouble left_number,
gdouble right_number) gdouble right_number)
{ {
GimpNumberPairEntryPrivate *priv; return (left_number >= entry->min_valid_value &&
left_number <= entry->max_valid_value &&
priv = gimp_number_pair_entry_get_instance_private (entry); right_number >= entry->min_valid_value &&
right_number <= entry->max_valid_value);
return (left_number >= priv->min_valid_value &&
left_number <= priv->max_valid_value &&
right_number >= priv->min_valid_value &&
right_number <= priv->max_valid_value);
} }

20
libgimpwidgets/gimpnumberpairentry.h
View file

@ -32,25 +32,7 @@ G_BEGIN_DECLS
#define GIMP_TYPE_NUMBER_PAIR_ENTRY (gimp_number_pair_entry_get_type ()) #define GIMP_TYPE_NUMBER_PAIR_ENTRY (gimp_number_pair_entry_get_type ())
G_DECLARE_DERIVABLE_TYPE (GimpNumberPairEntry, gimp_number_pair_entry, GIMP, NUMBER_PAIR_ENTRY, GtkEntry) G_DECLARE_FINAL_TYPE (GimpNumberPairEntry, gimp_number_pair_entry, GIMP, NUMBER_PAIR_ENTRY, GtkEntry)
struct _GimpNumberPairEntryClass
{
GtkEntryClass parent_class;
void (* numbers_changed) (GimpNumberPairEntry *entry);
void (* ratio_changed) (GimpNumberPairEntry *entry);
/* 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);
};
GtkWidget * gimp_number_pair_entry_new (const gchar *separators, GtkWidget * gimp_number_pair_entry_new (const gchar *separators,

184
libgimpwidgets/gimpoffsetarea.c
View file

@ -48,8 +48,10 @@ enum
}; };
typedef struct _GimpOffsetAreaPrivate struct _GimpOffsetArea
{ {
GtkDrawingArea parent_instance;
gint orig_width; gint orig_width;
gint orig_height; gint orig_height;
gint width; gint width;
@ -58,7 +60,7 @@ typedef struct _GimpOffsetAreaPrivate
gint offset_y; gint offset_y;
gdouble display_ratio_x; gdouble display_ratio_x;
gdouble display_ratio_y; gdouble display_ratio_y;
} GimpOffsetAreaPrivate; };
static void gimp_offset_area_resize (GimpOffsetArea *area); static void gimp_offset_area_resize (GimpOffsetArea *area);
@ -72,8 +74,7 @@ static gboolean gimp_offset_area_draw (GtkWidget *widget,
cairo_t *cr); cairo_t *cr);
G_DEFINE_TYPE_WITH_PRIVATE (GimpOffsetArea, gimp_offset_area, G_DEFINE_TYPE (GimpOffsetArea, gimp_offset_area, GTK_TYPE_DRAWING_AREA)
GTK_TYPE_DRAWING_AREA)
#define parent_class gimp_offset_area_parent_class #define parent_class gimp_offset_area_parent_class
@ -89,7 +90,7 @@ gimp_offset_area_class_init (GimpOffsetAreaClass *klass)
g_signal_new ("offsets-changed", g_signal_new ("offsets-changed",
G_TYPE_FROM_CLASS (klass), G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpOffsetAreaClass, offsets_changed), 0,
NULL, NULL, NULL, NULL,
_gimp_widgets_marshal_VOID__INT_INT, _gimp_widgets_marshal_VOID__INT_INT,
G_TYPE_NONE, 2, G_TYPE_NONE, 2,
@ -105,12 +106,8 @@ gimp_offset_area_class_init (GimpOffsetAreaClass *klass)
static void static void
gimp_offset_area_init (GimpOffsetArea *area) gimp_offset_area_init (GimpOffsetArea *area)
{ {
GimpOffsetAreaPrivate *private; area->display_ratio_x = 1.0;
area->display_ratio_y = 1.0;
private = gimp_offset_area_get_instance_private (area);
private->display_ratio_x = 1.0;
private->display_ratio_y = 1.0;
gtk_widget_add_events (GTK_WIDGET (area), gtk_widget_add_events (GTK_WIDGET (area),
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_PRESS_MASK |
@ -134,17 +131,14 @@ gimp_offset_area_new (gint orig_width,
gint orig_height) gint orig_height)
{ {
GimpOffsetArea *area; GimpOffsetArea *area;
GimpOffsetAreaPrivate *private;
g_return_val_if_fail (orig_width > 0, NULL); g_return_val_if_fail (orig_width > 0, NULL);
g_return_val_if_fail (orig_height > 0, NULL); g_return_val_if_fail (orig_height > 0, NULL);
area = g_object_new (GIMP_TYPE_OFFSET_AREA, NULL); area = g_object_new (GIMP_TYPE_OFFSET_AREA, NULL);
private = gimp_offset_area_get_instance_private (area); area->orig_width = area->width = orig_width;
area->orig_height = area->height = orig_height;
private->orig_width = private->width = orig_width;
private->orig_height = private->height = orig_height;
gimp_offset_area_resize (area); gimp_offset_area_resize (area);
@ -190,39 +184,35 @@ gimp_offset_area_set_size (GimpOffsetArea *area,
gint width, gint width,
gint height) gint height)
{ {
GimpOffsetAreaPrivate *private;
g_return_if_fail (GIMP_IS_OFFSET_AREA (area)); g_return_if_fail (GIMP_IS_OFFSET_AREA (area));
g_return_if_fail (width > 0 && height > 0); g_return_if_fail (width > 0 && height > 0);
private = gimp_offset_area_get_instance_private (area); if (area->width != width || area->height != height)
if (private->width != width || private->height != height)
{ {
gint offset_x; gint offset_x;
gint offset_y; gint offset_y;
private->width = width; area->width = width;
private->height = height; area->height = height;
if (private->orig_width <= private->width) if (area->orig_width <= area->width)
offset_x = CLAMP (private->offset_x, offset_x = CLAMP (area->offset_x,
0, private->width - private->orig_width); 0, area->width - area->orig_width);
else else
offset_x = CLAMP (private->offset_x, offset_x = CLAMP (area->offset_x,
private->width - private->orig_width, 0); area->width - area->orig_width, 0);
if (private->orig_height <= private->height) if (area->orig_height <= area->height)
offset_y = CLAMP (private->offset_y, offset_y = CLAMP (area->offset_y,
0, private->height - private->orig_height); 0, area->height - area->orig_height);
else else
offset_y = CLAMP (private->offset_y, offset_y = CLAMP (area->offset_y,
private->height - private->orig_height, 0); area->height - area->orig_height, 0);
if (offset_x != private->offset_x || offset_y != private->offset_y) if (offset_x != area->offset_x || offset_y != area->offset_y)
{ {
private->offset_x = offset_x; area->offset_x = offset_x;
private->offset_y = offset_y; area->offset_y = offset_y;
g_signal_emit (area, g_signal_emit (area,
gimp_offset_area_signals[OFFSETS_CHANGED], 0, gimp_offset_area_signals[OFFSETS_CHANGED], 0,
@ -247,27 +237,23 @@ gimp_offset_area_set_offsets (GimpOffsetArea *area,
gint offset_x, gint offset_x,
gint offset_y) gint offset_y)
{ {
GimpOffsetAreaPrivate *private;
g_return_if_fail (GIMP_IS_OFFSET_AREA (area)); g_return_if_fail (GIMP_IS_OFFSET_AREA (area));
private = gimp_offset_area_get_instance_private (area); if (area->offset_x != offset_x || area->offset_y != offset_y)
if (private->offset_x != offset_x || private->offset_y != offset_y)
{ {
if (private->orig_width <= private->width) if (area->orig_width <= area->width)
private->offset_x = CLAMP (offset_x, area->offset_x = CLAMP (offset_x,
0, private->width - private->orig_width); 0, area->width - area->orig_width);
else else
private->offset_x = CLAMP (offset_x, area->offset_x = CLAMP (offset_x,
private->width - private->orig_width, 0); area->width - area->orig_width, 0);
if (private->orig_height <= private->height) if (area->orig_height <= area->height)
private->offset_y = CLAMP (offset_y, area->offset_y = CLAMP (offset_y,
0, private->height - private->orig_height); 0, area->height - area->orig_height);
else else
private->offset_y = CLAMP (offset_y, area->offset_y = CLAMP (offset_y,
private->height - private->orig_height, 0); area->height - area->orig_height, 0);
gtk_widget_queue_draw (GTK_WIDGET (area)); gtk_widget_queue_draw (GTK_WIDGET (area));
} }
@ -276,25 +262,22 @@ gimp_offset_area_set_offsets (GimpOffsetArea *area,
static void static void
gimp_offset_area_resize (GimpOffsetArea *area) gimp_offset_area_resize (GimpOffsetArea *area)
{ {
GimpOffsetAreaPrivate *private;
gint width; gint width;
gint height; gint height;
gdouble ratio; gdouble ratio;
private = gimp_offset_area_get_instance_private (area); if (area->orig_width == 0 || area->orig_height == 0)
if (private->orig_width == 0 || private->orig_height == 0)
return; return;
if (private->orig_width <= private->width) if (area->orig_width <= area->width)
width = private->width; width = area->width;
else else
width = private->orig_width * 2 - private->width; width = area->orig_width * 2 - area->width;
if (private->orig_height <= private->height) if (area->orig_height <= area->height)
height = private->height; height = area->height;
else else
height = private->orig_height * 2 - private->height; height = area->orig_height * 2 - area->height;
ratio = (gdouble) DRAWING_AREA_SIZE / (gdouble) MAX (width, height); ratio = (gdouble) DRAWING_AREA_SIZE / (gdouble) MAX (width, height);
@ -310,22 +293,19 @@ gimp_offset_area_size_allocate (GtkWidget *widget,
GtkAllocation *allocation) GtkAllocation *allocation)
{ {
GimpOffsetArea *area = GIMP_OFFSET_AREA (widget); GimpOffsetArea *area = GIMP_OFFSET_AREA (widget);
GimpOffsetAreaPrivate *private;
GdkPixbuf *pixbuf; GdkPixbuf *pixbuf;
GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, allocation); GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, allocation);
private = gimp_offset_area_get_instance_private (area); area->display_ratio_x = ((gdouble) allocation->width /
((area->orig_width <= area->width) ?
area->width :
area->orig_width * 2 - area->width));
private->display_ratio_x = ((gdouble) allocation->width / area->display_ratio_y = ((gdouble) allocation->height /
((private->orig_width <= private->width) ? ((area->orig_height <= area->height) ?
private->width : area->height :
private->orig_width * 2 - private->width)); area->orig_height * 2 - area->height));
private->display_ratio_y = ((gdouble) allocation->height /
((private->orig_height <= private->height) ?
private->height :
private->orig_height * 2 - private->height));
pixbuf = g_object_get_data (G_OBJECT (area), "pixbuf"); pixbuf = g_object_get_data (G_OBJECT (area), "pixbuf");
@ -335,10 +315,10 @@ gimp_offset_area_size_allocate (GtkWidget *widget,
gint pixbuf_width; gint pixbuf_width;
gint pixbuf_height; gint pixbuf_height;
pixbuf_width = private->display_ratio_x * private->orig_width; pixbuf_width = area->display_ratio_x * area->orig_width;
pixbuf_width = MAX (pixbuf_width, 1); pixbuf_width = MAX (pixbuf_width, 1);
pixbuf_height = private->display_ratio_y * private->orig_height; pixbuf_height = area->display_ratio_y * area->orig_height;
pixbuf_height = MAX (pixbuf_height, 1); pixbuf_height = MAX (pixbuf_height, 1);
copy = g_object_get_data (G_OBJECT (area), "pixbuf-copy"); copy = g_object_get_data (G_OBJECT (area), "pixbuf-copy");
@ -384,13 +364,10 @@ gimp_offset_area_event (GtkWidget *widget,
static gint start_y = 0; static gint start_y = 0;
GimpOffsetArea *area = GIMP_OFFSET_AREA (widget); GimpOffsetArea *area = GIMP_OFFSET_AREA (widget);
GimpOffsetAreaPrivate *private;
gint offset_x; gint offset_x;
gint offset_y; gint offset_y;
private = gimp_offset_area_get_instance_private (area); if (area->orig_width == 0 || area->orig_height == 0)
if (private->orig_width == 0 || private->orig_height == 0)
return FALSE; return FALSE;
switch (event->type) switch (event->type)
@ -400,8 +377,8 @@ gimp_offset_area_event (GtkWidget *widget,
{ {
gtk_grab_add (widget); gtk_grab_add (widget);
orig_offset_x = private->offset_x; orig_offset_x = area->offset_x;
orig_offset_y = private->offset_y; orig_offset_y = area->offset_y;
start_x = event->button.x; start_x = event->button.x;
start_y = event->button.y; start_y = event->button.y;
} }
@ -409,17 +386,17 @@ gimp_offset_area_event (GtkWidget *widget,
case GDK_MOTION_NOTIFY: case GDK_MOTION_NOTIFY:
offset_x = (orig_offset_x + offset_x = (orig_offset_x +
(event->motion.x - start_x) / private->display_ratio_x); (event->motion.x - start_x) / area->display_ratio_x);
offset_y = (orig_offset_y + offset_y = (orig_offset_y +
(event->motion.y - start_y) / private->display_ratio_y); (event->motion.y - start_y) / area->display_ratio_y);
if (private->offset_x != offset_x || private->offset_y != offset_y) if (area->offset_x != offset_x || area->offset_y != offset_y)
{ {
gimp_offset_area_set_offsets (area, offset_x, offset_y); gimp_offset_area_set_offsets (area, offset_x, offset_y);
g_signal_emit (area, g_signal_emit (area,
gimp_offset_area_signals[OFFSETS_CHANGED], 0, gimp_offset_area_signals[OFFSETS_CHANGED], 0,
private->offset_x, private->offset_y); area->offset_x, area->offset_y);
} }
break; break;
@ -444,31 +421,28 @@ gimp_offset_area_draw (GtkWidget *widget,
cairo_t *cr) cairo_t *cr)
{ {
GimpOffsetArea *area = GIMP_OFFSET_AREA (widget); GimpOffsetArea *area = GIMP_OFFSET_AREA (widget);
GimpOffsetAreaPrivate *private;
GtkStyleContext *context = gtk_widget_get_style_context (widget); GtkStyleContext *context = gtk_widget_get_style_context (widget);
GtkAllocation allocation; GtkAllocation allocation;
GdkPixbuf *pixbuf; GdkPixbuf *pixbuf;
gint w, h; gint w, h;
gint x, y; gint x, y;
private = gimp_offset_area_get_instance_private (area);
gtk_widget_get_allocation (widget, &allocation); gtk_widget_get_allocation (widget, &allocation);
x = (private->display_ratio_x * x = (area->display_ratio_x *
((private->orig_width <= private->width) ? ((area->orig_width <= area->width) ?
private->offset_x : area->offset_x :
private->offset_x + private->orig_width - private->width)); area->offset_x + area->orig_width - area->width));
y = (private->display_ratio_y * y = (area->display_ratio_y *
((private->orig_height <= private->height) ? ((area->orig_height <= area->height) ?
private->offset_y : area->offset_y :
private->offset_y + private->orig_height - private->height)); area->offset_y + area->orig_height - area->height));
w = private->display_ratio_x * private->orig_width; w = area->display_ratio_x * area->orig_width;
w = MAX (w, 1); w = MAX (w, 1);
h = private->display_ratio_y * private->orig_height; h = area->display_ratio_y * area->orig_height;
h = MAX (h, 1); h = MAX (h, 1);
pixbuf = g_object_get_data (G_OBJECT (widget), "pixbuf-copy"); pixbuf = g_object_get_data (G_OBJECT (widget), "pixbuf-copy");
@ -488,15 +462,15 @@ gimp_offset_area_draw (GtkWidget *widget,
gtk_render_frame (context, cr, x, y, w, h); gtk_render_frame (context, cr, x, y, w, h);
} }
if (private->orig_width > private->width || if (area->orig_width > area->width ||
private->orig_height > private->height) area->orig_height > area->height)
{ {
gint line_width; gint line_width;
if (private->orig_width > private->width) if (area->orig_width > area->width)
{ {
x = private->display_ratio_x * (private->orig_width - private->width); x = area->display_ratio_x * (area->orig_width - area->width);
w = private->display_ratio_x * private->width; w = area->display_ratio_x * area->width;
} }
else else
{ {
@ -504,10 +478,10 @@ gimp_offset_area_draw (GtkWidget *widget,
w = allocation.width + 2; w = allocation.width + 2;
} }
if (private->orig_height > private->height) if (area->orig_height > area->height)
{ {
y = private->display_ratio_y * (private->orig_height - private->height); y = area->display_ratio_y * (area->orig_height - area->height);
h = private->display_ratio_y * private->height; h = area->display_ratio_y * area->height;
} }
else else
{ {

21
libgimpwidgets/gimpoffsetarea.h
View file

@ -32,26 +32,7 @@ G_BEGIN_DECLS
/* For information look into the C source or the html documentation */ /* For information look into the C source or the html documentation */
#define GIMP_TYPE_OFFSET_AREA (gimp_offset_area_get_type ()) #define GIMP_TYPE_OFFSET_AREA (gimp_offset_area_get_type ())
G_DECLARE_DERIVABLE_TYPE (GimpOffsetArea, gimp_offset_area, GIMP, OFFSET_AREA, GtkDrawingArea) G_DECLARE_FINAL_TYPE (GimpOffsetArea, gimp_offset_area, GIMP, OFFSET_AREA, GtkDrawingArea)
struct _GimpOffsetAreaClass
{
GtkDrawingAreaClass parent_class;
void (* offsets_changed) (GimpOffsetArea *offset_area,
gint offset_x,
gint offset_y);
/* 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);
};
GtkWidget * gimp_offset_area_new (gint orig_width, GtkWidget * gimp_offset_area_new (gint orig_width,

257
libgimpwidgets/gimppageselector.c
View file

@ -72,8 +72,10 @@ enum
}; };
typedef struct _GimpPageSelectorPrivate struct _GimpPageSelector
{ {
GtkBox parent_instance;
gint n_pages; gint n_pages;
GimpPageSelectorTarget target; GimpPageSelectorTarget target;
@ -84,7 +86,7 @@ typedef struct _GimpPageSelectorPrivate
GtkWidget *range_entry; GtkWidget *range_entry;
GdkPixbuf *default_thumbnail; GdkPixbuf *default_thumbnail;
} GimpPageSelectorPrivate; };
static void gimp_page_selector_finalize (GObject *object); static void gimp_page_selector_finalize (GObject *object);
@ -117,7 +119,7 @@ static GdkPixbuf * gimp_page_selector_add_frame (GtkWidget *widget,
GdkPixbuf *pixbuf); GdkPixbuf *pixbuf);
G_DEFINE_TYPE_WITH_PRIVATE (GimpPageSelector, gimp_page_selector, GTK_TYPE_BOX) G_DEFINE_TYPE (GimpPageSelector, gimp_page_selector, GTK_TYPE_BOX)
#define parent_class gimp_page_selector_parent_class #define parent_class gimp_page_selector_parent_class
@ -134,9 +136,6 @@ gimp_page_selector_class_init (GimpPageSelectorClass *klass)
object_class->get_property = gimp_page_selector_get_property; object_class->get_property = gimp_page_selector_get_property;
object_class->set_property = gimp_page_selector_set_property; object_class->set_property = gimp_page_selector_set_property;
klass->selection_changed = NULL;
klass->activate = NULL;
/** /**
* GimpPageSelector::selection-changed: * GimpPageSelector::selection-changed:
* @widget: the object which received the signal. * @widget: the object which received the signal.
@ -149,7 +148,7 @@ gimp_page_selector_class_init (GimpPageSelectorClass *klass)
g_signal_new ("selection-changed", g_signal_new ("selection-changed",
G_TYPE_FROM_CLASS (klass), G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpPageSelectorClass, selection_changed), 0,
NULL, NULL, NULL, NULL, NULL, NULL,
G_TYPE_NONE, 0); G_TYPE_NONE, 0);
@ -166,7 +165,7 @@ gimp_page_selector_class_init (GimpPageSelectorClass *klass)
g_signal_new ("activate", g_signal_new ("activate",
G_OBJECT_CLASS_TYPE (object_class), G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GimpPageSelectorClass, activate), 0,
NULL, NULL, NULL, NULL, NULL, NULL,
G_TYPE_NONE, 0); G_TYPE_NONE, 0);
widget_class->activate_signal = selector_signals[ACTIVATE]; widget_class->activate_signal = selector_signals[ACTIVATE];
@ -204,7 +203,6 @@ gimp_page_selector_class_init (GimpPageSelectorClass *klass)
static void static void
gimp_page_selector_init (GimpPageSelector *selector) gimp_page_selector_init (GimpPageSelector *selector)
{ {
GimpPageSelectorPrivate *priv;
GtkWidget *vbox; GtkWidget *vbox;
GtkWidget *sw; GtkWidget *sw;
GtkWidget *hbox; GtkWidget *hbox;
@ -214,10 +212,8 @@ gimp_page_selector_init (GimpPageSelector *selector)
GtkWidget *combo; GtkWidget *combo;
GtkCellRenderer *renderer; GtkCellRenderer *renderer;
priv = gimp_page_selector_get_instance_private (selector); selector->n_pages = 0;
selector->target = GIMP_PAGE_SELECTOR_TARGET_LAYERS;
priv->n_pages = 0;
priv->target = GIMP_PAGE_SELECTOR_TARGET_LAYERS;
gtk_orientable_set_orientation (GTK_ORIENTABLE (selector), gtk_orientable_set_orientation (GTK_ORIENTABLE (selector),
GTK_ORIENTATION_VERTICAL); GTK_ORIENTATION_VERTICAL);
@ -237,27 +233,27 @@ gimp_page_selector_init (GimpPageSelector *selector)
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
gtk_widget_show (sw); gtk_widget_show (sw);
priv->store = gtk_list_store_new (4, selector->store = gtk_list_store_new (4,
G_TYPE_INT, G_TYPE_INT,
GDK_TYPE_PIXBUF, GDK_TYPE_PIXBUF,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_BOOLEAN); G_TYPE_BOOLEAN);
priv->view = gtk_icon_view_new_with_model (GTK_TREE_MODEL (priv->store)); selector->view = gtk_icon_view_new_with_model (GTK_TREE_MODEL (selector->store));
gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (priv->view), gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (selector->view),
GTK_SELECTION_MULTIPLE); GTK_SELECTION_MULTIPLE);
gtk_container_add (GTK_CONTAINER (sw), priv->view); gtk_container_add (GTK_CONTAINER (sw), selector->view);
gtk_widget_show (priv->view); gtk_widget_show (selector->view);
renderer = gtk_cell_renderer_pixbuf_new (); renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (priv->view), renderer, FALSE); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (selector->view), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (priv->view), renderer, gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (selector->view), renderer,
"pixbuf", COLUMN_THUMBNAIL, "pixbuf", COLUMN_THUMBNAIL,
NULL); NULL);
renderer = gtk_cell_renderer_text_new (); renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (priv->view), renderer, FALSE); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (selector->view), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (priv->view), renderer, gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (selector->view), renderer,
"text", COLUMN_LABEL, "text", COLUMN_LABEL,
NULL); NULL);
g_object_set (renderer, g_object_set (renderer,
@ -267,22 +263,22 @@ gimp_page_selector_init (GimpPageSelector *selector)
"yalign", 0.0, "yalign", 0.0,
NULL); NULL);
g_signal_connect (priv->view, "selection-changed", g_signal_connect (selector->view, "selection-changed",
G_CALLBACK (gimp_page_selector_selection_changed), G_CALLBACK (gimp_page_selector_selection_changed),
selector); selector);
g_signal_connect (priv->view, "item-activated", g_signal_connect (selector->view, "item-activated",
G_CALLBACK (gimp_page_selector_item_activated), G_CALLBACK (gimp_page_selector_item_activated),
selector); selector);
/* Count label */ /* Count label */
priv->count_label = gtk_label_new (_("Nothing selected")); selector->count_label = gtk_label_new (_("Nothing selected"));
gtk_label_set_xalign (GTK_LABEL (priv->count_label), 0.0); gtk_label_set_xalign (GTK_LABEL (selector->count_label), 0.0);
gimp_label_set_attributes (GTK_LABEL (priv->count_label), gimp_label_set_attributes (GTK_LABEL (selector->count_label),
PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC,
-1); -1);
gtk_box_pack_start (GTK_BOX (vbox), priv->count_label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), selector->count_label, FALSE, FALSE, 0);
gtk_widget_show (priv->count_label); gtk_widget_show (selector->count_label);
/* Select all button & range entry */ /* Select all button & range entry */
@ -302,15 +298,15 @@ gimp_page_selector_init (GimpPageSelector *selector)
G_CALLBACK (gimp_page_selector_select_all), G_CALLBACK (gimp_page_selector_select_all),
selector); selector);
priv->range_entry = gtk_entry_new (); selector->range_entry = gtk_entry_new ();
gtk_widget_set_size_request (priv->range_entry, 80, -1); gtk_widget_set_size_request (selector->range_entry, 80, -1);
gtk_box_pack_end (GTK_BOX (hbox), priv->range_entry, TRUE, TRUE, 0); gtk_box_pack_end (GTK_BOX (hbox), selector->range_entry, TRUE, TRUE, 0);
gtk_widget_show (priv->range_entry); gtk_widget_show (selector->range_entry);
g_signal_connect (priv->range_entry, "focus-out-event", g_signal_connect (selector->range_entry, "focus-out-event",
G_CALLBACK (gimp_page_selector_range_focus_out), G_CALLBACK (gimp_page_selector_range_focus_out),
selector); selector);
g_signal_connect (priv->range_entry, "activate", g_signal_connect (selector->range_entry, "activate",
G_CALLBACK (gimp_page_selector_range_activate), G_CALLBACK (gimp_page_selector_range_activate),
selector); selector);
@ -318,7 +314,7 @@ gimp_page_selector_init (GimpPageSelector *selector)
gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label); gtk_widget_show (label);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), priv->range_entry); gtk_label_set_mnemonic_widget (GTK_LABEL (label), selector->range_entry);
/* Target combo */ /* Target combo */
@ -336,7 +332,7 @@ gimp_page_selector_init (GimpPageSelector *selector)
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo); gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
priv->default_thumbnail = selector->default_thumbnail =
gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
"text-x-generic", 32, 0, NULL); "text-x-generic", 32, 0, NULL);
} }
@ -345,11 +341,8 @@ static void
gimp_page_selector_finalize (GObject *object) gimp_page_selector_finalize (GObject *object)
{ {
GimpPageSelector *selector = GIMP_PAGE_SELECTOR (object); GimpPageSelector *selector = GIMP_PAGE_SELECTOR (object);
GimpPageSelectorPrivate *priv;
priv = gimp_page_selector_get_instance_private (selector); g_clear_object (&selector->default_thumbnail);
g_clear_object (&priv->default_thumbnail);
G_OBJECT_CLASS (parent_class)->finalize (object); G_OBJECT_CLASS (parent_class)->finalize (object);
} }
@ -361,17 +354,14 @@ gimp_page_selector_get_property (GObject *object,
GParamSpec *pspec) GParamSpec *pspec)
{ {
GimpPageSelector *selector = GIMP_PAGE_SELECTOR (object); GimpPageSelector *selector = GIMP_PAGE_SELECTOR (object);
GimpPageSelectorPrivate *priv;
priv = gimp_page_selector_get_instance_private (selector);
switch (property_id) switch (property_id)
{ {
case PROP_N_PAGES: case PROP_N_PAGES:
g_value_set_int (value, priv->n_pages); g_value_set_int (value, selector->n_pages);
break; break;
case PROP_TARGET: case PROP_TARGET:
g_value_set_enum (value, priv->target); g_value_set_enum (value, selector->target);
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
@ -386,9 +376,6 @@ gimp_page_selector_set_property (GObject *object,
GParamSpec *pspec) GParamSpec *pspec)
{ {
GimpPageSelector *selector = GIMP_PAGE_SELECTOR (object); GimpPageSelector *selector = GIMP_PAGE_SELECTOR (object);
GimpPageSelectorPrivate *priv;
priv = gimp_page_selector_get_instance_private (selector);
switch (property_id) switch (property_id)
{ {
@ -396,7 +383,7 @@ gimp_page_selector_set_property (GObject *object,
gimp_page_selector_set_n_pages (selector, g_value_get_int (value)); gimp_page_selector_set_n_pages (selector, g_value_get_int (value));
break; break;
case PROP_TARGET: case PROP_TARGET:
priv->target = g_value_get_enum (value); selector->target = g_value_get_enum (value);
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
@ -435,39 +422,35 @@ void
gimp_page_selector_set_n_pages (GimpPageSelector *selector, gimp_page_selector_set_n_pages (GimpPageSelector *selector,
gint n_pages) gint n_pages)
{ {
GimpPageSelectorPrivate *priv;
g_return_if_fail (GIMP_IS_PAGE_SELECTOR (selector)); g_return_if_fail (GIMP_IS_PAGE_SELECTOR (selector));
g_return_if_fail (n_pages >= 0); g_return_if_fail (n_pages >= 0);
priv = gimp_page_selector_get_instance_private (selector); if (n_pages != selector->n_pages)
if (n_pages != priv->n_pages)
{ {
GtkTreeIter iter; GtkTreeIter iter;
gint i; gint i;
if (n_pages < priv->n_pages) if (n_pages < selector->n_pages)
{ {
for (i = n_pages; i < priv->n_pages; i++) for (i = n_pages; i < selector->n_pages; i++)
{ {
gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (priv->store), gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (selector->store),
&iter, NULL, n_pages); &iter, NULL, n_pages);
gtk_list_store_remove (priv->store, &iter); gtk_list_store_remove (selector->store, &iter);
} }
} }
else else
{ {
for (i = priv->n_pages; i < n_pages; i++) for (i = selector->n_pages; i < n_pages; i++)
{ {
gchar *text; gchar *text;
text = g_strdup_printf (_("Page %d"), i + 1); text = g_strdup_printf (_("Page %d"), i + 1);
gtk_list_store_append (priv->store, &iter); gtk_list_store_append (selector->store, &iter);
gtk_list_store_set (priv->store, &iter, gtk_list_store_set (selector->store, &iter,
COLUMN_PAGE_NO, i, COLUMN_PAGE_NO, i,
COLUMN_THUMBNAIL, priv->default_thumbnail, COLUMN_THUMBNAIL, selector->default_thumbnail,
COLUMN_LABEL, text, COLUMN_LABEL, text,
COLUMN_LABEL_SET, FALSE, COLUMN_LABEL_SET, FALSE,
-1); -1);
@ -476,7 +459,7 @@ gimp_page_selector_set_n_pages (GimpPageSelector *selector,
} }
} }
priv->n_pages = n_pages; selector->n_pages = n_pages;
g_object_notify (G_OBJECT (selector), "n-pages"); g_object_notify (G_OBJECT (selector), "n-pages");
} }
@ -493,13 +476,9 @@ gimp_page_selector_set_n_pages (GimpPageSelector *selector,
gint gint
gimp_page_selector_get_n_pages (GimpPageSelector *selector) gimp_page_selector_get_n_pages (GimpPageSelector *selector)
{ {
GimpPageSelectorPrivate *priv;
g_return_val_if_fail (GIMP_IS_PAGE_SELECTOR (selector), 0); g_return_val_if_fail (GIMP_IS_PAGE_SELECTOR (selector), 0);
priv = gimp_page_selector_get_instance_private (selector); return selector->n_pages;
return priv->n_pages;
} }
/** /**
@ -513,16 +492,12 @@ void
gimp_page_selector_set_target (GimpPageSelector *selector, gimp_page_selector_set_target (GimpPageSelector *selector,
GimpPageSelectorTarget target) GimpPageSelectorTarget target)
{ {
GimpPageSelectorPrivate *priv;
g_return_if_fail (GIMP_IS_PAGE_SELECTOR (selector)); g_return_if_fail (GIMP_IS_PAGE_SELECTOR (selector));
g_return_if_fail (target <= GIMP_PAGE_SELECTOR_TARGET_IMAGES); g_return_if_fail (target <= GIMP_PAGE_SELECTOR_TARGET_IMAGES);
priv = gimp_page_selector_get_instance_private (selector); if (target != selector->target)
if (target != priv->target)
{ {
priv->target = target; selector->target = target;
g_object_notify (G_OBJECT (selector), "target"); g_object_notify (G_OBJECT (selector), "target");
} }
@ -539,14 +514,10 @@ gimp_page_selector_set_target (GimpPageSelector *selector,
GimpPageSelectorTarget GimpPageSelectorTarget
gimp_page_selector_get_target (GimpPageSelector *selector) gimp_page_selector_get_target (GimpPageSelector *selector)
{ {
GimpPageSelectorPrivate *priv;
g_return_val_if_fail (GIMP_IS_PAGE_SELECTOR (selector), g_return_val_if_fail (GIMP_IS_PAGE_SELECTOR (selector),
GIMP_PAGE_SELECTOR_TARGET_LAYERS); GIMP_PAGE_SELECTOR_TARGET_LAYERS);
priv = gimp_page_selector_get_instance_private (selector); return selector->target;
return priv->target;
} }
/** /**
@ -565,22 +536,19 @@ gimp_page_selector_set_page_thumbnail (GimpPageSelector *selector,
gint page_no, gint page_no,
GdkPixbuf *thumbnail) GdkPixbuf *thumbnail)
{ {
GimpPageSelectorPrivate *priv;
GtkTreeIter iter; GtkTreeIter iter;
g_return_if_fail (GIMP_IS_PAGE_SELECTOR (selector)); g_return_if_fail (GIMP_IS_PAGE_SELECTOR (selector));
g_return_if_fail (thumbnail == NULL || GDK_IS_PIXBUF (thumbnail)); g_return_if_fail (thumbnail == NULL || GDK_IS_PIXBUF (thumbnail));
priv = gimp_page_selector_get_instance_private (selector); g_return_if_fail (page_no >= 0 && page_no < selector->n_pages);
g_return_if_fail (page_no >= 0 && page_no < priv->n_pages); gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (selector->store),
gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (priv->store),
&iter, NULL, page_no); &iter, NULL, page_no);
if (! thumbnail) if (! thumbnail)
{ {
thumbnail = g_object_ref (priv->default_thumbnail); thumbnail = g_object_ref (selector->default_thumbnail);
} }
else else
{ {
@ -588,7 +556,7 @@ gimp_page_selector_set_page_thumbnail (GimpPageSelector *selector,
thumbnail); thumbnail);
} }
gtk_list_store_set (priv->store, &iter, gtk_list_store_set (selector->store, &iter,
COLUMN_THUMBNAIL, thumbnail, COLUMN_THUMBNAIL, thumbnail,
-1); -1);
g_clear_object (&thumbnail); g_clear_object (&thumbnail);
@ -609,26 +577,23 @@ GdkPixbuf *
gimp_page_selector_get_page_thumbnail (GimpPageSelector *selector, gimp_page_selector_get_page_thumbnail (GimpPageSelector *selector,
gint page_no) gint page_no)
{ {
GimpPageSelectorPrivate *priv;
GdkPixbuf *thumbnail; GdkPixbuf *thumbnail;
GtkTreeIter iter; GtkTreeIter iter;
g_return_val_if_fail (GIMP_IS_PAGE_SELECTOR (selector), NULL); g_return_val_if_fail (GIMP_IS_PAGE_SELECTOR (selector), NULL);
priv = gimp_page_selector_get_instance_private (selector); g_return_val_if_fail (page_no >= 0 && page_no < selector->n_pages, NULL);
g_return_val_if_fail (page_no >= 0 && page_no < priv->n_pages, NULL); gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (selector->store),
gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (priv->store),
&iter, NULL, page_no); &iter, NULL, page_no);
gtk_tree_model_get (GTK_TREE_MODEL (priv->store), &iter, gtk_tree_model_get (GTK_TREE_MODEL (selector->store), &iter,
COLUMN_THUMBNAIL, &thumbnail, COLUMN_THUMBNAIL, &thumbnail,
-1); -1);
if (thumbnail) if (thumbnail)
g_object_unref (thumbnail); g_object_unref (thumbnail);
if (thumbnail == priv->default_thumbnail) if (thumbnail == selector->default_thumbnail)
return NULL; return NULL;
return thumbnail; return thumbnail;
@ -649,24 +614,21 @@ gimp_page_selector_set_page_label (GimpPageSelector *selector,
gint page_no, gint page_no,
const gchar *label) const gchar *label)
{ {
GimpPageSelectorPrivate *priv;
GtkTreeIter iter; GtkTreeIter iter;
gchar *tmp; gchar *tmp;
g_return_if_fail (GIMP_IS_PAGE_SELECTOR (selector)); g_return_if_fail (GIMP_IS_PAGE_SELECTOR (selector));
priv = gimp_page_selector_get_instance_private (selector); g_return_if_fail (page_no >= 0 && page_no < selector->n_pages);
g_return_if_fail (page_no >= 0 && page_no < priv->n_pages);
if (! label) if (! label)
tmp = g_strdup_printf (_("Page %d"), page_no + 1); tmp = g_strdup_printf (_("Page %d"), page_no + 1);
else else
tmp = (gchar *) label; tmp = (gchar *) label;
gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (priv->store), gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (selector->store),
&iter, NULL, page_no); &iter, NULL, page_no);
gtk_list_store_set (priv->store, &iter, gtk_list_store_set (selector->store, &iter,
COLUMN_LABEL, tmp, COLUMN_LABEL, tmp,
COLUMN_LABEL_SET, label != NULL, COLUMN_LABEL_SET, label != NULL,
-1); -1);
@ -690,20 +652,17 @@ gchar *
gimp_page_selector_get_page_label (GimpPageSelector *selector, gimp_page_selector_get_page_label (GimpPageSelector *selector,
gint page_no) gint page_no)
{ {
GimpPageSelectorPrivate *priv;
GtkTreeIter iter; GtkTreeIter iter;
gchar *label; gchar *label;
gboolean label_set; gboolean label_set;
g_return_val_if_fail (GIMP_IS_PAGE_SELECTOR (selector), NULL); g_return_val_if_fail (GIMP_IS_PAGE_SELECTOR (selector), NULL);
priv = gimp_page_selector_get_instance_private (selector); g_return_val_if_fail (page_no >= 0 && page_no < selector->n_pages, NULL);
g_return_val_if_fail (page_no >= 0 && page_no < priv->n_pages, NULL); gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (selector->store),
gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (priv->store),
&iter, NULL, page_no); &iter, NULL, page_no);
gtk_tree_model_get (GTK_TREE_MODEL (priv->store), &iter, gtk_tree_model_get (GTK_TREE_MODEL (selector->store), &iter,
COLUMN_LABEL, &label, COLUMN_LABEL, &label,
COLUMN_LABEL_SET, &label_set, COLUMN_LABEL_SET, &label_set,
-1); -1);
@ -728,13 +687,9 @@ gimp_page_selector_get_page_label (GimpPageSelector *selector,
void void
gimp_page_selector_select_all (GimpPageSelector *selector) gimp_page_selector_select_all (GimpPageSelector *selector)
{ {
GimpPageSelectorPrivate *priv;
g_return_if_fail (GIMP_IS_PAGE_SELECTOR (selector)); g_return_if_fail (GIMP_IS_PAGE_SELECTOR (selector));
priv = gimp_page_selector_get_instance_private (selector); gtk_icon_view_select_all (GTK_ICON_VIEW (selector->view));
gtk_icon_view_select_all (GTK_ICON_VIEW (priv->view));
} }
/** /**
@ -748,13 +703,9 @@ gimp_page_selector_select_all (GimpPageSelector *selector)
void void
gimp_page_selector_unselect_all (GimpPageSelector *selector) gimp_page_selector_unselect_all (GimpPageSelector *selector)
{ {
GimpPageSelectorPrivate *priv;
g_return_if_fail (GIMP_IS_PAGE_SELECTOR (selector)); g_return_if_fail (GIMP_IS_PAGE_SELECTOR (selector));
priv = gimp_page_selector_get_instance_private (selector); gtk_icon_view_unselect_all (GTK_ICON_VIEW (selector->view));
gtk_icon_view_unselect_all (GTK_ICON_VIEW (priv->view));
} }
/** /**
@ -770,21 +721,18 @@ void
gimp_page_selector_select_page (GimpPageSelector *selector, gimp_page_selector_select_page (GimpPageSelector *selector,
gint page_no) gint page_no)
{ {
GimpPageSelectorPrivate *priv;
GtkTreeIter iter; GtkTreeIter iter;
GtkTreePath *path; GtkTreePath *path;
g_return_if_fail (GIMP_IS_PAGE_SELECTOR (selector)); g_return_if_fail (GIMP_IS_PAGE_SELECTOR (selector));
priv = gimp_page_selector_get_instance_private (selector); g_return_if_fail (page_no >= 0 && page_no < selector->n_pages);
g_return_if_fail (page_no >= 0 && page_no < priv->n_pages); gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (selector->store),
gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (priv->store),
&iter, NULL, page_no); &iter, NULL, page_no);
path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->store), &iter); path = gtk_tree_model_get_path (GTK_TREE_MODEL (selector->store), &iter);
gtk_icon_view_select_path (GTK_ICON_VIEW (priv->view), path); gtk_icon_view_select_path (GTK_ICON_VIEW (selector->view), path);
gtk_tree_path_free (path); gtk_tree_path_free (path);
} }
@ -802,21 +750,18 @@ void
gimp_page_selector_unselect_page (GimpPageSelector *selector, gimp_page_selector_unselect_page (GimpPageSelector *selector,
gint page_no) gint page_no)
{ {
GimpPageSelectorPrivate *priv;
GtkTreeIter iter; GtkTreeIter iter;
GtkTreePath *path; GtkTreePath *path;
g_return_if_fail (GIMP_IS_PAGE_SELECTOR (selector)); g_return_if_fail (GIMP_IS_PAGE_SELECTOR (selector));
priv = gimp_page_selector_get_instance_private (selector); g_return_if_fail (page_no >= 0 && page_no < selector->n_pages);
g_return_if_fail (page_no >= 0 && page_no < priv->n_pages); gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (selector->store),
gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (priv->store),
&iter, NULL, page_no); &iter, NULL, page_no);
path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->store), &iter); path = gtk_tree_model_get_path (GTK_TREE_MODEL (selector->store), &iter);
gtk_icon_view_unselect_path (GTK_ICON_VIEW (priv->view), path); gtk_icon_view_unselect_path (GTK_ICON_VIEW (selector->view), path);
gtk_tree_path_free (path); gtk_tree_path_free (path);
} }
@ -834,22 +779,19 @@ gboolean
gimp_page_selector_page_is_selected (GimpPageSelector *selector, gimp_page_selector_page_is_selected (GimpPageSelector *selector,
gint page_no) gint page_no)
{ {
GimpPageSelectorPrivate *priv;
GtkTreeIter iter; GtkTreeIter iter;
GtkTreePath *path; GtkTreePath *path;
gboolean selected; gboolean selected;
g_return_val_if_fail (GIMP_IS_PAGE_SELECTOR (selector), FALSE); g_return_val_if_fail (GIMP_IS_PAGE_SELECTOR (selector), FALSE);
priv = gimp_page_selector_get_instance_private (selector); g_return_val_if_fail (page_no >= 0 && page_no < selector->n_pages, FALSE);
g_return_val_if_fail (page_no >= 0 && page_no < priv->n_pages, FALSE); gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (selector->store),
gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (priv->store),
&iter, NULL, page_no); &iter, NULL, page_no);
path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->store), &iter); path = gtk_tree_model_get_path (GTK_TREE_MODEL (selector->store), &iter);
selected = gtk_icon_view_path_is_selected (GTK_ICON_VIEW (priv->view), selected = gtk_icon_view_path_is_selected (GTK_ICON_VIEW (selector->view),
path); path);
gtk_tree_path_free (path); gtk_tree_path_free (path);
@ -871,7 +813,6 @@ gint *
gimp_page_selector_get_selected_pages (GimpPageSelector *selector, gimp_page_selector_get_selected_pages (GimpPageSelector *selector,
gint *n_selected_pages) gint *n_selected_pages)
{ {
GimpPageSelectorPrivate *priv;
GList *selected; GList *selected;
GList *list; GList *list;
gint *array; gint *array;
@ -880,9 +821,7 @@ gimp_page_selector_get_selected_pages (GimpPageSelector *selector,
g_return_val_if_fail (GIMP_IS_PAGE_SELECTOR (selector), NULL); g_return_val_if_fail (GIMP_IS_PAGE_SELECTOR (selector), NULL);
g_return_val_if_fail (n_selected_pages != NULL, NULL); g_return_val_if_fail (n_selected_pages != NULL, NULL);
priv = gimp_page_selector_get_instance_private (selector); selected = gtk_icon_view_get_selected_items (GTK_ICON_VIEW (selector->view));
selected = gtk_icon_view_get_selected_items (GTK_ICON_VIEW (priv->view));
*n_selected_pages = g_list_length (selected); *n_selected_pages = g_list_length (selected);
array = g_new0 (gint, *n_selected_pages); array = g_new0 (gint, *n_selected_pages);
@ -921,17 +860,14 @@ void
gimp_page_selector_select_range (GimpPageSelector *selector, gimp_page_selector_select_range (GimpPageSelector *selector,
const gchar *range) const gchar *range)
{ {
GimpPageSelectorPrivate *priv;
gchar **ranges; gchar **ranges;
g_return_if_fail (GIMP_IS_PAGE_SELECTOR (selector)); g_return_if_fail (GIMP_IS_PAGE_SELECTOR (selector));
priv = gimp_page_selector_get_instance_private (selector);
if (! range) if (! range)
range = ""; range = "";
g_signal_handlers_block_by_func (priv->view, g_signal_handlers_block_by_func (selector->view,
gimp_page_selector_selection_changed, gimp_page_selector_selection_changed,
selector); selector);
@ -966,17 +902,17 @@ gimp_page_selector_select_range (GimpPageSelector *selector,
page_from = 1; page_from = 1;
if (sscanf (to, "%i", &page_to) != 1 && strlen (to) == 0) if (sscanf (to, "%i", &page_to) != 1 && strlen (to) == 0)
page_to = priv->n_pages; page_to = selector->n_pages;
if (page_from > 0 && if (page_from > 0 &&
page_to > 0 && page_to > 0 &&
page_from <= page_to && page_from <= page_to &&
page_from <= priv->n_pages) page_from <= selector->n_pages)
{ {
gint page_no; gint page_no;
page_from = MAX (page_from, 1) - 1; page_from = MAX (page_from, 1) - 1;
page_to = MIN (page_to, priv->n_pages) - 1; page_to = MIN (page_to, selector->n_pages) - 1;
for (page_no = page_from; page_no <= page_to; page_no++) for (page_no = page_from; page_no <= page_to; page_no++)
gimp_page_selector_select_page (selector, page_no); gimp_page_selector_select_page (selector, page_no);
@ -988,7 +924,7 @@ gimp_page_selector_select_range (GimpPageSelector *selector,
if (sscanf (range, "%i", &page_no) == 1 && if (sscanf (range, "%i", &page_no) == 1 &&
page_no >= 1 && page_no >= 1 &&
page_no <= priv->n_pages) page_no <= selector->n_pages)
{ {
gimp_page_selector_select_page (selector, page_no - 1); gimp_page_selector_select_page (selector, page_no - 1);
} }
@ -998,11 +934,11 @@ gimp_page_selector_select_range (GimpPageSelector *selector,
g_strfreev (ranges); g_strfreev (ranges);
} }
g_signal_handlers_unblock_by_func (priv->view, g_signal_handlers_unblock_by_func (selector->view,
gimp_page_selector_selection_changed, gimp_page_selector_selection_changed,
selector); selector);
gimp_page_selector_selection_changed (GTK_ICON_VIEW (priv->view), selector); gimp_page_selector_selection_changed (GTK_ICON_VIEW (selector->view), selector);
} }
/** /**
@ -1062,38 +998,35 @@ gimp_page_selector_get_selected_range (GimpPageSelector *selector)
} }
/* private functions */ /* selectorate functions */
static void static void
gimp_page_selector_selection_changed (GtkIconView *icon_view, gimp_page_selector_selection_changed (GtkIconView *icon_view,
GimpPageSelector *selector) GimpPageSelector *selector)
{ {
GimpPageSelectorPrivate *priv;
GList *selected; GList *selected;
gint n_selected; gint n_selected;
gchar *range; gchar *range;
priv = gimp_page_selector_get_instance_private (selector); selected = gtk_icon_view_get_selected_items (GTK_ICON_VIEW (selector->view));
selected = gtk_icon_view_get_selected_items (GTK_ICON_VIEW (priv->view));
n_selected = g_list_length (selected); n_selected = g_list_length (selected);
g_list_free_full (selected, (GDestroyNotify) gtk_tree_path_free); g_list_free_full (selected, (GDestroyNotify) gtk_tree_path_free);
if (n_selected == 0) if (n_selected == 0)
{ {
gtk_label_set_text (GTK_LABEL (priv->count_label), gtk_label_set_text (GTK_LABEL (selector->count_label),
_("Nothing selected")); _("Nothing selected"));
} }
else if (n_selected == 1) else if (n_selected == 1)
{ {
gtk_label_set_text (GTK_LABEL (priv->count_label), gtk_label_set_text (GTK_LABEL (selector->count_label),
_("One page selected")); _("One page selected"));
} }
else else
{ {
gchar *text; gchar *text;
if (n_selected == priv->n_pages) if (n_selected == selector->n_pages)
text = g_strdup_printf (ngettext ("%d page selected", text = g_strdup_printf (ngettext ("%d page selected",
"All %d pages selected", n_selected), "All %d pages selected", n_selected),
n_selected); n_selected);
@ -1103,15 +1036,15 @@ gimp_page_selector_selection_changed (GtkIconView *icon_view,
n_selected), n_selected),
n_selected); n_selected);
gtk_label_set_text (GTK_LABEL (priv->count_label), text); gtk_label_set_text (GTK_LABEL (selector->count_label), text);
g_free (text); g_free (text);
} }
range = gimp_page_selector_get_selected_range (selector); range = gimp_page_selector_get_selected_range (selector);
gtk_entry_set_text (GTK_ENTRY (priv->range_entry), range); gtk_entry_set_text (GTK_ENTRY (selector->range_entry), range);
g_free (range); g_free (range);
gtk_editable_set_position (GTK_EDITABLE (priv->range_entry), -1); gtk_editable_set_position (GTK_EDITABLE (selector->range_entry), -1);
g_signal_emit (selector, selector_signals[SELECTION_CHANGED], 0); g_signal_emit (selector, selector_signals[SELECTION_CHANGED], 0);
} }

20
libgimpwidgets/gimppageselector.h
View file

@ -29,25 +29,7 @@
G_BEGIN_DECLS G_BEGIN_DECLS
#define GIMP_TYPE_PAGE_SELECTOR (gimp_page_selector_get_type ()) #define GIMP_TYPE_PAGE_SELECTOR (gimp_page_selector_get_type ())
G_DECLARE_DERIVABLE_TYPE (GimpPageSelector, gimp_page_selector, GIMP, PAGE_SELECTOR, GtkBox) G_DECLARE_FINAL_TYPE (GimpPageSelector, gimp_page_selector, GIMP, PAGE_SELECTOR, GtkBox)
struct _GimpPageSelectorClass
{
GtkBoxClass parent_class;
void (* selection_changed) (GimpPageSelector *selector);
void (* activate) (GimpPageSelector *selector);
/* 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);
};
GtkWidget * gimp_page_selector_new (void); GtkWidget * gimp_page_selector_new (void);

252
libgimpwidgets/gimppatheditor.c
View file

@ -76,7 +76,7 @@ enum
}; };
typedef struct _GimpPathEditorPrivate struct _GimpPathEditor
{ {
GtkWidget *upper_hbox; GtkWidget *upper_hbox;
@ -95,9 +95,7 @@ typedef struct _GimpPathEditorPrivate
GtkTreeViewColumn *writable_column; GtkTreeViewColumn *writable_column;
gint num_items; gint num_items;
} GimpPathEditorPrivate; };
#define GET_PRIVATE(obj) ((GimpPathEditorPrivate *) gimp_path_editor_get_instance_private ((GimpPathEditor *) (obj)))
static void gimp_path_editor_new_clicked (GtkWidget *widget, static void gimp_path_editor_new_clicked (GtkWidget *widget,
@ -115,7 +113,7 @@ static void gimp_path_editor_writable_toggled (GtkCellRendererToggle *toggle
GimpPathEditor *editor); GimpPathEditor *editor);
G_DEFINE_TYPE_WITH_PRIVATE (GimpPathEditor, gimp_path_editor, GTK_TYPE_BOX) G_DEFINE_TYPE (GimpPathEditor, gimp_path_editor, GTK_TYPE_BOX)
#define parent_class gimp_path_editor_parent_class #define parent_class gimp_path_editor_parent_class
@ -135,7 +133,7 @@ gimp_path_editor_class_init (GimpPathEditorClass *klass)
g_signal_new ("path-changed", g_signal_new ("path-changed",
G_TYPE_FROM_CLASS (klass), G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpPathEditorClass, path_changed), 0,
NULL, NULL, NULL, NULL, NULL, NULL,
G_TYPE_NONE, 0); G_TYPE_NONE, 0);
@ -150,18 +148,14 @@ gimp_path_editor_class_init (GimpPathEditorClass *klass)
g_signal_new ("writable-changed", g_signal_new ("writable-changed",
G_TYPE_FROM_CLASS (klass), G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpPathEditorClass, writable_changed), 0,
NULL, NULL, NULL, NULL, NULL, NULL,
G_TYPE_NONE, 0); G_TYPE_NONE, 0);
klass->path_changed = NULL;
klass->writable_changed = NULL;
} }
static void static void
gimp_path_editor_init (GimpPathEditor *editor) gimp_path_editor_init (GimpPathEditor *editor)
{ {
GimpPathEditorPrivate *priv = GET_PRIVATE (editor);
GtkWidget *button_box; GtkWidget *button_box;
GtkWidget *button; GtkWidget *button;
GtkWidget *image; GtkWidget *image;
@ -170,23 +164,23 @@ gimp_path_editor_init (GimpPathEditor *editor)
GtkTreeViewColumn *col; GtkTreeViewColumn *col;
GtkCellRenderer *renderer; GtkCellRenderer *renderer;
priv->file_entry = NULL; editor->file_entry = NULL;
priv->sel_path = NULL; editor->sel_path = NULL;
priv->num_items = 0; editor->num_items = 0;
gtk_orientable_set_orientation (GTK_ORIENTABLE (editor), gtk_orientable_set_orientation (GTK_ORIENTABLE (editor),
GTK_ORIENTATION_VERTICAL); GTK_ORIENTATION_VERTICAL);
priv->upper_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); editor->upper_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (GTK_BOX (editor), priv->upper_hbox, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (editor), editor->upper_hbox, FALSE, TRUE, 0);
gtk_widget_show (priv->upper_hbox); gtk_widget_show (editor->upper_hbox);
button_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); button_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous (GTK_BOX (button_box), TRUE); gtk_box_set_homogeneous (GTK_BOX (button_box), TRUE);
gtk_box_pack_start (GTK_BOX (priv->upper_hbox), button_box, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (editor->upper_hbox), button_box, FALSE, TRUE, 0);
gtk_widget_show (button_box); gtk_widget_show (button_box);
priv->new_button = button = gtk_button_new (); editor->new_button = button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (button_box), button, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (button_box), button, TRUE, TRUE, 0);
gtk_widget_show (button); gtk_widget_show (button);
@ -199,11 +193,11 @@ gimp_path_editor_init (GimpPathEditor *editor)
G_CALLBACK (gimp_path_editor_new_clicked), G_CALLBACK (gimp_path_editor_new_clicked),
editor); editor);
gimp_help_set_help_data (priv->new_button, gimp_help_set_help_data (editor->new_button,
_("Add a new folder"), _("Add a new folder"),
NULL); NULL);
priv->up_button = button = gtk_button_new (); editor->up_button = button = gtk_button_new ();
gtk_widget_set_sensitive (button, FALSE); gtk_widget_set_sensitive (button, FALSE);
gtk_box_pack_start (GTK_BOX (button_box), button, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (button_box), button, TRUE, TRUE, 0);
gtk_widget_show (button); gtk_widget_show (button);
@ -217,11 +211,11 @@ gimp_path_editor_init (GimpPathEditor *editor)
G_CALLBACK (gimp_path_editor_move_clicked), G_CALLBACK (gimp_path_editor_move_clicked),
editor); editor);
gimp_help_set_help_data (priv->up_button, gimp_help_set_help_data (editor->up_button,
_("Move the selected folder up"), _("Move the selected folder up"),
NULL); NULL);
priv->down_button = button = gtk_button_new (); editor->down_button = button = gtk_button_new ();
gtk_widget_set_sensitive (button, FALSE); gtk_widget_set_sensitive (button, FALSE);
gtk_box_pack_start (GTK_BOX (button_box), button, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (button_box), button, TRUE, TRUE, 0);
gtk_widget_show (button); gtk_widget_show (button);
@ -235,11 +229,11 @@ gimp_path_editor_init (GimpPathEditor *editor)
G_CALLBACK (gimp_path_editor_move_clicked), G_CALLBACK (gimp_path_editor_move_clicked),
editor); editor);
gimp_help_set_help_data (priv->down_button, gimp_help_set_help_data (editor->down_button,
_("Move the selected folder down"), _("Move the selected folder down"),
NULL); NULL);
priv->delete_button = button = gtk_button_new (); editor->delete_button = button = gtk_button_new ();
gtk_widget_set_sensitive (button, FALSE); gtk_widget_set_sensitive (button, FALSE);
gtk_box_pack_start (GTK_BOX (button_box), button, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (button_box), button, TRUE, TRUE, 0);
gtk_widget_show (button); gtk_widget_show (button);
@ -253,7 +247,7 @@ gimp_path_editor_init (GimpPathEditor *editor)
G_CALLBACK (gimp_path_editor_delete_clicked), G_CALLBACK (gimp_path_editor_delete_clicked),
editor); editor);
gimp_help_set_help_data (priv->delete_button, gimp_help_set_help_data (editor->delete_button,
_("Remove the selected folder from the list"), _("Remove the selected folder from the list"),
NULL); NULL);
@ -266,12 +260,12 @@ gimp_path_editor_init (GimpPathEditor *editor)
gtk_box_pack_start (GTK_BOX (editor), scrolled_window, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (editor), scrolled_window, TRUE, TRUE, 2);
gtk_widget_show (scrolled_window); gtk_widget_show (scrolled_window);
priv->dir_list = gtk_list_store_new (NUM_COLUMNS, editor->dir_list = gtk_list_store_new (NUM_COLUMNS,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_BOOLEAN); G_TYPE_BOOLEAN);
tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (priv->dir_list)); tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (editor->dir_list));
g_object_unref (priv->dir_list); g_object_unref (editor->dir_list);
renderer = gtk_cell_renderer_toggle_new (); renderer = gtk_cell_renderer_toggle_new ();
@ -279,7 +273,7 @@ gimp_path_editor_init (GimpPathEditor *editor)
G_CALLBACK (gimp_path_editor_writable_toggled), G_CALLBACK (gimp_path_editor_writable_toggled),
editor); editor);
priv->writable_column = col = gtk_tree_view_column_new (); editor->writable_column = col = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (col, _("Writable")); gtk_tree_view_column_set_title (col, _("Writable"));
gtk_tree_view_column_pack_start (col, renderer, FALSE); gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_add_attribute (col, renderer, "active", COLUMN_WRITABLE); gtk_tree_view_column_add_attribute (col, renderer, "active", COLUMN_WRITABLE);
@ -299,8 +293,8 @@ gimp_path_editor_init (GimpPathEditor *editor)
gtk_container_add (GTK_CONTAINER (scrolled_window), tv); gtk_container_add (GTK_CONTAINER (scrolled_window), tv);
gtk_widget_show (tv); gtk_widget_show (tv);
priv->sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (tv)); editor->sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (tv));
g_signal_connect (priv->sel, "changed", g_signal_connect (editor->sel, "changed",
G_CALLBACK (gimp_path_editor_selection_changed), G_CALLBACK (gimp_path_editor_selection_changed),
editor); editor);
} }
@ -322,20 +316,18 @@ gimp_path_editor_new (const gchar *title,
const gchar *path) const gchar *path)
{ {
GimpPathEditor *editor; GimpPathEditor *editor;
GimpPathEditorPrivate *priv;
g_return_val_if_fail (title != NULL, NULL); g_return_val_if_fail (title != NULL, NULL);
editor = g_object_new (GIMP_TYPE_PATH_EDITOR, NULL); editor = g_object_new (GIMP_TYPE_PATH_EDITOR, NULL);
priv = GET_PRIVATE (editor);
priv->file_entry = gimp_file_entry_new (title, "", TRUE, TRUE); editor->file_entry = gimp_file_entry_new (title, "", TRUE, TRUE);
gtk_widget_set_sensitive (priv->file_entry, FALSE); gtk_widget_set_sensitive (editor->file_entry, FALSE);
gtk_box_pack_start (GTK_BOX (priv->upper_hbox), priv->file_entry, gtk_box_pack_start (GTK_BOX (editor->upper_hbox), editor->file_entry,
TRUE, TRUE, 0); TRUE, TRUE, 0);
gtk_widget_show (priv->file_entry); gtk_widget_show (editor->file_entry);
g_signal_connect (priv->file_entry, "filename-changed", g_signal_connect (editor->file_entry, "filename-changed",
G_CALLBACK (gimp_path_editor_file_entry_changed), G_CALLBACK (gimp_path_editor_file_entry_changed),
editor); editor);
@ -359,7 +351,6 @@ gimp_path_editor_new (const gchar *title,
gchar * gchar *
gimp_path_editor_get_path (GimpPathEditor *editor) gimp_path_editor_get_path (GimpPathEditor *editor)
{ {
GimpPathEditorPrivate *priv;
GtkTreeModel *model; GtkTreeModel *model;
GString *path; GString *path;
GtkTreeIter iter; GtkTreeIter iter;
@ -367,9 +358,7 @@ gimp_path_editor_get_path (GimpPathEditor *editor)
g_return_val_if_fail (GIMP_IS_PATH_EDITOR (editor), g_strdup ("")); g_return_val_if_fail (GIMP_IS_PATH_EDITOR (editor), g_strdup (""));
priv = GET_PRIVATE (editor); model = GTK_TREE_MODEL (editor->dir_list);
model = GTK_TREE_MODEL (priv->dir_list);
path = g_string_new (""); path = g_string_new ("");
@ -406,14 +395,12 @@ void
gimp_path_editor_set_path (GimpPathEditor *editor, gimp_path_editor_set_path (GimpPathEditor *editor,
const gchar *path) const gchar *path)
{ {
GimpPathEditorPrivate *priv;
gchar *old_path; gchar *old_path;
GList *path_list; GList *path_list;
GList *list; GList *list;
g_return_if_fail (GIMP_IS_PATH_EDITOR (editor)); g_return_if_fail (GIMP_IS_PATH_EDITOR (editor));
priv = GET_PRIVATE (editor);
old_path = gimp_path_editor_get_path (editor); old_path = gimp_path_editor_get_path (editor);
if (old_path && path && strcmp (old_path, path) == 0) if (old_path && path && strcmp (old_path, path) == 0)
@ -426,7 +413,7 @@ gimp_path_editor_set_path (GimpPathEditor *editor,
path_list = gimp_path_parse (path, 256, FALSE, NULL); path_list = gimp_path_parse (path, 256, FALSE, NULL);
gtk_list_store_clear (priv->dir_list); gtk_list_store_clear (editor->dir_list);
for (list = path_list; list; list = g_list_next (list)) for (list = path_list; list; list = g_list_next (list))
{ {
@ -436,8 +423,8 @@ gimp_path_editor_set_path (GimpPathEditor *editor,
utf8 = g_filename_to_utf8 (directory, -1, NULL, NULL, NULL); utf8 = g_filename_to_utf8 (directory, -1, NULL, NULL, NULL);
gtk_list_store_append (priv->dir_list, &iter); gtk_list_store_append (editor->dir_list, &iter);
gtk_list_store_set (priv->dir_list, &iter, gtk_list_store_set (editor->dir_list, &iter,
COLUMN_UTF8, utf8, COLUMN_UTF8, utf8,
COLUMN_DIRECTORY, directory, COLUMN_DIRECTORY, directory,
COLUMN_WRITABLE, FALSE, COLUMN_WRITABLE, FALSE,
@ -445,7 +432,7 @@ gimp_path_editor_set_path (GimpPathEditor *editor,
g_free (utf8); g_free (utf8);
priv->num_items++; editor->num_items++;
} }
gimp_path_free (path_list); gimp_path_free (path_list);
@ -456,7 +443,6 @@ gimp_path_editor_set_path (GimpPathEditor *editor,
gchar * gchar *
gimp_path_editor_get_writable_path (GimpPathEditor *editor) gimp_path_editor_get_writable_path (GimpPathEditor *editor)
{ {
GimpPathEditorPrivate *priv;
GtkTreeModel *model; GtkTreeModel *model;
GString *path; GString *path;
GtkTreeIter iter; GtkTreeIter iter;
@ -464,9 +450,7 @@ gimp_path_editor_get_writable_path (GimpPathEditor *editor)
g_return_val_if_fail (GIMP_IS_PATH_EDITOR (editor), g_strdup ("")); g_return_val_if_fail (GIMP_IS_PATH_EDITOR (editor), g_strdup (""));
priv = GET_PRIVATE (editor); model = GTK_TREE_MODEL (editor->dir_list);
model = GTK_TREE_MODEL (priv->dir_list);
path = g_string_new (""); path = g_string_new ("");
@ -500,7 +484,6 @@ void
gimp_path_editor_set_writable_path (GimpPathEditor *editor, gimp_path_editor_set_writable_path (GimpPathEditor *editor,
const gchar *path) const gchar *path)
{ {
GimpPathEditorPrivate *priv;
GtkTreeModel *model; GtkTreeModel *model;
GtkTreeIter iter; GtkTreeIter iter;
gboolean iter_valid; gboolean iter_valid;
@ -509,13 +492,11 @@ gimp_path_editor_set_writable_path (GimpPathEditor *editor,
g_return_if_fail (GIMP_IS_PATH_EDITOR (editor)); g_return_if_fail (GIMP_IS_PATH_EDITOR (editor));
priv = GET_PRIVATE (editor); gtk_tree_view_column_set_visible (editor->writable_column, TRUE);
gtk_tree_view_column_set_visible (priv->writable_column, TRUE);
path_list = gimp_path_parse (path, 256, FALSE, NULL); path_list = gimp_path_parse (path, 256, FALSE, NULL);
model = GTK_TREE_MODEL (priv->dir_list); model = GTK_TREE_MODEL (editor->dir_list);
for (iter_valid = gtk_tree_model_get_iter_first (model, &iter); for (iter_valid = gtk_tree_model_get_iter_first (model, &iter);
iter_valid; iter_valid;
@ -537,7 +518,7 @@ gimp_path_editor_set_writable_path (GimpPathEditor *editor,
if (dir_writable != new_writable) if (dir_writable != new_writable)
{ {
gtk_list_store_set (priv->dir_list, &iter, gtk_list_store_set (editor->dir_list, &iter,
COLUMN_WRITABLE, new_writable, COLUMN_WRITABLE, new_writable,
-1); -1);
@ -555,7 +536,6 @@ gboolean
gimp_path_editor_get_dir_writable (GimpPathEditor *editor, gimp_path_editor_get_dir_writable (GimpPathEditor *editor,
const gchar *directory) const gchar *directory)
{ {
GimpPathEditorPrivate *priv;
GtkTreeModel *model; GtkTreeModel *model;
GtkTreeIter iter; GtkTreeIter iter;
gboolean iter_valid; gboolean iter_valid;
@ -563,9 +543,7 @@ gimp_path_editor_get_dir_writable (GimpPathEditor *editor,
g_return_val_if_fail (GIMP_IS_PATH_EDITOR (editor), FALSE); g_return_val_if_fail (GIMP_IS_PATH_EDITOR (editor), FALSE);
g_return_val_if_fail (directory != NULL, FALSE); g_return_val_if_fail (directory != NULL, FALSE);
priv = GET_PRIVATE (editor); model = GTK_TREE_MODEL (editor->dir_list);
model = GTK_TREE_MODEL (priv->dir_list);
for (iter_valid = gtk_tree_model_get_iter_first (model, &iter); for (iter_valid = gtk_tree_model_get_iter_first (model, &iter);
iter_valid; iter_valid;
@ -597,7 +575,6 @@ gimp_path_editor_set_dir_writable (GimpPathEditor *editor,
const gchar *directory, const gchar *directory,
gboolean writable) gboolean writable)
{ {
GimpPathEditorPrivate *priv;
GtkTreeModel *model; GtkTreeModel *model;
GtkTreeIter iter; GtkTreeIter iter;
gboolean iter_valid; gboolean iter_valid;
@ -605,9 +582,7 @@ gimp_path_editor_set_dir_writable (GimpPathEditor *editor,
g_return_if_fail (GIMP_IS_PATH_EDITOR (editor)); g_return_if_fail (GIMP_IS_PATH_EDITOR (editor));
g_return_if_fail (directory != NULL); g_return_if_fail (directory != NULL);
priv = GET_PRIVATE (editor); model = GTK_TREE_MODEL (editor->dir_list);
model = GTK_TREE_MODEL (priv->dir_list);
for (iter_valid = gtk_tree_model_get_iter_first (model, &iter); for (iter_valid = gtk_tree_model_get_iter_first (model, &iter);
iter_valid; iter_valid;
@ -623,7 +598,7 @@ gimp_path_editor_set_dir_writable (GimpPathEditor *editor,
if (! strcmp (dir, directory) && dir_writable != writable) if (! strcmp (dir, directory) && dir_writable != writable)
{ {
gtk_list_store_set (priv->dir_list, &iter, gtk_list_store_set (editor->dir_list, &iter,
COLUMN_WRITABLE, writable ? TRUE : FALSE, COLUMN_WRITABLE, writable ? TRUE : FALSE,
-1); -1);
@ -638,46 +613,43 @@ gimp_path_editor_set_dir_writable (GimpPathEditor *editor,
} }
/* private functions */ /* editorate functions */
static void static void
gimp_path_editor_new_clicked (GtkWidget *widget, gimp_path_editor_new_clicked (GtkWidget *widget,
GimpPathEditor *editor) GimpPathEditor *editor)
{ {
GimpPathEditorPrivate *priv = GET_PRIVATE (editor); if (editor->sel_path)
if (priv->sel_path)
{ {
g_signal_handlers_block_by_func (priv->sel, g_signal_handlers_block_by_func (editor->sel,
gimp_path_editor_selection_changed, gimp_path_editor_selection_changed,
editor); editor);
gtk_tree_selection_unselect_path (priv->sel, priv->sel_path); gtk_tree_selection_unselect_path (editor->sel, editor->sel_path);
g_signal_handlers_unblock_by_func (priv->sel, g_signal_handlers_unblock_by_func (editor->sel,
gimp_path_editor_selection_changed, gimp_path_editor_selection_changed,
editor); editor);
gtk_tree_path_free (priv->sel_path); gtk_tree_path_free (editor->sel_path);
priv->sel_path = NULL; editor->sel_path = NULL;
} }
gtk_widget_set_sensitive (priv->delete_button, FALSE); gtk_widget_set_sensitive (editor->delete_button, FALSE);
gtk_widget_set_sensitive (priv->up_button, FALSE); gtk_widget_set_sensitive (editor->up_button, FALSE);
gtk_widget_set_sensitive (priv->down_button, FALSE); gtk_widget_set_sensitive (editor->down_button, FALSE);
gtk_widget_set_sensitive (priv->file_entry, TRUE); gtk_widget_set_sensitive (editor->file_entry, TRUE);
gtk_editable_set_position gtk_editable_set_position
(GTK_EDITABLE (gimp_file_entry_get_entry (GIMP_FILE_ENTRY (priv->file_entry))), -1); (GTK_EDITABLE (gimp_file_entry_get_entry (GIMP_FILE_ENTRY (editor->file_entry))), -1);
gtk_widget_grab_focus gtk_widget_grab_focus
(gimp_file_entry_get_entry (GIMP_FILE_ENTRY (priv->file_entry))); (gimp_file_entry_get_entry (GIMP_FILE_ENTRY (editor->file_entry)));
} }
static void static void
gimp_path_editor_move_clicked (GtkWidget *widget, gimp_path_editor_move_clicked (GtkWidget *widget,
GimpPathEditor *editor) GimpPathEditor *editor)
{ {
GimpPathEditorPrivate *priv = GET_PRIVATE (editor);
GtkTreePath *path; GtkTreePath *path;
GtkTreeModel *model; GtkTreeModel *model;
GtkTreeIter iter1, iter2; GtkTreeIter iter1, iter2;
@ -685,19 +657,19 @@ gimp_path_editor_move_clicked (GtkWidget *widget,
gchar *dir1, *dir2; gchar *dir1, *dir2;
gboolean writable1, writable2; gboolean writable1, writable2;
if (priv->sel_path == NULL) if (editor->sel_path == NULL)
return; return;
path = gtk_tree_path_copy (priv->sel_path); path = gtk_tree_path_copy (editor->sel_path);
if (widget == priv->up_button) if (widget == editor->up_button)
gtk_tree_path_prev (path); gtk_tree_path_prev (path);
else else
gtk_tree_path_next (path); gtk_tree_path_next (path);
model = GTK_TREE_MODEL (priv->dir_list); model = GTK_TREE_MODEL (editor->dir_list);
gtk_tree_model_get_iter (model, &iter1, priv->sel_path); gtk_tree_model_get_iter (model, &iter1, editor->sel_path);
gtk_tree_model_get_iter (model, &iter2, path); gtk_tree_model_get_iter (model, &iter2, path);
gtk_tree_model_get (model, &iter1, gtk_tree_model_get (model, &iter1,
@ -711,12 +683,12 @@ gimp_path_editor_move_clicked (GtkWidget *widget,
COLUMN_WRITABLE, &writable2, COLUMN_WRITABLE, &writable2,
-1); -1);
gtk_list_store_set (priv->dir_list, &iter1, gtk_list_store_set (editor->dir_list, &iter1,
COLUMN_UTF8, utf82, COLUMN_UTF8, utf82,
COLUMN_DIRECTORY, dir2, COLUMN_DIRECTORY, dir2,
COLUMN_WRITABLE, writable2, COLUMN_WRITABLE, writable2,
-1); -1);
gtk_list_store_set (priv->dir_list, &iter2, gtk_list_store_set (editor->dir_list, &iter2,
COLUMN_UTF8, utf81, COLUMN_UTF8, utf81,
COLUMN_DIRECTORY, dir1, COLUMN_DIRECTORY, dir1,
COLUMN_WRITABLE, writable1, COLUMN_WRITABLE, writable1,
@ -728,7 +700,7 @@ gimp_path_editor_move_clicked (GtkWidget *widget,
g_free (dir2); g_free (dir2);
g_free (dir1); g_free (dir1);
gtk_tree_selection_select_iter (priv->sel, &iter2); gtk_tree_selection_select_iter (editor->sel, &iter2);
g_signal_emit (editor, gimp_path_editor_signals[PATH_CHANGED], 0); g_signal_emit (editor, gimp_path_editor_signals[PATH_CHANGED], 0);
} }
@ -737,53 +709,52 @@ static void
gimp_path_editor_delete_clicked (GtkWidget *widget, gimp_path_editor_delete_clicked (GtkWidget *widget,
GimpPathEditor *editor) GimpPathEditor *editor)
{ {
GimpPathEditorPrivate *priv = GET_PRIVATE (editor);
GtkTreeIter iter; GtkTreeIter iter;
gboolean dir_writable; gboolean dir_writable;
if (priv->sel_path == NULL) if (editor->sel_path == NULL)
return; return;
gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->dir_list), &iter, gtk_tree_model_get_iter (GTK_TREE_MODEL (editor->dir_list), &iter,
priv->sel_path); editor->sel_path);
gtk_tree_model_get (GTK_TREE_MODEL (priv->dir_list), &iter, gtk_tree_model_get (GTK_TREE_MODEL (editor->dir_list), &iter,
COLUMN_WRITABLE, &dir_writable, COLUMN_WRITABLE, &dir_writable,
-1); -1);
gtk_list_store_remove (priv->dir_list, &iter); gtk_list_store_remove (editor->dir_list, &iter);
priv->num_items--; editor->num_items--;
if (priv->num_items == 0) if (editor->num_items == 0)
{ {
gtk_tree_path_free (priv->sel_path); gtk_tree_path_free (editor->sel_path);
priv->sel_path = NULL; editor->sel_path = NULL;
g_signal_handlers_block_by_func (priv->file_entry, g_signal_handlers_block_by_func (editor->file_entry,
gimp_path_editor_file_entry_changed, gimp_path_editor_file_entry_changed,
editor); editor);
gimp_file_entry_set_filename (GIMP_FILE_ENTRY (priv->file_entry), ""); gimp_file_entry_set_filename (GIMP_FILE_ENTRY (editor->file_entry), "");
g_signal_handlers_unblock_by_func (priv->file_entry, g_signal_handlers_unblock_by_func (editor->file_entry,
gimp_path_editor_file_entry_changed, gimp_path_editor_file_entry_changed,
editor); editor);
gtk_widget_set_sensitive (priv->delete_button, FALSE); gtk_widget_set_sensitive (editor->delete_button, FALSE);
gtk_widget_set_sensitive (priv->up_button, FALSE); gtk_widget_set_sensitive (editor->up_button, FALSE);
gtk_widget_set_sensitive (priv->down_button, FALSE); gtk_widget_set_sensitive (editor->down_button, FALSE);
gtk_widget_set_sensitive (priv->file_entry, FALSE); gtk_widget_set_sensitive (editor->file_entry, FALSE);
} }
else else
{ {
gint *indices; gint *indices;
indices = gtk_tree_path_get_indices (priv->sel_path); indices = gtk_tree_path_get_indices (editor->sel_path);
if ((indices[0] == priv->num_items) && (indices[0] > 0)) if ((indices[0] == editor->num_items) && (indices[0] > 0))
gtk_tree_path_prev (priv->sel_path); gtk_tree_path_prev (editor->sel_path);
gtk_tree_selection_select_path (priv->sel, priv->sel_path); gtk_tree_selection_select_path (editor->sel, editor->sel_path);
} }
g_signal_emit (editor, gimp_path_editor_signals[PATH_CHANGED], 0); g_signal_emit (editor, gimp_path_editor_signals[PATH_CHANGED], 0);
@ -796,7 +767,6 @@ static void
gimp_path_editor_file_entry_changed (GtkWidget *widget, gimp_path_editor_file_entry_changed (GtkWidget *widget,
GimpPathEditor *editor) GimpPathEditor *editor)
{ {
GimpPathEditorPrivate *priv = GET_PRIVATE (editor);
gchar *dir; gchar *dir;
gchar *utf8; gchar *utf8;
GtkTreeIter iter; GtkTreeIter iter;
@ -810,23 +780,23 @@ gimp_path_editor_file_entry_changed (GtkWidget *widget,
utf8 = g_filename_display_name (dir); utf8 = g_filename_display_name (dir);
if (priv->sel_path == NULL) if (editor->sel_path == NULL)
{ {
gtk_list_store_append (priv->dir_list, &iter); gtk_list_store_append (editor->dir_list, &iter);
gtk_list_store_set (priv->dir_list, &iter, gtk_list_store_set (editor->dir_list, &iter,
COLUMN_UTF8, utf8, COLUMN_UTF8, utf8,
COLUMN_DIRECTORY, dir, COLUMN_DIRECTORY, dir,
COLUMN_WRITABLE, FALSE, COLUMN_WRITABLE, FALSE,
-1); -1);
priv->num_items++; editor->num_items++;
gtk_tree_selection_select_iter (priv->sel, &iter); gtk_tree_selection_select_iter (editor->sel, &iter);
} }
else else
{ {
gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->dir_list), &iter, gtk_tree_model_get_iter (GTK_TREE_MODEL (editor->dir_list), &iter,
priv->sel_path); editor->sel_path);
gtk_list_store_set (priv->dir_list, &iter, gtk_list_store_set (editor->dir_list, &iter,
COLUMN_UTF8, utf8, COLUMN_UTF8, utf8,
COLUMN_DIRECTORY, dir, COLUMN_DIRECTORY, dir,
-1); -1);
@ -842,43 +812,42 @@ static void
gimp_path_editor_selection_changed (GtkTreeSelection *sel, gimp_path_editor_selection_changed (GtkTreeSelection *sel,
GimpPathEditor *editor) GimpPathEditor *editor)
{ {
GimpPathEditorPrivate *priv = GET_PRIVATE (editor);
GtkTreeIter iter; GtkTreeIter iter;
gchar *directory; gchar *directory;
gint *indices; gint *indices;
if (gtk_tree_selection_get_selected (sel, NULL, &iter)) if (gtk_tree_selection_get_selected (sel, NULL, &iter))
{ {
gtk_tree_model_get (GTK_TREE_MODEL (priv->dir_list), &iter, gtk_tree_model_get (GTK_TREE_MODEL (editor->dir_list), &iter,
COLUMN_DIRECTORY, &directory, COLUMN_DIRECTORY, &directory,
-1); -1);
g_signal_handlers_block_by_func (priv->file_entry, g_signal_handlers_block_by_func (editor->file_entry,
gimp_path_editor_file_entry_changed, gimp_path_editor_file_entry_changed,
editor); editor);
gimp_file_entry_set_filename (GIMP_FILE_ENTRY (priv->file_entry), gimp_file_entry_set_filename (GIMP_FILE_ENTRY (editor->file_entry),
directory); directory);
g_signal_handlers_unblock_by_func (priv->file_entry, g_signal_handlers_unblock_by_func (editor->file_entry,
gimp_path_editor_file_entry_changed, gimp_path_editor_file_entry_changed,
editor); editor);
g_free (directory); g_free (directory);
if (priv->sel_path) if (editor->sel_path)
gtk_tree_path_free (priv->sel_path); gtk_tree_path_free (editor->sel_path);
priv->sel_path = editor->sel_path =
gtk_tree_model_get_path (GTK_TREE_MODEL (priv->dir_list), &iter); gtk_tree_model_get_path (GTK_TREE_MODEL (editor->dir_list), &iter);
indices = gtk_tree_path_get_indices (priv->sel_path); indices = gtk_tree_path_get_indices (editor->sel_path);
gtk_widget_set_sensitive (priv->delete_button, TRUE); gtk_widget_set_sensitive (editor->delete_button, TRUE);
gtk_widget_set_sensitive (priv->up_button, (indices[0] > 0)); gtk_widget_set_sensitive (editor->up_button, (indices[0] > 0));
gtk_widget_set_sensitive (priv->down_button, gtk_widget_set_sensitive (editor->down_button,
(indices[0] < (priv->num_items - 1))); (indices[0] < (editor->num_items - 1)));
gtk_widget_set_sensitive (priv->file_entry, TRUE); gtk_widget_set_sensitive (editor->file_entry, TRUE);
} }
else else
{ {
@ -886,7 +855,7 @@ gimp_path_editor_selection_changed (GtkTreeSelection *sel,
gimp_path_editor_selection_changed, gimp_path_editor_selection_changed,
editor); editor);
gtk_tree_selection_select_path (priv->sel, priv->sel_path); gtk_tree_selection_select_path (editor->sel, editor->sel_path);
g_signal_handlers_unblock_by_func (sel, g_signal_handlers_unblock_by_func (sel,
gimp_path_editor_selection_changed, gimp_path_editor_selection_changed,
@ -899,21 +868,20 @@ gimp_path_editor_writable_toggled (GtkCellRendererToggle *toggle,
gchar *path_str, gchar *path_str,
GimpPathEditor *editor) GimpPathEditor *editor)
{ {
GimpPathEditorPrivate *priv = GET_PRIVATE (editor);
GtkTreePath *path; GtkTreePath *path;
GtkTreeIter iter; GtkTreeIter iter;
path = gtk_tree_path_new_from_string (path_str); path = gtk_tree_path_new_from_string (path_str);
if (gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->dir_list), &iter, path)) if (gtk_tree_model_get_iter (GTK_TREE_MODEL (editor->dir_list), &iter, path))
{ {
gboolean dir_writable; gboolean dir_writable;
gtk_tree_model_get (GTK_TREE_MODEL (priv->dir_list), &iter, gtk_tree_model_get (GTK_TREE_MODEL (editor->dir_list), &iter,
COLUMN_WRITABLE, &dir_writable, COLUMN_WRITABLE, &dir_writable,
-1); -1);
gtk_list_store_set (priv->dir_list, &iter, gtk_list_store_set (editor->dir_list, &iter,
COLUMN_WRITABLE, ! dir_writable, COLUMN_WRITABLE, ! dir_writable,
-1); -1);

20
libgimpwidgets/gimppatheditor.h
View file

@ -32,25 +32,7 @@ G_BEGIN_DECLS
#define GIMP_TYPE_PATH_EDITOR (gimp_path_editor_get_type ()) #define GIMP_TYPE_PATH_EDITOR (gimp_path_editor_get_type ())
G_DECLARE_DERIVABLE_TYPE (GimpPathEditor, gimp_path_editor, GIMP, PATH_EDITOR, GtkBox) G_DECLARE_FINAL_TYPE (GimpPathEditor, gimp_path_editor, GIMP, PATH_EDITOR, GtkBox)
struct _GimpPathEditorClass
{
GtkBoxClass parent_class;
void (* path_changed) (GimpPathEditor *editor);
void (* writable_changed) (GimpPathEditor *editor);
/* 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);
};
/* For information look into the C source or the html documentation */ /* For information look into the C source or the html documentation */

357
libgimpwidgets/gimpsizeentry.c
View file

@ -103,8 +103,10 @@ typedef struct _GimpSizeEntryField
} GimpSizeEntryField; } GimpSizeEntryField;
typedef struct _GimpSizeEntryPrivate struct _GimpSizeEntry
{ {
GtkGrid parent_instance;
GSList *fields; GSList *fields;
gint number_of_fields; gint number_of_fields;
@ -115,7 +117,7 @@ typedef struct _GimpSizeEntryPrivate
gboolean show_refval; gboolean show_refval;
GimpSizeEntryUpdatePolicy update_policy; GimpSizeEntryUpdatePolicy update_policy;
} GimpSizeEntryPrivate; };
static void gimp_size_entry_finalize (GObject *object); static void gimp_size_entry_finalize (GObject *object);
@ -142,7 +144,7 @@ static gboolean gimp_size_entry_eevl_unit_resolver (const gchar *ident,
gpointer data); gpointer data);
G_DEFINE_TYPE_WITH_PRIVATE (GimpSizeEntry, gimp_size_entry, GTK_TYPE_GRID) G_DEFINE_TYPE (GimpSizeEntry, gimp_size_entry, GTK_TYPE_GRID)
#define parent_class gimp_size_entry_parent_class #define parent_class gimp_size_entry_parent_class
@ -158,7 +160,7 @@ gimp_size_entry_class_init (GimpSizeEntryClass *klass)
g_signal_new ("value-changed", g_signal_new ("value-changed",
G_TYPE_FROM_CLASS (klass), G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpSizeEntryClass, value_changed), 0,
NULL, NULL, NULL, NULL, NULL, NULL,
G_TYPE_NONE, 0); G_TYPE_NONE, 0);
@ -166,7 +168,7 @@ gimp_size_entry_class_init (GimpSizeEntryClass *klass)
g_signal_new ("refval-changed", g_signal_new ("refval-changed",
G_TYPE_FROM_CLASS (klass), G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpSizeEntryClass, refval_changed), 0,
NULL, NULL, NULL, NULL, NULL, NULL,
G_TYPE_NONE, 0); G_TYPE_NONE, 0);
@ -174,48 +176,37 @@ gimp_size_entry_class_init (GimpSizeEntryClass *klass)
g_signal_new ("unit-changed", g_signal_new ("unit-changed",
G_TYPE_FROM_CLASS (klass), G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpSizeEntryClass, unit_changed), 0,
NULL, NULL, NULL, NULL, NULL, NULL,
G_TYPE_NONE, 0); G_TYPE_NONE, 0);
object_class->finalize = gimp_size_entry_finalize; object_class->finalize = gimp_size_entry_finalize;
klass->value_changed = NULL;
klass->refval_changed = NULL;
klass->unit_changed = NULL;
} }
static void static void
gimp_size_entry_init (GimpSizeEntry *gse) gimp_size_entry_init (GimpSizeEntry *gse)
{ {
GimpSizeEntryPrivate *priv; gse->unit = gimp_unit_pixel ();
gse->menu_show_pixels = TRUE;
priv = gimp_size_entry_get_instance_private (gse); gse->menu_show_percent = TRUE;
gse->show_refval = FALSE;
priv->unit = gimp_unit_pixel (); gse->update_policy = GIMP_SIZE_ENTRY_UPDATE_NONE;
priv->menu_show_pixels = TRUE;
priv->menu_show_percent = TRUE;
priv->show_refval = FALSE;
priv->update_policy = GIMP_SIZE_ENTRY_UPDATE_NONE;
} }
static void static void
gimp_size_entry_finalize (GObject *object) gimp_size_entry_finalize (GObject *object)
{ {
GimpSizeEntry *gse = GIMP_SIZE_ENTRY (object); GimpSizeEntry *gse = GIMP_SIZE_ENTRY (object);
GimpSizeEntryPrivate *priv;
priv = gimp_size_entry_get_instance_private (gse); if (gse->fields)
if (priv->fields)
{ {
GSList *list; GSList *list;
for (list = priv->fields; list; list = list->next) for (list = gse->fields; list; list = list->next)
g_slice_free (GimpSizeEntryField, list->data); g_slice_free (GimpSizeEntryField, list->data);
g_slist_free (priv->fields); g_slist_free (gse->fields);
priv->fields = NULL; gse->fields = NULL;
} }
G_OBJECT_CLASS (parent_class)->finalize (object); G_OBJECT_CLASS (parent_class)->finalize (object);
@ -278,7 +269,6 @@ gimp_size_entry_new (gint number_of_fields,
GimpSizeEntryUpdatePolicy update_policy) GimpSizeEntryUpdatePolicy update_policy)
{ {
GimpSizeEntry *gse; GimpSizeEntry *gse;
GimpSizeEntryPrivate *priv;
GimpUnitStore *store; GimpUnitStore *store;
gint i; gint i;
@ -288,35 +278,33 @@ gimp_size_entry_new (gint number_of_fields,
gse = g_object_new (GIMP_TYPE_SIZE_ENTRY, NULL); gse = g_object_new (GIMP_TYPE_SIZE_ENTRY, NULL);
priv = gimp_size_entry_get_instance_private (gse); gse->number_of_fields = number_of_fields;
gse->unit = unit;
priv->number_of_fields = number_of_fields; gse->show_refval = show_refval;
priv->unit = unit; gse->update_policy = update_policy;
priv->show_refval = show_refval;
priv->update_policy = update_policy;
/* show the 'pixels' menu entry only if we are a 'size' sizeentry and /* show the 'pixels' menu entry only if we are a 'size' sizeentry and
* don't have the reference value spinbutton * don't have the reference value spinbutton
*/ */
if ((update_policy == GIMP_SIZE_ENTRY_UPDATE_RESOLUTION) || if ((update_policy == GIMP_SIZE_ENTRY_UPDATE_RESOLUTION) ||
(show_refval == TRUE)) (show_refval == TRUE))
priv->menu_show_pixels = FALSE; gse->menu_show_pixels = FALSE;
else else
priv->menu_show_pixels = menu_show_pixels; gse->menu_show_pixels = menu_show_pixels;
/* show the 'percent' menu entry only if we are a 'size' sizeentry /* show the 'percent' menu entry only if we are a 'size' sizeentry
*/ */
if (update_policy == GIMP_SIZE_ENTRY_UPDATE_RESOLUTION) if (update_policy == GIMP_SIZE_ENTRY_UPDATE_RESOLUTION)
priv->menu_show_percent = FALSE; gse->menu_show_percent = FALSE;
else else
priv->menu_show_percent = menu_show_percent; gse->menu_show_percent = menu_show_percent;
for (i = 0; i < number_of_fields; i++) for (i = 0; i < number_of_fields; i++)
{ {
GimpSizeEntryField *gsef = g_slice_new0 (GimpSizeEntryField); GimpSizeEntryField *gsef = g_slice_new0 (GimpSizeEntryField);
gint digits; gint digits;
priv->fields = g_slist_append (priv->fields, gsef); gse->fields = g_slist_append (gse->fields, gsef);
gsef->gse = gse; gsef->gse = gse;
gsef->resolution = 1.0; /* just to avoid division by zero */ gsef->resolution = 1.0; /* just to avoid division by zero */
@ -361,14 +349,14 @@ gimp_size_entry_new (gint number_of_fields,
} }
gtk_grid_attach (GTK_GRID (gse), gsef->value_spinbutton, gtk_grid_attach (GTK_GRID (gse), gsef->value_spinbutton,
i+1, priv->show_refval+1, 1, 1); i+1, gse->show_refval+1, 1, 1);
g_signal_connect (gsef->value_adjustment, "value-changed", g_signal_connect (gsef->value_adjustment, "value-changed",
G_CALLBACK (gimp_size_entry_value_callback), G_CALLBACK (gimp_size_entry_value_callback),
gsef); gsef);
gtk_widget_show (gsef->value_spinbutton); gtk_widget_show (gsef->value_spinbutton);
if (priv->show_refval) if (gse->show_refval)
{ {
gsef->refval_adjustment = gtk_adjustment_new (gsef->refval, gsef->refval_adjustment = gtk_adjustment_new (gsef->refval,
gsef->min_refval, gsef->min_refval,
@ -392,15 +380,15 @@ gimp_size_entry_new (gint number_of_fields,
gtk_widget_show (gsef->refval_spinbutton); gtk_widget_show (gsef->refval_spinbutton);
} }
if (priv->menu_show_pixels && (unit == gimp_unit_pixel ()) && if (gse->menu_show_pixels && (unit == gimp_unit_pixel ()) &&
! priv->show_refval) ! gse->show_refval)
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (gsef->value_spinbutton), gtk_spin_button_set_digits (GTK_SPIN_BUTTON (gsef->value_spinbutton),
gsef->refval_digits); gsef->refval_digits);
} }
store = gimp_unit_store_new (priv->number_of_fields); store = gimp_unit_store_new (gse->number_of_fields);
gimp_unit_store_set_has_pixels (store, priv->menu_show_pixels); gimp_unit_store_set_has_pixels (store, gse->menu_show_pixels);
gimp_unit_store_set_has_percent (store, priv->menu_show_percent); gimp_unit_store_set_has_percent (store, gse->menu_show_percent);
if (unit_format) if (unit_format)
{ {
@ -418,17 +406,17 @@ gimp_size_entry_new (gint number_of_fields,
g_free (short_format); g_free (short_format);
} }
priv->unit_combo = gimp_unit_combo_box_new_with_model (store); gse->unit_combo = gimp_unit_combo_box_new_with_model (store);
g_object_unref (store); g_object_unref (store);
gimp_unit_combo_box_set_active (GIMP_UNIT_COMBO_BOX (priv->unit_combo), unit); gimp_unit_combo_box_set_active (GIMP_UNIT_COMBO_BOX (gse->unit_combo), unit);
gtk_grid_attach (GTK_GRID (gse), priv->unit_combo, gtk_grid_attach (GTK_GRID (gse), gse->unit_combo,
i+2, priv->show_refval+1, 1, 1); i+2, gse->show_refval+1, 1, 1);
g_signal_connect (priv->unit_combo, "changed", g_signal_connect (gse->unit_combo, "changed",
G_CALLBACK (gimp_size_entry_unit_callback), G_CALLBACK (gimp_size_entry_unit_callback),
gse); gse);
gtk_widget_show (priv->unit_combo); gtk_widget_show (gse->unit_combo);
return GTK_WIDGET (gse); return GTK_WIDGET (gse);
} }
@ -452,24 +440,21 @@ gimp_size_entry_add_field (GimpSizeEntry *gse,
GtkSpinButton *value_spinbutton, GtkSpinButton *value_spinbutton,
GtkSpinButton *refval_spinbutton) GtkSpinButton *refval_spinbutton)
{ {
GimpSizeEntryPrivate *priv;
GimpSizeEntryField *gsef; GimpSizeEntryField *gsef;
gint digits; gint digits;
g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse)); g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse));
g_return_if_fail (GTK_IS_SPIN_BUTTON (value_spinbutton)); g_return_if_fail (GTK_IS_SPIN_BUTTON (value_spinbutton));
priv = gimp_size_entry_get_instance_private (gse); if (gse->show_refval)
if (priv->show_refval)
{ {
g_return_if_fail (GTK_IS_SPIN_BUTTON (refval_spinbutton)); g_return_if_fail (GTK_IS_SPIN_BUTTON (refval_spinbutton));
} }
gsef = g_slice_new0 (GimpSizeEntryField); gsef = g_slice_new0 (GimpSizeEntryField);
priv->fields = g_slist_prepend (priv->fields, gsef); gse->fields = g_slist_prepend (gse->fields, gsef);
priv->number_of_fields++; gse->number_of_fields++;
gsef->gse = gse; gsef->gse = gse;
gsef->resolution = 1.0; /* just to avoid division by zero */ gsef->resolution = 1.0; /* just to avoid division by zero */
@ -482,7 +467,7 @@ gimp_size_entry_add_field (GimpSizeEntry *gse,
gsef->min_refval = 0; gsef->min_refval = 0;
gsef->max_refval = SIZE_MAX_VALUE; gsef->max_refval = SIZE_MAX_VALUE;
gsef->refval_digits = gsef->refval_digits =
(priv->update_policy == GIMP_SIZE_ENTRY_UPDATE_SIZE) ? 0 : 3; (gse->update_policy == GIMP_SIZE_ENTRY_UPDATE_SIZE) ? 0 : 3;
gsef->stop_recursion = 0; gsef->stop_recursion = 0;
gsef->value_adjustment = gtk_spin_button_get_adjustment (value_spinbutton); gsef->value_adjustment = gtk_spin_button_get_adjustment (value_spinbutton);
@ -494,7 +479,7 @@ gimp_size_entry_add_field (GimpSizeEntry *gse,
gimp_size_entry_attach_eevl (GTK_SPIN_BUTTON (gsef->value_spinbutton), gimp_size_entry_attach_eevl (GTK_SPIN_BUTTON (gsef->value_spinbutton),
gsef); gsef);
if (priv->show_refval) if (gse->show_refval)
{ {
gsef->refval_adjustment = gtk_spin_button_get_adjustment (refval_spinbutton); gsef->refval_adjustment = gtk_spin_button_get_adjustment (refval_spinbutton);
gsef->refval_spinbutton = GTK_WIDGET (refval_spinbutton); gsef->refval_spinbutton = GTK_WIDGET (refval_spinbutton);
@ -503,15 +488,15 @@ gimp_size_entry_add_field (GimpSizeEntry *gse,
gsef); gsef);
} }
digits = ((priv->unit == gimp_unit_pixel ()) ? gsef->refval_digits : digits = ((gse->unit == gimp_unit_pixel ()) ? gsef->refval_digits :
(priv->unit == gimp_unit_percent ()) ? 2 : (gse->unit == gimp_unit_percent ()) ? 2 :
GIMP_SIZE_ENTRY_DIGITS (priv->unit)); GIMP_SIZE_ENTRY_DIGITS (gse->unit));
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (value_spinbutton), digits); gtk_spin_button_set_digits (GTK_SPIN_BUTTON (value_spinbutton), digits);
if (priv->menu_show_pixels && if (gse->menu_show_pixels &&
!priv->show_refval && !gse->show_refval &&
(priv->unit == gimp_unit_pixel ())) (gse->unit == gimp_unit_pixel ()))
{ {
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (gsef->value_spinbutton), gtk_spin_button_set_digits (GTK_SPIN_BUTTON (gsef->value_spinbutton),
gsef->refval_digits); gsef->refval_digits);
@ -521,25 +506,17 @@ gimp_size_entry_add_field (GimpSizeEntry *gse,
GimpSizeEntryUpdatePolicy GimpSizeEntryUpdatePolicy
gimp_size_entry_get_update_policy (GimpSizeEntry *gse) gimp_size_entry_get_update_policy (GimpSizeEntry *gse)
{ {
GimpSizeEntryPrivate *priv;
g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (gse), GIMP_SIZE_ENTRY_UPDATE_SIZE); g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (gse), GIMP_SIZE_ENTRY_UPDATE_SIZE);
priv = gimp_size_entry_get_instance_private (gse); return gse->update_policy;
return priv->update_policy;
} }
gint gint
gimp_size_entry_get_n_fields (GimpSizeEntry *gse) gimp_size_entry_get_n_fields (GimpSizeEntry *gse)
{ {
GimpSizeEntryPrivate *priv;
g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (gse), 0); g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (gse), 0);
priv = gimp_size_entry_get_instance_private (gse); return gse->number_of_fields;
return priv->number_of_fields;
} }
/** /**
@ -551,13 +528,9 @@ gimp_size_entry_get_n_fields (GimpSizeEntry *gse)
GtkWidget * GtkWidget *
gimp_size_entry_get_unit_combo (GimpSizeEntry *gse) gimp_size_entry_get_unit_combo (GimpSizeEntry *gse)
{ {
GimpSizeEntryPrivate *priv;
g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (gse), NULL); g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (gse), NULL);
priv = gimp_size_entry_get_instance_private (gse); return gse->unit_combo;
return priv->unit_combo;
} }
/** /**
@ -645,19 +618,16 @@ gimp_size_entry_set_resolution (GimpSizeEntry *gse,
gdouble resolution, gdouble resolution,
gboolean keep_size) gboolean keep_size)
{ {
GimpSizeEntryPrivate *priv;
GimpSizeEntryField *gsef; GimpSizeEntryField *gsef;
gfloat val; gfloat val;
g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse)); g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse));
priv = gimp_size_entry_get_instance_private (gse); g_return_if_fail ((field >= 0) && (field < gse->number_of_fields));
g_return_if_fail ((field >= 0) && (field < priv->number_of_fields));
resolution = CLAMP (resolution, GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION); resolution = CLAMP (resolution, GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION);
gsef = (GimpSizeEntryField*) g_slist_nth_data (priv->fields, field); gsef = (GimpSizeEntryField*) g_slist_nth_data (gse->fields, field);
gsef->resolution = resolution; gsef->resolution = resolution;
val = gsef->value; val = gsef->value;
@ -694,17 +664,14 @@ gimp_size_entry_set_size (GimpSizeEntry *gse,
gdouble lower, gdouble lower,
gdouble upper) gdouble upper)
{ {
GimpSizeEntryPrivate *priv;
GimpSizeEntryField *gsef; GimpSizeEntryField *gsef;
g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse)); g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse));
priv = gimp_size_entry_get_instance_private (gse); g_return_if_fail ((field >= 0) && (field < gse->number_of_fields));
g_return_if_fail ((field >= 0) && (field < priv->number_of_fields));
g_return_if_fail (lower <= upper); g_return_if_fail (lower <= upper);
gsef = (GimpSizeEntryField*) g_slist_nth_data (priv->fields, field); gsef = (GimpSizeEntryField*) g_slist_nth_data (gse->fields, field);
gsef->lower = lower; gsef->lower = lower;
gsef->upper = upper; gsef->upper = upper;
@ -737,17 +704,14 @@ gimp_size_entry_set_value_boundaries (GimpSizeEntry *gse,
gdouble lower, gdouble lower,
gdouble upper) gdouble upper)
{ {
GimpSizeEntryPrivate *priv;
GimpSizeEntryField *gsef; GimpSizeEntryField *gsef;
g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse)); g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse));
priv = gimp_size_entry_get_instance_private (gse); g_return_if_fail ((field >= 0) && (field < gse->number_of_fields));
g_return_if_fail ((field >= 0) && (field < priv->number_of_fields));
g_return_if_fail (lower <= upper); g_return_if_fail (lower <= upper);
gsef = (GimpSizeEntryField*) g_slist_nth_data (priv->fields, field); gsef = (GimpSizeEntryField*) g_slist_nth_data (gse->fields, field);
gsef->min_value = lower; gsef->min_value = lower;
gsef->max_value = upper; gsef->max_value = upper;
@ -763,17 +727,17 @@ gimp_size_entry_set_value_boundaries (GimpSizeEntry *gse,
} }
gsef->stop_recursion++; gsef->stop_recursion++;
switch (priv->update_policy) switch (gse->update_policy)
{ {
case GIMP_SIZE_ENTRY_UPDATE_NONE: case GIMP_SIZE_ENTRY_UPDATE_NONE:
break; break;
case GIMP_SIZE_ENTRY_UPDATE_SIZE: case GIMP_SIZE_ENTRY_UPDATE_SIZE:
if (priv->unit == gimp_unit_pixel ()) if (gse->unit == gimp_unit_pixel ())
gimp_size_entry_set_refval_boundaries (gse, field, gimp_size_entry_set_refval_boundaries (gse, field,
gsef->min_value, gsef->min_value,
gsef->max_value); gsef->max_value);
else if (priv->unit == gimp_unit_percent ()) else if (gse->unit == gimp_unit_percent ())
gimp_size_entry_set_refval_boundaries (gse, field, gimp_size_entry_set_refval_boundaries (gse, field,
gsef->lower + gsef->lower +
(gsef->upper - gsef->lower) * (gsef->upper - gsef->lower) *
@ -785,18 +749,18 @@ gimp_size_entry_set_value_boundaries (GimpSizeEntry *gse,
gimp_size_entry_set_refval_boundaries (gse, field, gimp_size_entry_set_refval_boundaries (gse, field,
gsef->min_value * gsef->min_value *
gsef->resolution / gsef->resolution /
gimp_unit_get_factor (priv->unit), gimp_unit_get_factor (gse->unit),
gsef->max_value * gsef->max_value *
gsef->resolution / gsef->resolution /
gimp_unit_get_factor (priv->unit)); gimp_unit_get_factor (gse->unit));
break; break;
case GIMP_SIZE_ENTRY_UPDATE_RESOLUTION: case GIMP_SIZE_ENTRY_UPDATE_RESOLUTION:
gimp_size_entry_set_refval_boundaries (gse, field, gimp_size_entry_set_refval_boundaries (gse, field,
gsef->min_value * gsef->min_value *
gimp_unit_get_factor (priv->unit), gimp_unit_get_factor (gse->unit),
gsef->max_value * gsef->max_value *
gimp_unit_get_factor (priv->unit)); gimp_unit_get_factor (gse->unit));
break; break;
default: default:
@ -830,16 +794,13 @@ gdouble
gimp_size_entry_get_value (GimpSizeEntry *gse, gimp_size_entry_get_value (GimpSizeEntry *gse,
gint field) gint field)
{ {
GimpSizeEntryPrivate *priv;
GimpSizeEntryField *gsef; GimpSizeEntryField *gsef;
g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (gse), 0); g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (gse), 0);
priv = gimp_size_entry_get_instance_private (gse); g_return_val_if_fail ((field >= 0) && (field < gse->number_of_fields), 0);
g_return_val_if_fail ((field >= 0) && (field < priv->number_of_fields), 0); gsef = (GimpSizeEntryField *) g_slist_nth_data (gse->fields, field);
gsef = (GimpSizeEntryField *) g_slist_nth_data (priv->fields, field);
return gsef->value; return gsef->value;
} }
@ -848,38 +809,36 @@ static void
gimp_size_entry_update_value (GimpSizeEntryField *gsef, gimp_size_entry_update_value (GimpSizeEntryField *gsef,
gdouble value) gdouble value)
{ {
GimpSizeEntryPrivate *priv = gimp_size_entry_get_instance_private (gsef->gse);
if (gsef->stop_recursion > 1) if (gsef->stop_recursion > 1)
return; return;
gsef->value = value; gsef->value = value;
switch (priv->update_policy) switch (gsef->gse->update_policy)
{ {
case GIMP_SIZE_ENTRY_UPDATE_NONE: case GIMP_SIZE_ENTRY_UPDATE_NONE:
break; break;
case GIMP_SIZE_ENTRY_UPDATE_SIZE: case GIMP_SIZE_ENTRY_UPDATE_SIZE:
if (priv->unit == gimp_unit_pixel ()) if (gsef->gse->unit == gimp_unit_pixel ())
gsef->refval = value; gsef->refval = value;
else if (priv->unit == gimp_unit_percent ()) else if (gsef->gse->unit == gimp_unit_percent ())
gsef->refval = CLAMP (gsef->lower + (gsef->upper - gsef->lower) * value / 100, gsef->refval = CLAMP (gsef->lower + (gsef->upper - gsef->lower) * value / 100,
gsef->min_refval, gsef->max_refval); gsef->min_refval, gsef->max_refval);
else else
gsef->refval = CLAMP (value * gsef->resolution / gsef->refval = CLAMP (value * gsef->resolution /
gimp_unit_get_factor (priv->unit), gimp_unit_get_factor (gsef->gse->unit),
gsef->min_refval, gsef->max_refval); gsef->min_refval, gsef->max_refval);
if (priv->show_refval) if (gsef->gse->show_refval)
gtk_adjustment_set_value (gsef->refval_adjustment, gsef->refval); gtk_adjustment_set_value (gsef->refval_adjustment, gsef->refval);
break; break;
case GIMP_SIZE_ENTRY_UPDATE_RESOLUTION: case GIMP_SIZE_ENTRY_UPDATE_RESOLUTION:
gsef->refval = gsef->refval =
CLAMP (value * gimp_unit_get_factor (priv->unit), CLAMP (value * gimp_unit_get_factor (gsef->gse->unit),
gsef->min_refval, gsef->max_refval); gsef->min_refval, gsef->max_refval);
if (priv->show_refval) if (gsef->gse->show_refval)
gtk_adjustment_set_value (gsef->refval_adjustment, gsef->refval); gtk_adjustment_set_value (gsef->refval_adjustment, gsef->refval);
break; break;
@ -911,16 +870,13 @@ gimp_size_entry_set_value (GimpSizeEntry *gse,
gint field, gint field,
gdouble value) gdouble value)
{ {
GimpSizeEntryPrivate *priv;
GimpSizeEntryField *gsef; GimpSizeEntryField *gsef;
g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse)); g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse));
priv = gimp_size_entry_get_instance_private (gse); g_return_if_fail ((field >= 0) && (field < gse->number_of_fields));
g_return_if_fail ((field >= 0) && (field < priv->number_of_fields)); gsef = (GimpSizeEntryField *) g_slist_nth_data (gse->fields, field);
gsef = (GimpSizeEntryField *) g_slist_nth_data (priv->fields, field);
value = CLAMP (value, gsef->min_value, gsef->max_value); value = CLAMP (value, gsef->min_value, gsef->max_value);
gtk_adjustment_set_value (gsef->value_adjustment, value); gtk_adjustment_set_value (gsef->value_adjustment, value);
@ -964,21 +920,18 @@ gimp_size_entry_set_refval_boundaries (GimpSizeEntry *gse,
gdouble lower, gdouble lower,
gdouble upper) gdouble upper)
{ {
GimpSizeEntryPrivate *priv;
GimpSizeEntryField *gsef; GimpSizeEntryField *gsef;
g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse)); g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse));
priv = gimp_size_entry_get_instance_private (gse); g_return_if_fail ((field >= 0) && (field < gse->number_of_fields));
g_return_if_fail ((field >= 0) && (field < priv->number_of_fields));
g_return_if_fail (lower <= upper); g_return_if_fail (lower <= upper);
gsef = (GimpSizeEntryField *) g_slist_nth_data (priv->fields, field); gsef = (GimpSizeEntryField *) g_slist_nth_data (gse->fields, field);
gsef->min_refval = lower; gsef->min_refval = lower;
gsef->max_refval = upper; gsef->max_refval = upper;
if (priv->show_refval) if (gse->show_refval)
{ {
g_object_freeze_notify (G_OBJECT (gsef->refval_adjustment)); g_object_freeze_notify (G_OBJECT (gsef->refval_adjustment));
@ -988,24 +941,24 @@ gimp_size_entry_set_refval_boundaries (GimpSizeEntry *gse,
if (gsef->stop_recursion) /* this is a hack (but useful ;-) */ if (gsef->stop_recursion) /* this is a hack (but useful ;-) */
{ {
if (priv->show_refval) if (gse->show_refval)
g_object_thaw_notify (G_OBJECT (gsef->refval_adjustment)); g_object_thaw_notify (G_OBJECT (gsef->refval_adjustment));
return; return;
} }
gsef->stop_recursion++; gsef->stop_recursion++;
switch (priv->update_policy) switch (gse->update_policy)
{ {
case GIMP_SIZE_ENTRY_UPDATE_NONE: case GIMP_SIZE_ENTRY_UPDATE_NONE:
break; break;
case GIMP_SIZE_ENTRY_UPDATE_SIZE: case GIMP_SIZE_ENTRY_UPDATE_SIZE:
if (priv->unit == gimp_unit_pixel ()) if (gse->unit == gimp_unit_pixel ())
gimp_size_entry_set_value_boundaries (gse, field, gimp_size_entry_set_value_boundaries (gse, field,
gsef->min_refval, gsef->min_refval,
gsef->max_refval); gsef->max_refval);
else if (priv->unit == gimp_unit_percent ()) else if (gse->unit == gimp_unit_percent ())
gimp_size_entry_set_value_boundaries (gse, field, gimp_size_entry_set_value_boundaries (gse, field,
100 * (gsef->min_refval - 100 * (gsef->min_refval -
gsef->lower) / gsef->lower) /
@ -1016,19 +969,19 @@ gimp_size_entry_set_refval_boundaries (GimpSizeEntry *gse,
else else
gimp_size_entry_set_value_boundaries (gse, field, gimp_size_entry_set_value_boundaries (gse, field,
gsef->min_refval * gsef->min_refval *
gimp_unit_get_factor (priv->unit) / gimp_unit_get_factor (gse->unit) /
gsef->resolution, gsef->resolution,
gsef->max_refval * gsef->max_refval *
gimp_unit_get_factor (priv->unit) / gimp_unit_get_factor (gse->unit) /
gsef->resolution); gsef->resolution);
break; break;
case GIMP_SIZE_ENTRY_UPDATE_RESOLUTION: case GIMP_SIZE_ENTRY_UPDATE_RESOLUTION:
gimp_size_entry_set_value_boundaries (gse, field, gimp_size_entry_set_value_boundaries (gse, field,
gsef->min_refval / gsef->min_refval /
gimp_unit_get_factor (priv->unit), gimp_unit_get_factor (gse->unit),
gsef->max_refval / gsef->max_refval /
gimp_unit_get_factor (priv->unit)); gimp_unit_get_factor (gse->unit));
break; break;
default: default:
@ -1038,7 +991,7 @@ gimp_size_entry_set_refval_boundaries (GimpSizeEntry *gse,
gimp_size_entry_set_refval (gse, field, gsef->refval); gimp_size_entry_set_refval (gse, field, gsef->refval);
if (priv->show_refval) if (gse->show_refval)
g_object_thaw_notify (G_OBJECT (gsef->refval_adjustment)); g_object_thaw_notify (G_OBJECT (gsef->refval_adjustment));
} }
@ -1061,25 +1014,22 @@ gimp_size_entry_set_refval_digits (GimpSizeEntry *gse,
gint field, gint field,
gint digits) gint digits)
{ {
GimpSizeEntryPrivate *priv;
GimpSizeEntryField *gsef; GimpSizeEntryField *gsef;
g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse)); g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse));
priv = gimp_size_entry_get_instance_private (gse); g_return_if_fail ((field >= 0) && (field < gse->number_of_fields));
g_return_if_fail ((field >= 0) && (field < priv->number_of_fields));
g_return_if_fail ((digits >= 0) && (digits <= 6)); g_return_if_fail ((digits >= 0) && (digits <= 6));
gsef = (GimpSizeEntryField*) g_slist_nth_data (priv->fields, field); gsef = (GimpSizeEntryField*) g_slist_nth_data (gse->fields, field);
gsef->refval_digits = digits; gsef->refval_digits = digits;
if (priv->update_policy == GIMP_SIZE_ENTRY_UPDATE_SIZE) if (gse->update_policy == GIMP_SIZE_ENTRY_UPDATE_SIZE)
{ {
if (priv->show_refval) if (gse->show_refval)
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (gsef->refval_spinbutton), gtk_spin_button_set_digits (GTK_SPIN_BUTTON (gsef->refval_spinbutton),
gsef->refval_digits); gsef->refval_digits);
else if (priv->unit == gimp_unit_pixel ()) else if (gse->unit == gimp_unit_pixel ())
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (gsef->value_spinbutton), gtk_spin_button_set_digits (GTK_SPIN_BUTTON (gsef->value_spinbutton),
gsef->refval_digits); gsef->refval_digits);
} }
@ -1102,17 +1052,14 @@ gdouble
gimp_size_entry_get_refval (GimpSizeEntry *gse, gimp_size_entry_get_refval (GimpSizeEntry *gse,
gint field) gint field)
{ {
GimpSizeEntryPrivate *priv;
GimpSizeEntryField *gsef; GimpSizeEntryField *gsef;
/* return 1.0 to avoid division by zero */ /* return 1.0 to avoid division by zero */
g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (gse), 1.0); g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (gse), 1.0);
priv = gimp_size_entry_get_instance_private (gse); g_return_val_if_fail ((field >= 0) && (field < gse->number_of_fields), 1.0);
g_return_val_if_fail ((field >= 0) && (field < priv->number_of_fields), 1.0); gsef = (GimpSizeEntryField*) g_slist_nth_data (gse->fields, field);
gsef = (GimpSizeEntryField*) g_slist_nth_data (priv->fields, field);
return gsef->refval; return gsef->refval;
} }
@ -1121,26 +1068,24 @@ static void
gimp_size_entry_update_refval (GimpSizeEntryField *gsef, gimp_size_entry_update_refval (GimpSizeEntryField *gsef,
gdouble refval) gdouble refval)
{ {
GimpSizeEntryPrivate *priv = gimp_size_entry_get_instance_private (gsef->gse);
if (gsef->stop_recursion > 1) if (gsef->stop_recursion > 1)
return; return;
gsef->refval = refval; gsef->refval = refval;
switch (priv->update_policy) switch (gsef->gse->update_policy)
{ {
case GIMP_SIZE_ENTRY_UPDATE_NONE: case GIMP_SIZE_ENTRY_UPDATE_NONE:
break; break;
case GIMP_SIZE_ENTRY_UPDATE_SIZE: case GIMP_SIZE_ENTRY_UPDATE_SIZE:
if (priv->unit == gimp_unit_pixel ()) if (gsef->gse->unit == gimp_unit_pixel ())
gsef->value = refval; gsef->value = refval;
else if (priv->unit == gimp_unit_percent ()) else if (gsef->gse->unit == gimp_unit_percent ())
gsef->value = CLAMP (100 * (refval - gsef->lower) / (gsef->upper - gsef->lower), gsef->value = CLAMP (100 * (refval - gsef->lower) / (gsef->upper - gsef->lower),
gsef->min_value, gsef->max_value); gsef->min_value, gsef->max_value);
else else
gsef->value = CLAMP (refval * gimp_unit_get_factor (priv->unit) / gsef->value = CLAMP (refval * gimp_unit_get_factor (gsef->gse->unit) /
gsef->resolution, gsef->resolution,
gsef->min_value, gsef->max_value); gsef->min_value, gsef->max_value);
@ -1149,7 +1094,7 @@ gimp_size_entry_update_refval (GimpSizeEntryField *gsef,
case GIMP_SIZE_ENTRY_UPDATE_RESOLUTION: case GIMP_SIZE_ENTRY_UPDATE_RESOLUTION:
gsef->value = gsef->value =
CLAMP (refval / gimp_unit_get_factor (priv->unit), CLAMP (refval / gimp_unit_get_factor (gsef->gse->unit),
gsef->min_value, gsef->max_value); gsef->min_value, gsef->max_value);
gtk_adjustment_set_value (gsef->value_adjustment, gsef->value); gtk_adjustment_set_value (gsef->value_adjustment, gsef->value);
break; break;
@ -1178,20 +1123,17 @@ gimp_size_entry_set_refval (GimpSizeEntry *gse,
gint field, gint field,
gdouble refval) gdouble refval)
{ {
GimpSizeEntryPrivate *priv;
GimpSizeEntryField *gsef; GimpSizeEntryField *gsef;
g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse)); g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse));
priv = gimp_size_entry_get_instance_private (gse); g_return_if_fail ((field >= 0) && (field < gse->number_of_fields));
g_return_if_fail ((field >= 0) && (field < priv->number_of_fields)); gsef = (GimpSizeEntryField *) g_slist_nth_data (gse->fields, field);
gsef = (GimpSizeEntryField *) g_slist_nth_data (priv->fields, field);
refval = CLAMP (refval, gsef->min_refval, gsef->max_refval); refval = CLAMP (refval, gsef->min_refval, gsef->max_refval);
if (priv->show_refval) if (gse->show_refval)
gtk_adjustment_set_value (gsef->refval_adjustment, refval); gtk_adjustment_set_value (gsef->refval_adjustment, refval);
gimp_size_entry_update_refval (gsef, refval); gimp_size_entry_update_refval (gsef, refval);
@ -1225,34 +1167,29 @@ gimp_size_entry_refval_callback (GtkAdjustment *adjustment,
GimpUnit * GimpUnit *
gimp_size_entry_get_unit (GimpSizeEntry *gse) gimp_size_entry_get_unit (GimpSizeEntry *gse)
{ {
GimpSizeEntryPrivate *priv;
g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (gse), gimp_unit_inch ()); g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (gse), gimp_unit_inch ());
priv = gimp_size_entry_get_instance_private (gse); return gse->unit;
return priv->unit;
} }
static void static void
gimp_size_entry_update_unit (GimpSizeEntry *gse, gimp_size_entry_update_unit (GimpSizeEntry *gse,
GimpUnit *unit) GimpUnit *unit)
{ {
GimpSizeEntryPrivate *priv = gimp_size_entry_get_instance_private (gse);
GimpSizeEntryField *gsef; GimpSizeEntryField *gsef;
gint i; gint i;
gint digits; gint digits;
priv->unit = unit; gse->unit = unit;
digits = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (gse), digits = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (gse),
"gimp-pixel-digits")); "gimp-pixel-digits"));
for (i = 0; i < priv->number_of_fields; i++) for (i = 0; i < gse->number_of_fields; i++)
{ {
gsef = (GimpSizeEntryField *) g_slist_nth_data (priv->fields, i); gsef = (GimpSizeEntryField *) g_slist_nth_data (gse->fields, i);
if (priv->update_policy == GIMP_SIZE_ENTRY_UPDATE_SIZE) if (gse->update_policy == GIMP_SIZE_ENTRY_UPDATE_SIZE)
{ {
if (unit == gimp_unit_pixel ()) if (unit == gimp_unit_pixel ())
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (gsef->value_spinbutton), gtk_spin_button_set_digits (GTK_SPIN_BUTTON (gsef->value_spinbutton),
@ -1264,7 +1201,7 @@ gimp_size_entry_update_unit (GimpSizeEntry *gse,
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (gsef->value_spinbutton), gtk_spin_button_set_digits (GTK_SPIN_BUTTON (gsef->value_spinbutton),
GIMP_SIZE_ENTRY_DIGITS (unit) + digits); GIMP_SIZE_ENTRY_DIGITS (unit) + digits);
} }
else if (priv->update_policy == GIMP_SIZE_ENTRY_UPDATE_RESOLUTION) else if (gse->update_policy == GIMP_SIZE_ENTRY_UPDATE_RESOLUTION)
{ {
digits = (gimp_unit_get_digits (gimp_unit_inch ()) - gimp_unit_get_digits (unit)); digits = (gimp_unit_get_digits (gimp_unit_inch ()) - gimp_unit_get_digits (unit));
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (gsef->value_spinbutton), gtk_spin_button_set_digits (GTK_SPIN_BUTTON (gsef->value_spinbutton),
@ -1296,16 +1233,12 @@ void
gimp_size_entry_set_unit (GimpSizeEntry *gse, gimp_size_entry_set_unit (GimpSizeEntry *gse,
GimpUnit *unit) GimpUnit *unit)
{ {
GimpSizeEntryPrivate *priv;
g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse)); g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse));
priv = gimp_size_entry_get_instance_private (gse); g_return_if_fail (gse->menu_show_pixels || (unit != gimp_unit_pixel ()));
g_return_if_fail (gse->menu_show_percent || (unit != gimp_unit_percent ()));
g_return_if_fail (priv->menu_show_pixels || (unit != gimp_unit_pixel ())); gimp_unit_combo_box_set_active (GIMP_UNIT_COMBO_BOX (gse->unit_combo), unit);
g_return_if_fail (priv->menu_show_percent || (unit != gimp_unit_percent ()));
gimp_unit_combo_box_set_active (GIMP_UNIT_COMBO_BOX (priv->unit_combo), unit);
gimp_size_entry_update_unit (gse, unit); gimp_size_entry_update_unit (gse, unit);
} }
@ -1313,14 +1246,11 @@ static void
gimp_size_entry_unit_callback (GtkWidget *widget, gimp_size_entry_unit_callback (GtkWidget *widget,
GimpSizeEntry *gse) GimpSizeEntry *gse)
{ {
GimpSizeEntryPrivate *priv;
GimpUnit *new_unit; GimpUnit *new_unit;
new_unit = gimp_unit_combo_box_get_active (GIMP_UNIT_COMBO_BOX (widget)); new_unit = gimp_unit_combo_box_get_active (GIMP_UNIT_COMBO_BOX (widget));
priv = gimp_size_entry_get_instance_private (gse); if (gse->unit != new_unit)
if (priv->unit != new_unit)
gimp_size_entry_update_unit (gse, new_unit); gimp_size_entry_update_unit (gse, new_unit);
} }
@ -1350,7 +1280,6 @@ gimp_size_entry_eevl_input_callback (GtkSpinButton *spinner,
gpointer *data) gpointer *data)
{ {
GimpSizeEntryField *gsef = (GimpSizeEntryField *) data; GimpSizeEntryField *gsef = (GimpSizeEntryField *) data;
GimpSizeEntryPrivate *priv;
GimpEevlOptions options = GIMP_EEVL_OPTIONS_INIT; GimpEevlOptions options = GIMP_EEVL_OPTIONS_INIT;
gboolean success = FALSE; gboolean success = FALSE;
const gchar *error_pos = NULL; const gchar *error_pos = NULL;
@ -1360,13 +1289,11 @@ gimp_size_entry_eevl_input_callback (GtkSpinButton *spinner,
g_return_val_if_fail (GTK_IS_SPIN_BUTTON (spinner), FALSE); g_return_val_if_fail (GTK_IS_SPIN_BUTTON (spinner), FALSE);
g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (gsef->gse), FALSE); g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (gsef->gse), FALSE);
priv = gimp_size_entry_get_instance_private (gsef->gse);
options.unit_resolver_proc = gimp_size_entry_eevl_unit_resolver; options.unit_resolver_proc = gimp_size_entry_eevl_unit_resolver;
options.data = data; options.data = data;
/* enable ratio expressions when there are two fields */ /* enable ratio expressions when there are two fields */
if (priv->number_of_fields == 2) if (gsef->gse->number_of_fields == 2)
{ {
GimpSizeEntryField *other_gsef; GimpSizeEntryField *other_gsef;
GimpEevlQuantity default_unit_factor; GimpEevlQuantity default_unit_factor;
@ -1374,15 +1301,15 @@ gimp_size_entry_eevl_input_callback (GtkSpinButton *spinner,
options.ratio_expressions = TRUE; options.ratio_expressions = TRUE;
if (gsef == priv->fields->data) if (gsef == gsef->gse->fields->data)
{ {
other_gsef = priv->fields->next->data; other_gsef = gsef->gse->fields->next->data;
options.ratio_invert = FALSE; options.ratio_invert = FALSE;
} }
else else
{ {
other_gsef = priv->fields->data; other_gsef = gsef->gse->fields->data;
options.ratio_invert = TRUE; options.ratio_invert = TRUE;
} }
@ -1418,14 +1345,14 @@ gimp_size_entry_eevl_input_callback (GtkSpinButton *spinner,
gtk_widget_error_bell (GTK_WIDGET (spinner)); gtk_widget_error_bell (GTK_WIDGET (spinner));
return GTK_INPUT_ERROR; return GTK_INPUT_ERROR;
} }
else if (result.dimension != 1 && priv->unit != gimp_unit_percent ()) else if (result.dimension != 1 && gsef->gse->unit != gimp_unit_percent ())
{ {
g_printerr ("ERROR: result has wrong dimension (expected 1, got %d)\n", result.dimension); g_printerr ("ERROR: result has wrong dimension (expected 1, got %d)\n", result.dimension);
gtk_widget_error_bell (GTK_WIDGET (spinner)); gtk_widget_error_bell (GTK_WIDGET (spinner));
return GTK_INPUT_ERROR; return GTK_INPUT_ERROR;
} }
else if (result.dimension != 0 && priv->unit == gimp_unit_percent ()) else if (result.dimension != 0 && gsef->gse->unit == gimp_unit_percent ())
{ {
g_printerr ("ERROR: result has wrong dimension (expected 0, got %d)\n", result.dimension); g_printerr ("ERROR: result has wrong dimension (expected 0, got %d)\n", result.dimension);
@ -1439,19 +1366,19 @@ gimp_size_entry_eevl_input_callback (GtkSpinButton *spinner,
GtkAdjustment *adj; GtkAdjustment *adj;
gdouble val; gdouble val;
if (priv->unit == gimp_unit_pixel ()) if (gsef->gse->unit == gimp_unit_pixel ())
{ {
ui_unit.value = gsef->resolution; ui_unit.value = gsef->resolution;
ui_unit.dimension = 1; ui_unit.dimension = 1;
} }
else if (priv->unit == gimp_unit_percent ()) else if (gsef->gse->unit == gimp_unit_percent ())
{ {
ui_unit.value = 1.0; ui_unit.value = 1.0;
ui_unit.dimension = 0; ui_unit.dimension = 0;
} }
else else
{ {
ui_unit.value = gimp_unit_get_factor(priv->unit); ui_unit.value = gimp_unit_get_factor(gsef->gse->unit);
ui_unit.dimension = 1; ui_unit.dimension = 1;
} }
@ -1484,7 +1411,6 @@ gimp_size_entry_eevl_unit_resolver (const gchar *identifier,
gpointer data) gpointer data)
{ {
GimpSizeEntryField *gsef = (GimpSizeEntryField *) data; GimpSizeEntryField *gsef = (GimpSizeEntryField *) data;
GimpSizeEntryPrivate *priv;
gboolean resolve_default_unit = (identifier == NULL); gboolean resolve_default_unit = (identifier == NULL);
GimpUnit *unit = gimp_unit_pixel (); GimpUnit *unit = gimp_unit_pixel ();
gint i = 1; gint i = 1;
@ -1494,20 +1420,18 @@ gimp_size_entry_eevl_unit_resolver (const gchar *identifier,
g_return_val_if_fail (offset != NULL, FALSE); g_return_val_if_fail (offset != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (gsef->gse), FALSE); g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (gsef->gse), FALSE);
priv = gimp_size_entry_get_instance_private (gsef->gse);
*offset = 0.0; *offset = 0.0;
while (unit != NULL) while (unit != NULL)
{ {
if ((resolve_default_unit && unit == priv->unit) || if ((resolve_default_unit && unit == gsef->gse->unit) ||
(identifier && (identifier &&
(strcmp (gimp_unit_get_symbol (unit), identifier) == 0 || (strcmp (gimp_unit_get_symbol (unit), identifier) == 0 ||
strcmp (gimp_unit_get_abbreviation (unit), identifier) == 0))) strcmp (gimp_unit_get_abbreviation (unit), identifier) == 0)))
{ {
if (unit == gimp_unit_percent ()) if (unit == gimp_unit_percent ())
{ {
if (priv->unit == gimp_unit_percent ()) if (gsef->gse->unit == gimp_unit_percent ())
{ {
factor->value = 1; factor->value = 1;
factor->dimension = 0; factor->dimension = 0;
@ -1532,7 +1456,7 @@ gimp_size_entry_eevl_unit_resolver (const gchar *identifier,
factor->value = gimp_unit_get_factor (unit); factor->value = gimp_unit_get_factor (unit);
} }
if (priv->unit == gimp_unit_percent ()) if (gsef->gse->unit == gimp_unit_percent ())
{ {
/* map non-percentages onto percent */ /* map non-percentages onto percent */
factor->value = gsef->upper/(100*gsef->resolution); factor->value = gsef->upper/(100*gsef->resolution);
@ -1574,13 +1498,9 @@ void
gimp_size_entry_show_unit_menu (GimpSizeEntry *gse, gimp_size_entry_show_unit_menu (GimpSizeEntry *gse,
gboolean show) gboolean show)
{ {
GimpSizeEntryPrivate *priv;
g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse)); g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse));
priv = gimp_size_entry_get_instance_private (gse); gtk_widget_set_visible (gse->unit_combo, show);
gtk_widget_set_visible (priv->unit_combo, show);
} }
@ -1596,13 +1516,11 @@ void
gimp_size_entry_set_pixel_digits (GimpSizeEntry *gse, gimp_size_entry_set_pixel_digits (GimpSizeEntry *gse,
gint digits) gint digits)
{ {
GimpSizeEntryPrivate *priv;
GimpUnitComboBox *combo; GimpUnitComboBox *combo;
g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse)); g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse));
priv = gimp_size_entry_get_instance_private (gse); combo = GIMP_UNIT_COMBO_BOX (gse->unit_combo);
combo = GIMP_UNIT_COMBO_BOX (priv->unit_combo);
g_object_set_data (G_OBJECT (gse), "gimp-pixel-digits", g_object_set_data (G_OBJECT (gse), "gimp-pixel-digits",
GINT_TO_POINTER (digits)); GINT_TO_POINTER (digits));
@ -1620,16 +1538,13 @@ gimp_size_entry_set_pixel_digits (GimpSizeEntry *gse,
void void
gimp_size_entry_grab_focus (GimpSizeEntry *gse) gimp_size_entry_grab_focus (GimpSizeEntry *gse)
{ {
GimpSizeEntryPrivate *priv;
GimpSizeEntryField *gsef; GimpSizeEntryField *gsef;
g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse)); g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse));
priv = gimp_size_entry_get_instance_private (gse); gsef = gse->fields->data;
gsef = priv->fields->data;
if (gsef) if (gsef)
gtk_widget_grab_focus (priv->show_refval ? gtk_widget_grab_focus (gse->show_refval ?
gsef->refval_spinbutton : gsef->value_spinbutton); gsef->refval_spinbutton : gsef->value_spinbutton);
} }
@ -1647,14 +1562,11 @@ void
gimp_size_entry_set_activates_default (GimpSizeEntry *gse, gimp_size_entry_set_activates_default (GimpSizeEntry *gse,
gboolean setting) gboolean setting)
{ {
GimpSizeEntryPrivate *priv;
GSList *list; GSList *list;
g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse)); g_return_if_fail (GIMP_IS_SIZE_ENTRY (gse));
priv = gimp_size_entry_get_instance_private (gse); for (list = gse->fields; list; list = g_slist_next (list))
for (list = priv->fields; list; list = g_slist_next (list))
{ {
GimpSizeEntryField *gsef = list->data; GimpSizeEntryField *gsef = list->data;
@ -1683,16 +1595,13 @@ GtkWidget *
gimp_size_entry_get_help_widget (GimpSizeEntry *gse, gimp_size_entry_get_help_widget (GimpSizeEntry *gse,
gint field) gint field)
{ {
GimpSizeEntryPrivate *priv;
GimpSizeEntryField *gsef; GimpSizeEntryField *gsef;
g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (gse), NULL); g_return_val_if_fail (GIMP_IS_SIZE_ENTRY (gse), NULL);
priv = gimp_size_entry_get_instance_private (gse); g_return_val_if_fail ((field >= 0) && (field < gse->number_of_fields), NULL);
g_return_val_if_fail ((field >= 0) && (field < priv->number_of_fields), NULL); gsef = g_slist_nth_data (gse->fields, field);
gsef = g_slist_nth_data (priv->fields, field);
if (!gsef) if (!gsef)
return NULL; return NULL;

21
libgimpwidgets/gimpsizeentry.h
View file

@ -33,26 +33,7 @@ G_BEGIN_DECLS
#define GIMP_TYPE_SIZE_ENTRY (gimp_size_entry_get_type ()) #define GIMP_TYPE_SIZE_ENTRY (gimp_size_entry_get_type ())
G_DECLARE_DERIVABLE_TYPE (GimpSizeEntry, gimp_size_entry, GIMP, SIZE_ENTRY, GtkGrid) G_DECLARE_FINAL_TYPE (GimpSizeEntry, gimp_size_entry, GIMP, SIZE_ENTRY, GtkGrid)
struct _GimpSizeEntryClass
{
GtkGridClass parent_class;
void (* value_changed) (GimpSizeEntry *gse);
void (* refval_changed) (GimpSizeEntry *gse);
void (* unit_changed) (GimpSizeEntry *gse);
/* 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);
};
/* For information look into the C source or the html documentation */ /* For information look into the C source or the html documentation */