summaryrefslogtreecommitdiffstats
path: root/plug-ins/common/unit-editor.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--plug-ins/common/unit-editor.c700
1 files changed, 700 insertions, 0 deletions
diff --git a/plug-ins/common/unit-editor.c b/plug-ins/common/unit-editor.c
new file mode 100644
index 0000000..4156fe6
--- /dev/null
+++ b/plug-ins/common/unit-editor.c
@@ -0,0 +1,700 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This is a plug-in for GIMP.
+ *
+ * Copyright (C) 2000 Michael Natterer <mitch@gimp.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include <libgimp/gimp.h>
+#include <libgimp/gimpui.h>
+
+#include "libgimp/stdplugins-intl.h"
+
+
+#define PLUG_IN_PROC "plug-in-unit-editor"
+#define PLUG_IN_BINARY "unit-editor"
+#define PLUG_IN_ROLE "gimp-unit-editor"
+#define RESPONSE_REFRESH 1
+
+enum
+{
+ SAVE,
+ IDENTIFIER,
+ FACTOR,
+ DIGITS,
+ SYMBOL,
+ ABBREVIATION,
+ SINGULAR,
+ PLURAL,
+ UNIT,
+ USER_UNIT,
+ BG_COLOR,
+ NUM_COLUMNS
+};
+
+typedef struct
+{
+ const gchar *title;
+ const gchar *help;
+
+} UnitColumn;
+
+
+static void query (void);
+static void run (const gchar *name,
+ gint n_params,
+ const GimpParam *param,
+ gint *n_return_vals,
+ GimpParam **return_vals);
+
+static GimpUnit new_unit_dialog (GtkWidget *main_dialog,
+ GimpUnit template);
+static void unit_editor_dialog (void);
+static void unit_editor_response (GtkWidget *widget,
+ gint response_id,
+ gpointer data);
+static void new_callback (GtkAction *action,
+ GtkTreeView *tv);
+static void duplicate_callback (GtkAction *action,
+ GtkTreeView *tv);
+static void saved_toggled_callback (GtkCellRendererToggle *celltoggle,
+ gchar *path_string,
+ GtkListStore *list_store);
+static void unit_list_init (GtkTreeView *tv);
+
+
+const GimpPlugInInfo PLUG_IN_INFO =
+{
+ NULL, /* init_proc */
+ NULL, /* quit_proc */
+ query, /* query_proc */
+ run, /* run_proc */
+};
+
+static const UnitColumn columns[] =
+{
+ { N_("Saved"), N_("A unit definition will only be saved before "
+ "GIMP exits if this column is checked.") },
+ { N_("ID"), N_("This string will be used to identify a "
+ "unit in GIMP's configuration files.") },
+ { N_("Factor"), N_("How many units make up an inch.") },
+ { N_("Digits"), N_("This field is a hint for numerical input "
+ "fields. It specifies how many decimal digits "
+ "the input field should provide to get "
+ "approximately the same accuracy as an "
+ "\"inch\" input field with two decimal digits.") },
+ { N_("Symbol"), N_("The unit's symbol if it has one (e.g. \" "
+ "for inches). The unit's abbreviation is used "
+ "if doesn't have a symbol.") },
+ { N_("Abbreviation"), N_("The unit's abbreviation (e.g. \"cm\" for "
+ "centimeters).") },
+ { N_("Singular"), N_("The unit's singular form.") },
+ { N_("Plural"), N_("The unit's plural form.") }
+};
+
+static GtkActionEntry actions[] =
+{
+ { "unit-editor-toolbar", NULL,
+ "Unit Editor Toolbar", NULL, NULL, NULL
+ },
+
+ { "unit-editor-new", GIMP_ICON_DOCUMENT_NEW,
+ NULL, "<control>N",
+ N_("Create a new unit from scratch"),
+ G_CALLBACK (new_callback)
+ },
+
+ { "unit-editor-duplicate", GIMP_ICON_OBJECT_DUPLICATE,
+ NULL, "<control>D",
+ N_("Create a new unit using the currently selected unit as template"),
+ G_CALLBACK (duplicate_callback)
+ }
+};
+
+
+MAIN ()
+
+
+static void
+query (void)
+{
+ static const GimpParamDef args[] =
+ {
+ { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0) }" }
+ };
+
+ gimp_install_procedure (PLUG_IN_PROC,
+ N_("Create or alter units used in GIMP"),
+ "The GIMP unit editor",
+ "Michael Natterer <mitch@gimp.org>",
+ "Michael Natterer <mitch@gimp.org>",
+ "2000",
+ N_("U_nits"),
+ "",
+ GIMP_PLUGIN,
+ G_N_ELEMENTS (args), 0,
+ args, NULL);
+
+ gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Edit/Preferences");
+ gimp_plugin_icon_register (PLUG_IN_PROC, GIMP_ICON_TYPE_ICON_NAME,
+ (const guint8 *) GIMP_ICON_TOOL_MEASURE);
+}
+
+static void
+run (const gchar *name,
+ gint nparams,
+ const GimpParam *param,
+ gint *nreturn_vals,
+ GimpParam **return_vals)
+{
+ static GimpParam values[2];
+
+ INIT_I18N ();
+
+ *nreturn_vals = 1;
+ *return_vals = values;
+
+ values[0].type = GIMP_PDB_STATUS;
+ values[0].data.d_status = GIMP_PDB_CALLING_ERROR;
+
+ if (strcmp (name, PLUG_IN_PROC) == 0)
+ {
+ values[0].data.d_status = GIMP_PDB_SUCCESS;
+
+ unit_editor_dialog ();
+ }
+}
+
+static GimpUnit
+new_unit_dialog (GtkWidget *main_dialog,
+ GimpUnit template)
+{
+ GtkWidget *dialog;
+ GtkWidget *table;
+ GtkWidget *entry;
+ GtkWidget *spinbutton;
+
+ GtkWidget *identifier_entry;
+ GtkAdjustment *factor_adj;
+ GtkAdjustment *digits_adj;
+ GtkWidget *symbol_entry;
+ GtkWidget *abbreviation_entry;
+ GtkWidget *singular_entry;
+ GtkWidget *plural_entry;
+
+ GimpUnit unit = GIMP_UNIT_PIXEL;
+
+ dialog = gimp_dialog_new (_("Add a New Unit"), PLUG_IN_ROLE,
+ main_dialog, GTK_DIALOG_MODAL,
+ gimp_standard_help_func, PLUG_IN_PROC,
+
+ _("_Cancel"), GTK_RESPONSE_CANCEL,
+ _("_Add"), GTK_RESPONSE_OK,
+
+ NULL);
+
+ gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
+ GTK_RESPONSE_OK,
+ GTK_RESPONSE_CANCEL,
+ -1);
+
+ table = gtk_table_new (7, 2, FALSE);
+ gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+ gtk_table_set_row_spacings (GTK_TABLE (table), 6);
+ gtk_container_set_border_width (GTK_CONTAINER (table), 12);
+ gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+ table, FALSE, FALSE, 0);
+ gtk_widget_show (table);
+
+ entry = identifier_entry = gtk_entry_new ();
+ if (template != GIMP_UNIT_PIXEL)
+ {
+ gtk_entry_set_text (GTK_ENTRY (entry),
+ gimp_unit_get_identifier (template));
+ }
+ gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
+ _("_ID:"), 0.0, 0.5,
+ entry, 1, FALSE);
+
+ gimp_help_set_help_data (entry, gettext (columns[IDENTIFIER].help), NULL);
+
+ factor_adj = (GtkAdjustment *)
+ gtk_adjustment_new ((template != GIMP_UNIT_PIXEL) ?
+ gimp_unit_get_factor (template) : 1.0,
+ GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION,
+ 0.01, 0.1, 0.0);
+ spinbutton = gimp_spin_button_new (factor_adj, 0.01, 5);
+ gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
+ gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
+ _("_Factor:"), 0.0, 0.5,
+ spinbutton, 1, TRUE);
+
+ gimp_help_set_help_data (spinbutton, gettext (columns[FACTOR].help), NULL);
+
+ digits_adj = (GtkAdjustment *)
+ gtk_adjustment_new ((template != GIMP_UNIT_PIXEL) ?
+ gimp_unit_get_digits (template) : 2.0,
+ 0, 5, 1, 1, 0);
+ spinbutton = gimp_spin_button_new (digits_adj, 0, 0);
+ gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
+ gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
+ _("_Digits:"), 0.0, 0.5,
+ spinbutton, 1, TRUE);
+
+ gimp_help_set_help_data (spinbutton, gettext (columns[DIGITS].help), NULL);
+
+ entry = symbol_entry = gtk_entry_new ();
+ if (template != GIMP_UNIT_PIXEL)
+ {
+ gtk_entry_set_text (GTK_ENTRY (entry),
+ gimp_unit_get_symbol (template));
+ }
+ gimp_table_attach_aligned (GTK_TABLE (table), 0, 3,
+ _("_Symbol:"), 0.0, 0.5,
+ entry, 1, FALSE);
+
+ gimp_help_set_help_data (entry, gettext (columns[SYMBOL].help), NULL);
+
+ entry = abbreviation_entry = gtk_entry_new ();
+ if (template != GIMP_UNIT_PIXEL)
+ {
+ gtk_entry_set_text (GTK_ENTRY (entry),
+ gimp_unit_get_abbreviation (template));
+ }
+ gimp_table_attach_aligned (GTK_TABLE (table), 0, 4,
+ _("_Abbreviation:"), 0.0, 0.5,
+ entry, 1, FALSE);
+
+ gimp_help_set_help_data (entry, gettext (columns[ABBREVIATION].help), NULL);
+
+ entry = singular_entry = gtk_entry_new ();
+ if (template != GIMP_UNIT_PIXEL)
+ {
+ gtk_entry_set_text (GTK_ENTRY (entry),
+ gimp_unit_get_singular (template));
+ }
+ gimp_table_attach_aligned (GTK_TABLE (table), 0, 5,
+ _("Si_ngular:"), 0.0, 0.5,
+ entry, 1, FALSE);
+
+ gimp_help_set_help_data (entry, gettext (columns[SINGULAR].help), NULL);
+
+ entry = plural_entry = gtk_entry_new ();
+ if (template != GIMP_UNIT_PIXEL)
+ {
+ gtk_entry_set_text (GTK_ENTRY (entry),
+ gimp_unit_get_plural (template));
+ }
+ gimp_table_attach_aligned (GTK_TABLE (table), 0, 6,
+ _("_Plural:"), 0.0, 0.5,
+ entry, 1, FALSE);
+
+ gimp_help_set_help_data (entry, gettext (columns[PLURAL].help), NULL);
+
+ gtk_widget_show (dialog);
+
+ while (TRUE)
+ {
+ gchar *identifier;
+ gdouble factor;
+ gint digits;
+ gchar *symbol;
+ gchar *abbreviation;
+ gchar *singular;
+ gchar *plural;
+
+ if (gimp_dialog_run (GIMP_DIALOG (dialog)) != GTK_RESPONSE_OK)
+ break;
+
+ identifier = g_strdup (gtk_entry_get_text (GTK_ENTRY (identifier_entry)));
+ factor = gtk_adjustment_get_value (GTK_ADJUSTMENT (factor_adj));
+ digits = gtk_adjustment_get_value (GTK_ADJUSTMENT (digits_adj));
+ symbol = g_strdup (gtk_entry_get_text (GTK_ENTRY (symbol_entry)));
+ abbreviation = g_strdup (gtk_entry_get_text (GTK_ENTRY (abbreviation_entry)));
+ singular = g_strdup (gtk_entry_get_text (GTK_ENTRY (singular_entry)));
+ plural = g_strdup (gtk_entry_get_text (GTK_ENTRY (plural_entry)));
+
+ identifier = g_strstrip (identifier);
+ symbol = g_strstrip (symbol);
+ abbreviation = g_strstrip (abbreviation);
+ singular = g_strstrip (singular);
+ plural = g_strstrip (plural);
+
+ if (! strlen (identifier) ||
+ ! strlen (symbol) ||
+ ! strlen (abbreviation) ||
+ ! strlen (singular) ||
+ ! strlen (plural))
+ {
+ GtkWidget *msg = gtk_message_dialog_new (GTK_WINDOW (dialog), 0,
+ GTK_MESSAGE_ERROR,
+ GTK_BUTTONS_OK,
+ _("Incomplete input"));
+
+ gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (msg),
+ _("Please fill in all text fields."));
+ gtk_dialog_run (GTK_DIALOG (msg));
+ gtk_widget_destroy (msg);
+
+ continue;
+ }
+
+ unit = gimp_unit_new (identifier,
+ factor, digits,
+ symbol, abbreviation, singular, plural);
+
+ g_free (identifier);
+ g_free (symbol);
+ g_free (abbreviation);
+ g_free (singular);
+ g_free (plural);
+
+ break;
+ }
+
+ gtk_widget_destroy (dialog);
+
+ return unit;
+}
+
+static void
+unit_editor_dialog (void)
+{
+ GtkWidget *dialog;
+ GtkWidget *scrolled_win;
+ GtkUIManager *ui_manager;
+ GtkActionGroup *group;
+ GtkWidget *toolbar;
+ GtkListStore *list_store;
+ GtkWidget *tv;
+ GtkTreeViewColumn *col;
+ GtkWidget *col_widget;
+ GtkWidget *button;
+ GtkCellRenderer *rend;
+ gint i;
+
+ gimp_ui_init (PLUG_IN_BINARY, FALSE);
+
+ list_store = gtk_list_store_new (NUM_COLUMNS,
+ G_TYPE_BOOLEAN, /* SAVE */
+ G_TYPE_STRING, /* IDENTIFIER */
+ G_TYPE_DOUBLE, /* FACTOR */
+ G_TYPE_INT, /* DIGITS */
+ G_TYPE_STRING, /* SYMBOL */
+ G_TYPE_STRING, /* ABBREVIATION */
+ G_TYPE_STRING, /* SINGULAR */
+ G_TYPE_STRING, /* PLURAL */
+ GIMP_TYPE_UNIT, /* UNIT */
+ G_TYPE_BOOLEAN, /* USER_UNIT */
+ GDK_TYPE_COLOR); /* BG_COLOR */
+
+ tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
+ g_object_unref (list_store);
+
+ dialog = gimp_dialog_new (_("Unit Editor"), PLUG_IN_ROLE,
+ NULL, 0,
+ gimp_standard_help_func, PLUG_IN_PROC,
+
+ _("_Refresh"), RESPONSE_REFRESH,
+ _("_Close"), GTK_RESPONSE_CLOSE,
+
+ NULL);
+
+ gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
+
+ g_signal_connect (dialog, "response",
+ G_CALLBACK (unit_editor_response),
+ tv);
+ g_signal_connect (dialog, "destroy",
+ G_CALLBACK (gtk_main_quit),
+ NULL);
+
+ /* the toolbar */
+ ui_manager = gtk_ui_manager_new ();
+
+ group = gtk_action_group_new ("unit-editor");
+
+ gtk_action_group_set_translation_domain (group, NULL);
+ gtk_action_group_add_actions (group, actions, G_N_ELEMENTS (actions), tv);
+
+ gtk_window_add_accel_group (GTK_WINDOW (dialog),
+ gtk_ui_manager_get_accel_group (ui_manager));
+ gtk_accel_group_lock (gtk_ui_manager_get_accel_group (ui_manager));
+
+ gtk_ui_manager_insert_action_group (ui_manager, group, -1);
+ g_object_unref (group);
+
+ gtk_ui_manager_add_ui_from_string
+ (ui_manager,
+ "<ui>\n"
+ " <toolbar action=\"unit-editor-toolbar\">\n"
+ " <toolitem action=\"unit-editor-new\" />\n"
+ " <toolitem action=\"unit-editor-duplicate\" />\n"
+ " </toolbar>\n"
+ "</ui>\n",
+ -1, NULL);
+
+ toolbar = gtk_ui_manager_get_widget (ui_manager, "/unit-editor-toolbar");
+ gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+ toolbar, FALSE, FALSE, 0);
+ gtk_widget_show (toolbar);
+
+ scrolled_win = gtk_scrolled_window_new (NULL, NULL);
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win),
+ GTK_SHADOW_IN);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
+ GTK_POLICY_NEVER,
+ GTK_POLICY_ALWAYS);
+ gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 12);
+ gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+ scrolled_win, TRUE, TRUE, 0);
+ gtk_widget_show (scrolled_win);
+
+ gtk_widget_set_size_request (tv, -1, 220);
+ gtk_container_add (GTK_CONTAINER (scrolled_win), tv);
+ gtk_widget_show (tv);
+
+ rend = gtk_cell_renderer_toggle_new ();
+ col =
+ gtk_tree_view_column_new_with_attributes (gettext (columns[SAVE].title),
+ rend,
+ "active", SAVE,
+ "activatable", USER_UNIT,
+ "cell-background-gdk", BG_COLOR,
+ NULL);
+
+ gtk_tree_view_append_column (GTK_TREE_VIEW (tv), col);
+
+ col_widget = gtk_tree_view_column_get_widget (col);
+ if (col_widget)
+ {
+ button = gtk_widget_get_ancestor (col_widget, GTK_TYPE_BUTTON);
+
+ if (button)
+ gimp_help_set_help_data (button,
+ gettext (columns[SAVE].help), NULL);
+ }
+
+ g_signal_connect (rend, "toggled",
+ G_CALLBACK (saved_toggled_callback),
+ list_store);
+
+ for (i = 0; i < G_N_ELEMENTS (columns); i++)
+ {
+ if (i == SAVE)
+ continue;
+
+ col =
+ gtk_tree_view_column_new_with_attributes (gettext (columns[i].title),
+ gtk_cell_renderer_text_new (),
+ "text", i,
+ "cell-background-gdk", BG_COLOR,
+ NULL);
+
+ gtk_tree_view_append_column (GTK_TREE_VIEW (tv), col);
+
+ col_widget = gtk_tree_view_column_get_widget (col);
+ if (col_widget)
+ {
+ button = gtk_widget_get_ancestor (col_widget, GTK_TYPE_BUTTON);
+
+ if (button)
+ gimp_help_set_help_data (button, gettext (columns[i].help), NULL);
+ }
+ }
+
+ unit_list_init (GTK_TREE_VIEW (tv));
+
+ gtk_widget_show (dialog);
+
+ gtk_main ();
+}
+
+static void
+unit_editor_response (GtkWidget *widget,
+ gint response_id,
+ gpointer data)
+{
+ switch (response_id)
+ {
+ case RESPONSE_REFRESH:
+ unit_list_init (GTK_TREE_VIEW (data));
+ break;
+
+ default:
+ gtk_widget_destroy (widget);
+ break;
+ }
+}
+
+static void
+new_callback (GtkAction *action,
+ GtkTreeView *tv)
+{
+ GimpUnit unit;
+
+ unit = new_unit_dialog (gtk_widget_get_toplevel (GTK_WIDGET (tv)),
+ GIMP_UNIT_PIXEL);
+
+ if (unit != GIMP_UNIT_PIXEL)
+ {
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+
+ unit_list_init (tv);
+
+ model = gtk_tree_view_get_model (tv);
+
+ if (gtk_tree_model_get_iter_first (model, &iter) &&
+ gtk_tree_model_iter_nth_child (model, &iter,
+ NULL, unit - GIMP_UNIT_INCH))
+ {
+ GtkAdjustment *adj;
+
+ gtk_tree_selection_select_iter (gtk_tree_view_get_selection (tv),
+ &iter);
+
+ adj = gtk_tree_view_get_vadjustment (tv);
+ gtk_adjustment_set_value (adj, gtk_adjustment_get_upper (adj));
+ }
+ }
+}
+
+static void
+duplicate_callback (GtkAction *action,
+ GtkTreeView *tv)
+{
+ GtkTreeModel *model;
+ GtkTreeSelection *sel;
+ GtkTreeIter iter;
+
+ model = gtk_tree_view_get_model (tv);
+ sel = gtk_tree_view_get_selection (tv);
+
+ if (gtk_tree_selection_get_selected (sel, NULL, &iter))
+ {
+ GimpUnit unit;
+
+ gtk_tree_model_get (model, &iter,
+ UNIT, &unit,
+ -1);
+
+ unit = new_unit_dialog (gtk_widget_get_toplevel (GTK_WIDGET (tv)),
+ unit);
+
+ if (unit != GIMP_UNIT_PIXEL)
+ {
+ GtkTreeIter iter;
+
+ unit_list_init (tv);
+
+ if (gtk_tree_model_get_iter_first (model, &iter) &&
+ gtk_tree_model_iter_nth_child (model, &iter,
+ NULL, unit - GIMP_UNIT_INCH))
+ {
+ GtkAdjustment *adj;
+
+ gtk_tree_selection_select_iter (sel, &iter);
+
+ adj = gtk_tree_view_get_vadjustment (tv);
+ gtk_adjustment_set_value (adj, gtk_adjustment_get_upper (adj));
+ }
+ }
+ }
+}
+
+static void
+saved_toggled_callback (GtkCellRendererToggle *celltoggle,
+ gchar *path_string,
+ GtkListStore *list_store)
+{
+ GtkTreePath *path;
+ GtkTreeIter iter;
+ gboolean saved;
+ GimpUnit unit;
+
+ path = gtk_tree_path_new_from_string (path_string);
+
+ if (! gtk_tree_model_get_iter (GTK_TREE_MODEL (list_store), &iter, path))
+ {
+ g_warning ("%s: bad tree path?", G_STRLOC);
+ return;
+ }
+ gtk_tree_path_free (path);
+
+ gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
+ SAVE, &saved,
+ UNIT, &unit,
+ -1);
+
+ if (unit >= gimp_unit_get_number_of_built_in_units ())
+ {
+ gimp_unit_set_deletion_flag (unit, saved);
+ gtk_list_store_set (GTK_LIST_STORE (list_store), &iter,
+ SAVE, ! saved,
+ -1);
+ }
+}
+
+static void
+unit_list_init (GtkTreeView *tv)
+{
+ GtkListStore *list_store;
+ GtkTreeIter iter;
+ gint num_units;
+ GimpUnit unit;
+ GdkColor color;
+
+ list_store = GTK_LIST_STORE (gtk_tree_view_get_model (tv));
+
+ gtk_list_store_clear (list_store);
+
+ num_units = gimp_unit_get_number_of_units ();
+
+ color.red = 0xdddd;
+ color.green = 0xdddd;
+ color.blue = 0xffff;
+
+ for (unit = GIMP_UNIT_INCH; unit < num_units; unit++)
+ {
+ gboolean user_unit = (unit >= gimp_unit_get_number_of_built_in_units ());
+
+ gtk_list_store_append (list_store, &iter);
+ gtk_list_store_set (list_store, &iter,
+ SAVE, ! gimp_unit_get_deletion_flag (unit),
+ IDENTIFIER, gimp_unit_get_identifier (unit),
+ FACTOR, gimp_unit_get_factor (unit),
+ DIGITS, gimp_unit_get_digits (unit),
+ SYMBOL, gimp_unit_get_symbol (unit),
+ ABBREVIATION, gimp_unit_get_abbreviation (unit),
+ SINGULAR, gimp_unit_get_singular (unit),
+ PLURAL, gimp_unit_get_plural (unit),
+ UNIT, unit,
+ USER_UNIT, user_unit,
+
+ user_unit ? -1 : BG_COLOR, &color,
+
+ -1);
+ }
+
+ if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter))
+ gtk_tree_selection_select_iter (gtk_tree_view_get_selection (tv), &iter);
+}