[gimp/soc-2011-gimpunitentry: 62/68] GimpUnitEntry: first part of refactoring following code review
- From: Michael Natterer <mitch src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gimp/soc-2011-gimpunitentry: 62/68] GimpUnitEntry: first part of refactoring following code review
- Date: Fri, 13 Sep 2013 19:59:11 +0000 (UTC)
commit 42070d449c8febec0c170b1cd5fb85406b15bc1e
Author: Enrico Schröder <enni schroeder gmail com>
Date: Wed Aug 10 13:04:36 2011 +0200
GimpUnitEntry: first part of refactoring following code review
.gitignore | 3 -
app/dialogs/layer-options-dialog.c | 8 +-
app/dialogs/offset-dialog.c | 17 +-
app/dialogs/preferences-dialog.c | 129 ++++++++--------
app/dialogs/resize-dialog.c | 40 +++---
app/dialogs/resolution-calibrate-dialog.c | 21 +--
app/dialogs/resolution-calibrate-dialog.h | 4 +-
app/tools/gimprotatetool.c | 7 +-
app/tools/gimprotatetool.h | 2 +-
app/widgets/gimpgrideditor.c | 8 +-
app/widgets/gimptemplateeditor.c | 41 ++---
libgimpwidgets/.gitignore | 2 +
libgimpwidgets/Makefile.am | 5 +-
libgimpwidgets/gimppropwidgets.c | 6 +-
libgimpwidgets/gimpunitadjustment.c | 217 ++++++++++++++------------
libgimpwidgets/gimpunitadjustment.h | 55 +++----
libgimpwidgets/gimpunitentries.c | 194 +++++++++++++-----------
libgimpwidgets/gimpunitentries.h | 17 +--
libgimpwidgets/gimpunitentry.c | 238 ++++++++++++++++++----------
libgimpwidgets/gimpunitentry.h | 21 +--
libgimpwidgets/gimpunitparser.c | 43 +++---
libgimpwidgets/gimpunitparser.h | 2 +-
libgimpwidgets/gimpwidgets.def | 5 +-
libgimpwidgets/test-unitentrygui.c | 12 +-
24 files changed, 575 insertions(+), 522 deletions(-)
---
diff --git a/.gitignore b/.gitignore
index 002ed9c..f6c77ce 100644
--- a/.gitignore
+++ b/.gitignore
@@ -46,6 +46,3 @@
/stamp-h
/stamp-h.in
/stamp-h1
-
-/libgimpwidgets/test-unitentry
-/libgimpwidgets/test-unitentrygui
\ No newline at end of file
diff --git a/app/dialogs/layer-options-dialog.c b/app/dialogs/layer-options-dialog.c
index 22e9f30..652342b 100644
--- a/app/dialogs/layer-options-dialog.c
+++ b/app/dialogs/layer-options-dialog.c
@@ -137,12 +137,12 @@ layer_options_dialog_new (GimpImage *image,
gimp_image_get_resolution (image, &xres, &yres);
- /* UnitEntry */
+ /* the size unit-entries */
options->unit_entries = GIMP_UNIT_ENTRIES (gimp_unit_entries_new ());
- width_entry = gimp_unit_entries_add_entry_defaults (options->unit_entries, "width", _("Width:"));
- height_entry = gimp_unit_entries_add_entry_defaults (options->unit_entries, "height", _("Height:"));
+ width_entry = gimp_unit_entries_add_entry (options->unit_entries, "width", _("Width:"));
+ height_entry = gimp_unit_entries_add_entry (options->unit_entries, "height", _("Height:"));
- gimp_unit_entry_set_unit (GIMP_UNIT_ENTRY (width_entry), GIMP_UNIT_PIXEL);
+ gimp_unit_entries_set_unit (options->unit_entries, GIMP_UNIT_PIXEL);
gimp_unit_entry_set_resolution (GIMP_UNIT_ENTRY (width_entry), xres);
gimp_unit_entry_set_resolution (GIMP_UNIT_ENTRY (height_entry), yres);
diff --git a/app/dialogs/offset-dialog.c b/app/dialogs/offset-dialog.c
index 44f4c28..c2df0b6 100644
--- a/app/dialogs/offset-dialog.c
+++ b/app/dialogs/offset-dialog.c
@@ -49,14 +49,14 @@
typedef struct
{
- GimpContext *context;
+ GimpContext *context;
- GtkWidget *dialog;
- GObject *offset_entries;
+ GtkWidget *dialog;
+ GimpUnitEntries *offset_entries;
- GimpOffsetType fill_type;
+ GimpOffsetType fill_type;
- GimpImage *image;
+ GimpImage *image;
} OffsetDialog;
@@ -160,11 +160,10 @@ offset_dialog_new (GimpDrawable *drawable,
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
- dialog->offset_entries = gimp_unit_entries_new ();
- entries = GIMP_UNIT_ENTRIES (dialog->offset_entries);
+ dialog->offset_entries = entries = gimp_unit_entries_new ();
- gimp_unit_entries_add_entry_defaults (entries, GIMP_UNIT_ENTRIES_OFFSET_X, _("X:"));
- gimp_unit_entries_add_entry_defaults (entries, GIMP_UNIT_ENTRIES_OFFSET_Y, _("X:"));
+ gimp_unit_entries_add_entry (entries, GIMP_UNIT_ENTRIES_OFFSET_X, _("X:"));
+ gimp_unit_entries_add_entry (entries, GIMP_UNIT_ENTRIES_OFFSET_Y, _("X:"));
gtk_box_pack_start (GTK_BOX (vbox), gimp_unit_entries_get_table (entries), FALSE, FALSE, 0);
diff --git a/app/dialogs/preferences-dialog.c b/app/dialogs/preferences-dialog.c
index 18563ca..c965976 100644
--- a/app/dialogs/preferences-dialog.c
+++ b/app/dialogs/preferences-dialog.c
@@ -75,48 +75,48 @@
/* preferences local functions */
-static GtkWidget * prefs_dialog_new (Gimp *gimp,
- GimpConfig *config);
-static void prefs_config_notify (GObject *config,
- GParamSpec *param_spec,
- GObject *config_copy);
-static void prefs_config_copy_notify (GObject *config_copy,
- GParamSpec *param_spec,
- GObject *config);
-static void prefs_response (GtkWidget *widget,
- gint response_id,
- GtkWidget *dialog);
-
-static void prefs_message (GtkMessageType type,
- gboolean destroy,
- const gchar *message);
-
-static void prefs_resolution_source_callback (GtkWidget *widget,
- GObject *config);
-static void prefs_resolution_calibrate_callback (GtkWidget *widget,
- GObject *entries);
-static void prefs_input_devices_dialog (GtkWidget *widget,
- Gimp *gimp);
-static void prefs_keyboard_shortcuts_dialog (GtkWidget *widget,
- Gimp *gimp);
-static void prefs_menus_save_callback (GtkWidget *widget,
- Gimp *gimp);
-static void prefs_menus_clear_callback (GtkWidget *widget,
- Gimp *gimp);
-static void prefs_menus_remove_callback (GtkWidget *widget,
- Gimp *gimp);
-static void prefs_session_save_callback (GtkWidget *widget,
- Gimp *gimp);
-static void prefs_session_clear_callback (GtkWidget *widget,
- Gimp *gimp);
-static void prefs_devices_save_callback (GtkWidget *widget,
- Gimp *gimp);
-static void prefs_devices_clear_callback (GtkWidget *widget,
- Gimp *gimp);
-static void prefs_tool_options_save_callback (GtkWidget *widget,
- Gimp *gimp);
-static void prefs_tool_options_clear_callback (GtkWidget *widget,
- Gimp *gimp);
+static GtkWidget * prefs_dialog_new (Gimp *gimp,
+ GimpConfig *config);
+static void prefs_config_notify (GObject *config,
+ GParamSpec *param_spec,
+ GObject *config_copy);
+static void prefs_config_copy_notify (GObject *config_copy,
+ GParamSpec *param_spec,
+ GObject *config);
+static void prefs_response (GtkWidget *widget,
+ gint response_id,
+ GtkWidget *dialog);
+
+static void prefs_message (GtkMessageType type,
+ gboolean destroy,
+ const gchar *message);
+
+static void prefs_resolution_source_callback (GtkWidget *widget,
+ GObject *config);
+static void prefs_resolution_calibrate_callback (GtkWidget *widget,
+ GimpUnitEntries *entries);
+static void prefs_input_devices_dialog (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_keyboard_shortcuts_dialog (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_menus_save_callback (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_menus_clear_callback (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_menus_remove_callback (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_session_save_callback (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_session_clear_callback (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_devices_save_callback (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_devices_clear_callback (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_tool_options_save_callback (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_tool_options_clear_callback (GtkWidget *widget,
+ Gimp *gimp);
/* private variables */
@@ -451,18 +451,13 @@ prefs_resolution_source_callback (GtkWidget *widget,
}
else
{
- GimpUnitEntries *entries = GIMP_UNIT_ENTRIES (
- g_object_get_data (G_OBJECT (widget),
- "monitor_resolution_sizeentry"));
+ GimpUnitEntries *entries = g_object_get_data (G_OBJECT (widget),
+ "monitor_resolution_sizeentry");
g_return_if_fail (GIMP_IS_UNIT_ENTRIES (entries));
- xres = gimp_unit_entry_get_value_in_unit (
- gimp_unit_entries_get_nth_entry (entries, 0),
- GIMP_UNIT_PIXEL);
- yres = gimp_unit_entry_get_value_in_unit (
- gimp_unit_entries_get_nth_entry (entries, 1),
- GIMP_UNIT_PIXEL);
+ xres = gimp_unit_entries_get_pixels (entries, "monitor-xresolution");
+ yres = gimp_unit_entries_get_pixels (entries, "monitor-yresolution");
}
g_object_set (config,
@@ -473,15 +468,14 @@ prefs_resolution_source_callback (GtkWidget *widget,
}
static void
-prefs_resolution_calibrate_callback (GtkWidget *widget,
- GObject *unit_entries)
+prefs_resolution_calibrate_callback (GtkWidget *widget,
+ GimpUnitEntries *unit_entries)
{
GtkWidget *dialog;
GtkWidget *prefs_box;
GtkWidget *image;
- dialog = gtk_widget_get_toplevel (gimp_unit_entries_get_table (
- GIMP_UNIT_ENTRIES (unit_entries)));
+ dialog = gtk_widget_get_toplevel (gimp_unit_entries_get_table (unit_entries));
prefs_box = g_object_get_data (G_OBJECT (dialog), "prefs-box");
image = gimp_prefs_box_get_image (GIMP_PREFS_BOX (prefs_box));
@@ -1296,7 +1290,7 @@ prefs_dialog_new (Gimp *gimp,
GSList *group;
GtkWidget *editor;
gint i;
- GimpUnitEntries *unit_entries;
+ GimpUnitEntries *unit_entries;
GObject *object;
GimpCoreConfig *core_config;
@@ -2177,8 +2171,8 @@ prefs_dialog_new (Gimp *gimp,
"monitor-yresolution",
_("Horizontal"),
_("Vertical"),
- NULL,
- 1.0, 1.0, /* FIXME: UnitEntry needs 1.0 as "resolution of resolution"
, otherwise calculation is not correct */
+ NULL, /* unit_property_name */
+ -1.0, -1.0,
TRUE));
gimp_unit_entries_set_mode (unit_entries, GIMP_UNIT_ENTRY_MODE_RESOLUTION);
@@ -2186,9 +2180,10 @@ prefs_dialog_new (Gimp *gimp,
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- gtk_box_pack_start (GTK_BOX (hbox), unit_entries->table, TRUE, TRUE, 24);
- gtk_widget_show (unit_entries->table);
- gtk_widget_set_sensitive (unit_entries->table, ! display_config->monitor_res_from_gdk);
+ gtk_box_pack_start (GTK_BOX (hbox), gimp_unit_entries_get_table (unit_entries), TRUE, TRUE, 24);
+ gtk_widget_show (gimp_unit_entries_get_table (unit_entries));
+ gtk_widget_set_sensitive (gimp_unit_entries_get_table (unit_entries),
+ ! display_config->monitor_res_from_gdk);
group = NULL;
@@ -2239,11 +2234,15 @@ prefs_dialog_new (Gimp *gimp,
gtk_widget_set_sensitive (calibrate_button,
! display_config->monitor_res_from_gdk);
- g_object_bind_property (button, "active",
- unit_entries->table, "sensitive",
+ g_object_bind_property (button,
+ "active",
+ gimp_unit_entries_get_table (unit_entries),
+ "sensitive",
G_BINDING_SYNC_CREATE);
- g_object_bind_property (button, "active",
- calibrate_button, "sensitive",
+ g_object_bind_property (button,
+ "active",
+ calibrate_button,
+ "sensitive",
G_BINDING_SYNC_CREATE);
g_signal_connect (calibrate_button, "clicked",
diff --git a/app/dialogs/resize-dialog.c b/app/dialogs/resize-dialog.c
index 3710753..6270af8 100644
--- a/app/dialogs/resize-dialog.c
+++ b/app/dialogs/resize-dialog.c
@@ -91,21 +91,19 @@ resize_dialog_new (GimpViewable *viewable,
GimpResizeCallback callback,
gpointer user_data)
{
- GtkWidget *dialog;
- GtkWidget *main_vbox;
- GtkWidget *vbox;
- GtkWidget *abox;
- GtkWidget *frame;
- GtkWidget *button;
- GtkWidget *spinbutton;
- GimpUnitEntries *unit_entries;
- GtkObject *adjustment;
- GdkPixbuf *pixbuf;
- ResizeDialog *private;
- GimpImage *image = NULL;
- const gchar *text = NULL;
- gint width, height;
- gdouble xres, yres;
+ GtkWidget *dialog;
+ GtkWidget *main_vbox;
+ GtkWidget *vbox;
+ GtkWidget *abox;
+ GtkWidget *frame;
+ GtkWidget *button;
+ GimpUnitEntries *unit_entries;
+ GdkPixbuf *pixbuf;
+ ResizeDialog *private;
+ GimpImage *image = NULL;
+ const gchar *text = NULL;
+ gint width, height;
+ gdouble xres, yres;
g_return_val_if_fail (GIMP_IS_VIEWABLE (viewable), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
@@ -208,12 +206,12 @@ resize_dialog_new (GimpViewable *viewable,
/* the offset unit-entries */
private->offset_unit_entries = unit_entries = GIMP_UNIT_ENTRIES (gimp_unit_entries_new ());
- gimp_unit_entries_add_entry_defaults (unit_entries,
- GIMP_UNIT_ENTRIES_OFFSET_X,
- _("X"));
- gimp_unit_entries_add_entry_defaults (unit_entries,
- GIMP_UNIT_ENTRIES_OFFSET_Y,
- _("Y"));
+ gimp_unit_entries_add_entry (unit_entries,
+ GIMP_UNIT_ENTRIES_OFFSET_X,
+ _("X"));
+ gimp_unit_entries_add_entry (unit_entries,
+ GIMP_UNIT_ENTRIES_OFFSET_Y,
+ _("Y"));
gtk_box_pack_start (GTK_BOX (vbox), gimp_unit_entries_get_table (unit_entries), FALSE, FALSE, 0);
diff --git a/app/dialogs/resolution-calibrate-dialog.c b/app/dialogs/resolution-calibrate-dialog.c
index 94e0268..99538cb 100644
--- a/app/dialogs/resolution-calibrate-dialog.c
+++ b/app/dialogs/resolution-calibrate-dialog.c
@@ -45,8 +45,8 @@ static gint ruler_height = 1;
* is connected to a #GimpSizeEntry handling the resolution to be set.
**/
void
-resolution_calibrate_dialog (GObject *unit_entries,
- GdkPixbuf *pixbuf)
+resolution_calibrate_dialog (GimpUnitEntries *resolution_entries,
+ GdkPixbuf *pixbuf)
{
GtkWidget *dialog;
GtkWidget *table;
@@ -57,18 +57,15 @@ resolution_calibrate_dialog (GObject *unit_entries,
GdkScreen *screen;
GdkRectangle rect;
gint monitor;
- GimpUnitEntries *resolution_entries;
GimpUnitEntry *horizontal_entry, *vertical_entry;
- g_return_if_fail (GIMP_IS_UNIT_ENTRIES (unit_entries));
+ g_return_if_fail (GIMP_IS_UNIT_ENTRIES (resolution_entries));
g_return_if_fail (pixbuf == NULL || GDK_IS_PIXBUF (pixbuf));
/* this dialog can only exist once */
if (calibrate_entries)
return;
- resolution_entries = GIMP_UNIT_ENTRIES (unit_entries);
-
dialog = gimp_dialog_new (_("Calibrate Monitor Resolution"),
"gimp-resolution-calibration",
gtk_widget_get_toplevel (gimp_unit_entries_get_table (resolution_entries)),
@@ -143,18 +140,18 @@ resolution_calibrate_dialog (GObject *unit_entries,
gtk_widget_show (hbox);
calibrate_xres =
- gimp_unit_entries_get_nth_pixels (resolution_entries, 0);
+ gimp_unit_entries_get_pixels (resolution_entries, "monitor-xresolution");
calibrate_yres =
- gimp_unit_entries_get_nth_pixels (resolution_entries, 1);
+ gimp_unit_entries_get_pixels (resolution_entries, "monitor-yresolution");
calibrate_entries =
GIMP_UNIT_ENTRIES (gimp_unit_entries_new ());
gimp_unit_entries_set_bounds (calibrate_entries, GIMP_UNIT_PIXEL, GIMP_MAX_IMAGE_SIZE, 1);
horizontal_entry =
- GIMP_UNIT_ENTRY (gimp_unit_entries_add_entry_defaults (calibrate_entries, "horizontal",
_("Horizontal")));
+ GIMP_UNIT_ENTRY (gimp_unit_entries_add_entry (calibrate_entries, "horizontal", _("Horizontal")));
vertical_entry =
- GIMP_UNIT_ENTRY (gimp_unit_entries_add_entry_defaults (calibrate_entries, "vertical", _("Vertical")));
+ GIMP_UNIT_ENTRY (gimp_unit_entries_add_entry (calibrate_entries, "vertical", _("Vertical")));
gimp_unit_entry_set_resolution (horizontal_entry, calibrate_xres);
gimp_unit_entry_set_resolution (vertical_entry, calibrate_yres);
gimp_unit_entry_set_pixels (horizontal_entry, ruler_width);
@@ -187,8 +184,8 @@ resolution_calibrate_dialog (GObject *unit_entries,
gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chain_button),
FALSE);
- gimp_unit_entries_set_nth_pixels (resolution_entries, 0, calibrate_xres);
- gimp_unit_entries_set_nth_pixels (resolution_entries, 1, calibrate_yres);
+ gimp_unit_entries_set_pixels (resolution_entries, "monitor-xresolution", calibrate_xres);
+ gimp_unit_entries_set_pixels (resolution_entries, "monitor-xresolution", calibrate_yres);
}
default:
diff --git a/app/dialogs/resolution-calibrate-dialog.h b/app/dialogs/resolution-calibrate-dialog.h
index 7c9a721..5c183aa 100644
--- a/app/dialogs/resolution-calibrate-dialog.h
+++ b/app/dialogs/resolution-calibrate-dialog.h
@@ -19,8 +19,8 @@
#define __RESOLUTION_CALIBRATE_DIALOG_H__
-void resolution_calibrate_dialog (GObject *resolution_entries,
- GdkPixbuf *pixbuf);
+void resolution_calibrate_dialog (GimpUnitEntries *resolution_entries,
+ GdkPixbuf *pixbuf);
#endif /* __RESOLUTION_CALIBRATE_DIALOG_H__ */
diff --git a/app/tools/gimprotatetool.c b/app/tools/gimprotatetool.c
index eaeda83..be97e56 100644
--- a/app/tools/gimprotatetool.c
+++ b/app/tools/gimprotatetool.c
@@ -203,10 +203,9 @@ gimp_rotate_tool_dialog (GimpTransformTool *tr_tool)
GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 0);
gtk_widget_show (scale);
- rotate->unit_entries = gimp_unit_entries_new ();
- entries = GIMP_UNIT_ENTRIES (rotate->unit_entries);
- gimp_unit_entries_add_entry_defaults (entries, "center_x", _("Center X:"));
- gimp_unit_entries_add_entry_defaults (entries, "center_y", _("Center Y:"));
+ rotate->unit_entries = entries = gimp_unit_entries_new ();
+ gimp_unit_entries_add_entry (entries, "center_x", _("Center X:"));
+ gimp_unit_entries_add_entry (entries, "center_y", _("Center Y:"));
gimp_table_attach_aligned (GTK_TABLE (table), 0, 3, NULL,
0.0, 0.5, gimp_unit_entries_get_table (entries), 1, TRUE);
diff --git a/app/tools/gimprotatetool.h b/app/tools/gimprotatetool.h
index 779b1dc..d3011c5 100644
--- a/app/tools/gimprotatetool.h
+++ b/app/tools/gimprotatetool.h
@@ -39,7 +39,7 @@ struct _GimpRotateTool
GtkAdjustment *angle_adj;
GtkWidget *angle_spin_button;
- GObject *unit_entries;
+ GimpUnitEntries *unit_entries;
};
struct _GimpRotateToolClass
diff --git a/app/widgets/gimpgrideditor.c b/app/widgets/gimpgrideditor.c
index ca49127..8ab7ada 100644
--- a/app/widgets/gimpgrideditor.c
+++ b/app/widgets/gimpgrideditor.c
@@ -189,8 +189,8 @@ gimp_grid_editor_constructed (GObject *object)
editor->yresolution,
TRUE));
- gtk_box_pack_start (GTK_BOX (hbox), entries->table, TRUE, TRUE, 0);
- gtk_widget_show (entries->table);
+ gtk_box_pack_start (GTK_BOX (hbox), gimp_unit_entries_get_table (entries), TRUE, TRUE, 0);
+ gtk_widget_show (gimp_unit_entries_get_table (entries));
gtk_widget_show (hbox);
@@ -212,8 +212,8 @@ gimp_grid_editor_constructed (GObject *object)
editor->yresolution,
TRUE));
- gtk_box_pack_start (GTK_BOX (hbox), entries->table, TRUE, TRUE, 0);
- gtk_widget_show (entries->table);
+ gtk_box_pack_start (GTK_BOX (hbox), gimp_unit_entries_get_table (entries), TRUE, TRUE, 0);
+ gtk_widget_show (gimp_unit_entries_get_table (entries));
gtk_widget_show (hbox);
}
diff --git a/app/widgets/gimptemplateeditor.c b/app/widgets/gimptemplateeditor.c
index a42203c..27077dc 100644
--- a/app/widgets/gimptemplateeditor.c
+++ b/app/widgets/gimptemplateeditor.c
@@ -144,7 +144,6 @@ gimp_template_editor_constructed (GObject *object)
GtkWidget *scrolled_window;
GtkWidget *text_view;
GtkTextBuffer *text_buffer;
- GList *focus_chain = NULL;
gchar *text;
G_OBJECT_CLASS (parent_class)->constructed (object);
@@ -181,17 +180,17 @@ gimp_template_editor_constructed (GObject *object)
private->unit_entries = GIMP_UNIT_ENTRIES (gimp_unit_entries_new ());
- gtk_table_attach_defaults (GTK_TABLE (table), private->unit_entries->table, 0, 2, 0, 2);
+ gtk_table_attach_defaults (GTK_TABLE (table), gimp_unit_entries_get_table (private->unit_entries), 0, 2,
0, 2);
- gimp_unit_entries_add_entry_defaults (private->unit_entries,
- "width",
+ gimp_unit_entries_add_entry (private->unit_entries,
+ GIMP_UNIT_ENTRIES_WIDTH,
_("Width:"));
- gimp_unit_entries_add_entry_defaults (private->unit_entries,
- "height",
+ gimp_unit_entries_add_entry (private->unit_entries,
+ GIMP_UNIT_ENTRIES_HEIGHT,
_("Height:"));
gimp_prop_coordinates_connect (G_OBJECT (template),
- "width", "height", "unit",
+ GIMP_UNIT_ENTRIES_WIDTH, GIMP_UNIT_ENTRIES_HEIGHT, "unit",
G_OBJECT (private->unit_entries), NULL,
gimp_template_get_resolution_x (template),
gimp_template_get_resolution_y (template));
@@ -284,16 +283,16 @@ gimp_template_editor_constructed (GObject *object)
private->resolution_entries = GIMP_UNIT_ENTRIES (gimp_unit_entries_new ());
- gimp_unit_entries_add_entry_defaults (private->resolution_entries,
+ gimp_unit_entries_add_entry (private->resolution_entries,
"xres",
_("X resolution:"));
- gimp_unit_entries_add_entry_defaults (private->resolution_entries,
+ gimp_unit_entries_add_entry (private->resolution_entries,
"yres",
_("Y resolution:"));
gimp_unit_entries_set_mode (private->resolution_entries, GIMP_UNIT_ENTRY_MODE_RESOLUTION);
- gtk_box_pack_start (GTK_BOX (hbox), private->resolution_entries->table, TRUE, TRUE, 0);
- gtk_widget_show (private->resolution_entries->table);
+ gtk_box_pack_start (GTK_BOX (hbox), gimp_unit_entries_get_table (private->resolution_entries), TRUE, TRUE,
0);
+ gtk_widget_show (gimp_unit_entries_get_table (private->resolution_entries));
gimp_unit_entry_set_resolution (gimp_unit_entries_get_nth_entry (private->unit_entries, 0),
gimp_template_get_resolution_x (template));
@@ -310,16 +309,6 @@ gimp_template_editor_constructed (GObject *object)
G_OBJECT (private->resolution_entries), chainbutton,
1.0, 1.0);
- /*focus_chain = g_list_prepend (focus_chain,
- GIMP_SIZE_ENTRY (private->resolution_entries)->unitmenu);
- focus_chain = g_list_prepend (focus_chain, chainbutton);
- focus_chain = g_list_prepend (focus_chain, yres);
- focus_chain = g_list_prepend (focus_chain, xres);
-
- gtk_container_set_focus_chain (GTK_CONTAINER (private->resolution_entries),
- focus_chain);*/
- g_list_free (focus_chain);
-
combo = gimp_prop_enum_combo_box_new (G_OBJECT (template),
"image-type",
GIMP_RGB, GIMP_GRAY);
@@ -544,14 +533,16 @@ gimp_template_editor_aspect_callback (GtkWidget *widget,
gimp_template_editor_template_notify,
editor);
- gimp_unit_entry_set_resolution (gimp_unit_entries_get_nth_entry (private->unit_entries, 0),
+ gimp_unit_entry_set_resolution (gimp_unit_entries_get_entry (private->unit_entries,
+ GIMP_UNIT_ENTRIES_WIDTH),
yresolution);
- gimp_unit_entry_set_resolution (gimp_unit_entries_get_nth_entry (private->unit_entries, 1),
+ gimp_unit_entry_set_resolution (gimp_unit_entries_get_entry (private->unit_entries,
+ GIMP_UNIT_ENTRIES_WIDTH),
xresolution);
g_object_set (template,
- "width", height,
- "height", width,
+ GIMP_UNIT_ENTRIES_WIDTH, height,
+ GIMP_UNIT_ENTRIES_HEIGHT, width,
"xresolution", yresolution,
"yresolution", xresolution,
NULL);
diff --git a/libgimpwidgets/.gitignore b/libgimpwidgets/.gitignore
index 12291fa..13b7620 100644
--- a/libgimpwidgets/.gitignore
+++ b/libgimpwidgets/.gitignore
@@ -11,3 +11,5 @@
/makefile.mingw
/test-eevl*
/test-preview-area
+/test-unitentry
+/test-unitentrygui
diff --git a/libgimpwidgets/Makefile.am b/libgimpwidgets/Makefile.am
index 9b4a141..33e1482 100644
--- a/libgimpwidgets/Makefile.am
+++ b/libgimpwidgets/Makefile.am
@@ -165,10 +165,10 @@ libgimpwidgets_sources = \
gimpstock.h \
gimpstringcombobox.c \
gimpstringcombobox.h \
- gimpunitcombobox.c \
- gimpunitcombobox.h \
gimpunitadjustment.c \
gimpunitadjustment.h \
+ gimpunitcombobox.c \
+ gimpunitcombobox.h \
gimpunitentry.c \
gimpunitentry.h \
gimpunitentries.c \
@@ -255,6 +255,7 @@ libgimpwidgetsinclude_HEADERS = \
gimpstock.h \
gimpstringcombobox.h \
gimpunitcombobox.h \
+ gimpunitadjustment.h \
gimpunitentry.h \
gimpunitmenu.h \
gimpunitstore.h \
diff --git a/libgimpwidgets/gimppropwidgets.c b/libgimpwidgets/gimppropwidgets.c
index d6c9b8e..518aff5 100644
--- a/libgimpwidgets/gimppropwidgets.c
+++ b/libgimpwidgets/gimppropwidgets.c
@@ -2874,8 +2874,8 @@ gimp_prop_coordinates_new (GObject *config,
unit_entries = GIMP_UNIT_ENTRIES (gimp_unit_entries_new ());
- gimp_unit_entries_add_entry_defaults (unit_entries, x_property_name, x_label_str);
- gimp_unit_entries_add_entry_defaults (unit_entries, y_property_name, y_label_str);
+ gimp_unit_entries_add_entry (unit_entries, x_property_name, x_label_str);
+ gimp_unit_entries_add_entry (unit_entries, y_property_name, y_label_str);
if (has_chainbutton)
{
@@ -2893,7 +2893,7 @@ gimp_prop_coordinates_new (GObject *config,
xresolution,
yresolution))
{
- gtk_widget_destroy (unit_entries->table);
+ gtk_widget_destroy (gimp_unit_entries_get_table (unit_entries));
return NULL;
}
diff --git a/libgimpwidgets/gimpunitadjustment.c b/libgimpwidgets/gimpunitadjustment.c
index 7fe1ab3..8b95d4b 100644
--- a/libgimpwidgets/gimpunitadjustment.c
+++ b/libgimpwidgets/gimpunitadjustment.c
@@ -43,7 +43,6 @@
#define DEFAULT_UNIT GIMP_UNIT_INCH
#define DEFAULT_RESOLUTION 72.0
#define DEFAULT_UPPER GIMP_MAX_IMAGE_SIZE
-#define UNIT_ADJUSTMENT_STRING_LENGTH 15
enum
{
@@ -52,29 +51,48 @@ enum
LAST_SIGNAL
};
+typedef struct
+{
+ GimpUnit unit; /* the unit our value is in */
+ gdouble resolution; /* resolution in dpi */
+} GimpUnitAdjustmentPrivate;
+
+#define GIMP_UNIT_ADJUSTMENT_GET_PRIVATE(obj) \
+ ((GimpUnitAdjustmentPrivate *) ((GimpUnitAdjustment *) (obj))->private)
+
G_DEFINE_TYPE (GimpUnitAdjustment, gimp_unit_adjustment, GTK_TYPE_ADJUSTMENT);
-static void gimp_unit_adjustment_convert_unit (GimpUnitAdjustment *adj, GimpUnit unit);
-static void gimp_unit_adjustment_changed_handler (GimpUnitAdjustment *adj, gpointer userData);
+static void gimp_unit_adjustment_convert_to_unit (GimpUnitAdjustment *adj, GimpUnit unit);
+static void gimp_unit_adjustment_other_unit_changed_handler (GimpUnitAdjustment *adj, gpointer userData);
static guint unit_adjustment_signals[LAST_SIGNAL] = {0};
static void
gimp_unit_adjustment_init (GimpUnitAdjustment *unit_adjustment)
{
+ GimpUnitAdjustmentPrivate *private;
+
+ unit_adjustment->private = G_TYPE_INSTANCE_GET_PRIVATE (unit_adjustment,
+ GIMP_TYPE_UNIT_ADJUSTMENT,
+ GimpUnitAdjustmentPrivate);
+
+ private = GIMP_UNIT_ADJUSTMENT_GET_PRIVATE (unit_adjustment);
+
/* set default values */
gtk_adjustment_set_upper (&unit_adjustment->parent_instance, DEFAULT_UPPER);
gtk_adjustment_set_step_increment (&unit_adjustment->parent_instance, 1.0);
gtk_adjustment_set_page_increment (&unit_adjustment->parent_instance, 10.0);
/* default unit, resolution */
- unit_adjustment->unit = DEFAULT_UNIT;
- unit_adjustment->resolution = DEFAULT_RESOLUTION;
+ private->unit = DEFAULT_UNIT;
+ private->resolution = DEFAULT_RESOLUTION;
}
static void
gimp_unit_adjustment_class_init (GimpUnitAdjustmentClass *klass)
{
+ g_type_class_add_private (klass, sizeof (GimpUnitAdjustmentPrivate));
+
unit_adjustment_signals [UNIT_CHANGED] =
g_signal_new ("unit-changed",
GIMP_TYPE_UNIT_ADJUSTMENT,
@@ -98,76 +116,80 @@ gimp_unit_adjustment_class_init (GimpUnitAdjustmentClass *klass)
0);
}
-GObject *
+GimpUnitAdjustment *
gimp_unit_adjustment_new (void)
{
- return g_object_new (GIMP_TYPE_UNIT_ADJUSTMENT, NULL);
+ return GIMP_UNIT_ADJUSTMENT (g_object_new (GIMP_TYPE_UNIT_ADJUSTMENT, NULL));
}
static void
-gimp_unit_adjustment_changed_handler (GimpUnitAdjustment *adj,
- gpointer user_data)
+gimp_unit_adjustment_other_unit_changed_handler (GimpUnitAdjustment *adj,
+ gpointer user_data)
{
- GimpUnitAdjustment *adjustment = GIMP_UNIT_ADJUSTMENT (user_data);
- GimpUnit unit = gimp_unit_adjustment_get_unit (adj);
+ GimpUnitAdjustment *other_adj = GIMP_UNIT_ADJUSTMENT (user_data);
+ GimpUnit unit = gimp_unit_adjustment_get_unit (other_adj);
- gimp_unit_adjustment_convert_unit (adjustment, unit);
+ gimp_unit_adjustment_convert_to_unit (adj, unit);
}
/* connects adjustment to another adjustment */
void
-gimp_unit_adjustment_connect (GimpUnitAdjustment *adj,
- GimpUnitAdjustment *target)
+gimp_unit_adjustment_follow_unit_of (GimpUnitAdjustment *adj,
+ GimpUnitAdjustment *other)
{
- g_signal_connect (target,
- "unit-changed",
- G_CALLBACK (gimp_unit_adjustment_changed_handler),
- (gpointer*) adj);
+ g_signal_connect_swapped (other,
+ "unit-changed",
+ G_CALLBACK (gimp_unit_adjustment_other_unit_changed_handler),
+ (gpointer*) adj);
}
/* converts value from one unit to another */
static void
-gimp_unit_adjustment_convert_unit (GimpUnitAdjustment *adj,
- GimpUnit unit)
+gimp_unit_adjustment_convert_to_unit (GimpUnitAdjustment *adj,
+ GimpUnit unit)
{
- gdouble new_value = 0, lower, upper;
- if (adj->unit != unit)
- {
- DEBUG (("GimpUnitAdjustment: changing unit from %s to %s\n",
- gimp_unit_get_abbreviation (adj->unit),
- gimp_unit_get_abbreviation (unit));)
-
- /* convert value to new unit */
- new_value = gimp_units_to_pixels (gtk_adjustment_get_value (&(adj->parent_instance)),
- adj->unit,
- adj->resolution);
- new_value = gimp_pixels_to_units (new_value,
- unit,
- adj->resolution);
-
- /* also convert bounds */
- upper = gimp_units_to_pixels (gtk_adjustment_get_upper (GTK_ADJUSTMENT (adj)),
- adj->unit,
- adj->resolution);
- lower = gimp_units_to_pixels (gtk_adjustment_get_lower (GTK_ADJUSTMENT (adj)),
- adj->unit,
- adj->resolution);
-
- upper = gimp_pixels_to_units (upper,
- unit,
- adj->resolution);
- lower = gimp_pixels_to_units (lower,
- unit,
- adj->resolution);
-
- gtk_adjustment_set_upper (GTK_ADJUSTMENT (adj), upper);
- gtk_adjustment_set_lower (GTK_ADJUSTMENT (adj), lower);
-
- /* set the new unit */
- adj->unit = unit;
-
- gimp_unit_adjustment_set_value (adj, new_value);
- }
+ GimpUnitAdjustmentPrivate *private = GIMP_UNIT_ADJUSTMENT_GET_PRIVATE (adj);
+ gdouble new_value = 0;
+ gdouble lower;
+ gdouble upper;
+
+ if (private->unit == unit)
+ return;
+
+ DEBUG (("GimpUnitAdjustment: changing unit from %s to %s\n",
+ gimp_unit_get_abbreviation (private->unit),
+ gimp_unit_get_abbreviation (unit));)
+
+ /* convert value to new unit */
+ new_value = gimp_units_to_pixels (gtk_adjustment_get_value (&(adj->parent_instance)),
+ private->unit,
+ private->resolution);
+ new_value = gimp_pixels_to_units (new_value,
+ unit,
+ private->resolution);
+
+ /* also convert bounds */
+ upper = gimp_units_to_pixels (gtk_adjustment_get_upper (GTK_ADJUSTMENT (adj)),
+ private->unit,
+ private->resolution);
+ lower = gimp_units_to_pixels (gtk_adjustment_get_lower (GTK_ADJUSTMENT (adj)),
+ private->unit,
+ private->resolution);
+
+ upper = gimp_pixels_to_units (upper,
+ unit,
+ private->resolution);
+ lower = gimp_pixels_to_units (lower,
+ unit,
+ private->resolution);
+
+ gtk_adjustment_set_upper (GTK_ADJUSTMENT (adj), upper);
+ gtk_adjustment_set_lower (GTK_ADJUSTMENT (adj), lower);
+
+ /* set the new unit */
+ private->unit = unit;
+
+ gimp_unit_adjustment_set_value (adj, new_value);
}
/* sets unit of adjustment, does conversion if neccessary */
@@ -175,7 +197,7 @@ void
gimp_unit_adjustment_set_unit (GimpUnitAdjustment *adj,
GimpUnit unit)
{
- gimp_unit_adjustment_convert_unit (adj, unit);
+ gimp_unit_adjustment_convert_to_unit (adj, unit);
/* emit "unit-changed" */
g_signal_emit(adj, unit_adjustment_signals [UNIT_CHANGED], 0);
@@ -195,9 +217,11 @@ gimp_unit_adjustment_set_value_in_unit (GimpUnitAdjustment *adj,
gdouble value,
GimpUnit unit)
{
+ GimpUnitAdjustmentPrivate *private = GIMP_UNIT_ADJUSTMENT_GET_PRIVATE (adj);
+
/* convert from given unit to adjustments unit */
- value = gimp_units_to_pixels (value, unit, adj->resolution);
- value = gimp_pixels_to_units (value, adj->unit, adj->resolution);
+ value = gimp_units_to_pixels (value, unit, private->resolution);
+ value = gimp_pixels_to_units (value, private->unit, private->resolution);
gimp_unit_adjustment_set_value (adj, value);
}
@@ -216,10 +240,11 @@ gdouble
gimp_unit_adjustment_get_value_in_unit (GimpUnitAdjustment *adj,
GimpUnit unit)
{
- gdouble value = gimp_unit_adjustment_get_value (adj);
+ GimpUnitAdjustmentPrivate *private = GIMP_UNIT_ADJUSTMENT_GET_PRIVATE (adj);
+ gdouble value = gimp_unit_adjustment_get_value (adj);
- value = gimp_units_to_pixels (value, adj->unit, adj->resolution);
- value = gimp_pixels_to_units (value, unit, adj->resolution);
+ value = gimp_units_to_pixels (value, private->unit, private->resolution);
+ value = gimp_pixels_to_units (value, unit, private->resolution);
return value;
}
@@ -228,9 +253,11 @@ void
gimp_unit_adjustment_set_resolution (GimpUnitAdjustment *adj,
gdouble res)
{
- if (adj->resolution != res)
+ GimpUnitAdjustmentPrivate *private = GIMP_UNIT_ADJUSTMENT_GET_PRIVATE (adj);
+
+ if (private->resolution != res)
{
- adj->resolution = res;
+ private->resolution = res;
/* emit "resolution-changed" */
g_signal_emit(adj, unit_adjustment_signals [RESOLUTION_CHANGED], 0);
}
@@ -239,59 +266,51 @@ gimp_unit_adjustment_set_resolution (GimpUnitAdjustment *adj,
gdouble
gimp_unit_adjustment_get_resolution (GimpUnitAdjustment *adj)
{
- return adj->resolution;
-}
+ GimpUnitAdjustmentPrivate *private = GIMP_UNIT_ADJUSTMENT_GET_PRIVATE (adj);
-/* get string in format "value unit" */
-gchar*
-gimp_unit_adjustment_to_string (GimpUnitAdjustment *adj)
-{
- return gimp_unit_adjustment_to_string_in_unit (adj, adj->unit);
-}
-
-gchar*
-gimp_unit_adjustment_to_string_in_unit (GimpUnitAdjustment *adj,
- GimpUnit unit)
-{
- gdouble value;
- gchar *text = g_malloc (sizeof (gchar) * UNIT_ADJUSTMENT_STRING_LENGTH);
-
- value = gimp_unit_adjustment_get_value_in_unit (adj, unit);
-
- g_snprintf (text, UNIT_ADJUSTMENT_STRING_LENGTH, "%.*f %s",
- gimp_unit_get_digits (unit),
- value,
- gimp_unit_get_abbreviation (unit));
-
- return text;
+ return private->resolution;
}
GimpUnit
gimp_unit_adjustment_get_unit (GimpUnitAdjustment *adj)
{
- return adj->unit;
+ GimpUnitAdjustmentPrivate *private = GIMP_UNIT_ADJUSTMENT_GET_PRIVATE (adj);
+
+ return private->unit;
}
void
gimp_unit_adjustment_set_bounds (GimpUnitAdjustment *adj,
GimpUnit unit,
- gdouble upper,
- gdouble lower)
+ gdouble lower,
+ gdouble upper)
{
+ GimpUnitAdjustmentPrivate *private = GIMP_UNIT_ADJUSTMENT_GET_PRIVATE (adj);
+ gdouble temp;
+
+ /* switch lower and upper bounds if neccessary
+ (older revisions used gimp_unit_adjustment_set_bounds (adj, unit, upper, lower)) */
+ if (lower > upper)
+ {
+ temp = upper;
+ upper = lower;
+ lower = temp;
+ }
+
/* convert bounds from given unit to current unit */
upper = gimp_units_to_pixels (upper,
unit,
- adj->resolution);
+ private->resolution);
lower = gimp_units_to_pixels (lower,
unit,
- adj->resolution);
+ private->resolution);
upper = gimp_pixels_to_units (upper,
- adj->unit,
- adj->resolution);
+ private->unit,
+ private->resolution);
lower = gimp_pixels_to_units (lower,
- adj->unit,
- adj->resolution);
+ private->unit,
+ private->resolution);
/* set bounds */
gtk_adjustment_set_upper (GTK_ADJUSTMENT (adj), upper);
diff --git a/libgimpwidgets/gimpunitadjustment.h b/libgimpwidgets/gimpunitadjustment.h
index f334c13..1fc985b 100644
--- a/libgimpwidgets/gimpunitadjustment.h
+++ b/libgimpwidgets/gimpunitadjustment.h
@@ -26,9 +26,6 @@
G_BEGIN_DECLS
-/**
- * boiler-plate
- **/
#define GIMP_TYPE_UNIT_ADJUSTMENT (gimp_unit_adjustment_get_type ())
#define GIMP_UNIT_ADJUSTMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_UNIT_ADJUSTMENT,
GimpUnitAdjustment))
#define GIMP_UNIT_ADJUSTMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_UNIT_ADJUSTMENT,
GimpUnitAdjustmentClass))
@@ -43,10 +40,7 @@ struct _GimpUnitAdjustment
{
GtkAdjustment parent_instance;
- /* private */
- /* TODO move private fields into own struct? */
- GimpUnit unit; /* the unit our value is in */
- gdouble resolution; /* resolution in dpi */
+ gpointer private;
};
struct _GimpUnitAdjustmentClass
@@ -55,35 +49,32 @@ struct _GimpUnitAdjustmentClass
};
-GType gimp_unit_adjustment_get_type (void);
-GObject *gimp_unit_adjustment_new (void);
+GType gimp_unit_adjustment_get_type (void);
+GimpUnitAdjustment *gimp_unit_adjustment_new (void);
-void gimp_unit_adjustment_set_unit (GimpUnitAdjustment *adj,
- GimpUnit unit);
-void gimp_unit_adjustment_set_value (GimpUnitAdjustment *adj,
- gdouble value);
-void gimp_unit_adjustment_set_value_in_unit (GimpUnitAdjustment *adj,
- gdouble value,
- GimpUnit unit);
-void gimp_unit_adjustment_set_resolution (GimpUnitAdjustment *adj,
- gdouble res);
-void gimp_unit_adjustment_set_bounds (GimpUnitAdjustment *adj,
- GimpUnit unit,
- gdouble upper,
- gdouble lower);
+void gimp_unit_adjustment_set_unit (GimpUnitAdjustment *adj,
+ GimpUnit unit);
+void gimp_unit_adjustment_set_value (GimpUnitAdjustment *adj,
+ gdouble value);
+void gimp_unit_adjustment_set_value_in_unit (GimpUnitAdjustment *adj,
+ gdouble value,
+ GimpUnit unit);
+void gimp_unit_adjustment_set_resolution (GimpUnitAdjustment *adj,
+ gdouble res);
+void gimp_unit_adjustment_set_bounds (GimpUnitAdjustment *adj,
+ GimpUnit unit,
+ gdouble lower,
+ gdouble upper);
-gdouble gimp_unit_adjustment_get_value (GimpUnitAdjustment *adj);
-gdouble gimp_unit_adjustment_get_value_in_unit (GimpUnitAdjustment *adj,
- GimpUnit unit);
-gdouble gimp_unit_adjustment_get_resolution (GimpUnitAdjustment *adj);
-GimpUnit gimp_unit_adjustment_get_unit (GimpUnitAdjustment *adj);
+gdouble gimp_unit_adjustment_get_value (GimpUnitAdjustment *adj);
+gdouble gimp_unit_adjustment_get_value_in_unit (GimpUnitAdjustment *adj,
+ GimpUnit unit);
+gdouble gimp_unit_adjustment_get_resolution (GimpUnitAdjustment *adj);
+GimpUnit gimp_unit_adjustment_get_unit (GimpUnitAdjustment *adj);
-gchar* gimp_unit_adjustment_to_string (GimpUnitAdjustment *adj);
-gchar* gimp_unit_adjustment_to_string_in_unit (GimpUnitAdjustment *adj,
- GimpUnit unit);
-void gimp_unit_adjustment_connect (GimpUnitAdjustment *adj,
- GimpUnitAdjustment *target);
+void gimp_unit_adjustment_follow_unit_of (GimpUnitAdjustment *adj,
+ GimpUnitAdjustment *other);
G_END_DECLS
diff --git a/libgimpwidgets/gimpunitentries.c b/libgimpwidgets/gimpunitentries.c
index 547396b..20d378f 100644
--- a/libgimpwidgets/gimpunitentries.c
+++ b/libgimpwidgets/gimpunitentries.c
@@ -35,12 +35,25 @@
#define DEBUG(x) /* nothing */
#endif
+#define UNIT_ENTRIES_LEFT_ATTACH 2
+#define UNIT_ENTRIES_RIGHT_ATTACH 3
+
enum
{
CHANGED,
LAST_SIGNAL
};
+typedef struct
+{
+ GtkWidget *table;
+ GtkWidget *chain_button;
+ GHashTable *entries_store;
+} GimpUnitEntriesPrivate;
+
+#define GIMP_UNIT_ENTRIES_GET_PRIVATE(obj) \
+ ((GimpUnitEntriesPrivate *) ((GimpUnitEntries *) (obj))->private)
+
G_DEFINE_TYPE (GimpUnitEntries, gimp_unit_entries, G_TYPE_OBJECT);
static void gimp_unit_entries_label_updater (GtkAdjustment *adj, gpointer user_data);
@@ -51,16 +64,24 @@ static guint unit_entries_signals[LAST_SIGNAL] = {0};
static void
gimp_unit_entries_init (GimpUnitEntries *entries)
{
- entries->table = gtk_table_new (1, 1, FALSE);
- entries->entries_store = g_hash_table_new (NULL, NULL);
- entries->chain_button = NULL;
- entries->bottom = 0;
- entries->right = 0;
+ GimpUnitEntriesPrivate *private;
+
+ entries->private = G_TYPE_INSTANCE_GET_PRIVATE (entries,
+ GIMP_TYPE_UNIT_ENTRIES,
+ GimpUnitEntriesPrivate);
+
+ private = GIMP_UNIT_ENTRIES_GET_PRIVATE (entries);
+
+ private->table = gtk_table_new (1, 1, FALSE);
+ private->entries_store = g_hash_table_new (g_str_hash, g_str_equal);
+ private->chain_button = NULL;
}
static void
gimp_unit_entries_class_init (GimpUnitEntriesClass *klass)
{
+ g_type_class_add_private (klass, sizeof (GimpUnitEntriesPrivate));
+
unit_entries_signals[CHANGED] =
g_signal_new ("changed",
GIMP_TYPE_UNIT_ENTRIES,
@@ -73,32 +94,41 @@ gimp_unit_entries_class_init (GimpUnitEntriesClass *klass)
G_TYPE_OBJECT);
}
-GObject*
+GimpUnitEntries*
gimp_unit_entries_new (void)
{
- GObject *table;
+ GObject *entries;
- table = g_object_new (GIMP_TYPE_UNIT_ENTRIES, NULL);
+ entries = g_object_new (GIMP_TYPE_UNIT_ENTRIES, NULL);
- return table;
+ return GIMP_UNIT_ENTRIES (entries);
}
/* add an UnitEntry */
GtkWidget*
gimp_unit_entries_add_entry (GimpUnitEntries *entries,
const gchar *id,
- const gchar *labelStr,
- gint x,
- gint y)
+ const gchar *label_str)
{
- GimpUnitEntry *entry = GIMP_UNIT_ENTRY (gimp_unit_entry_new ());
- GtkWidget *label;
+ GimpUnitEntriesPrivate *private = GIMP_UNIT_ENTRIES_GET_PRIVATE (entries);
+ GimpUnitEntry *entry = GIMP_UNIT_ENTRY (gimp_unit_entry_new ());
+ GimpUnitEntry *other_entry;
+ GtkWidget *label;
+ guint bottom;
+ gint i;
+ gint left_attach,
+ right_attach,
+ top_attach,
+ bottom_attach;
+
+ /* retrieve bottom row of table */
+ gtk_table_get_size (GTK_TABLE (gimp_unit_entries_get_table (entries)), &bottom, NULL);
/* position of the entry (leave one row/column empty for labels etc) */
- gint left_attach = x + 1,
- right_attach = x + 2,
- top_attach = y + 1,
- bottom_attach = y + 2;
+ left_attach = UNIT_ENTRIES_LEFT_ATTACH,
+ right_attach = UNIT_ENTRIES_RIGHT_ATTACH,
+ top_attach = bottom,
+ bottom_attach = bottom + 1;
/* remember position in table so that we later can place other widgets around it */
g_object_set_data (G_OBJECT (entry), "left_attach", GINT_TO_POINTER (left_attach));
@@ -107,24 +137,18 @@ gimp_unit_entries_add_entry (GimpUnitEntries *entries,
g_object_set_data (G_OBJECT (entry), "bottom_attach", GINT_TO_POINTER (bottom_attach));
/* add entry to table at position (1, count) */
- gtk_table_attach_defaults (GTK_TABLE (entries->table),
+ gtk_table_attach_defaults (GTK_TABLE (gimp_unit_entries_get_table (entries)),
GTK_WIDGET (entry),
left_attach,
right_attach,
top_attach,
bottom_attach);
- /* save new size of our table if neccessary */
- if (bottom_attach > entries->bottom)
- entries->bottom = bottom_attach;
- if (right_attach > entries->right)
- entries->right = right_attach;
-
/* if label string is given, create label and attach to the left of entry */
- if (labelStr != NULL)
+ if (label_str != NULL)
{
- label = gtk_label_new (labelStr);
- gtk_table_attach (GTK_TABLE (entries->table),
+ label = gtk_label_new (label_str);
+ gtk_table_attach (GTK_TABLE (gimp_unit_entries_get_table (entries)),
label,
left_attach-1 , left_attach, top_attach, bottom_attach,
GTK_SHRINK, GTK_EXPAND | GTK_FILL,
@@ -136,36 +160,19 @@ gimp_unit_entries_add_entry (GimpUnitEntries *entries,
g_signal_connect (gimp_unit_entry_get_adjustment (entry), "value-changed",
G_CALLBACK (gimp_unit_entries_entry_changed), (gpointer) entries);
g_signal_connect (gimp_unit_entry_get_adjustment (entry), "resolution-changed",
- G_CALLBACK (gimp_unit_entries_entry_changed), (gpointer) entries);
-
- gtk_widget_show_all (entries->table);
-
- g_hash_table_insert (entries->entries_store, (gpointer) id, (gpointer) entry);
-
- return GTK_WIDGET (entry);
-}
-
-GtkWidget*
-gimp_unit_entries_add_entry_defaults (GimpUnitEntries *entries,
- const gchar *id,
- const gchar *labelStr)
-{
- GimpUnitEntry *entry, *entry2;
- gint i;
-
- entry = GIMP_UNIT_ENTRY (gimp_unit_entries_add_entry (entries,
- id,
- labelStr,
- 1,
- entries->bottom));
-
+ G_CALLBACK (gimp_unit_entries_entry_changed), (gpointer) entries);
+
/* connect entry to others */
- for (i = 0; i < g_hash_table_size (entries->entries_store); i++)
+ for (i = 0; i < g_hash_table_size (private->entries_store); i++)
{
- entry2 = gimp_unit_entries_get_nth_entry (entries, i);
- gimp_unit_entry_connect (GIMP_UNIT_ENTRY (entry), GIMP_UNIT_ENTRY (entry2));
- gimp_unit_entry_connect (GIMP_UNIT_ENTRY (entry2), GIMP_UNIT_ENTRY (entry));
- }
+ other_entry = gimp_unit_entries_get_nth_entry (entries, i);
+ gimp_unit_entry_connect (GIMP_UNIT_ENTRY (entry), GIMP_UNIT_ENTRY (other_entry));
+ gimp_unit_entry_connect (GIMP_UNIT_ENTRY (other_entry), GIMP_UNIT_ENTRY (entry));
+ }
+
+ gtk_widget_show_all (gimp_unit_entries_get_table (entries));
+
+ g_hash_table_insert (private->entries_store, (gpointer) id, (gpointer) entry);
return GTK_WIDGET (entry);
}
@@ -177,10 +184,13 @@ gimp_unit_entries_add_preview_label (GimpUnitEntries *entries,
const gchar *id1,
const gchar *id2)
{
- GtkWidget *label = gtk_label_new("preview");
+ GtkWidget *label = gtk_label_new("preview");
GimpUnitEntry *entry1 = gimp_unit_entries_get_entry (entries, id1);
GimpUnitEntry *entry2 = gimp_unit_entries_get_entry (entries, id2);
- gint left_attach, right_attach, top_attach, bottom_attach;
+ gint left_attach,
+ right_attach,
+ top_attach,
+ bottom_attach;
/* save unit */
g_object_set_data (G_OBJECT (label), "unit", GINT_TO_POINTER (unit));
@@ -195,7 +205,7 @@ gimp_unit_entries_add_preview_label (GimpUnitEntries *entries,
bottom_attach = top_attach + 1;
/* add label below unit entries */
- gtk_table_attach (GTK_TABLE (entries->table),
+ gtk_table_attach (GTK_TABLE (gimp_unit_entries_get_table (entries)),
label,
left_attach, right_attach,
top_attach, bottom_attach,
@@ -208,8 +218,6 @@ gimp_unit_entries_add_preview_label (GimpUnitEntries *entries,
PANGO_ATTR_SCALE, PANGO_SCALE_SMALL,
-1);*/
- entries->bottom++;
-
gtk_widget_show (GTK_WIDGET (label));
/* connect label updater to changed signal */
@@ -228,19 +236,20 @@ gimp_unit_entries_add_chain_button (GimpUnitEntries *entries,
const gchar *id1,
const gchar *id2)
{
- GtkWidget *chain_button;
- GimpUnitEntry *entry1 = gimp_unit_entries_get_entry (entries, id1);
- GimpUnitEntry *entry2 = gimp_unit_entries_get_entry (entries, id2);
+ GimpUnitEntriesPrivate *private = GIMP_UNIT_ENTRIES_GET_PRIVATE (entries);
+ GtkWidget *chain_button;
+ GimpUnitEntry *entry1 = gimp_unit_entries_get_entry (entries, id1);
+ GimpUnitEntry *entry2 = gimp_unit_entries_get_entry (entries, id2);
/* retrieve position of entries */
gint right_attach = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (entry1), "right_attach"));
gint top_attach = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (entry1), "top_attach"));
gint bottom_attach = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (entry2), "bottom_attach"));
- chain_button = gimp_chain_button_new(GIMP_CHAIN_RIGHT);
+ chain_button = gimp_chain_button_new (GIMP_CHAIN_RIGHT);
/* add chain_button to right of entries, spanning from the first to the second */
- gtk_table_attach (GTK_TABLE (entries->table),
+ gtk_table_attach (GTK_TABLE (gimp_unit_entries_get_table (entries)),
GTK_WIDGET (chain_button),
right_attach, right_attach + 1,
top_attach, bottom_attach,
@@ -250,7 +259,7 @@ gimp_unit_entries_add_chain_button (GimpUnitEntries *entries,
gtk_widget_show (chain_button);
- entries->chain_button = chain_button;
+ private->chain_button = chain_button;
return chain_button;
}
@@ -260,9 +269,10 @@ GimpUnitEntry*
gimp_unit_entries_get_entry (GimpUnitEntries *entries,
const gchar *id)
{
- GimpUnitEntry *entry;
+ GimpUnitEntriesPrivate *private = GIMP_UNIT_ENTRIES_GET_PRIVATE (entries);
+ GimpUnitEntry *entry;
- entry = GIMP_UNIT_ENTRY (g_hash_table_lookup (entries->entries_store, id));
+ entry = GIMP_UNIT_ENTRY (g_hash_table_lookup (private->entries_store, id));
if (entry == NULL)
{
@@ -277,11 +287,13 @@ GimpUnitEntry*
gimp_unit_entries_get_nth_entry (GimpUnitEntries *entries,
gint index)
{
- GHashTableIter iter;
- gpointer key, value;
- gint i;
+ GimpUnitEntriesPrivate *private = GIMP_UNIT_ENTRIES_GET_PRIVATE (entries);
+ GHashTableIter iter;
+ gpointer key,
+ value;
+ gint i;
- if (g_hash_table_size (entries->entries_store) <= index || index < 0)
+ if (g_hash_table_size (private->entries_store) <= index || index < 0)
{
g_warning ("gimp_unit_entries_get_nth_entry: index < 0 or hash table size smaller than index");
return NULL;
@@ -289,7 +301,7 @@ gimp_unit_entries_get_nth_entry (GimpUnitEntries *entries,
i = 0;
- g_hash_table_iter_init (&iter, entries->entries_store);
+ g_hash_table_iter_init (&iter, private->entries_store);
while (g_hash_table_iter_next (&iter, &key, &value))
{
@@ -310,18 +322,14 @@ gimp_unit_entries_label_updater (GtkAdjustment *adj,
GtkLabel *label = GTK_LABEL (user_data);
GimpUnitEntry *entry1 = GIMP_UNIT_ENTRY (g_object_get_data (G_OBJECT (label), "entry1"));
GimpUnitEntry *entry2 = GIMP_UNIT_ENTRY (g_object_get_data (G_OBJECT (label), "entry2"));
- GimpUnitAdjustment *adjustment;
GimpUnit unit;
/* retrieve preview unit */
unit = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (label), "unit"));
/* retrieve values of the two entries */
- adjustment = gimp_unit_entry_get_adjustment (entry1);
- g_sprintf (str, "%s", gimp_unit_adjustment_to_string_in_unit (adjustment, unit));
-
- adjustment = gimp_unit_entry_get_adjustment (entry2);
- g_sprintf (str, "%s x %s ", str, gimp_unit_adjustment_to_string_in_unit (adjustment, unit));
+ g_sprintf (str, "%s", gimp_unit_entry_to_string_in_unit (entry1, unit));
+ g_sprintf (str, "%s x %s ", str, gimp_unit_entry_to_string_in_unit (entry2, unit));
gtk_label_set_text (label, str);
}
@@ -344,14 +352,16 @@ gimp_unit_entries_entry_changed (GtkAdjustment *adj,
}
/* emit "changed" */
- g_signal_emit(entries, unit_entries_signals[CHANGED], 0, entry);
+ g_signal_emit (entries, unit_entries_signals[CHANGED], 0, entry);
}
/* get count of attached unit entries */
gint
gimp_unit_entries_get_entry_count (GimpUnitEntries *entries)
{
- return g_hash_table_size (entries->entries_store);
+ GimpUnitEntriesPrivate *private = GIMP_UNIT_ENTRIES_GET_PRIVATE (entries);
+
+ return g_hash_table_size (private->entries_store);
}
/* get value of given entry in pixels */
@@ -427,6 +437,7 @@ gimp_unit_entries_set_mode (GimpUnitEntries *entries,
{
entry = gimp_unit_entries_get_nth_entry (entries, i);
gimp_unit_entry_set_mode (entry, mode);
+ gimp_unit_entry_set_resolution (entry, 1.0); /* otherwise calculation is not correct */
}
}
@@ -449,8 +460,8 @@ gimp_unit_entries_set_activates_default (GimpUnitEntries *entries,
void
gimp_unit_entries_set_bounds (GimpUnitEntries *entries,
GimpUnit unit,
- gdouble upper,
- gdouble lower)
+ gdouble lower,
+ gdouble upper)
{
GimpUnitEntry *entry;
gint i, count = gimp_unit_entries_get_entry_count (entries);
@@ -459,26 +470,31 @@ gimp_unit_entries_set_bounds (GimpUnitEntries *entries,
for (i = 0; i < count; i++)
{
entry = gimp_unit_entries_get_nth_entry (entries, i);
- gimp_unit_entry_set_bounds (entry, unit, upper, lower);
+ gimp_unit_entry_set_bounds (entry, unit, lower, upper);
}
}
void
gimp_unit_entries_grab_focus (GimpUnitEntries *entries)
{
- gtk_widget_grab_focus (GTK_WIDGET (gimp_unit_entries_get_nth_entry (entries, 0)));
+ if (gimp_unit_entries_get_entry_count > 0)
+ gtk_widget_grab_focus (GTK_WIDGET (gimp_unit_entries_get_nth_entry (entries, 0)));
}
GtkWidget*
gimp_unit_entries_get_table (GimpUnitEntries *entries)
{
- return entries->table;
+ GimpUnitEntriesPrivate *private = GIMP_UNIT_ENTRIES_GET_PRIVATE (entries);
+
+ return private->table;
}
GtkWidget*
gimp_unit_entries_get_chain_button (GimpUnitEntries *entries)
{
- return entries->chain_button;
+ GimpUnitEntriesPrivate *private = GIMP_UNIT_ENTRIES_GET_PRIVATE (entries);
+
+ return private->chain_button;
}
void
@@ -503,4 +519,4 @@ gimp_unit_entries_set_nth_pixels (GimpUnitEntries *entries,
entry = gimp_unit_entries_get_nth_entry (entries, index);
gimp_unit_entry_set_value_in_unit (entry, value, GIMP_UNIT_PIXEL);
-}
+}
diff --git a/libgimpwidgets/gimpunitentries.h b/libgimpwidgets/gimpunitentries.h
index 3514dbe..211e813 100644
--- a/libgimpwidgets/gimpunitentries.h
+++ b/libgimpwidgets/gimpunitentries.h
@@ -49,15 +49,9 @@ typedef struct _GimpUnitEntriesClass GimpUnitEntriesClass;
struct _GimpUnitEntries
{
- GObject parent_instance;
+ GObject parent_instance;
- /* private */
- GtkWidget *table;
- GtkWidget *chain_button;
- GHashTable *entries_store;
-
- /* dimensions of "sub-table" containing the actual entries */
- gint bottom, right;
+ gpointer private;
};
struct _GimpUnitEntriesClass
@@ -66,15 +60,10 @@ struct _GimpUnitEntriesClass
};
GType gimp_unit_entries_get_type (void);
-GObject* gimp_unit_entries_new (void);
+GimpUnitEntries*gimp_unit_entries_new (void);
GtkWidget* gimp_unit_entries_add_entry (GimpUnitEntries *entries,
const gchar *id,
- const gchar *label,
- gint x,
- gint y);
-GtkWidget* gimp_unit_entries_add_entry_defaults (GimpUnitEntries *entries,
- const gchar *id,
const gchar *label);
void gimp_unit_entries_add_preview_label (GimpUnitEntries *entries,
GimpUnit unit,
diff --git a/libgimpwidgets/gimpunitentry.c b/libgimpwidgets/gimpunitentry.c
index 57ac049..4c33408 100644
--- a/libgimpwidgets/gimpunitentry.c
+++ b/libgimpwidgets/gimpunitentry.c
@@ -51,6 +51,27 @@
#define UNIT_ENTRY_ERROR_COLOR "LightSalmon"
#define UNIT_ENTRY_SIZE_REQUEST 200
+typedef struct
+{
+ GimpUnitAdjustment *unit_adjustment;
+
+ /* flag set TRUE when entry's text should not be overwritten
+ (i.e. during user input) */
+ /* FIXME: maybe it's possible to block signals that trigger updates instead */
+ gboolean dont_update_text;
+
+ /* input mode */
+ GimpUnitEntryMode mode;
+
+ /* is our input valid? (for error indication) */
+ gboolean input_valid;
+ /* the timer source which handles the error indication */
+ GSource *timer;
+} GimpUnitEntryPrivate;
+
+#define GIMP_UNIT_ENTRY_GET_PRIVATE(obj) \
+ ((GimpUnitEntryPrivate *) ((GimpUnitEntry *) (obj))->private)
+
G_DEFINE_TYPE (GimpUnitEntry, gimp_unit_entry, GTK_TYPE_SPIN_BUTTON);
static gboolean gimp_unit_entry_parse (GimpUnitEntry *unitEntry);
@@ -65,50 +86,57 @@ static gint gimp_unit_entry_input (GtkSpinButton *spinbut
static void gimp_unit_entry_populate_popup (GtkEntry *entry,
GtkMenu *menu,
gpointer user_data);
-static void gimp_unit_entry_menu_item (GtkWidget *menuItem,
+static void gimp_unit_entry_menu_item (GtkWidget *menu_item,
gpointer *user_data);
static gboolean gimp_unit_entry_timer_callback (GtkWidget *entry);
static void
-gimp_unit_entry_init (GimpUnitEntry *unitEntry)
+gimp_unit_entry_init (GimpUnitEntry *unit_entry)
{
- /* create and set our adjustment subclass */
- GObject *adjustment = gimp_unit_adjustment_new ();
+ GimpUnitEntryPrivate *private;
+
+ unit_entry->private = G_TYPE_INSTANCE_GET_PRIVATE (unit_entry,
+ GIMP_TYPE_UNIT_ENTRY,
+ GimpUnitEntryPrivate);
+
+ private = GIMP_UNIT_ENTRY_GET_PRIVATE (unit_entry);
- unitEntry->unitAdjustment = GIMP_UNIT_ADJUSTMENT (adjustment);
- gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (unitEntry),
- GTK_ADJUSTMENT (adjustment));
+ /* create and set our adjustment subclass */
+ private->unit_adjustment = gimp_unit_adjustment_new ();
+ gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (unit_entry),
+ GTK_ADJUSTMENT (private->unit_adjustment));
/* some default values */
- unitEntry->dontUpdateText = FALSE;
- unitEntry->mode = GIMP_UNIT_ENTRY_MODE_UNIT;
- unitEntry->input_valid = TRUE;
- unitEntry->timer = NULL;
+ private->dont_update_text = FALSE;
+ private->mode = GIMP_UNIT_ENTRY_MODE_UNIT;
+ private->input_valid = TRUE;
+ private->timer = NULL;
/* connect signals */
- g_signal_connect (&unitEntry->parent_instance,
+ g_signal_connect (&unit_entry->parent_instance,
"output",
G_CALLBACK(gimp_unit_entry_output),
- (gpointer) adjustment);
- g_signal_connect (&unitEntry->parent_instance,
+ (gpointer) gimp_unit_entry_get_adjustment (unit_entry));
+ g_signal_connect (&unit_entry->parent_instance,
"input",
G_CALLBACK(gimp_unit_entry_input),
- (gpointer) unitEntry);
- g_signal_connect (&unitEntry->parent_instance.entry,
+ (gpointer) unit_entry);
+ g_signal_connect (&unit_entry->parent_instance.entry,
"changed",
G_CALLBACK(gimp_unit_entry_text_changed),
- (gpointer) unitEntry);
- g_signal_connect (&unitEntry->parent_instance.entry,
+ (gpointer) unit_entry);
+ g_signal_connect (&unit_entry->parent_instance.entry,
"populate-popup",
G_CALLBACK(gimp_unit_entry_populate_popup),
NULL);
- gtk_widget_set_size_request (GTK_WIDGET (unitEntry), UNIT_ENTRY_SIZE_REQUEST, -1);
+ gtk_widget_set_size_request (GTK_WIDGET (unit_entry), UNIT_ENTRY_SIZE_REQUEST, -1);
}
static void
gimp_unit_entry_class_init (GimpUnitEntryClass *class)
{
+ g_type_class_add_private (class, sizeof (GimpUnitEntryPrivate));
}
GtkWidget*
@@ -122,7 +150,9 @@ gimp_unit_entry_new (void)
GimpUnitAdjustment*
gimp_unit_entry_get_adjustment (GimpUnitEntry *entry)
{
- return entry->unitAdjustment;
+ GimpUnitEntryPrivate *private = GIMP_UNIT_ENTRY_GET_PRIVATE (entry);
+
+ return private->unit_adjustment;
}
/* connect to another entry */
@@ -130,21 +160,24 @@ void
gimp_unit_entry_connect (GimpUnitEntry *entry,
GimpUnitEntry *target)
{
- gimp_unit_adjustment_connect (entry->unitAdjustment, target->unitAdjustment);
+ gimp_unit_adjustment_follow_unit_of (gimp_unit_entry_get_adjustment (entry),
+ gimp_unit_entry_get_adjustment (target));
}
/* read and parse entered text */
static gboolean
gimp_unit_entry_parse (GimpUnitEntry *entry)
{
+ GimpUnitEntryPrivate *private = GIMP_UNIT_ENTRY_GET_PRIVATE (entry);
GimpUnitParserResult result;
gboolean success;
- const gchar *str = gtk_entry_get_text (GTK_ENTRY (entry));
+ const gchar *str = gtk_entry_get_text (GTK_ENTRY (entry));
+ GimpUnitAdjustment *unit_adjustment = gimp_unit_entry_get_adjustment (entry);
/* set resolution (important for correct calculation of px) */
- result.resolution = entry->unitAdjustment->resolution;
+ result.resolution = gimp_unit_adjustment_get_resolution (unit_adjustment);
/* set unit (we want to use current unit if the user didn't enter one) */
- result.unit = entry->unitAdjustment->unit;
+ result.unit = gimp_unit_adjustment_get_unit (unit_adjustment);
/* parse string of entry */
success = gimp_unit_parser_parse (str, &result);
@@ -153,31 +186,31 @@ gimp_unit_entry_parse (GimpUnitEntry *entry)
{
/* reset color */
gtk_widget_modify_base (GTK_WIDGET (entry), GTK_STATE_NORMAL, NULL);
- entry->input_valid = TRUE;
+ private->input_valid = TRUE;
/* set new unit */
- if (result.unit != entry->unitAdjustment->unit)
+ if (result.unit != gimp_unit_adjustment_get_unit (unit_adjustment))
{
- gimp_unit_adjustment_set_unit (entry->unitAdjustment, result.unit);
+ gimp_unit_adjustment_set_unit (gimp_unit_entry_get_adjustment (entry), result.unit);
}
/* set new value */
- if (gimp_unit_adjustment_get_value (entry->unitAdjustment) != result.value)
+ if (result.value != gimp_unit_adjustment_get_value (gimp_unit_entry_get_adjustment (entry)))
{
/* result from parser is in inch, so convert to desired unit */
result.value = gimp_units_to_pixels (result.value,
- GIMP_UNIT_INCH,
- entry->unitAdjustment->resolution);
+ GIMP_UNIT_INCH,
+ gimp_unit_adjustment_get_resolution (unit_adjustment));
result.value = gimp_pixels_to_units (result.value,
- entry->unitAdjustment->unit,
- entry->unitAdjustment->resolution);
+ gimp_unit_adjustment_get_unit (unit_adjustment),
+ gimp_unit_adjustment_get_resolution (unit_adjustment));
- gimp_unit_adjustment_set_value (entry->unitAdjustment, result.value);
+ gimp_unit_adjustment_set_value (gimp_unit_entry_get_adjustment (entry), result.value);
}
}
else
{
- entry->input_valid = FALSE;
+ private->input_valid = FALSE;
return FALSE;
}
@@ -189,33 +222,34 @@ static gboolean
gimp_unit_entry_output (GtkSpinButton *spin,
gpointer data)
{
- GimpUnitAdjustment *adj = GIMP_UNIT_ADJUSTMENT (data);
- GimpUnitEntry *entry = GIMP_UNIT_ENTRY (spin);
- gchar *adj_string;
- gchar res_string [UNIT_ENTRY_STRING_LENGTH];
+ GimpUnitAdjustment *adj = GIMP_UNIT_ADJUSTMENT (data);
+ GimpUnitEntry *entry = GIMP_UNIT_ENTRY (spin);
+ GimpUnitEntryPrivate *private = GIMP_UNIT_ENTRY_GET_PRIVATE (entry);
+ gchar *output = NULL;
+ gchar resolution_mode_output [UNIT_ENTRY_STRING_LENGTH];
/* if updating disabled => return (user input must not be overwritten) */
- if (entry->dontUpdateText)
+ if (private->dont_update_text)
{
return TRUE;
}
/* set text of the entry */
- if (entry->mode == GIMP_UNIT_ENTRY_MODE_UNIT)
+ if (private->mode == GIMP_UNIT_ENTRY_MODE_UNIT)
{
- adj_string = gimp_unit_adjustment_to_string (adj);
- gtk_entry_set_text (GTK_ENTRY (entry), adj_string);
- g_free (adj_string);
+ output = gimp_unit_entry_to_string (entry);
+ gtk_entry_set_text (GTK_ENTRY (entry), output);
+ g_free (output);
}
else
{
- snprintf (res_string, UNIT_ENTRY_STRING_LENGTH, "%.1f px/%s",
+ snprintf (resolution_mode_output, UNIT_ENTRY_STRING_LENGTH, "%.1f px/%s",
gimp_unit_adjustment_get_value (adj),
gimp_unit_get_abbreviation (gimp_unit_adjustment_get_unit (adj)));
- gtk_entry_set_text (GTK_ENTRY (entry), res_string);
+ gtk_entry_set_text (GTK_ENTRY (entry), resolution_mode_output);
}
- DEBUG (("on_output: %s\n", text);)
+ DEBUG (("on_output: %s\n", output);)
return TRUE;
}
@@ -225,7 +259,8 @@ static void
gimp_unit_entry_text_changed (GtkEditable *editable,
gpointer user_data)
{
- GimpUnitEntry *entry = GIMP_UNIT_ENTRY (user_data);
+ GimpUnitEntry *entry = GIMP_UNIT_ENTRY (user_data);
+ GimpUnitEntryPrivate *private = GIMP_UNIT_ENTRY_GET_PRIVATE (entry);
DEBUG (("on_text_changed\n");)
@@ -233,41 +268,45 @@ gimp_unit_entry_text_changed (GtkEditable *editable,
if (gtk_widget_has_focus (GTK_WIDGET (entry)))
{
/* if timer exists, reset */
- if (entry->timer != NULL)
+ if (private->timer != NULL)
{
- g_source_destroy (entry->timer);
+ g_source_destroy (private->timer);
}
/* create timer */
- entry->timer = g_timeout_source_new_seconds (UNIT_ENTRY_ERROR_TIMEOUT);
- g_source_set_callback (entry->timer,
+ private->timer = g_timeout_source_new_seconds (UNIT_ENTRY_ERROR_TIMEOUT);
+ g_source_set_callback (private->timer,
(GSourceFunc) gimp_unit_entry_timer_callback,
(gpointer) entry,
NULL);
- g_source_attach (entry->timer, NULL);
+ g_source_attach (private->timer, NULL);
}
- if (!entry->mode == GIMP_UNIT_ENTRY_MODE_RESOLUTION)
+ if (!private->mode == GIMP_UNIT_ENTRY_MODE_RESOLUTION)
{
/* disable updating the displayed text (user input must not be overwriten) */
- entry->dontUpdateText = TRUE;
+ private->dont_update_text = TRUE;
/* parse input */
gimp_unit_entry_parse (entry);
/* reenable updating */
- entry->dontUpdateText = FALSE;
+ private->dont_update_text = FALSE;
}
}
static gint
-gimp_unit_entry_input (GtkSpinButton *spinButton,
+gimp_unit_entry_input (GtkSpinButton *spin_button,
gpointer arg1,
gpointer user_data)
{
- if (!GIMP_UNIT_ENTRY (spinButton)->mode == GIMP_UNIT_ENTRY_MODE_RESOLUTION)
+ GimpUnitEntry *entry = GIMP_UNIT_ENTRY (spin_button);
+ GimpUnitEntryPrivate *private = GIMP_UNIT_ENTRY_GET_PRIVATE (entry);
+
+ if (!private->mode == GIMP_UNIT_ENTRY_MODE_RESOLUTION)
{
/* parse and set value ourselves before GtkSpinButton does so, because
- GtkSpinButton would truncate our input and ignore parts of it */
- gimp_unit_entry_parse (GIMP_UNIT_ENTRY (spinButton));
- gimp_unit_entry_output (spinButton, (gpointer)GIMP_UNIT_ENTRY(spinButton)->unitAdjustment);
+ GtkSpinButton would truncate our input and ignore everything which
+ is not a numbner */
+ gimp_unit_entry_parse (GIMP_UNIT_ENTRY (spin_button));
+ gimp_unit_entry_output (spin_button, (gpointer) gimp_unit_entry_get_adjustment (entry));
}
/* we want GtkSpinButton to handle the input nontheless (there is no problem anymore
@@ -278,18 +317,18 @@ gimp_unit_entry_input (GtkSpinButton *spinButton,
static gboolean
gimp_unit_entry_timer_callback (GtkWidget *entry)
{
- GimpUnitEntry *unit_entry = GIMP_UNIT_ENTRY (entry);
+ GimpUnitEntryPrivate *private = GIMP_UNIT_ENTRY_GET_PRIVATE (GIMP_UNIT_ENTRY (entry));
/* paint entry red if input is invalid */
- if (!unit_entry->input_valid)
+ if (!private->input_valid)
{
GdkColor color;
gdk_color_parse (UNIT_ENTRY_ERROR_COLOR, &color);
- gtk_widget_modify_base (GTK_WIDGET (entry), GTK_STATE_NORMAL, &color);
+ gtk_widget_modify_base (entry, GTK_STATE_NORMAL, &color);
}
/* delete timer */
- unit_entry->timer = NULL;
+ private->timer = NULL;
return FALSE;
}
@@ -299,45 +338,45 @@ gimp_unit_entry_populate_popup (GtkEntry *entry,
GtkMenu *menu,
gpointer user_data)
{
- GtkWidget *menuItem;
- int i = 0;
+ GimpUnitEntryPrivate *private = GIMP_UNIT_ENTRY_GET_PRIVATE (GIMP_UNIT_ENTRY (entry));
+ GtkWidget *menu_item;
+ gint i = 0;
+ gint first_unit;
- /* populate popup with item for each available unit */
- menuItem = gtk_separator_menu_item_new ();
- gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuItem);
+ menu_item = gtk_separator_menu_item_new ();
+ gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
/* ignore PIXEL when in resolution mode */
- (GIMP_UNIT_ENTRY (entry)->mode == GIMP_UNIT_ENTRY_MODE_RESOLUTION) ? (i = 1) : (i = 0);
+ (private->mode == GIMP_UNIT_ENTRY_MODE_RESOLUTION)
+ ? (first_unit = 1) : (first_unit = 0);
- for (; i < gimp_unit_get_number_of_units(); i++)
+ /* populate popup with item for each available unit
+ (reversing iteration order to display commonly used units first) */
+ for (i = gimp_unit_get_number_of_units() - 1; i >= first_unit; i--)
{
- menuItem = gtk_menu_item_new_with_label (gimp_unit_get_singular (i));
- gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuItem);
+ menu_item = gtk_menu_item_new_with_label (gimp_unit_get_singular (i));
+ gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
/* save corresponding unit in menu item */
- g_object_set_data (G_OBJECT (menuItem), "unit", GINT_TO_POINTER (i));
+ g_object_set_data (G_OBJECT (menu_item), "unit", GINT_TO_POINTER (i));
- g_signal_connect(menuItem, "activate",
+ g_signal_connect(menu_item, "activate",
(GCallback) gimp_unit_entry_menu_item,
gimp_unit_entry_get_adjustment (GIMP_UNIT_ENTRY (entry)));
}
- menuItem = gtk_menu_item_new_with_label ("Set Unit:");
- gtk_widget_set_sensitive (menuItem, FALSE);
- gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuItem);
-
gtk_widget_show_all (GTK_WIDGET (menu));
}
static void
-gimp_unit_entry_menu_item (GtkWidget *menuItem,
+gimp_unit_entry_menu_item (GtkWidget *menu_item,
gpointer *user_data)
{
GimpUnitAdjustment *adj = GIMP_UNIT_ADJUSTMENT (user_data);
GimpUnit unit;
/* get selected unit */
- unit = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menuItem), "unit"));
+ unit = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menu_item), "unit"));
/* change unit according to selected unit */
gimp_unit_adjustment_set_unit (adj, unit);
@@ -408,11 +447,11 @@ gimp_unit_entry_get_unit (GimpUnitEntry *entry)
void
gimp_unit_entry_set_bounds (GimpUnitEntry *entry,
GimpUnit unit,
- gdouble upper,
- gdouble lower)
+ gdouble lower,
+ gdouble upper)
{
GimpUnitAdjustment *adj = gimp_unit_entry_get_adjustment (entry);
- gimp_unit_adjustment_set_bounds (adj, unit, upper, lower);
+ gimp_unit_adjustment_set_bounds (adj, unit, lower, upper);
}
void
@@ -426,5 +465,34 @@ void
gimp_unit_entry_set_mode (GimpUnitEntry *entry,
GimpUnitEntryMode mode)
{
- entry->mode = mode;
+ GimpUnitEntryPrivate *private = GIMP_UNIT_ENTRY_GET_PRIVATE (entry);
+
+ private->mode = mode;
+}
+
+/* get string in format "value unit" */
+gchar*
+gimp_unit_entry_to_string (GimpUnitEntry *entry)
+{
+ return gimp_unit_entry_to_string_in_unit (
+ entry,
+ gimp_unit_adjustment_get_unit (gimp_unit_entry_get_adjustment (entry)));
}
+
+gchar*
+gimp_unit_entry_to_string_in_unit (GimpUnitEntry *entry,
+ GimpUnit unit)
+{
+ gdouble value;
+ gchar *text = g_malloc (sizeof (gchar) * UNIT_ENTRY_STRING_LENGTH);
+
+ value = gimp_unit_adjustment_get_value_in_unit (gimp_unit_entry_get_adjustment (entry),
+ unit);
+
+ g_snprintf (text, UNIT_ENTRY_STRING_LENGTH, "%.*f %s",
+ gimp_unit_get_digits (unit),
+ value,
+ gimp_unit_get_abbreviation (unit));
+
+ return text;
+}
diff --git a/libgimpwidgets/gimpunitentry.h b/libgimpwidgets/gimpunitentry.h
index 96ec627..50d90f3 100644
--- a/libgimpwidgets/gimpunitentry.h
+++ b/libgimpwidgets/gimpunitentry.h
@@ -48,20 +48,7 @@ struct _GimpUnitEntry
{
GtkSpinButton parent_instance;
- /* private */
- GimpUnitAdjustment *unitAdjustment; /* for convinience */
-
- /* flag set TRUE when entry's text should not be overwritten
- (i.e. during user input) */
- gboolean dontUpdateText;
-
- /* input mode */
- GimpUnitEntryMode mode;
-
- /* is our input valid? (for error indication) */
- gboolean input_valid;
- /* the timer source which handles the error indication */
- GSource *timer;
+ gpointer private;
};
struct _GimpUnitEntryClass
@@ -95,7 +82,11 @@ void gimp_unit_entry_set_value_in_unit (GimpUnitEntry *ent
gdouble value,
GimpUnit unit);
void gimp_unit_entry_set_pixels (GimpUnitEntry *entry,
- gdouble value);
+ gdouble value);
+
+gchar* gimp_unit_entry_to_string (GimpUnitEntry *entry);
+gchar* gimp_unit_entry_to_string_in_unit (GimpUnitEntry *entry,
+ GimpUnit unit);
void gimp_unit_entry_connect (GimpUnitEntry *entry,
GimpUnitEntry *target);
diff --git a/libgimpwidgets/gimpunitparser.c b/libgimpwidgets/gimpunitparser.c
index 72ebc8a..37693b2 100644
--- a/libgimpwidgets/gimpunitparser.c
+++ b/libgimpwidgets/gimpunitparser.c
@@ -31,10 +31,6 @@
#define DEBUG(x) /* nothing */
#endif
-/**
- * prototypes
- */
-
/* unit resolver for GimpEevl */
static gboolean unit_resolver (const gchar *ident,
GimpEevlQuantity *result,
@@ -46,38 +42,38 @@ gboolean
gimp_unit_parser_parse (const char *str, GimpUnitParserResult *result)
{
/* GimpEevl related stuff */
- GimpEevlQuantity eevlResult;
+ GimpEevlQuantity eevl_result;
GError *error = NULL;
const gchar *errorpos = 0;
if (strlen (str) <= 0)
return FALSE;
- /* set unitFound to FALSE so we can determine the first unit the user entered and use that
+ /* set unit_found to FALSE so we can determine the first unit the user entered and use that
as unit for our result */
- result->unitFound = FALSE;
+ result->unit_found = FALSE;
DEBUG (("parsing: %s", str));
/* parse text via GimpEevl */
gimp_eevl_evaluate (str,
unit_resolver,
- &eevlResult,
+ &eevl_result,
(gpointer) result,
&errorpos,
&error);
- if (error || errorpos || eevlResult.dimension > 1)
+ if (error || errorpos || eevl_result.dimension > 1)
{
DEBUG (("gimpeevl parsing error \n"));
return FALSE;
}
else
{
- DEBUG (("gimpeevl parser result: %s = %lg (%d)", str, eevlResult.value, eevlResult.dimension));
+ DEBUG (("gimpeevl parser result: %s = %lg (%d)", str, eevl_result.value, eevl_result.dimension));
DEBUG (("determined unit: %s\n", gimp_unit_get_abbreviation (result->unit)));
- result->value = eevlResult.value;
+ result->value = eevl_result.value;
}
return TRUE;
@@ -89,11 +85,11 @@ gboolean unit_resolver (const gchar *ident,
GimpEevlQuantity *result,
gpointer user_data)
{
- GimpUnitParserResult *parserResult = (GimpUnitParserResult*) user_data;
- GimpUnit *unit = &(parserResult->unit);
+ GimpUnitParserResult *parser_result = (GimpUnitParserResult*) user_data;
+ GimpUnit *unit = &(parser_result->unit);
gboolean resolved = FALSE;
gboolean default_unit = (ident == NULL);
- gint numUnits = gimp_unit_get_number_of_units ();
+ gint num_units = gimp_unit_get_number_of_units ();
const gchar *abbr;
gint i = 0;
@@ -110,17 +106,18 @@ gboolean unit_resolver (const gchar *ident,
result->dimension = 1;
if (*unit == GIMP_UNIT_PIXEL) /* handle case that unit is px */
- result->value = parserResult->resolution;
- else /* otherwise use factor */
+ result->value = parser_result->resolution;
+ else /* otherwise use unit factor */
result->value = gimp_unit_get_factor (*unit);
- parserResult->unitFound = TRUE;
- resolved = TRUE;
+ parser_result->unit_found = TRUE;
+ resolved = TRUE;
+
return resolved;
}
/* find matching unit */
- for (i = 0; i < numUnits; i++)
+ for (i = 0; i < num_units; i++)
{
abbr = gimp_unit_get_abbreviation (i);
@@ -128,17 +125,17 @@ gboolean unit_resolver (const gchar *ident,
{
/* handle case that unit is px */
if (i == GIMP_UNIT_PIXEL)
- result->value = parserResult->resolution;
+ result->value = parser_result->resolution;
else
result->value = gimp_unit_get_factor (i);
- if (!parserResult->unitFound)
+ if (!parser_result->unit_found)
{
*unit = i;
- parserResult->unitFound = TRUE;
+ parser_result->unit_found = TRUE;
}
- i = numUnits;
+ i = num_units;
resolved = TRUE;
}
}
diff --git a/libgimpwidgets/gimpunitparser.h b/libgimpwidgets/gimpunitparser.h
index 1f32413..230986f 100644
--- a/libgimpwidgets/gimpunitparser.h
+++ b/libgimpwidgets/gimpunitparser.h
@@ -32,7 +32,7 @@ struct _GimpUnitParserResult
gdouble value;
gdouble resolution;
GimpUnit unit;
- gboolean unitFound;
+ gboolean unit_found;
};
gboolean gimp_unit_parser_parse (const char *str, GimpUnitParserResult *result);
diff --git a/libgimpwidgets/gimpwidgets.def b/libgimpwidgets/gimpwidgets.def
index 1dd92ae..7864df9 100644
--- a/libgimpwidgets/gimpwidgets.def
+++ b/libgimpwidgets/gimpwidgets.def
@@ -370,8 +370,6 @@ EXPORTS
gimp_unit_adjustment_set_unit
gimp_unit_adjustment_set_value
gimp_unit_adjustment_set_value_in_unit
- gimp_unit_adjustment_to_string
- gimp_unit_adjustment_to_string_in_unit
gimp_unit_combo_box_get_active
gimp_unit_combo_box_get_type
gimp_unit_combo_box_new
@@ -379,7 +377,6 @@ EXPORTS
gimp_unit_combo_box_set_active
gimp_unit_entries_add_chain_button
gimp_unit_entries_add_entry
- gimp_unit_entries_add_entry_defaults
gimp_unit_entries_add_preview_label
gimp_unit_entries_get_chain_button
gimp_unit_entries_get_entry
@@ -414,6 +411,8 @@ EXPORTS
gimp_unit_entry_set_unit
gimp_unit_entry_set_value
gimp_unit_entry_set_value_in_unit
+ gimp_unit_entry_to_string
+ gimp_unit_entry_to_string_in_unit
gimp_unit_menu_get_pixel_digits
gimp_unit_menu_get_type
gimp_unit_menu_get_unit
diff --git a/libgimpwidgets/test-unitentrygui.c b/libgimpwidgets/test-unitentrygui.c
index f16dfcb..077dcda 100644
--- a/libgimpwidgets/test-unitentrygui.c
+++ b/libgimpwidgets/test-unitentrygui.c
@@ -41,8 +41,8 @@ create_interface(void)
/* entry table */
entries = GIMP_UNIT_ENTRIES (gimp_unit_entries_new ());
- gimp_unit_entries_add_entry_defaults (entries, "width", "Width");
- gimp_unit_entries_add_entry_defaults (entries, "height", "Height");
+ gimp_unit_entries_add_entry (entries, "width", "Width");
+ gimp_unit_entries_add_entry (entries, "height", "Height");
gimp_unit_entries_add_preview_label (entries, GIMP_UNIT_PIXEL, "width", "height");
gimp_unit_entries_add_chain_button (entries, "width", "height");
@@ -53,12 +53,12 @@ create_interface(void)
gimp_unit_adjustment_set_value (gimp_unit_entry_get_adjustment (a), 20);
gimp_unit_adjustment_set_value (gimp_unit_entry_get_adjustment (b), 20);
- gtk_box_pack_start (GTK_BOX (vbox), entries->table, FALSE, TRUE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), gimp_unit_entries_get_table (entries), FALSE, TRUE, 0);
/* resolution entry */
entries = GIMP_UNIT_ENTRIES (gimp_unit_entries_new ());
- gimp_unit_entries_add_entry_defaults (entries, "xres", "X Resolution");
- gimp_unit_entries_add_entry_defaults (entries, "yres", "Y Resolution");
+ gimp_unit_entries_add_entry (entries, "xres", "X Resolution");
+ gimp_unit_entries_add_entry (entries, "yres", "Y Resolution");
/* set some default values */
a = gimp_unit_entries_get_entry (entries, "xres");
@@ -68,7 +68,7 @@ create_interface(void)
gimp_unit_entry_set_mode (a, GIMP_UNIT_ENTRY_MODE_RESOLUTION);
gimp_unit_entry_set_mode (b, GIMP_UNIT_ENTRY_MODE_RESOLUTION);
- gtk_box_pack_end (GTK_BOX (vbox), entries->table, FALSE, TRUE, 5);
+ gtk_box_pack_end (GTK_BOX (vbox), gimp_unit_entries_get_table (entries), FALSE, TRUE, 5);
/* signals */
g_signal_connect_swapped (G_OBJECT(window), "destroy",
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
