← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/gnome-panel/oneiric

« back to all changes in this revision

Viewing changes to gnome-panel/panel-properties-dialog.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2011-05-30 11:04:49 UTC
  • mfrom: (1.3.4 upstream)
  • mto: This revision was merged to the branch mainline in revision 204.
  • Revision ID: james.westby@ubuntu.com-20110530110449-ut1tc5t61rpvf9e3
Tags: upstream-3.0.2
Import upstream version 3.0.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnome-panel/panel-properties-dialog.c
24
24
 
25
25
#include <config.h>
26
26
 
27
 
#include "panel-properties-dialog.h"
28
 
 
29
27
#include <string.h>
30
28
#include <glib/gi18n.h>
31
29
 
35
33
#include <libpanel-util/panel-icon-chooser.h>
36
34
#include <libpanel-util/panel-show.h>
37
35
 
38
 
#include "nothing.h"
39
 
#include "panel-profile.h"
40
 
#include "panel-gconf.h"
41
 
#include "panel-util.h"
42
 
#include "panel-globals.h"
43
36
#include "panel-icon-names.h"
 
37
#include "panel-schemas.h"
 
38
#include "panel-widget.h"
 
39
 
 
40
#include "panel-properties-dialog.h"
44
41
 
45
42
typedef struct {
46
43
        PanelToplevel *toplevel;
47
44
 
 
45
        GSettings     *settings;
 
46
        GSettings     *settings_background;
 
47
 
48
48
        GtkWidget     *properties_dialog;
49
49
 
50
 
        GtkWidget     *general_table;
51
 
        GtkWidget     *general_vbox;
52
50
        GtkWidget     *orientation_combo;
53
 
        GtkWidget     *orientation_label;
54
 
        GtkWidget     *size_widgets;
55
51
        GtkWidget     *size_spin;
56
 
        GtkWidget     *size_label;
57
 
        GtkWidget     *size_label_pixels;
58
 
        GtkWidget     *icon_align;
59
 
        GtkWidget     *icon_chooser;
60
 
        GtkWidget     *icon_label;
61
 
        GtkWidget     *expand_toggle;
62
 
        GtkWidget     *autohide_toggle;
63
52
        GtkWidget     *hidebuttons_toggle;
64
53
        GtkWidget     *arrows_toggle;
65
54
        GtkWidget     *default_radio;
68
57
        GtkWidget     *color_widgets;
69
58
        GtkWidget     *image_widgets;
70
59
        GtkWidget     *color_button;
71
 
        GtkWidget     *color_label;
72
60
        GtkWidget     *image_chooser;
73
61
        GtkWidget     *opacity_scale;
74
 
        GtkWidget     *opacity_label;
75
 
        GtkWidget     *opacity_legend;
76
62
 
77
63
        GtkWidget     *writability_warn_general;
78
64
        GtkWidget     *writability_warn_background;
79
 
 
80
 
        guint          toplevel_notify;
81
 
        guint          background_notify;
82
 
 
83
 
        /* FIXME: This is a workaround for GTK+ bug #327243 */
84
 
        int            selection_emitted;
85
65
} PanelPropertiesDialog;
86
66
 
87
67
static GQuark panel_properties_dialog_quark = 0;
88
68
 
89
 
static void
90
 
panel_properties_dialog_free (PanelPropertiesDialog *dialog)
91
 
{
92
 
        GConfClient *client;
93
 
 
94
 
        client = panel_gconf_get_client ();
95
 
 
96
 
        if (dialog->toplevel_notify)
97
 
                gconf_client_notify_remove (client, dialog->toplevel_notify);
98
 
        dialog->toplevel_notify = 0;
99
 
 
100
 
        if (dialog->background_notify)
101
 
                gconf_client_notify_remove (client, dialog->background_notify);
102
 
        dialog->background_notify = 0;
103
 
 
104
 
        if (dialog->properties_dialog)
105
 
                gtk_widget_destroy (dialog->properties_dialog);
106
 
        dialog->properties_dialog = NULL;
107
 
 
108
 
        g_free (dialog);
109
 
}
110
 
 
111
69
enum {
112
70
        COLUMN_TEXT,
113
71
        COLUMN_ITEM,
127
85
};
128
86
 
129
87
static void
 
88
panel_properties_size_spin_update_range (PanelPropertiesDialog *dialog)
 
89
{
 
90
        //TODO: we should also do this when the monitor size changes
 
91
 
 
92
        /* note: we might not be fully setup, so we have to do checks */
 
93
        if (!dialog->size_spin)
 
94
                return;
 
95
 
 
96
        gtk_spin_button_set_range (GTK_SPIN_BUTTON (dialog->size_spin),
 
97
                                   panel_toplevel_get_minimum_size (dialog->toplevel),
 
98
                                   panel_toplevel_get_maximum_size (dialog->toplevel));
 
99
}
 
100
 
 
101
/*************************\
 
102
 * Orientation combo box *
 
103
\*************************/
 
104
 
 
105
static void
 
106
panel_properties_dialog_orientation_update (PanelPropertiesDialog *dialog)
 
107
{
 
108
        PanelOrientation      orientation;
 
109
        GtkTreeModel         *model;
 
110
        GtkTreeIter           iter;
 
111
        OrientationComboItem *item;
 
112
 
 
113
        orientation = g_settings_get_enum (dialog->settings,
 
114
                                           PANEL_TOPLEVEL_ORIENTATION_KEY);
 
115
 
 
116
        /* change the maximum size of the panel */
 
117
        panel_properties_size_spin_update_range (dialog);
 
118
 
 
119
        /* update the orientation combo box */
 
120
        model = gtk_combo_box_get_model (GTK_COMBO_BOX (dialog->orientation_combo));
 
121
 
 
122
        if (!gtk_tree_model_get_iter_first (model, &iter))
 
123
                return;
 
124
 
 
125
        do {
 
126
                gtk_tree_model_get (model, &iter, COLUMN_ITEM, &item, -1);
 
127
                if (item != NULL && item->orientation == orientation) {
 
128
                        gtk_combo_box_set_active_iter (GTK_COMBO_BOX (dialog->orientation_combo),
 
129
                                                       &iter);
 
130
                        return;
 
131
                }
 
132
        } while (gtk_tree_model_iter_next (model, &iter));
 
133
}
 
134
 
 
135
static void
130
136
panel_properties_dialog_orientation_changed (PanelPropertiesDialog *dialog,
131
137
                                             GtkComboBox           *combo_box)
132
138
{
134
140
        GtkTreeModel         *model;
135
141
        OrientationComboItem *item;
136
142
 
137
 
        g_assert (dialog->orientation_combo == GTK_WIDGET (combo_box));
138
 
 
139
143
        if (!gtk_combo_box_get_active_iter (combo_box, &iter))
140
144
                return;
141
145
 
144
148
        if (item == NULL)
145
149
                return;
146
150
 
147
 
        panel_profile_set_toplevel_orientation (dialog->toplevel,
148
 
                                                item->orientation);
 
151
        g_settings_set_enum (dialog->settings,
 
152
                             PANEL_TOPLEVEL_ORIENTATION_KEY,
 
153
                             item->orientation);
 
154
 
 
155
        /* change the maximum size of the panel */
 
156
        panel_properties_size_spin_update_range (dialog);
 
157
}
 
158
 
 
159
static void
 
160
panel_properties_dialog_orientation_setting_changed (GSettings             *settings,
 
161
                                                     char                  *key,
 
162
                                                     PanelPropertiesDialog *dialog)
 
163
{
 
164
        panel_properties_dialog_orientation_update (dialog);
149
165
}
150
166
 
151
167
static void
152
168
panel_properties_dialog_setup_orientation_combo (PanelPropertiesDialog *dialog,
153
169
                                                 GtkBuilder            *gui)
154
170
{
155
 
        PanelOrientation  orientation;
 
171
        GtkWidget        *orientation_label;
156
172
        GtkListStore     *model;
157
173
        GtkTreeIter       iter;
158
174
        GtkCellRenderer  *renderer;
160
176
 
161
177
        dialog->orientation_combo = PANEL_GTK_BUILDER_GET (gui, "orientation_combo");
162
178
        g_return_if_fail (dialog->orientation_combo != NULL);
163
 
        dialog->orientation_label = PANEL_GTK_BUILDER_GET (gui, "orientation_label");
164
 
        g_return_if_fail (dialog->orientation_label != NULL);
165
 
 
166
 
        orientation = panel_profile_get_toplevel_orientation (dialog->toplevel);
 
179
        orientation_label = PANEL_GTK_BUILDER_GET (gui, "orientation_label");
 
180
        g_return_if_fail (orientation_label != NULL);
167
181
 
168
182
        model = gtk_list_store_new (NUMBER_COLUMNS,
169
183
                                    G_TYPE_STRING,
178
192
                                    COLUMN_TEXT, g_dpgettext2 (NULL, "Orientation", orientation_items [i].name),
179
193
                                    COLUMN_ITEM, &(orientation_items [i]),
180
194
                                    -1);
181
 
                if (orientation == orientation_items [i].orientation)
182
 
                        gtk_combo_box_set_active_iter (GTK_COMBO_BOX (dialog->orientation_combo),
183
 
                                                       &iter);
184
195
        }
185
196
 
186
197
        renderer = gtk_cell_renderer_text_new ();
189
200
        gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (dialog->orientation_combo),
190
201
                                        renderer, "text", COLUMN_TEXT, NULL);
191
202
 
 
203
        panel_properties_dialog_orientation_update (dialog);
 
204
 
192
205
        g_signal_connect_swapped (dialog->orientation_combo, "changed",
193
206
                                  G_CALLBACK (panel_properties_dialog_orientation_changed),
194
207
                                  dialog);
195
 
 
196
 
        if (! panel_profile_is_writable_toplevel_orientation (dialog->toplevel)) {
197
 
                gtk_widget_set_sensitive (dialog->orientation_combo, FALSE);
198
 
                gtk_widget_set_sensitive (dialog->orientation_label, FALSE);
 
208
        g_signal_connect (dialog->settings_background,
 
209
                          "changed::"PANEL_TOPLEVEL_ORIENTATION_KEY,
 
210
                          G_CALLBACK (panel_properties_dialog_orientation_setting_changed),
 
211
                          dialog);
 
212
 
 
213
        g_settings_bind_writable (dialog->settings, PANEL_TOPLEVEL_ORIENTATION_KEY,
 
214
                                  orientation_label, "sensitive", FALSE);
 
215
        g_settings_bind_writable (dialog->settings, PANEL_TOPLEVEL_ORIENTATION_KEY,
 
216
                                  dialog->orientation_combo, "sensitive", FALSE);
 
217
 
 
218
        if (!g_settings_is_writable (dialog->settings, PANEL_TOPLEVEL_ORIENTATION_KEY))
199
219
                gtk_widget_show (dialog->writability_warn_general);
200
 
        }
201
 
}
202
 
 
203
 
static void
204
 
panel_properties_dialog_size_changed (PanelPropertiesDialog *dialog,
205
 
                                      GtkSpinButton         *spin_button)
206
 
{
207
 
        panel_profile_set_toplevel_size (dialog->toplevel,
208
 
                                         gtk_spin_button_get_value_as_int (spin_button));
209
 
}
210
 
 
211
 
static void
212
 
panel_properties_dialog_setup_size_spin (PanelPropertiesDialog *dialog,
 
220
}
 
221
 
 
222
/********************\
 
223
 * Size spin button *
 
224
\********************/
 
225
 
 
226
static void
 
227
panel_properties_dialog_size_spin_setup (PanelPropertiesDialog *dialog,
213
228
                                         GtkBuilder            *gui)
214
229
{
215
 
        dialog->size_widgets = PANEL_GTK_BUILDER_GET (gui, "size_widgets");
216
 
        g_return_if_fail (dialog->size_widgets != NULL);
 
230
        GtkWidget *size_label;
 
231
        GtkWidget *size_label_pixels;
 
232
 
217
233
        dialog->size_spin = PANEL_GTK_BUILDER_GET (gui, "size_spin");
218
234
        g_return_if_fail (dialog->size_spin != NULL);
219
 
        dialog->size_label = PANEL_GTK_BUILDER_GET (gui, "size_label");
220
 
        g_return_if_fail (dialog->size_label != NULL);
221
 
        dialog->size_label_pixels = PANEL_GTK_BUILDER_GET (gui, "size_label_pixels");
222
 
        g_return_if_fail (dialog->size_label_pixels != NULL);
223
 
 
224
 
        gtk_spin_button_set_range (GTK_SPIN_BUTTON (dialog->size_spin),
225
 
                                   panel_toplevel_get_minimum_size (dialog->toplevel),
226
 
                                   panel_toplevel_get_maximum_size (dialog->toplevel));
227
 
 
228
 
        gtk_spin_button_set_value (GTK_SPIN_BUTTON (dialog->size_spin),
229
 
                                   panel_profile_get_toplevel_size (dialog->toplevel));
230
 
 
231
 
        g_signal_connect_swapped (dialog->size_spin, "value_changed",
232
 
                                  G_CALLBACK (panel_properties_dialog_size_changed),
 
235
        size_label = PANEL_GTK_BUILDER_GET (gui, "size_label");
 
236
        g_return_if_fail (size_label != NULL);
 
237
        size_label_pixels = PANEL_GTK_BUILDER_GET (gui, "size_label_pixels");
 
238
        g_return_if_fail (size_label_pixels != NULL);
 
239
 
 
240
        panel_properties_size_spin_update_range (dialog);
 
241
 
 
242
        g_settings_bind (dialog->settings, PANEL_TOPLEVEL_SIZE_KEY,
 
243
                         dialog->size_spin, "value",
 
244
                         G_SETTINGS_BIND_DEFAULT);
 
245
 
 
246
        g_settings_bind_writable (dialog->settings, PANEL_TOPLEVEL_SIZE_KEY,
 
247
                                  size_label, "sensitive", FALSE);
 
248
        g_settings_bind_writable (dialog->settings, PANEL_TOPLEVEL_SIZE_KEY,
 
249
                                  size_label_pixels, "sensitive", FALSE);
 
250
 
 
251
        if (!g_settings_is_writable (dialog->settings, PANEL_TOPLEVEL_SIZE_KEY))
 
252
                gtk_widget_show (dialog->writability_warn_general);
 
253
}
 
254
 
 
255
/******************\
 
256
 * Toggle buttons *
 
257
\******************/
 
258
 
 
259
static void
 
260
panel_properties_dialog_setup_toggle (PanelPropertiesDialog *dialog,
 
261
                                      GtkBuilder            *gui,
 
262
                                      const char            *toggle_name_in_ui,
 
263
                                      const char            *settings_key,
 
264
                                      gboolean               bind_sensitivity)
 
265
{
 
266
        GtkWidget          *toggle = PANEL_GTK_BUILDER_GET (gui, toggle_name_in_ui);
 
267
        GSettingsBindFlags  flags = G_SETTINGS_BIND_DEFAULT;
 
268
 
 
269
        if (!bind_sensitivity)
 
270
                flags |= G_SETTINGS_BIND_NO_SENSITIVITY;
 
271
 
 
272
        g_settings_bind (dialog->settings, settings_key,
 
273
                         toggle, "active",
 
274
                         flags);
 
275
 
 
276
        if (!g_settings_is_writable (dialog->settings, settings_key))
 
277
                gtk_widget_show (dialog->writability_warn_general);
 
278
}
 
279
 
 
280
static void
 
281
panel_properties_dialog_expand_toggle_setup (PanelPropertiesDialog *dialog,
 
282
                                             GtkBuilder            *gui)
 
283
{
 
284
        panel_properties_dialog_setup_toggle (dialog, gui, "expand_toggle",
 
285
                                              PANEL_TOPLEVEL_EXPAND_KEY,
 
286
                                              TRUE);
 
287
}
 
288
 
 
289
static void
 
290
panel_properties_dialog_autohide_toggle_setup (PanelPropertiesDialog *dialog,
 
291
                                               GtkBuilder            *gui)
 
292
{
 
293
        panel_properties_dialog_setup_toggle (dialog, gui, "autohide_toggle",
 
294
                                              PANEL_TOPLEVEL_AUTO_HIDE_KEY,
 
295
                                              TRUE);
 
296
}
 
297
 
 
298
static void
 
299
panel_properties_dialog_hidebuttons_toggle_setup (PanelPropertiesDialog *dialog,
 
300
                                                  GtkBuilder            *gui)
 
301
{
 
302
        panel_properties_dialog_setup_toggle (dialog, gui, "hidebuttons_toggle",
 
303
                                              PANEL_TOPLEVEL_ENABLE_BUTTONS_KEY,
 
304
                                              TRUE);
 
305
 
 
306
        dialog->hidebuttons_toggle = PANEL_GTK_BUILDER_GET (gui,
 
307
                                                            "hidebuttons_toggle");
 
308
}
 
309
 
 
310
static void
 
311
panel_properties_dialog_arrows_sensitivity_update (GSettings             *settings,
 
312
                                                   char                  *key,
 
313
                                                   PanelPropertiesDialog *dialog)
 
314
{
 
315
        gboolean sensitive;
 
316
 
 
317
        sensitive = (g_settings_get_boolean (settings,
 
318
                                             PANEL_TOPLEVEL_ENABLE_BUTTONS_KEY) &&
 
319
                     g_settings_is_writable (settings,
 
320
                                             PANEL_TOPLEVEL_ENABLE_ARROWS_KEY));
 
321
 
 
322
        gtk_widget_set_sensitive (dialog->arrows_toggle, sensitive);
 
323
}
 
324
 
 
325
 
 
326
static void
 
327
panel_properties_dialog_arrows_toggle_setup (PanelPropertiesDialog *dialog,
 
328
                                             GtkBuilder            *gui)
 
329
{
 
330
        panel_properties_dialog_setup_toggle (dialog, gui, "arrows_toggle",
 
331
                                              PANEL_TOPLEVEL_ENABLE_ARROWS_KEY,
 
332
                                              FALSE);
 
333
 
 
334
        dialog->arrows_toggle = PANEL_GTK_BUILDER_GET (gui,
 
335
                                                       "arrows_toggle");
 
336
 
 
337
        panel_properties_dialog_arrows_sensitivity_update (dialog->settings,
 
338
                                                           NULL, dialog);
 
339
 
 
340
        g_signal_connect (dialog->settings,
 
341
                          "changed::"PANEL_TOPLEVEL_ENABLE_BUTTONS_KEY,
 
342
                          G_CALLBACK (panel_properties_dialog_arrows_sensitivity_update),
 
343
                          dialog);
 
344
        g_signal_connect (dialog->settings,
 
345
                          "writable-changed::"PANEL_TOPLEVEL_ENABLE_ARROWS_KEY,
 
346
                          G_CALLBACK (panel_properties_dialog_arrows_sensitivity_update),
 
347
                          dialog);
 
348
}
 
349
 
 
350
/********************\
 
351
 * Background image *
 
352
\********************/
 
353
 
 
354
static void
 
355
panel_properties_dialog_background_image_update (PanelPropertiesDialog *dialog)
 
356
{
 
357
        char *uri;
 
358
 
 
359
        uri = g_settings_get_string (dialog->settings_background,
 
360
                                     PANEL_BACKGROUND_IMAGE_URI_KEY);
 
361
 
 
362
        if (PANEL_GLIB_STR_EMPTY (uri))
 
363
                gtk_file_chooser_unselect_all (GTK_FILE_CHOOSER (dialog->image_chooser));
 
364
        else
 
365
                gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (dialog->image_chooser),
 
366
                                          uri);
 
367
 
 
368
        g_free (uri);
 
369
}
 
370
 
 
371
static void
 
372
panel_properties_dialog_image_chooser_changed (PanelPropertiesDialog *dialog)
 
373
{
 
374
        char *uri;
 
375
 
 
376
        uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog->image_chooser));
 
377
        if (!uri)
 
378
                uri = g_strdup ("");
 
379
 
 
380
        g_settings_set_string (dialog->settings_background,
 
381
                               PANEL_BACKGROUND_IMAGE_URI_KEY, uri);
 
382
        g_free (uri);
 
383
}
 
384
 
 
385
static void
 
386
panel_properties_dialog_image_chooser_setup (PanelPropertiesDialog *dialog,
 
387
                                             GtkBuilder            *gui)
 
388
{
 
389
        dialog->image_chooser = PANEL_GTK_BUILDER_GET (gui, "image_chooser");
 
390
        panel_gtk_file_chooser_add_image_preview (GTK_FILE_CHOOSER (dialog->image_chooser));
 
391
 
 
392
        panel_properties_dialog_background_image_update (dialog);
 
393
 
 
394
        g_signal_connect_swapped (dialog->image_chooser, "file-set",
 
395
                                  G_CALLBACK (panel_properties_dialog_image_chooser_changed),
233
396
                                  dialog);
234
397
 
235
 
        if ( ! panel_profile_is_writable_toplevel_size (dialog->toplevel)) {
236
 
                gtk_widget_set_sensitive (dialog->size_spin, FALSE);
237
 
                gtk_widget_set_sensitive (dialog->size_label, FALSE);
238
 
                gtk_widget_set_sensitive (dialog->size_label_pixels, FALSE);
239
 
                gtk_widget_show (dialog->writability_warn_general);
240
 
        }
241
 
}
242
 
 
243
 
static void
244
 
panel_properties_dialog_icon_changed (PanelIconChooser      *chooser,
245
 
                                      const char            *icon,
246
 
                                      PanelPropertiesDialog *dialog)
247
 
{
248
 
        panel_profile_set_attached_custom_icon (dialog->toplevel, icon);
249
 
}
250
 
 
251
 
static void
252
 
panel_properties_dialog_setup_icon_chooser (PanelPropertiesDialog *dialog,
253
 
                                            GtkBuilder            *gui)
254
 
{
255
 
        char *custom_icon;
256
 
 
257
 
        dialog->icon_align = PANEL_GTK_BUILDER_GET (gui, "icon_align");
258
 
        g_return_if_fail (dialog->icon_align != NULL);
259
 
 
260
 
        dialog->icon_chooser = panel_icon_chooser_new (NULL);
261
 
        panel_icon_chooser_set_fallback_icon_name (PANEL_ICON_CHOOSER (dialog->icon_chooser),
262
 
                                                   PANEL_ICON_DRAWER);
263
 
        gtk_widget_show (dialog->icon_chooser);
264
 
        gtk_container_add (GTK_CONTAINER (dialog->icon_align),
265
 
                           dialog->icon_chooser);
266
 
 
267
 
        dialog->icon_label = PANEL_GTK_BUILDER_GET (gui, "icon_label");
268
 
        g_return_if_fail (dialog->icon_label != NULL);
269
 
 
270
 
        custom_icon = panel_profile_get_attached_custom_icon (dialog->toplevel);
271
 
        panel_icon_chooser_set_icon (PANEL_ICON_CHOOSER (dialog->icon_chooser),
272
 
                                     custom_icon);
273
 
        g_free (custom_icon);
274
 
 
275
 
        g_signal_connect (dialog->icon_chooser, "changed",
276
 
                          G_CALLBACK (panel_properties_dialog_icon_changed), dialog);
277
 
 
278
 
        if (!panel_profile_is_writable_attached_custom_icon (dialog->toplevel)) {
279
 
                gtk_widget_set_sensitive (dialog->icon_chooser, FALSE);
280
 
                gtk_widget_set_sensitive (dialog->icon_label, FALSE);
281
 
                gtk_widget_show (dialog->writability_warn_general);
282
 
        }
283
 
}
284
 
 
285
 
/* Note: this is only for toggle buttons on the general page, if needed for togglebuttons
286
 
   elsewhere you must make this respect the writability warning thing for the right page */
287
 
#define SETUP_TOGGLE_BUTTON(wid, n, p)                                                            \
288
 
        static void                                                                               \
289
 
        panel_properties_dialog_##n (PanelPropertiesDialog *dialog,                               \
290
 
                                     GtkToggleButton       *n)                                    \
291
 
        {                                                                                         \
292
 
                panel_profile_set_toplevel_##p (dialog->toplevel,                                 \
293
 
                                                gtk_toggle_button_get_active (n));                \
294
 
        }                                                                                         \
295
 
        static void                                                                               \
296
 
        panel_properties_dialog_setup_##n (PanelPropertiesDialog *dialog,                         \
297
 
                                           GtkBuilder            *gui)                            \
298
 
        {                                                                                         \
299
 
                dialog->n = PANEL_GTK_BUILDER_GET (gui, wid);                                      \
300
 
                gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->n),                      \
301
 
                                              panel_profile_get_toplevel_##p (dialog->toplevel)); \
302
 
                g_signal_connect_swapped (dialog->n, "toggled",                                   \
303
 
                                          G_CALLBACK (panel_properties_dialog_##n), dialog);      \
304
 
                if ( ! panel_profile_is_writable_toplevel_##p (dialog->toplevel)) {               \
305
 
                        gtk_widget_set_sensitive (dialog->n, FALSE);                              \
306
 
                        gtk_widget_show (dialog->writability_warn_general);                       \
307
 
                }                                                                                 \
308
 
        }
309
 
 
310
 
SETUP_TOGGLE_BUTTON ("expand_toggle",      expand_toggle,      expand)
311
 
SETUP_TOGGLE_BUTTON ("autohide_toggle",    autohide_toggle,    auto_hide)
312
 
SETUP_TOGGLE_BUTTON ("hidebuttons_toggle", hidebuttons_toggle, enable_buttons)
313
 
SETUP_TOGGLE_BUTTON ("arrows_toggle",      arrows_toggle,      enable_arrows)
314
 
 
315
 
static void
316
 
panel_properties_dialog_color_changed (PanelPropertiesDialog *dialog,
317
 
                                       GtkColorButton        *color_button)
318
 
{
319
 
        GdkColor color;
320
 
 
321
 
        g_assert (dialog->color_button == GTK_WIDGET (color_button));
322
 
 
323
 
        gtk_color_button_get_color (color_button, &color);
324
 
        panel_profile_set_background_gdk_color (dialog->toplevel, &color);
325
 
}
326
 
 
327
 
static void
328
 
panel_properties_dialog_setup_color_button (PanelPropertiesDialog *dialog,
329
 
                                            GtkBuilder            *gui)
330
 
{
331
 
        PanelColor color;
 
398
        g_settings_bind_writable (dialog->settings_background,
 
399
                                  PANEL_BACKGROUND_IMAGE_URI_KEY,
 
400
                                  dialog->image_chooser, "sensitive", FALSE);
 
401
 
 
402
        if (!g_settings_is_writable (dialog->settings_background,
 
403
                                     PANEL_BACKGROUND_IMAGE_URI_KEY))
 
404
                gtk_widget_show (dialog->writability_warn_background);
 
405
}
 
406
 
 
407
/********************\
 
408
 * Background color *
 
409
\********************/
 
410
 
 
411
static void
 
412
panel_properties_dialog_background_color_get_rgba (PanelPropertiesDialog *dialog,
 
413
                                                   GdkRGBA               *color)
 
414
{
 
415
        char *color_str;
 
416
 
 
417
        color_str = g_settings_get_string (dialog->settings_background,
 
418
                                           PANEL_BACKGROUND_COLOR_KEY);
 
419
 
 
420
        if (!gdk_rgba_parse (color, color_str))
 
421
                gdk_rgba_parse (color, PANEL_BACKGROUND_COLOR_DEFAULT);
 
422
        g_free (color_str);
 
423
}
 
424
 
 
425
static void
 
426
panel_properties_dialog_background_color_update_from_rgba (PanelPropertiesDialog *dialog,
 
427
                                                           GdkRGBA               *color)
 
428
{
 
429
        /* note: we might not be fully setup, so we have to do checks */
 
430
        if (dialog->opacity_scale)
 
431
                gtk_range_set_value (GTK_RANGE (dialog->opacity_scale),
 
432
                                     color->alpha * 100.);
 
433
        if (dialog->color_button)
 
434
                gtk_color_button_set_rgba (GTK_COLOR_BUTTON (dialog->color_button),
 
435
                                           color);
 
436
}
 
437
 
 
438
static void
 
439
panel_properties_dialog_background_color_set_from_rgba (PanelPropertiesDialog *dialog,
 
440
                                                        GdkRGBA               *color)
 
441
{
 
442
        char *color_str;
 
443
 
 
444
        color_str = gdk_rgba_to_string (color);
 
445
        g_settings_set_string (dialog->settings_background,
 
446
                               PANEL_BACKGROUND_COLOR_KEY, color_str);
 
447
        g_free (color_str);
 
448
 
 
449
        /* make sure all widgets are consistent */
 
450
        panel_properties_dialog_background_color_update_from_rgba (dialog, color);
 
451
}
 
452
 
 
453
static void
 
454
panel_properties_dialog_background_color_update (PanelPropertiesDialog *dialog)
 
455
{
 
456
        GdkRGBA color;
 
457
 
 
458
        panel_properties_dialog_background_color_get_rgba (dialog, &color);
 
459
        panel_properties_dialog_background_color_update_from_rgba (dialog, &color);
 
460
}
 
461
 
 
462
static void
 
463
panel_properties_dialog_color_button_changed (PanelPropertiesDialog *dialog,
 
464
                                              GtkColorButton        *color_button)
 
465
{
 
466
        GdkRGBA old_color;
 
467
        GdkRGBA new_color;
 
468
 
 
469
        panel_properties_dialog_background_color_get_rgba (dialog, &old_color);
 
470
        gtk_color_button_get_rgba (color_button, &new_color);
 
471
        new_color.alpha = old_color.alpha;
 
472
        panel_properties_dialog_background_color_set_from_rgba (dialog, &new_color);
 
473
}
 
474
 
 
475
static void
 
476
panel_properties_dialog_color_button_setup (PanelPropertiesDialog *dialog,
 
477
                                            GtkBuilder            *gui)
 
478
{
 
479
        GtkWidget *color_label;
332
480
 
333
481
        dialog->color_button = PANEL_GTK_BUILDER_GET (gui, "color_button");
334
482
        g_return_if_fail (dialog->color_button != NULL);
335
 
        dialog->color_label = PANEL_GTK_BUILDER_GET (gui, "color_label");
336
 
        g_return_if_fail (dialog->color_label != NULL);
337
 
 
338
 
        panel_profile_get_background_color (dialog->toplevel, &color);
339
 
 
340
 
        gtk_color_button_set_color (GTK_COLOR_BUTTON (dialog->color_button),
341
 
                                    &(color.gdk));
 
483
        color_label = PANEL_GTK_BUILDER_GET (gui, "color_label");
 
484
        g_return_if_fail (color_label != NULL);
 
485
 
 
486
        panel_properties_dialog_background_color_update (dialog);
342
487
 
343
488
        g_signal_connect_swapped (dialog->color_button, "color_set",
344
 
                                  G_CALLBACK (panel_properties_dialog_color_changed),
345
 
                                  dialog);
346
 
 
347
 
        if ( ! panel_profile_is_writable_background_color (dialog->toplevel)) {
348
 
                gtk_widget_set_sensitive (dialog->color_button, FALSE);
349
 
                gtk_widget_set_sensitive (dialog->color_label, FALSE);
350
 
                gtk_widget_show (dialog->writability_warn_background);
351
 
        }
352
 
}
353
 
 
354
 
static void
355
 
panel_properties_dialog_image_changed (PanelPropertiesDialog *dialog)
356
 
{
357
 
        char *image;
358
 
 
359
 
        image = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog->image_chooser));
360
 
 
361
 
        /* FIXME: This is an ugly workaround for GTK+ bug #327243.
362
 
         * FIXME: Note that GTK+ 2.12 and file-set signal might help. */
363
 
        if (!dialog->selection_emitted < 2 && !image) {
364
 
                dialog->selection_emitted++;
365
 
                return;
366
 
        }
367
 
        panel_profile_set_background_image (dialog->toplevel, image);
368
 
 
369
 
        g_free (image);
370
 
}
371
 
 
372
 
static void
373
 
panel_properties_dialog_setup_image_chooser (PanelPropertiesDialog *dialog,
374
 
                                             GtkBuilder            *gui)
375
 
{
376
 
        char *image;
377
 
 
378
 
        dialog->image_chooser = PANEL_GTK_BUILDER_GET (gui, "image_chooser");
379
 
        panel_gtk_file_chooser_add_image_preview (GTK_FILE_CHOOSER (dialog->image_chooser));
380
 
 
381
 
        image = panel_profile_get_background_image (dialog->toplevel);
382
 
 
383
 
        if (PANEL_GLIB_STR_EMPTY (image))
384
 
                gtk_file_chooser_unselect_all (GTK_FILE_CHOOSER (dialog->image_chooser));
385
 
        else
386
 
                gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog->image_chooser),
387
 
                                               image);
388
 
        
389
 
        if (image)
390
 
                g_free (image);
391
 
 
392
 
        dialog->selection_emitted = 0;
393
 
        g_signal_connect_swapped (dialog->image_chooser, "selection-changed",
394
 
                                  G_CALLBACK (panel_properties_dialog_image_changed),
395
 
                                  dialog);
396
 
 
397
 
        if ( ! panel_profile_is_writable_background_image (dialog->toplevel)) {
398
 
                gtk_widget_set_sensitive (dialog->image_chooser, FALSE);
399
 
                gtk_widget_show (dialog->writability_warn_background);
400
 
        }
401
 
}
402
 
 
403
 
static void
404
 
panel_properties_dialog_opacity_changed (PanelPropertiesDialog *dialog)
 
489
                                  G_CALLBACK (panel_properties_dialog_color_button_changed),
 
490
                                  dialog);
 
491
 
 
492
        g_settings_bind_writable (dialog->settings_background,
 
493
                                  PANEL_BACKGROUND_COLOR_KEY,
 
494
                                  color_label, "sensitive", FALSE);
 
495
        g_settings_bind_writable (dialog->settings_background,
 
496
                                  PANEL_BACKGROUND_COLOR_KEY,
 
497
                                  dialog->color_button, "sensitive", FALSE);
 
498
 
 
499
        if (!g_settings_is_writable (dialog->settings_background,
 
500
                                     PANEL_BACKGROUND_COLOR_KEY))
 
501
                gtk_widget_show (dialog->writability_warn_background);
 
502
}
 
503
 
 
504
 
 
505
static void
 
506
panel_properties_dialog_opacity_scale_changed (PanelPropertiesDialog *dialog)
405
507
{
406
508
        gdouble percentage;
407
 
        guint16 opacity;
 
509
        GdkRGBA color;
408
510
 
409
511
        percentage = gtk_range_get_value (GTK_RANGE (dialog->opacity_scale));
410
512
 
413
515
        else if (percentage <= 2)
414
516
                percentage = 0;
415
517
 
416
 
        opacity = (percentage / 100) * 65535;
417
 
 
418
 
        panel_profile_set_background_opacity (dialog->toplevel, opacity);
 
518
        panel_properties_dialog_background_color_get_rgba (dialog, &color);
 
519
        color.alpha = (percentage / 100.);
 
520
        panel_properties_dialog_background_color_set_from_rgba (dialog, &color);
419
521
}
420
522
 
421
523
static void
422
 
panel_properties_dialog_setup_opacity_scale (PanelPropertiesDialog *dialog,
 
524
panel_properties_dialog_opacity_scale_setup (PanelPropertiesDialog *dialog,
423
525
                                             GtkBuilder            *gui)
424
526
{
425
 
        guint16 opacity;
426
 
        gdouble percentage;
 
527
        GtkWidget *opacity_label;
 
528
        GtkWidget *opacity_legend;
427
529
 
428
530
        dialog->opacity_scale = PANEL_GTK_BUILDER_GET (gui, "opacity_scale");
429
531
        g_return_if_fail (dialog->opacity_scale != NULL);
430
 
        dialog->opacity_label = PANEL_GTK_BUILDER_GET (gui, "opacity_label");
431
 
        g_return_if_fail (dialog->opacity_label != NULL);
432
 
        dialog->opacity_legend = PANEL_GTK_BUILDER_GET (gui, "opacity_legend");
433
 
        g_return_if_fail (dialog->opacity_legend != NULL);
434
 
 
435
 
        opacity = panel_profile_get_background_opacity (dialog->toplevel);
436
 
 
437
 
        percentage = (opacity * 100.0) / 65535;
438
 
 
439
 
        gtk_range_set_value (GTK_RANGE (dialog->opacity_scale), percentage);
 
532
        opacity_label = PANEL_GTK_BUILDER_GET (gui, "opacity_label");
 
533
        g_return_if_fail (opacity_label != NULL);
 
534
        opacity_legend = PANEL_GTK_BUILDER_GET (gui, "opacity_legend");
 
535
        g_return_if_fail (opacity_legend != NULL);
 
536
 
 
537
        panel_properties_dialog_background_color_update (dialog);
440
538
 
441
539
        g_signal_connect_swapped (dialog->opacity_scale, "value_changed",
442
 
                                  G_CALLBACK (panel_properties_dialog_opacity_changed),
 
540
                                  G_CALLBACK (panel_properties_dialog_opacity_scale_changed),
443
541
                                  dialog);
444
542
 
445
 
        if ( ! panel_profile_is_writable_background_opacity (dialog->toplevel)) {
446
 
                gtk_widget_set_sensitive (dialog->opacity_scale, FALSE);
447
 
                gtk_widget_set_sensitive (dialog->opacity_label, FALSE);
448
 
                gtk_widget_set_sensitive (dialog->opacity_legend, FALSE);
 
543
        g_settings_bind_writable (dialog->settings_background,
 
544
                                  PANEL_BACKGROUND_COLOR_KEY,
 
545
                                  opacity_label, "sensitive", FALSE);
 
546
        g_settings_bind_writable (dialog->settings_background,
 
547
                                  PANEL_BACKGROUND_COLOR_KEY,
 
548
                                  opacity_legend, "sensitive", FALSE);
 
549
        g_settings_bind_writable (dialog->settings_background,
 
550
                                  PANEL_BACKGROUND_COLOR_KEY,
 
551
                                  dialog->opacity_scale, "sensitive", FALSE);
 
552
 
 
553
        if (!g_settings_is_writable (dialog->settings_background,
 
554
                                     PANEL_BACKGROUND_COLOR_KEY))
449
555
                gtk_widget_show (dialog->writability_warn_background);
450
 
        }
451
556
}
452
557
 
 
558
/*******************\
 
559
 * Background type *
 
560
\*******************/
 
561
 
453
562
static void
454
 
panel_properties_dialog_upd_sensitivity (PanelPropertiesDialog *dialog,
455
 
                                         PanelBackgroundType    background_type)
 
563
panel_properties_dialog_background_sensitivity_update (PanelPropertiesDialog *dialog,
 
564
                                                       PanelBackgroundType    background_type)
456
565
{
457
566
        gtk_widget_set_sensitive (dialog->color_widgets,
458
567
                                  background_type == PANEL_BACK_COLOR);
461
570
}
462
571
 
463
572
static void
464
 
panel_properties_dialog_background_toggled (PanelPropertiesDialog *dialog,
465
 
                                            GtkWidget             *radio)
 
573
panel_properties_dialog_background_type_update (PanelPropertiesDialog *dialog)
 
574
{
 
575
        PanelBackgroundType  background_type;
 
576
        GtkWidget           *active_radio;
 
577
 
 
578
        background_type = g_settings_get_enum (dialog->settings_background,
 
579
                                               PANEL_BACKGROUND_TYPE_KEY);
 
580
 
 
581
        switch (background_type) {
 
582
        case PANEL_BACK_NONE:
 
583
                active_radio = dialog->default_radio;
 
584
                break;
 
585
        case PANEL_BACK_COLOR:
 
586
                active_radio = dialog->color_radio;
 
587
                break;
 
588
        case PANEL_BACK_IMAGE:
 
589
                active_radio = dialog->image_radio;
 
590
                break;
 
591
        default:
 
592
                active_radio = NULL;
 
593
                g_assert_not_reached ();
 
594
                break;
 
595
        }
 
596
 
 
597
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (active_radio), TRUE);
 
598
 
 
599
        panel_properties_dialog_background_sensitivity_update (dialog, background_type);
 
600
}
 
601
 
 
602
static void
 
603
panel_properties_dialog_background_radios_toggled (PanelPropertiesDialog *dialog,
 
604
                                                   GtkWidget             *radio)
466
605
{
467
606
        PanelBackgroundType background_type = PANEL_BACK_NONE;
468
607
 
478
617
        else if (radio == dialog->image_radio)
479
618
                background_type = PANEL_BACK_IMAGE;
480
619
 
481
 
        panel_properties_dialog_upd_sensitivity (dialog, background_type);
 
620
        g_settings_set_enum (dialog->settings_background,
 
621
                             PANEL_BACKGROUND_TYPE_KEY,
 
622
                             background_type);
482
623
 
483
 
        panel_profile_set_background_type (dialog->toplevel, background_type);
 
624
        panel_properties_dialog_background_sensitivity_update (dialog, background_type);
484
625
}
485
626
                                
486
627
static void
487
 
panel_properties_dialog_setup_background_radios (PanelPropertiesDialog *dialog,
 
628
panel_properties_dialog_background_radios_setup (PanelPropertiesDialog *dialog,
488
629
                                                 GtkBuilder            *gui)
489
630
{
490
 
        PanelBackgroundType  background_type;
491
 
        GtkWidget           *active_radio;
492
 
 
493
631
        dialog->default_radio     = PANEL_GTK_BUILDER_GET (gui, "default_radio");
494
632
        dialog->color_radio       = PANEL_GTK_BUILDER_GET (gui, "color_radio");
495
633
        dialog->image_radio       = PANEL_GTK_BUILDER_GET (gui, "image_radio");
496
634
        dialog->color_widgets     = PANEL_GTK_BUILDER_GET (gui, "color_widgets");
497
635
        dialog->image_widgets     = PANEL_GTK_BUILDER_GET (gui, "image_widgets");
498
636
 
499
 
        background_type = panel_profile_get_background_type (dialog->toplevel);
500
 
        switch (background_type) {
501
 
        case PANEL_BACK_NONE:
502
 
                active_radio = dialog->default_radio;
503
 
                break;
504
 
        case PANEL_BACK_COLOR:
505
 
                active_radio = dialog->color_radio;
506
 
                break;
507
 
        case PANEL_BACK_IMAGE:
508
 
                active_radio = dialog->image_radio;
509
 
                break;
510
 
        default:
511
 
                active_radio = NULL;
512
 
                g_assert_not_reached ();
513
 
        }
514
 
 
515
 
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (active_radio), TRUE);
516
 
 
517
 
        panel_properties_dialog_upd_sensitivity (dialog, background_type);
 
637
        panel_properties_dialog_background_type_update (dialog);
518
638
 
519
639
        g_signal_connect_swapped (dialog->default_radio, "toggled",
520
 
                                  G_CALLBACK (panel_properties_dialog_background_toggled),
 
640
                                  G_CALLBACK (panel_properties_dialog_background_radios_toggled),
521
641
                                  dialog);
522
642
        g_signal_connect_swapped (dialog->color_radio, "toggled",
523
 
                                  G_CALLBACK (panel_properties_dialog_background_toggled),
 
643
                                  G_CALLBACK (panel_properties_dialog_background_radios_toggled),
524
644
                                  dialog);
525
645
        g_signal_connect_swapped (dialog->image_radio, "toggled",
526
 
                                  G_CALLBACK (panel_properties_dialog_background_toggled),
 
646
                                  G_CALLBACK (panel_properties_dialog_background_radios_toggled),
527
647
                                  dialog);
528
648
 
529
 
        if ( ! panel_profile_is_writable_background_type (dialog->toplevel)) {
530
 
                gtk_widget_set_sensitive (dialog->default_radio, FALSE);
531
 
                gtk_widget_set_sensitive (dialog->color_radio, FALSE);
532
 
                gtk_widget_set_sensitive (dialog->image_radio, FALSE);
 
649
        g_settings_bind_writable (dialog->settings_background,
 
650
                                  PANEL_BACKGROUND_TYPE_KEY,
 
651
                                  dialog->default_radio, "sensitive", FALSE);
 
652
        g_settings_bind_writable (dialog->settings_background,
 
653
                                  PANEL_BACKGROUND_TYPE_KEY,
 
654
                                  dialog->color_radio, "sensitive", FALSE);
 
655
        g_settings_bind_writable (dialog->settings_background,
 
656
                                  PANEL_BACKGROUND_TYPE_KEY,
 
657
                                  dialog->image_radio, "sensitive", FALSE);
 
658
 
 
659
        if (!g_settings_is_writable (dialog->settings_background,
 
660
                                     PANEL_BACKGROUND_TYPE_KEY))
533
661
                gtk_widget_show (dialog->writability_warn_background);
534
 
        }
535
662
}
536
663
 
 
664
/*************************\
 
665
 * Update from GSettings *
 
666
\*************************/
 
667
 
537
668
static void
538
 
panel_properties_update_arrows_toggle_visible (PanelPropertiesDialog *dialog,
539
 
                                               GtkToggleButton       *toggle)
 
669
panel_properties_dialog_background_changed (GSettings             *settings,
 
670
                                            char                  *key,
 
671
                                            PanelPropertiesDialog *dialog)
540
672
{
541
 
        if (gtk_toggle_button_get_active (toggle))
542
 
                gtk_widget_set_sensitive (dialog->arrows_toggle,
543
 
                                          panel_profile_is_writable_toplevel_enable_arrows (dialog->toplevel));
544
 
        else
545
 
                gtk_widget_set_sensitive (dialog->arrows_toggle, FALSE);
 
673
        if (g_strcmp0 (key, PANEL_BACKGROUND_TYPE_KEY) == 0)
 
674
                panel_properties_dialog_background_type_update (dialog);
 
675
        else if (g_strcmp0 (key, PANEL_BACKGROUND_IMAGE_URI_KEY) == 0)
 
676
                panel_properties_dialog_background_image_update (dialog);
 
677
        else if (g_strcmp0 (key, PANEL_BACKGROUND_COLOR_KEY) == 0)
 
678
                panel_properties_dialog_background_color_update (dialog);
546
679
}
547
680
 
 
681
/******************************\
 
682
 * Code to make all this work *
 
683
\******************************/
 
684
 
548
685
static void
549
686
panel_properties_dialog_response (PanelPropertiesDialog *dialog,
550
687
                                  int                    response,
551
688
                                  GtkWidget             *properties_dialog)
552
689
{
553
 
        char *help_id;
554
 
 
555
690
        switch (response) {
556
691
        case GTK_RESPONSE_CLOSE:
557
692
                gtk_widget_destroy (properties_dialog);
558
693
                break;
559
694
        case GTK_RESPONSE_HELP:
560
 
                if (panel_toplevel_get_is_attached (dialog->toplevel)) {
561
 
                        help_id = "gospanel-550";
562
 
                } else {
563
 
                        help_id = "gospanel-28";
564
 
                }
565
695
                panel_show_help (gtk_window_get_screen (GTK_WINDOW (properties_dialog)),
566
 
                                 "user-guide", help_id, NULL);
 
696
                                 "user-guide", "gospanel-28", NULL);
567
697
                break;
568
698
        default:
569
699
                break;
580
710
}
581
711
 
582
712
static void
583
 
panel_properties_dialog_update_orientation (PanelPropertiesDialog *dialog,
584
 
                                            GConfValue            *value)
585
 
{
586
 
        PanelOrientation      orientation;
587
 
        GtkTreeModel         *model;
588
 
        GtkTreeIter           iter;
589
 
        OrientationComboItem *item;
590
 
        int                   max_size;
591
 
        int                   spin_size;
592
 
        int                   profile_size;
593
 
 
594
 
        if (!value || value->type != GCONF_VALUE_STRING)
595
 
                return;
596
 
 
597
 
        if (!panel_profile_map_orientation_string (gconf_value_get_string (value), &orientation))
598
 
                return;
599
 
 
600
 
        /* change the maximum size of the panel */
601
 
        //TODO: we should also do this when the monitor size changes
602
 
        max_size = panel_toplevel_get_maximum_size (dialog->toplevel);
603
 
        spin_size = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (dialog->size_spin));
604
 
        profile_size = panel_profile_get_toplevel_size (dialog->toplevel);
605
 
 
606
 
        gtk_spin_button_set_range (GTK_SPIN_BUTTON (dialog->size_spin),
607
 
                                   panel_toplevel_get_minimum_size (dialog->toplevel),
608
 
                                   max_size);
609
 
 
610
 
        if (spin_size > max_size)
611
 
                gtk_spin_button_set_value (GTK_SPIN_BUTTON (dialog->size_spin),
612
 
                                           max_size);
613
 
        else if (spin_size != profile_size)
614
 
                gtk_spin_button_set_value (GTK_SPIN_BUTTON (dialog->size_spin),
615
 
                                           MIN (profile_size, max_size));
616
 
 
617
 
        /* update the orientation combo box */
618
 
        model = gtk_combo_box_get_model (GTK_COMBO_BOX (dialog->orientation_combo));
619
 
 
620
 
        if (!gtk_tree_model_get_iter_first (model, &iter))
621
 
                return;
622
 
 
623
 
        do {
624
 
                gtk_tree_model_get (model, &iter, COLUMN_ITEM, &item, -1);
625
 
                if (item != NULL && item->orientation == orientation) {
626
 
                        gtk_combo_box_set_active_iter (GTK_COMBO_BOX (dialog->orientation_combo),
627
 
                                                       &iter);
628
 
                        return;
629
 
                }
630
 
        } while (gtk_tree_model_iter_next (model, &iter));
631
 
}
632
 
 
633
 
static void
634
 
panel_properties_dialog_update_size (PanelPropertiesDialog *dialog,
635
 
                                     GConfValue            *value)
636
 
{
637
 
        if (!value || value->type != GCONF_VALUE_INT)
638
 
                return;
639
 
 
640
 
        gtk_spin_button_set_value (GTK_SPIN_BUTTON (dialog->size_spin),
641
 
                                   gconf_value_get_int (value));
642
 
}
643
 
 
644
 
static void
645
 
panel_properties_dialog_toplevel_notify (GConfClient           *client,
646
 
                                         guint                  cnxn_id,
647
 
                                         GConfEntry            *entry,
648
 
                                         PanelPropertiesDialog *dialog)
649
 
{
650
 
        GConfValue *value;
651
 
        const char *key;
652
 
 
653
 
        key = panel_gconf_basename (gconf_entry_get_key (entry));
654
 
        if (!key)
655
 
                return;
656
 
 
657
 
        value = gconf_entry_get_value (entry);
658
 
 
659
 
#define UPDATE_TOGGLE(p, n)                                                                        \
660
 
        if (!strcmp (key, p)) {                                                                    \
661
 
                if (value && value->type == GCONF_VALUE_BOOL) {                                    \
662
 
                        gboolean val = gconf_value_get_bool (value);                               \
663
 
                        if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->n)) != val)   \
664
 
                                gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->n), val); \
665
 
                }                                                                                  \
666
 
        }
667
 
 
668
 
        if (!strcmp (key, "orientation"))
669
 
                panel_properties_dialog_update_orientation (dialog, value);
670
 
        else if (!strcmp (key, "size"))
671
 
                panel_properties_dialog_update_size (dialog, value);
672
 
        else UPDATE_TOGGLE ("expand",         expand_toggle)
673
 
        else UPDATE_TOGGLE ("auto_hide",      autohide_toggle)
674
 
        else UPDATE_TOGGLE ("enable_buttons", hidebuttons_toggle)
675
 
        else UPDATE_TOGGLE ("enable_arrows",  arrows_toggle)
676
 
}
677
 
 
678
 
static void
679
 
panel_properties_dialog_update_background_type (PanelPropertiesDialog *dialog,
680
 
                                                GConfValue            *value)
681
 
{
682
 
        PanelBackgroundType  background_type;
683
 
        GtkWidget           *active_radio;
684
 
 
685
 
        if (!value || value->type != GCONF_VALUE_STRING)
686
 
                return;
687
 
 
688
 
        if (!panel_profile_map_background_type_string (gconf_value_get_string (value),
689
 
                                                       &background_type))
690
 
                return;
691
 
 
692
 
        switch (background_type) {
693
 
        case PANEL_BACK_NONE:
694
 
                active_radio = dialog->default_radio;
695
 
                break;
696
 
        case PANEL_BACK_COLOR:
697
 
                active_radio = dialog->color_radio;
698
 
                break;
699
 
        case PANEL_BACK_IMAGE:
700
 
                active_radio = dialog->image_radio;
701
 
                break;
702
 
        default:
703
 
                active_radio = NULL;
704
 
                g_assert_not_reached ();
705
 
                break;
706
 
        }
707
 
 
708
 
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (active_radio), TRUE);
709
 
}
710
 
 
711
 
static void
712
 
panel_properties_dialog_update_background_color (PanelPropertiesDialog *dialog,
713
 
                                                 GConfValue            *value)
714
 
{
715
 
        GdkColor new_color = { 0, };
716
 
        GdkColor old_color;
717
 
 
718
 
        if (!value || value->type != GCONF_VALUE_STRING)
719
 
                return;
720
 
        
721
 
        if (!gdk_color_parse (gconf_value_get_string (value), &new_color))
722
 
                return;
723
 
 
724
 
        gtk_color_button_get_color (GTK_COLOR_BUTTON (dialog->color_button),
725
 
                                    &old_color);
726
 
 
727
 
        if (old_color.red   != new_color.red ||
728
 
            old_color.green != new_color.green ||
729
 
            old_color.blue  != new_color.blue)
730
 
                gtk_color_button_set_color (GTK_COLOR_BUTTON (dialog->color_button),
731
 
                                            &new_color);
732
 
}
733
 
 
734
 
static void
735
 
panel_properties_dialog_update_background_opacity (PanelPropertiesDialog *dialog,
736
 
                                                   GConfValue            *value)
737
 
{
738
 
        gdouble percentage;
739
 
 
740
 
        if (!value || value->type != GCONF_VALUE_INT)
741
 
                return;
742
 
 
743
 
        percentage = ((gdouble) (gconf_value_get_int (value) * 100)) / 65535;
744
 
 
745
 
        if ((int) gtk_range_get_value (GTK_RANGE (dialog->opacity_scale)) != (int) percentage)
746
 
                gtk_range_set_value (GTK_RANGE (dialog->opacity_scale), percentage);
747
 
}
748
 
 
749
 
static void
750
 
panel_properties_dialog_update_background_image (PanelPropertiesDialog *dialog,
751
 
                                                 GConfValue            *value)
752
 
{
753
 
        const char *text;
754
 
        char       *old_text;
755
 
 
756
 
        if (!value || value->type != GCONF_VALUE_STRING)
757
 
                return;
758
 
 
759
 
        text = gconf_value_get_string (value);
760
 
        old_text = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog->image_chooser));
761
 
 
762
 
        if (PANEL_GLIB_STR_EMPTY (text) && old_text)
763
 
                gtk_file_chooser_unselect_all (GTK_FILE_CHOOSER (dialog->image_chooser));
764
 
        else if (!PANEL_GLIB_STR_EMPTY (text) &&
765
 
                 (!old_text || strcmp (text, old_text)))
766
 
                gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog->image_chooser),
767
 
                                               text);
768
 
 
769
 
        if (old_text)
770
 
                g_free (old_text);
771
 
}
772
 
 
773
 
static void
774
 
panel_properties_dialog_background_notify (GConfClient           *client,
775
 
                                           guint                  cnxn_id,
776
 
                                           GConfEntry            *entry,
777
 
                                           PanelPropertiesDialog *dialog)
778
 
{
779
 
        GConfValue *value;
780
 
        const char *key;
781
 
 
782
 
        key = panel_gconf_basename (gconf_entry_get_key (entry));
783
 
        if (!key)
784
 
                return;
785
 
 
786
 
        value = gconf_entry_get_value (entry);
787
 
 
788
 
        if (!strcmp (key, "type"))
789
 
                panel_properties_dialog_update_background_type (dialog, value);
790
 
        else if (!strcmp (key, "color"))
791
 
                panel_properties_dialog_update_background_color (dialog, value);
792
 
        else if (!strcmp (key, "opacity"))
793
 
                panel_properties_dialog_update_background_opacity (dialog, value);
794
 
        else if (!strcmp (key, "image"))
795
 
                panel_properties_dialog_update_background_image (dialog, value);
796
 
}
797
 
 
798
 
static void
799
 
panel_properties_dialog_remove_orientation_combo (PanelPropertiesDialog *dialog)
800
 
{
801
 
        GtkContainer *container = GTK_CONTAINER (dialog->general_table);
802
 
        GtkTable     *table     = GTK_TABLE (dialog->general_table);
803
 
 
804
 
        g_object_ref (dialog->size_label);
805
 
        g_object_ref (dialog->size_widgets);
806
 
        g_object_ref (dialog->icon_label);
807
 
        g_object_ref (dialog->icon_align);
808
 
 
809
 
        gtk_container_remove (container, dialog->orientation_label);
810
 
        gtk_container_remove (container, dialog->orientation_combo);
811
 
        gtk_container_remove (container, dialog->size_label);
812
 
        gtk_container_remove (container, dialog->size_widgets);
813
 
        gtk_container_remove (container, dialog->icon_label);
814
 
        gtk_container_remove (container, dialog->icon_align);
815
 
 
816
 
        gtk_table_attach_defaults (table, dialog->size_label,   0, 1, 1, 2);
817
 
        gtk_table_attach_defaults (table, dialog->size_widgets, 1, 2, 1, 2);
818
 
        gtk_table_attach_defaults (table, dialog->icon_label,   0, 1, 2, 3);
819
 
        gtk_table_attach_defaults (table, dialog->icon_align,   1, 2, 2, 3);
820
 
 
821
 
        dialog->orientation_label = NULL;
822
 
        dialog->orientation_combo = NULL;
823
 
        g_object_unref (dialog->size_label);
824
 
        g_object_unref (dialog->size_widgets);
825
 
        g_object_unref (dialog->icon_label);
826
 
        g_object_unref (dialog->icon_align);
827
 
 
828
 
        gtk_table_resize (table, 3, 2);
829
 
}
830
 
 
831
 
static void
832
 
panel_properties_dialog_remove_icon_chooser (PanelPropertiesDialog *dialog)
833
 
{
834
 
        GtkContainer *container = GTK_CONTAINER (dialog->general_table);
835
 
 
836
 
        gtk_container_remove (container, dialog->icon_label);
837
 
        gtk_container_remove (container, dialog->icon_align);
838
 
 
839
 
        dialog->icon_label = NULL;
840
 
        dialog->icon_align = NULL;
841
 
        dialog->icon_chooser = NULL;
842
 
 
843
 
        gtk_table_resize (GTK_TABLE (dialog->general_table), 3, 2);
844
 
}
845
 
 
846
 
static void
847
 
panel_properties_dialog_remove_toggles (PanelPropertiesDialog *dialog)
848
 
{
849
 
        GtkContainer *container = GTK_CONTAINER (dialog->general_vbox);
850
 
 
851
 
        gtk_container_remove (container, dialog->autohide_toggle);
852
 
        gtk_container_remove (container, dialog->expand_toggle);
853
 
 
854
 
        dialog->autohide_toggle = NULL;
855
 
        dialog->expand_toggle   = NULL;
856
 
}
857
 
 
858
 
static void
859
 
panel_properties_dialog_update_for_attached (PanelPropertiesDialog *dialog,
860
 
                                             gboolean               attached)
861
 
{
862
 
        if (!attached)
863
 
                panel_properties_dialog_remove_icon_chooser (dialog);
864
 
        else {
865
 
                gtk_window_set_title (GTK_WINDOW (dialog->properties_dialog),
866
 
                                      _("Drawer Properties"));
867
 
                panel_properties_dialog_remove_toggles (dialog);
868
 
                panel_properties_dialog_remove_orientation_combo (dialog);
869
 
        }
 
713
panel_properties_dialog_free (PanelPropertiesDialog *dialog)
 
714
{
 
715
        if (dialog->properties_dialog)
 
716
                gtk_widget_destroy (dialog->properties_dialog);
 
717
        dialog->properties_dialog = NULL;
 
718
 
 
719
        if (dialog->settings_background)
 
720
                g_object_unref (dialog->settings_background);
 
721
        dialog->settings_background = NULL;
 
722
 
 
723
        if (dialog->settings)
 
724
                g_object_unref (dialog->settings);
 
725
        dialog->settings = NULL;
 
726
 
 
727
        g_free (dialog);
870
728
}
871
729
 
872
730
static PanelPropertiesDialog *
874
732
                             GtkBuilder    *gui)
875
733
{
876
734
        PanelPropertiesDialog *dialog;
 
735
        char                  *toplevel_settings_path;
877
736
 
878
737
        dialog = g_new0 (PanelPropertiesDialog, 1);
879
738
 
884
743
 
885
744
        dialog->toplevel = toplevel;
886
745
 
 
746
        g_object_get (toplevel, "settings-path", &toplevel_settings_path, NULL);
 
747
        dialog->settings = g_settings_new_with_path (PANEL_TOPLEVEL_SCHEMA,
 
748
                                                     toplevel_settings_path);
 
749
        dialog->settings_background = g_settings_get_child (dialog->settings,
 
750
                                                            PANEL_BACKGROUND_SCHEMA_CHILD);
 
751
 
 
752
        g_free (toplevel_settings_path);
 
753
 
887
754
        dialog->properties_dialog = PANEL_GTK_BUILDER_GET (gui, "panel_properties_dialog");
888
755
        g_signal_connect_swapped (dialog->properties_dialog, "response",
889
756
                                  G_CALLBACK (panel_properties_dialog_response), dialog);
896
763
        dialog->writability_warn_general = PANEL_GTK_BUILDER_GET (gui, "writability_warn_general");
897
764
        dialog->writability_warn_background = PANEL_GTK_BUILDER_GET (gui, "writability_warn_background");
898
765
 
899
 
        dialog->general_vbox  = PANEL_GTK_BUILDER_GET (gui, "general_vbox");
900
 
        dialog->general_table = PANEL_GTK_BUILDER_GET (gui, "general_table");
901
 
 
902
766
        panel_properties_dialog_setup_orientation_combo  (dialog, gui);
903
 
        panel_properties_dialog_setup_size_spin          (dialog, gui);
904
 
        panel_properties_dialog_setup_icon_chooser       (dialog, gui);
905
 
        panel_properties_dialog_setup_expand_toggle      (dialog, gui);
906
 
        panel_properties_dialog_setup_autohide_toggle    (dialog, gui);
907
 
        panel_properties_dialog_setup_hidebuttons_toggle (dialog, gui);
908
 
        panel_properties_dialog_setup_arrows_toggle      (dialog, gui);
909
 
 
910
 
        panel_properties_update_arrows_toggle_visible (
911
 
                dialog, GTK_TOGGLE_BUTTON (dialog->hidebuttons_toggle));
912
 
        g_signal_connect_swapped (dialog->hidebuttons_toggle, "toggled",
913
 
                                  G_CALLBACK (panel_properties_update_arrows_toggle_visible),
914
 
                                  dialog);
915
 
 
916
 
        dialog->toplevel_notify =
917
 
                panel_profile_toplevel_notify_add (
918
 
                        dialog->toplevel,
919
 
                        NULL,
920
 
                        (GConfClientNotifyFunc) panel_properties_dialog_toplevel_notify,
921
 
                        dialog);
922
 
 
923
 
        panel_properties_dialog_setup_color_button      (dialog, gui);
924
 
        panel_properties_dialog_setup_image_chooser     (dialog, gui);
925
 
        panel_properties_dialog_setup_opacity_scale     (dialog, gui);
926
 
        panel_properties_dialog_setup_background_radios (dialog, gui);
927
 
 
928
 
        dialog->background_notify =
929
 
                panel_profile_toplevel_notify_add (
930
 
                        dialog->toplevel,
931
 
                        "background",
932
 
                        (GConfClientNotifyFunc) panel_properties_dialog_background_notify,
933
 
                        dialog);
934
 
 
935
 
        panel_properties_dialog_update_for_attached (dialog,
936
 
                                                     panel_toplevel_get_is_attached (dialog->toplevel));
 
767
        panel_properties_dialog_size_spin_setup          (dialog, gui);
 
768
        panel_properties_dialog_expand_toggle_setup      (dialog, gui);
 
769
        panel_properties_dialog_autohide_toggle_setup    (dialog, gui);
 
770
        panel_properties_dialog_hidebuttons_toggle_setup (dialog, gui);
 
771
        panel_properties_dialog_arrows_toggle_setup      (dialog, gui);
 
772
 
 
773
        panel_properties_dialog_image_chooser_setup     (dialog, gui);
 
774
        panel_properties_dialog_color_button_setup      (dialog, gui);
 
775
        panel_properties_dialog_opacity_scale_setup     (dialog, gui);
 
776
        panel_properties_dialog_background_radios_setup (dialog, gui);
 
777
 
 
778
        g_signal_connect (dialog->settings_background, "changed",
 
779
                          G_CALLBACK (panel_properties_dialog_background_changed),
 
780
                          dialog);
937
781
 
938
782
        panel_toplevel_push_autohide_disabler (dialog->toplevel);
939
783
        panel_widget_register_open_dialog (panel_toplevel_get_panel_widget (dialog->toplevel),
940
784
                                           dialog->properties_dialog);
941
785
 
942
 
        g_signal_connect (dialog->properties_dialog, "event",
943
 
                          G_CALLBACK (config_event),
944
 
                          PANEL_GTK_BUILDER_GET (gui, "notebook"));
945
 
 
946
786
        gtk_widget_show (dialog->properties_dialog);
947
787
 
948
788
        return dialog;