← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to libgimp/gimppalettemenu.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2007-05-02 16:33:03 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070502163303-bvzhjzbpw8qglc4y
Tags: 2.3.16-1ubuntu1
* Resynchronized with Debian, remaining Ubuntu changes:
  - debian/rules: i18n magic.
* debian/control.in:
  - Maintainer: Ubuntu Core Developers <ubuntu-devel@lists.ubuntu.com>
* debian/patches/02_help-message.patch,
  debian/patches/03_gimp.desktop.in.in.patch,
  debian/patches/10_dont_show_wizard.patch: updated.
* debian/patches/04_composite-signedness.patch,
  debian/patches/05_add-letter-spacing.patch: dropped, used upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libgimp/gimppalettemenu.c
23
23
#include "config.h"
24
24
 
25
25
#include "gimp.h"
26
 
#include "gimpui.h"
27
 
 
28
 
#include "libgimp-intl.h"
29
 
 
30
 
 
31
 
#define PALETTE_SELECT_DATA_KEY  "gimp-palette-selct-data"
32
 
 
33
 
 
34
 
typedef struct _PaletteSelect PaletteSelect;
35
 
 
36
 
struct _PaletteSelect
 
26
 
 
27
#include "gimpuitypes.h"
 
28
#include "gimppaletteselectbutton.h"
 
29
 
 
30
#undef GIMP_DISABLE_DEPRECATED
 
31
#include "gimppalettemenu.h"
 
32
 
 
33
 
 
34
typedef struct _CompatCallbackData CompatCallbackData;
 
35
 
 
36
struct _CompatCallbackData
37
37
{
38
 
  gchar                  *title;
39
 
  GimpRunPaletteCallback  callback;
40
 
  gpointer                data;
41
 
 
42
 
  GtkWidget              *button;
43
 
  GtkWidget              *label;
44
 
 
45
 
  gchar                  *palette_name;      /* Local copy */
46
 
 
47
 
  const gchar            *temp_palette_callback;
 
38
  GimpRunPaletteCallback callback;
 
39
  gpointer               data;
48
40
};
49
41
 
50
42
 
51
 
/*  local function prototypes  */
52
 
 
53
 
static void   gimp_palette_select_widget_callback (const gchar   *name,
54
 
                                                   gboolean       closing,
55
 
                                                   gpointer       data);
56
 
static void   gimp_palette_select_widget_clicked  (GtkWidget     *widget,
57
 
                                                   PaletteSelect *palette_sel);
58
 
static void   gimp_palette_select_widget_destroy  (GtkWidget     *widget,
59
 
                                                   PaletteSelect *palette_sel);
 
43
static void compat_callback (GimpPaletteSelectButton *palette_button,
 
44
                             const gchar             *palette_name,
 
45
                             gboolean                 dialog_closing,
 
46
                             gpointer                 data);
60
47
 
61
48
 
62
49
/**
63
50
 * gimp_palette_select_widget_new:
64
 
 * @title:        Title of the dialog to use or %NULL means to use the default
65
 
 *                title.
 
51
 * @title:        Title of the dialog to use or %NULL to use the default title.
66
52
 * @palette_name: Initial palette name.
67
53
 * @callback:     A function to call when the selected palette changes.
68
54
 * @data:         A pointer to arbitary data to be used in the call to @callback.
81
67
                                GimpRunPaletteCallback  callback,
82
68
                                gpointer                data)
83
69
{
84
 
  PaletteSelect *palette_sel;
85
 
  GtkWidget     *hbox;
86
 
  GtkWidget     *image;
 
70
  GtkWidget          *palette_button;
 
71
  CompatCallbackData *compat_data;
87
72
 
88
73
  g_return_val_if_fail (callback != NULL, NULL);
89
74
 
90
 
  if (! title)
91
 
    title = _("Palette Selection");
92
 
 
93
 
  palette_sel = g_new0 (PaletteSelect, 1);
94
 
 
95
 
  palette_sel->title    = g_strdup (title);
96
 
  palette_sel->callback = callback;
97
 
  palette_sel->data     = data;
98
 
 
99
 
  palette_sel->palette_name = g_strdup (palette_name);
100
 
 
101
 
  palette_sel->button = gtk_button_new ();
102
 
 
103
 
  g_signal_connect (palette_sel->button, "clicked",
104
 
                    G_CALLBACK (gimp_palette_select_widget_clicked),
105
 
                    palette_sel);
106
 
  g_signal_connect (palette_sel->button, "destroy",
107
 
                    G_CALLBACK (gimp_palette_select_widget_destroy),
108
 
                    palette_sel);
109
 
 
110
 
  hbox = gtk_hbox_new (FALSE, 4);
111
 
  gtk_container_add (GTK_CONTAINER (palette_sel->button), hbox);
112
 
  gtk_widget_show (hbox);
113
 
 
114
 
  image = gtk_image_new_from_stock (GIMP_STOCK_PALETTE, GTK_ICON_SIZE_BUTTON);
115
 
  gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
116
 
  gtk_widget_show (image);
117
 
 
118
 
  palette_sel->label = gtk_label_new (palette_name);
119
 
  gtk_box_pack_start (GTK_BOX (hbox), palette_sel->label, TRUE, TRUE, 4);
120
 
  gtk_widget_show (palette_sel->label);
121
 
 
122
 
  g_object_set_data (G_OBJECT (palette_sel->button),
123
 
                     PALETTE_SELECT_DATA_KEY, palette_sel);
124
 
 
125
 
  return palette_sel->button;
 
75
  palette_button = gimp_palette_select_button_new (title, palette_name);
 
76
 
 
77
  compat_data = g_new (CompatCallbackData, 1);
 
78
  compat_data->callback = callback;
 
79
  compat_data->data = data;
 
80
 
 
81
  g_signal_connect_data (palette_button, "palette-set",
 
82
                         G_CALLBACK (compat_callback),
 
83
                         compat_data, (GClosureNotify) g_free, 0);
 
84
 
 
85
  return palette_button;
126
86
}
127
87
 
128
88
/**
136
96
void
137
97
gimp_palette_select_widget_close (GtkWidget *widget)
138
98
{
139
 
  PaletteSelect *palette_sel;
140
 
 
141
 
  palette_sel = g_object_get_data (G_OBJECT (widget), PALETTE_SELECT_DATA_KEY);
142
 
 
143
 
  g_return_if_fail (palette_sel != NULL);
144
 
 
145
 
  if (palette_sel->temp_palette_callback)
146
 
    {
147
 
      gimp_palette_select_destroy (palette_sel->temp_palette_callback);
148
 
      palette_sel->temp_palette_callback = NULL;
149
 
    }
 
99
  g_return_if_fail (widget != NULL);
 
100
 
 
101
  gimp_select_button_close_popup (GIMP_SELECT_BUTTON (widget));
150
102
}
151
103
 
152
104
/**
164
116
gimp_palette_select_widget_set (GtkWidget   *widget,
165
117
                                const gchar *palette_name)
166
118
{
167
 
  PaletteSelect *palette_sel;
168
 
 
169
 
  palette_sel = g_object_get_data (G_OBJECT (widget), PALETTE_SELECT_DATA_KEY);
170
 
 
171
 
  g_return_if_fail (palette_sel != NULL);
172
 
 
173
 
  if (palette_sel->temp_palette_callback)
174
 
    gimp_palettes_set_popup (palette_sel->temp_palette_callback, palette_name);
175
 
  else
176
 
    gimp_palette_select_widget_callback (palette_name, FALSE, palette_sel);
177
 
}
178
 
 
179
 
 
180
 
/*  private functions  */
181
 
 
182
 
static void
183
 
gimp_palette_select_widget_callback (const gchar *name,
184
 
                                     gboolean     closing,
185
 
                                     gpointer     data)
186
 
{
187
 
  PaletteSelect *palette_sel = (PaletteSelect *) data;
188
 
 
189
 
  g_free (palette_sel->palette_name);
190
 
  palette_sel->palette_name = g_strdup (name);
191
 
 
192
 
  gtk_label_set_text (GTK_LABEL (palette_sel->label), name);
193
 
 
194
 
  if (palette_sel->callback)
195
 
    palette_sel->callback (name, closing, palette_sel->data);
196
 
 
197
 
  if (closing)
198
 
    palette_sel->temp_palette_callback = NULL;
199
 
}
200
 
 
201
 
static void
202
 
gimp_palette_select_widget_clicked (GtkWidget     *widget,
203
 
                                    PaletteSelect *palette_sel)
204
 
{
205
 
  if (palette_sel->temp_palette_callback)
206
 
    {
207
 
      /*  calling gimp_palettes_set_popup() raises the dialog  */
208
 
      gimp_palettes_set_popup (palette_sel->temp_palette_callback,
209
 
                               palette_sel->palette_name);
210
 
    }
211
 
  else
212
 
    {
213
 
      palette_sel->temp_palette_callback =
214
 
        gimp_palette_select_new (palette_sel->title,
215
 
                                 palette_sel->palette_name,
216
 
                                 gimp_palette_select_widget_callback,
217
 
                                 palette_sel);
218
 
    }
219
 
}
220
 
 
221
 
static void
222
 
gimp_palette_select_widget_destroy (GtkWidget     *widget,
223
 
                                    PaletteSelect *palette_sel)
224
 
{
225
 
  if (palette_sel->temp_palette_callback)
226
 
    {
227
 
      gimp_palette_select_destroy (palette_sel->temp_palette_callback);
228
 
      palette_sel->temp_palette_callback = NULL;
229
 
    }
230
 
 
231
 
  g_free (palette_sel->title);
232
 
  g_free (palette_sel->palette_name);
233
 
  g_free (palette_sel);
 
119
  g_return_if_fail (widget != NULL);
 
120
 
 
121
  gimp_palette_select_button_set_palette (GIMP_PALETTE_SELECT_BUTTON (widget),
 
122
                                          palette_name);
 
123
}
 
124
 
 
125
static void
 
126
compat_callback (GimpPaletteSelectButton *palette_button,
 
127
                 const gchar             *palette_name,
 
128
                 gboolean                 dialog_closing,
 
129
                 gpointer                 data)
 
130
{
 
131
  CompatCallbackData *compat_data = data;
 
132
 
 
133
  compat_data->callback (palette_name, dialog_closing, compat_data->data);
234
134
}