← Back to branch summary

~ubuntu-branches/ubuntu/maverick/gimp/maverick-updates

« back to all changes in this revision

Viewing changes to libgimpwidgets/gimpintcombobox.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2005-12-09 19:44:52 UTC
  • Revision ID: james.westby@ubuntu.com-20051209194452-yggpemjlofpjqyf4
Tags: upstream-2.2.9
Import upstream version 2.2.9

Show diffs side-by-side

added added

removed removed

Lines of Context:
libgimpwidgets/gimpintcombobox.c
 
1
/* LIBGIMP - The GIMP Library
 
2
 * Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
 
3
 *
 
4
 * gimpintcombobox.c
 
5
 * Copyright (C) 2004  Sven Neumann <sven@gimp.org>
 
6
 *
 
7
 * This library is free software; you can redistribute it and/or
 
8
 * modify it under the terms of the GNU Lesser General Public
 
9
 * License as published by the Free Software Foundation; either
 
10
 * version 2 of the License, or (at your option) any later version.
 
11
 *
 
12
 * This library is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
15
 * Lesser General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU Lesser General Public
 
18
 * License along with this library; if not, write to the
 
19
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 
20
 * Boston, MA 02111-1307, USA.
 
21
 */
 
22
 
 
23
#include "config.h"
 
24
 
 
25
#include <libintl.h>
 
26
 
 
27
#include <gtk/gtk.h>
 
28
 
 
29
#include "gimpwidgetstypes.h"
 
30
 
 
31
#include "gimpintcombobox.h"
 
32
#include "gimpintstore.h"
 
33
 
 
34
 
 
35
static void  gimp_int_combo_box_init (GimpIntComboBox *combo_box);
 
36
 
 
37
 
 
38
GType
 
39
gimp_int_combo_box_get_type (void)
 
40
{
 
41
  static GType box_type = 0;
 
42
 
 
43
  if (! box_type)
 
44
    {
 
45
      static const GTypeInfo box_info =
 
46
      {
 
47
        sizeof (GimpIntComboBoxClass),
 
48
        NULL,           /* base_init      */
 
49
        NULL,           /* base_finalize  */
 
50
        NULL,           /* class_init     */
 
51
        NULL,           /* class_finalize */
 
52
        NULL,           /* class_data     */
 
53
        sizeof (GimpIntComboBox),
 
54
        0,              /* n_preallocs    */
 
55
        (GInstanceInitFunc) gimp_int_combo_box_init
 
56
      };
 
57
 
 
58
      box_type = g_type_register_static (GTK_TYPE_COMBO_BOX,
 
59
                                         "GimpIntComboBox",
 
60
                                         &box_info, 0);
 
61
    }
 
62
 
 
63
  return box_type;
 
64
}
 
65
 
 
66
static void
 
67
gimp_int_combo_box_init (GimpIntComboBox *combo_box)
 
68
{
 
69
  GtkListStore    *store;
 
70
  GtkCellRenderer *cell;
 
71
 
 
72
  store = gimp_int_store_new ();
 
73
 
 
74
  gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (store));
 
75
 
 
76
  g_object_unref (store);
 
77
 
 
78
  cell = gtk_cell_renderer_pixbuf_new ();
 
79
  gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), cell, FALSE);
 
80
  gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), cell,
 
81
                                  "stock_id", GIMP_INT_STORE_STOCK_ID,
 
82
                                  "pixbuf",   GIMP_INT_STORE_PIXBUF,
 
83
                                  NULL);
 
84
 
 
85
  cell = gtk_cell_renderer_text_new ();
 
86
  gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), cell, TRUE);
 
87
  gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), cell,
 
88
                                  "text", GIMP_INT_STORE_LABEL,
 
89
                                  NULL);
 
90
}
 
91
 
 
92
 
 
93
/**
 
94
 * gimp_int_combo_box_new:
 
95
 * @first_label: the label of the first item
 
96
 * @first_value: the value of the first item
 
97
 * @...: a %NULL terminated list of more label, value pairs
 
98
 *
 
99
 * Creates a GtkComboBox that has integer values associated with each
 
100
 * item. The items to fill the combo box with are specified as a %NULL
 
101
 * terminated list of label/value pairs.
 
102
 *
 
103
 * Return value: a new #GimpIntComboBox.
 
104
 *
 
105
 * Since: GIMP 2.2
 
106
 **/
 
107
GtkWidget *
 
108
gimp_int_combo_box_new (const gchar *first_label,
 
109
                        gint         first_value,
 
110
                        ...)
 
111
{
 
112
  GtkWidget *combo_box;
 
113
  va_list    args;
 
114
 
 
115
  va_start (args, first_value);
 
116
 
 
117
  combo_box = gimp_int_combo_box_new_valist (first_label, first_value, args);
 
118
 
 
119
  va_end (args);
 
120
 
 
121
  return combo_box;
 
122
}
 
123
 
 
124
/**
 
125
 * gimp_int_combo_box_new_valist:
 
126
 * @first_label: the label of the first item
 
127
 * @first_value: the value of the first item
 
128
 * @values: a va_list with more values
 
129
 *
 
130
 * A variant of gimp_int_combo_box_new() that takes a va_list of
 
131
 * label/value pairs. Probably only useful for language bindings.
 
132
 *
 
133
 * Return value: a new #GimpIntComboBox.
 
134
 *
 
135
 * Since: GIMP 2.2
 
136
 **/
 
137
GtkWidget *
 
138
gimp_int_combo_box_new_valist (const gchar *first_label,
 
139
                               gint         first_value,
 
140
                               va_list      values)
 
141
{
 
142
  GtkWidget    *combo_box;
 
143
  GtkListStore *store;
 
144
  const gchar  *label;
 
145
  gint          value;
 
146
 
 
147
  store = gimp_int_store_new ();
 
148
 
 
149
  combo_box = g_object_new (GIMP_TYPE_INT_COMBO_BOX,
 
150
                            "model", store,
 
151
                            NULL);
 
152
  g_object_unref (store);
 
153
 
 
154
  for (label = first_label, value = first_value;
 
155
       label;
 
156
       label = va_arg (values, const gchar *), value = va_arg (values, gint))
 
157
    {
 
158
      GtkTreeIter  iter;
 
159
 
 
160
      gtk_list_store_append (store, &iter);
 
161
      gtk_list_store_set (store, &iter,
 
162
                          GIMP_INT_STORE_VALUE, value,
 
163
                          GIMP_INT_STORE_LABEL, label,
 
164
                          -1);
 
165
    }
 
166
 
 
167
  return combo_box;
 
168
}
 
169
 
 
170
/**
 
171
 * gimp_int_combo_box_new_array:
 
172
 * @n_values: the number of values
 
173
 * @labels:   an array of labels (array length must be @n_values)
 
174
 *
 
175
 * A variant of gimp_int_combo_box_new() that takes an array of labels.
 
176
 * The array indices are used as values.
 
177
 *
 
178
 * Return value: a new #GimpIntComboBox.
 
179
 *
 
180
 * Since: GIMP 2.2
 
181
 **/
 
182
GtkWidget *
 
183
gimp_int_combo_box_new_array (gint         n_values,
 
184
                              const gchar *labels[])
 
185
{
 
186
  GtkWidget    *combo_box;
 
187
  GtkListStore *store;
 
188
  gint          i;
 
189
 
 
190
  g_return_val_if_fail (n_values > 0, NULL);
 
191
  g_return_val_if_fail (labels != NULL, NULL);
 
192
 
 
193
  store = gimp_int_store_new ();
 
194
 
 
195
  combo_box = g_object_new (GIMP_TYPE_INT_COMBO_BOX,
 
196
                            "model", store,
 
197
                            NULL);
 
198
  g_object_unref (store);
 
199
 
 
200
  for (i = 0; i < n_values; i++)
 
201
    {
 
202
      GtkTreeIter  iter;
 
203
 
 
204
      if (labels[i])
 
205
        {
 
206
          gtk_list_store_append (store, &iter);
 
207
          gtk_list_store_set (store, &iter,
 
208
                              GIMP_INT_STORE_VALUE, i,
 
209
                              GIMP_INT_STORE_LABEL, gettext (labels[i]),
 
210
                              -1);
 
211
        }
 
212
    }
 
213
 
 
214
  return combo_box;
 
215
}
 
216
 
 
217
/**
 
218
 * gimp_int_combo_box_prepend:
 
219
 * @combo_box: a #GimpIntComboBox
 
220
 * @...:       pairs of column number and value, terminated with -1
 
221
 *
 
222
 * This function provides a convenient way to prepend items to a
 
223
 * #GimpIntComboBox. It prepends a row to the @combo_box's list store
 
224
 * and calls gtk_list_store_set() for you.
 
225
 *
 
226
 * The column number must be taken from the enum #GimpIntStoreColumns.
 
227
 *
 
228
 * Since: GIMP 2.2
 
229
 **/
 
230
void
 
231
gimp_int_combo_box_prepend (GimpIntComboBox *combo_box,
 
232
                            ...)
 
233
{
 
234
  GtkListStore *store;
 
235
  GtkTreeIter   iter;
 
236
  va_list       args;
 
237
 
 
238
  g_return_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box));
 
239
 
 
240
  store = GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box)));
 
241
 
 
242
  va_start (args, combo_box);
 
243
 
 
244
  gtk_list_store_prepend (store, &iter);
 
245
  gtk_list_store_set_valist (store, &iter, args);
 
246
 
 
247
  va_end (args);
 
248
}
 
249
 
 
250
/**
 
251
 * gimp_int_combo_box_append:
 
252
 * @combo_box: a #GimpIntComboBox
 
253
 * @...:       pairs of column number and value, terminated with -1
 
254
 *
 
255
 * This function provides a convenient way to append items to a
 
256
 * #GimpIntComboBox. It appends a row to the @combo_box's list store
 
257
 * and calls gtk_list_store_set() for you.
 
258
 *
 
259
 * The column number must be taken from the enum #GimpIntStoreColumns.
 
260
 *
 
261
 * Since: GIMP 2.2
 
262
 **/
 
263
void
 
264
gimp_int_combo_box_append (GimpIntComboBox *combo_box,
 
265
                           ...)
 
266
{
 
267
  GtkListStore *store;
 
268
  GtkTreeIter   iter;
 
269
  va_list       args;
 
270
 
 
271
  g_return_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box));
 
272
 
 
273
  store = GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box)));
 
274
 
 
275
  va_start (args, combo_box);
 
276
 
 
277
  gtk_list_store_append (store, &iter);
 
278
  gtk_list_store_set_valist (store, &iter, args);
 
279
 
 
280
  va_end (args);
 
281
}
 
282
 
 
283
/**
 
284
 * gimp_int_combo_box_set_active:
 
285
 * @combo_box: a #GimpIntComboBox
 
286
 * @value:     an integer value
 
287
 *
 
288
 * Looks up the item that belongs to the given @value and makes it the
 
289
 * selected item in the @combo_box.
 
290
 *
 
291
 * Return value: %TRUE on success or %FALSE if there was no item for
 
292
 *               this value.
 
293
 *
 
294
 * Since: GIMP 2.2
 
295
 **/
 
296
gboolean
 
297
gimp_int_combo_box_set_active (GimpIntComboBox *combo_box,
 
298
                               gint             value)
 
299
{
 
300
  GtkTreeModel *model;
 
301
  GtkTreeIter   iter;
 
302
 
 
303
  g_return_val_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box), FALSE);
 
304
 
 
305
  model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box));
 
306
 
 
307
  if (gimp_int_store_lookup_by_value (model, value, &iter))
 
308
    {
 
309
      gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo_box), &iter);
 
310
      return TRUE;
 
311
    }
 
312
 
 
313
  return FALSE;
 
314
}
 
315
 
 
316
/**
 
317
 * gimp_int_combo_box_get_active:
 
318
 * @combo_box: a #GimpIntComboBox
 
319
 * @value:     return location for the integer value
 
320
 *
 
321
 * Retrieves the value of the selected (active) item in the @combo_box.
 
322
 *
 
323
 * Return value: %TRUE if @value has been set or %FALSE if no item was
 
324
 *               active.
 
325
 *
 
326
 * Since: GIMP 2.2
 
327
 **/
 
328
gboolean
 
329
gimp_int_combo_box_get_active (GimpIntComboBox *combo_box,
 
330
                               gint            *value)
 
331
{
 
332
  GtkTreeIter  iter;
 
333
 
 
334
  g_return_val_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box), FALSE);
 
335
  g_return_val_if_fail (value != NULL, FALSE);
 
336
 
 
337
  if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo_box), &iter))
 
338
    {
 
339
      gtk_tree_model_get (gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box)),
 
340
                          &iter,
 
341
                          GIMP_INT_STORE_VALUE, value,
 
342
                          -1);
 
343
      return TRUE;
 
344
    }
 
345
 
 
346
  return FALSE;
 
347
}
 
348
 
 
349
/**
 
350
 * gimp_int_combo_box_connect:
 
351
 * @combo_box: a #GimpIntComboBox
 
352
 * @value:     the value to set
 
353
 * @callback:  a callback to connect to the @combo_box's "changed" signal
 
354
 * @data:      a pointer passed as data to g_signal_connect()
 
355
 *
 
356
 * A convenience function that sets the inital @value of a
 
357
 * #GimpIntComboBox and connects @callback to the "changed"
 
358
 * signal.
 
359
 *
 
360
 * This function also calls the @callback once after setting the
 
361
 * initial @value. This is often convenient when working with combo
 
362
 * boxes that select a default active item (like for example
 
363
 * gimp_drawable_combo_box_new). If you pass an invalid initial
 
364
 * @value, the @callback will be called with the default item active.
 
365
 *
 
366
 * Return value: the signal handler ID as returned by g_signal_connect()
 
367
 *
 
368
 * Since: GIMP 2.2
 
369
 **/
 
370
gulong
 
371
gimp_int_combo_box_connect (GimpIntComboBox *combo_box,
 
372
                            gint             value,
 
373
                            GCallback        callback,
 
374
                            gpointer         data)
 
375
{
 
376
  gulong handler = 0;
 
377
 
 
378
  g_return_val_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box), 0);
 
379
 
 
380
  if (callback)
 
381
    handler = g_signal_connect (combo_box, "changed", callback, data);
 
382
 
 
383
  if (! gimp_int_combo_box_set_active (combo_box, value))
 
384
    g_signal_emit_by_name (combo_box, "changed", NULL);
 
385
 
 
386
  return handler;
 
387
}