← Back to branch summary

~kroq-gar78/ubuntu/precise/gnome-control-center/fix-885947

« back to all changes in this revision

Viewing changes to capplets/appearance/appearance-style.c

  • Committer: Bazaar Package Importer
  • Author(s): Rodrigo Moya
  • Date: 2011-05-17 10:47:27 UTC
  • mfrom: (0.1.11 experimental) (1.1.45 upstream)
  • Revision ID: james.westby@ubuntu.com-20110517104727-lqel6m8vhfw5jby1
Tags: 1:3.0.1.1-1ubuntu1
* Rebase on Debian, remaining Ubuntu changes:
* debian/control:
  - Build-Depend on hardening-wrapper, dpkg-dev and dh-autoreconf
  - Add dependency on ubuntu-system-service
  - Remove dependency on gnome-icon-theme-symbolic
  - Move dependency on apg, gnome-icon-theme-symbolic and accountsservice to
    be a Recommends: until we get them in main
* debian/rules:
  - Use autoreconf
  - Add binary-post-install rule for gnome-control-center-data
  - Run dh-autoreconf
* debian/gnome-control-center.dirs:
* debian/gnome-control-center.links:
  - Add a link to the control center shell for indicators
* debian/patches/00_disable-nm.patch:
  - Temporary patch to disable building with NetworkManager until we get
    the new one in the archive
* debian/patches/01_git_remove_gettext_calls.patch:
  - Remove calls to AM_GNU_GETTEXT, IT_PROG_INTLTOOL should be enough
* debian/patches/01_git_kill_warning.patch:
  - Kill warning
* debian/patches/50_ubuntu_systemwide_prefs.patch:
  - Ubuntu specific proxy preferences
* debian/patches/51_ubuntu_system_keyboard.patch:
  - Implement the global keyboard spec at https://wiki.ubuntu.com/DefaultKeyboardSettings

Show diffs side-by-side

added added

removed removed

Lines of Context:
capplets/appearance/appearance-style.c
1
 
/*
2
 
 * Copyright (C) 2007, 2010 The GNOME Foundation
3
 
 * Written by Thomas Wood <thos@gnome.org>
4
 
 * All Rights Reserved
5
 
 *
6
 
 * This program is free software; you can redistribute it and/or modify
7
 
 * it under the terms of the GNU General Public License as published by
8
 
 * the Free Software Foundation; either version 2 of the License, or
9
 
 * (at your option) any later version.
10
 
 *
11
 
 * This program is distributed in the hope that it will be useful,
12
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 * GNU General Public License for more details.
15
 
 *
16
 
 * You should have received a copy of the GNU General Public License along
17
 
 * with this program; if not, write to the Free Software Foundation, Inc.,
18
 
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19
 
 */
20
 
#include "appearance.h"
21
 
 
22
 
#include <string.h>
23
 
#include <pango/pango.h>
24
 
#include <glib/gi18n.h>
25
 
 
26
 
#include "theme-util.h"
27
 
#include "gtkrc-utils.h"
28
 
#include "gconf-property-editor.h"
29
 
#include "theme-thumbnail.h"
30
 
#include "capplet-util.h"
31
 
 
32
 
typedef void (* ThumbnailGenFunc) (void               *type,
33
 
                                   ThemeThumbnailFunc  theme,
34
 
                                   AppearanceData     *data,
35
 
                                   GDestroyNotify     *destroy);
36
 
 
37
 
typedef struct {
38
 
  AppearanceData *data;
39
 
  GdkPixbuf *thumbnail;
40
 
} PEditorConvData;
41
 
 
42
 
static void update_message_area (AppearanceData *data);
43
 
static void create_thumbnail (const gchar *name, GdkPixbuf *default_thumb, AppearanceData *data);
44
 
 
45
 
static const gchar *symbolic_names[NUM_SYMBOLIC_COLORS] = {
46
 
  "fg_color", "bg_color",
47
 
  "text_color", "base_color",
48
 
  "selected_fg_color", "selected_bg_color",
49
 
  "tooltip_fg_color", "tooltip_bg_color"
50
 
};
51
 
 
52
 
static gchar *
53
 
find_string_in_model (GtkTreeModel *model, const gchar *value, gint column)
54
 
{
55
 
  GtkTreeIter iter;
56
 
  gboolean valid;
57
 
  gchar *path = NULL, *test;
58
 
 
59
 
  if (!value)
60
 
    return NULL;
61
 
 
62
 
  for (valid = gtk_tree_model_get_iter_first (model, &iter); valid;
63
 
       valid = gtk_tree_model_iter_next (model, &iter))
64
 
  {
65
 
    gtk_tree_model_get (model, &iter, column, &test, -1);
66
 
 
67
 
    if (test)
68
 
    {
69
 
      gint cmp = strcmp (test, value);
70
 
      g_free (test);
71
 
 
72
 
      if (!cmp)
73
 
      {
74
 
        path = gtk_tree_model_get_string_from_iter (model, &iter);
75
 
        break;
76
 
      }
77
 
    }
78
 
  }
79
 
 
80
 
  return path;
81
 
}
82
 
 
83
 
static GConfValue *
84
 
conv_to_widget_cb (GConfPropertyEditor *peditor, const GConfValue *value)
85
 
{
86
 
  GtkTreeModel *store;
87
 
  GtkTreeView *list;
88
 
  const gchar *curr_value;
89
 
  GConfValue *new_value;
90
 
  gchar *path;
91
 
 
92
 
  /* find value in model */
93
 
  curr_value = gconf_value_get_string (value);
94
 
  list = GTK_TREE_VIEW (gconf_property_editor_get_ui_control (peditor));
95
 
  store = gtk_tree_view_get_model (list);
96
 
 
97
 
  path = find_string_in_model (store, curr_value, COL_NAME);
98
 
 
99
 
  /* Add a temporary item if we can't find a match
100
 
   * TODO: delete this item if it is no longer selected?
101
 
   */
102
 
  if (!path)
103
 
  {
104
 
    GtkListStore *list_store;
105
 
    GtkTreeIter iter, sort_iter;
106
 
    PEditorConvData *conv;
107
 
 
108
 
    list_store = GTK_LIST_STORE (gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (store)));
109
 
 
110
 
    g_object_get (peditor, "data", &conv, NULL);
111
 
    gtk_list_store_insert_with_values (list_store, &iter, 0,
112
 
                                       COL_LABEL, curr_value,
113
 
                                       COL_NAME, curr_value,
114
 
                                       COL_THUMBNAIL, conv->thumbnail,
115
 
                                       -1);
116
 
    /* convert the tree store iter for use with the sort model */
117
 
    gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (store),
118
 
                                                    &sort_iter, &iter);
119
 
    path = gtk_tree_model_get_string_from_iter (store, &sort_iter);
120
 
 
121
 
    create_thumbnail (curr_value, conv->thumbnail, conv->data);
122
 
  }
123
 
 
124
 
  new_value = gconf_value_new (GCONF_VALUE_STRING);
125
 
  gconf_value_set_string (new_value, path);
126
 
  g_free (path);
127
 
 
128
 
  return new_value;
129
 
}
130
 
 
131
 
static GConfValue *
132
 
conv_from_widget_cb (GConfPropertyEditor *peditor, const GConfValue *value)
133
 
{
134
 
  GConfValue *new_value = NULL;
135
 
  GtkTreeIter iter;
136
 
  GtkTreeSelection *selection;
137
 
  GtkTreeModel *model;
138
 
  GtkTreeView *list;
139
 
 
140
 
  list = GTK_TREE_VIEW (gconf_property_editor_get_ui_control (peditor));
141
 
  selection = gtk_tree_view_get_selection (list);
142
 
 
143
 
  if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
144
 
    gchar *list_value;
145
 
 
146
 
    gtk_tree_model_get (model, &iter, COL_NAME, &list_value, -1);
147
 
 
148
 
    if (list_value) {
149
 
      new_value = gconf_value_new (GCONF_VALUE_STRING);
150
 
      gconf_value_set_string (new_value, list_value);
151
 
      g_free (list_value);
152
 
    }
153
 
  }
154
 
 
155
 
  return new_value;
156
 
}
157
 
 
158
 
static gint
159
 
cursor_theme_sort_func (GtkTreeModel *model,
160
 
                        GtkTreeIter *a,
161
 
                        GtkTreeIter *b,
162
 
                        gpointer user_data)
163
 
{
164
 
  gchar *a_label = NULL;
165
 
  gchar *b_label = NULL;
166
 
  const gchar *default_label;
167
 
  gint result;
168
 
 
169
 
  gtk_tree_model_get (model, a, COL_LABEL, &a_label, -1);
170
 
  gtk_tree_model_get (model, b, COL_LABEL, &b_label, -1);
171
 
 
172
 
  default_label = _("Default Pointer");
173
 
 
174
 
  if (!strcmp (a_label, default_label))
175
 
    result = -1;
176
 
  else if (!strcmp (b_label, default_label))
177
 
    result = 1;
178
 
  else
179
 
    result = strcmp (a_label, b_label);
180
 
 
181
 
  g_free (a_label);
182
 
  g_free (b_label);
183
 
 
184
 
  return result;
185
 
}
186
 
 
187
 
static void
188
 
style_message_area_response_cb (GtkWidget *w,
189
 
                                gint response_id,
190
 
                                AppearanceData *data)
191
 
{
192
 
  GtkSettings *settings = gtk_settings_get_default ();
193
 
  gchar *theme;
194
 
  gchar *engine_path;
195
 
 
196
 
  g_object_get (settings, "gtk-theme-name", &theme, NULL);
197
 
  engine_path = gtk_theme_info_missing_engine (theme, FALSE);
198
 
  g_free (theme);
199
 
 
200
 
  if (engine_path != NULL) {
201
 
    theme_install_file (GTK_WINDOW (gtk_widget_get_toplevel (data->style_message_area)),
202
 
                        engine_path);
203
 
    g_free (engine_path);
204
 
  }
205
 
  update_message_area (data);
206
 
}
207
 
 
208
 
static void
209
 
update_message_area (AppearanceData *data)
210
 
{
211
 
  GtkSettings *settings = gtk_settings_get_default ();
212
 
  gchar *theme = NULL;
213
 
  gchar *engine;
214
 
 
215
 
  g_object_get (settings, "gtk-theme-name", &theme, NULL);
216
 
  engine = gtk_theme_info_missing_engine (theme, TRUE);
217
 
  g_free (theme);
218
 
 
219
 
  if (data->style_message_area == NULL) {
220
 
    GtkWidget *hbox;
221
 
    GtkWidget *parent;
222
 
    GtkWidget *icon;
223
 
    GtkWidget *content;
224
 
 
225
 
    if (engine == NULL)
226
 
      return;
227
 
 
228
 
    data->style_message_area = gtk_info_bar_new ();
229
 
 
230
 
    g_signal_connect (data->style_message_area, "response",
231
 
                      (GCallback) style_message_area_response_cb, data);
232
 
 
233
 
    data->style_install_button = gtk_info_bar_add_button (
234
 
        GTK_INFO_BAR (data->style_message_area),
235
 
        _("Install"), GTK_RESPONSE_APPLY);
236
 
 
237
 
    data->style_message_label = gtk_label_new (NULL);
238
 
    gtk_label_set_line_wrap (GTK_LABEL (data->style_message_label), TRUE);
239
 
    gtk_misc_set_alignment (GTK_MISC (data->style_message_label), 0.0, 0.5);
240
 
 
241
 
    hbox = gtk_hbox_new (FALSE, 9);
242
 
    icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG);
243
 
    gtk_misc_set_alignment (GTK_MISC (icon), 0.5, 0);
244
 
    gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
245
 
    gtk_box_pack_start (GTK_BOX (hbox), data->style_message_label, TRUE, TRUE, 0);
246
 
    content = gtk_info_bar_get_content_area (GTK_INFO_BAR (data->style_message_area));
247
 
    gtk_container_add (GTK_CONTAINER (content), hbox);
248
 
    gtk_widget_show_all (data->style_message_area);
249
 
    gtk_widget_set_no_show_all (data->style_message_area, TRUE);
250
 
 
251
 
    parent = appearance_capplet_get_widget (data, "gtk_themes_vbox");
252
 
    gtk_box_pack_start (GTK_BOX (parent), data->style_message_area, FALSE, FALSE, 0);
253
 
  }
254
 
 
255
 
  if (engine != NULL) {
256
 
    gchar *message = g_strdup_printf (_("This theme will not look as intended because the required GTK+ theme engine '%s' is not installed."),
257
 
                                      engine);
258
 
    gtk_label_set_text (GTK_LABEL (data->style_message_label), message);
259
 
    g_free (message);
260
 
    g_free (engine);
261
 
 
262
 
    if (packagekit_available ())
263
 
      gtk_widget_show (data->style_install_button);
264
 
    else
265
 
      gtk_widget_hide (data->style_install_button);
266
 
 
267
 
    gtk_widget_show (data->style_message_area);
268
 
    gtk_widget_queue_draw (data->style_message_area);
269
 
  } else {
270
 
    gtk_widget_hide (data->style_message_area);
271
 
  }
272
 
}
273
 
 
274
 
static void
275
 
update_color_buttons_from_string (const gchar *color_scheme, AppearanceData *data)
276
 
{
277
 
  GdkColor colors[NUM_SYMBOLIC_COLORS];
278
 
  GtkWidget *widget;
279
 
  gint i;
280
 
 
281
 
  if (!gnome_theme_color_scheme_parse (color_scheme, colors))
282
 
    return;
283
 
 
284
 
  /* now set all the buttons to the correct settings */
285
 
  for (i = 0; i < NUM_SYMBOLIC_COLORS; ++i) {
286
 
    widget = appearance_capplet_get_widget (data, symbolic_names[i]);
287
 
    gtk_color_button_set_color (GTK_COLOR_BUTTON (widget), &colors[i]);
288
 
  }
289
 
}
290
 
 
291
 
static void
292
 
update_color_buttons_from_settings (GtkSettings *settings,
293
 
                                    AppearanceData *data)
294
 
{
295
 
  gchar *scheme, *setting;
296
 
 
297
 
  scheme = gconf_client_get_string (data->client, COLOR_SCHEME_KEY, NULL);
298
 
  g_object_get (settings, "gtk-color-scheme", &setting, NULL);
299
 
 
300
 
  if (scheme == NULL || strcmp (scheme, "") == 0)
301
 
    gtk_widget_set_sensitive (appearance_capplet_get_widget (data, "color_scheme_defaults_button"), FALSE);
302
 
 
303
 
  g_free (scheme);
304
 
  update_color_buttons_from_string (setting, data);
305
 
  g_free (setting);
306
 
}
307
 
 
308
 
static void
309
 
color_scheme_changed (GObject    *settings,
310
 
                      GParamSpec *pspec,
311
 
                      AppearanceData  *data)
312
 
{
313
 
  update_color_buttons_from_settings (GTK_SETTINGS (settings), data);
314
 
}
315
 
 
316
 
static void
317
 
check_color_schemes_enabled (GtkSettings *settings,
318
 
                             AppearanceData *data)
319
 
{
320
 
  gchar *theme = NULL;
321
 
  gchar *filename;
322
 
  GSList *symbolic_colors = NULL;
323
 
  gboolean enable_colors = FALSE;
324
 
  gint i;
325
 
 
326
 
  g_object_get (settings, "gtk-theme-name", &theme, NULL);
327
 
  filename = gtkrc_find_named (theme);
328
 
  g_free (theme);
329
 
 
330
 
  gtkrc_get_details (filename, NULL, &symbolic_colors);
331
 
  g_free (filename);
332
 
 
333
 
  for (i = 0; i < NUM_SYMBOLIC_COLORS; ++i) {
334
 
    gboolean found;
335
 
 
336
 
    found = (g_slist_find_custom (symbolic_colors, symbolic_names[i], (GCompareFunc) strcmp) != NULL);
337
 
    gtk_widget_set_sensitive (appearance_capplet_get_widget (data, symbolic_names[i]), found);
338
 
 
339
 
    enable_colors |= found;
340
 
  }
341
 
 
342
 
  g_slist_foreach (symbolic_colors, (GFunc) g_free, NULL);
343
 
  g_slist_free (symbolic_colors);
344
 
 
345
 
  gtk_widget_set_sensitive (appearance_capplet_get_widget (data, "color_scheme_table"), enable_colors);
346
 
  gtk_widget_set_sensitive (appearance_capplet_get_widget (data, "color_scheme_defaults_button"), enable_colors);
347
 
 
348
 
  if (enable_colors)
349
 
    gtk_widget_hide (appearance_capplet_get_widget (data, "color_scheme_message_hbox"));
350
 
  else
351
 
    gtk_widget_show (appearance_capplet_get_widget (data, "color_scheme_message_hbox"));
352
 
}
353
 
 
354
 
static void
355
 
color_button_clicked_cb (GtkWidget *colorbutton, AppearanceData *data)
356
 
{
357
 
  GtkWidget *widget;
358
 
  GdkColor color;
359
 
  GString *scheme = g_string_new (NULL);
360
 
  gchar *colstr;
361
 
  gchar *old_scheme = NULL;
362
 
  gint i;
363
 
 
364
 
  for (i = 0; i < NUM_SYMBOLIC_COLORS; ++i) {
365
 
    widget = appearance_capplet_get_widget (data, symbolic_names[i]);
366
 
    gtk_color_button_get_color (GTK_COLOR_BUTTON (widget), &color);
367
 
 
368
 
    colstr = gdk_color_to_string (&color);
369
 
    g_string_append_printf (scheme, "%s:%s\n", symbolic_names[i], colstr);
370
 
    g_free (colstr);
371
 
  }
372
 
  /* remove the last newline */
373
 
  g_string_truncate (scheme, scheme->len - 1);
374
 
 
375
 
  /* verify that the scheme really has changed */
376
 
  g_object_get (gtk_settings_get_default (), "gtk-color-scheme", &old_scheme, NULL);
377
 
 
378
 
  if (!gnome_theme_color_scheme_equal (old_scheme, scheme->str)) {
379
 
    gconf_client_set_string (data->client, COLOR_SCHEME_KEY, scheme->str, NULL);
380
 
 
381
 
    gtk_widget_set_sensitive (appearance_capplet_get_widget (data, "color_scheme_defaults_button"), TRUE);
382
 
  }
383
 
  g_free (old_scheme);
384
 
  g_string_free (scheme, TRUE);
385
 
}
386
 
 
387
 
static void
388
 
color_scheme_defaults_button_clicked_cb (GtkWidget *button, AppearanceData *data)
389
 
{
390
 
  gconf_client_unset (data->client, COLOR_SCHEME_KEY, NULL);
391
 
  gtk_widget_set_sensitive (appearance_capplet_get_widget (data, "color_scheme_defaults_button"), FALSE);
392
 
}
393
 
 
394
 
static void
395
 
style_response_cb (GtkDialog *dialog, gint response_id)
396
 
{
397
 
  if (response_id == GTK_RESPONSE_HELP) {
398
 
    capplet_help (GTK_WINDOW (dialog), "goscustdesk-61");
399
 
  } else {
400
 
    gtk_widget_hide (GTK_WIDGET (dialog));
401
 
  }
402
 
}
403
 
 
404
 
static void
405
 
gtk_theme_changed (GConfPropertyEditor *peditor,
406
 
                   const gchar *key,
407
 
                   const GConfValue *value,
408
 
                   AppearanceData *data)
409
 
{
410
 
  GnomeThemeInfo *theme = NULL;
411
 
  const gchar *name;
412
 
  GtkSettings *settings = gtk_settings_get_default ();
413
 
 
414
 
  if (value && (name = gconf_value_get_string (value))) {
415
 
    gchar *current;
416
 
 
417
 
    theme = gnome_theme_info_find (name);
418
 
 
419
 
    /* Manually update GtkSettings to new gtk+ theme.
420
 
     * This will eventually happen anyway, but we need the
421
 
     * info for the color scheme updates already. */
422
 
    g_object_get (settings, "gtk-theme-name", &current, NULL);
423
 
 
424
 
    if (strcmp (current, name) != 0) {
425
 
      g_object_set (settings, "gtk-theme-name", name, NULL);
426
 
      update_message_area (data);
427
 
    }
428
 
 
429
 
    g_free (current);
430
 
 
431
 
    check_color_schemes_enabled (settings, data);
432
 
    update_color_buttons_from_settings (settings, data);
433
 
  }
434
 
 
435
 
  gtk_widget_set_sensitive (appearance_capplet_get_widget (data, "gtk_themes_delete"),
436
 
                            theme_is_writable (theme));
437
 
}
438
 
 
439
 
static void
440
 
window_theme_changed (GConfPropertyEditor *peditor,
441
 
                      const gchar *key,
442
 
                      const GConfValue *value,
443
 
                      AppearanceData *data)
444
 
{
445
 
  GnomeThemeInfo *theme = NULL;
446
 
  const gchar *name;
447
 
 
448
 
  if (value && (name = gconf_value_get_string (value)))
449
 
    theme = gnome_theme_info_find (name);
450
 
 
451
 
  gtk_widget_set_sensitive (appearance_capplet_get_widget (data, "window_themes_delete"),
452
 
                            theme_is_writable (theme));
453
 
}
454
 
 
455
 
static void
456
 
icon_theme_changed (GConfPropertyEditor *peditor,
457
 
                    const gchar *key,
458
 
                    const GConfValue *value,
459
 
                    AppearanceData *data)
460
 
{
461
 
  GnomeThemeIconInfo *theme = NULL;
462
 
  const gchar *name;
463
 
 
464
 
  if (value && (name = gconf_value_get_string (value)))
465
 
    theme = gnome_theme_icon_info_find (name);
466
 
 
467
 
  gtk_widget_set_sensitive (appearance_capplet_get_widget (data, "icon_themes_delete"),
468
 
                            theme_is_writable (theme));
469
 
}
470
 
 
471
 
#ifdef HAVE_XCURSOR
472
 
static void
473
 
cursor_size_changed_cb (int size, AppearanceData *data)
474
 
{
475
 
  gconf_client_set_int (data->client, CURSOR_SIZE_KEY, size, NULL);
476
 
}
477
 
 
478
 
static void
479
 
cursor_size_scale_value_changed_cb (GtkRange *range, AppearanceData *data)
480
 
{
481
 
  GnomeThemeCursorInfo *theme;
482
 
  gchar *name;
483
 
 
484
 
  name = gconf_client_get_string (data->client, CURSOR_THEME_KEY, NULL);
485
 
  if (name == NULL)
486
 
    return;
487
 
 
488
 
  theme = gnome_theme_cursor_info_find (name);
489
 
  g_free (name);
490
 
 
491
 
  if (theme) {
492
 
    gint size;
493
 
 
494
 
    size = g_array_index (theme->sizes, gint, (int) gtk_range_get_value (range));
495
 
    cursor_size_changed_cb (size, data);
496
 
  }
497
 
}
498
 
#endif
499
 
 
500
 
static void
501
 
update_cursor_size_scale (GnomeThemeCursorInfo *theme,
502
 
                          AppearanceData *data)
503
 
{
504
 
#ifdef HAVE_XCURSOR
505
 
  GtkWidget *cursor_size_scale;
506
 
  GtkWidget *cursor_size_label;
507
 
  GtkWidget *cursor_size_small_label;
508
 
  GtkWidget *cursor_size_large_label;
509
 
  gboolean sensitive;
510
 
  gint size, gconf_size;
511
 
 
512
 
  cursor_size_scale = appearance_capplet_get_widget (data, "cursor_size_scale");
513
 
  cursor_size_label = appearance_capplet_get_widget (data, "cursor_size_label");
514
 
  cursor_size_small_label = appearance_capplet_get_widget (data, "cursor_size_small_label");
515
 
  cursor_size_large_label = appearance_capplet_get_widget (data, "cursor_size_large_label");
516
 
 
517
 
  sensitive = theme && theme->sizes->len > 1;
518
 
  gtk_widget_set_sensitive (cursor_size_scale, sensitive);
519
 
  gtk_widget_set_sensitive (cursor_size_label, sensitive);
520
 
  gtk_widget_set_sensitive (cursor_size_small_label, sensitive);
521
 
  gtk_widget_set_sensitive (cursor_size_large_label, sensitive);
522
 
 
523
 
  gconf_size = gconf_client_get_int (data->client, CURSOR_SIZE_KEY, NULL);
524
 
 
525
 
  if (sensitive) {
526
 
    GtkAdjustment *adjustment;
527
 
    gint i, index;
528
 
    GtkRange *range = GTK_RANGE (cursor_size_scale);
529
 
 
530
 
    adjustment = gtk_range_get_adjustment (range);
531
 
    g_object_set (adjustment, "upper", (gdouble) theme->sizes->len - 1, NULL);
532
 
 
533
 
 
534
 
    /* fallback if the gconf value is bigger than all available sizes;
535
 
       use the largest we have */
536
 
    index = theme->sizes->len - 1;
537
 
 
538
 
    /* set the slider to the cursor size which matches the gconf setting best  */
539
 
    for (i = 0; i < theme->sizes->len; i++) {
540
 
      size = g_array_index (theme->sizes, gint, i);
541
 
 
542
 
      if (size == gconf_size) {
543
 
        index = i;
544
 
        break;
545
 
      } else if (size > gconf_size) {
546
 
        if (i == 0) {
547
 
          index = 0;
548
 
        } else {
549
 
          gint diff, diff_to_last;
550
 
 
551
 
          diff = size - gconf_size;
552
 
          diff_to_last = gconf_size - g_array_index (theme->sizes, gint, i - 1);
553
 
 
554
 
          index = (diff < diff_to_last) ? i : i - 1;
555
 
        }
556
 
        break;
557
 
      }
558
 
    }
559
 
 
560
 
    gtk_range_set_value (range, (gdouble) index);
561
 
 
562
 
    size = g_array_index (theme->sizes, gint, index);
563
 
  } else {
564
 
    if (theme && theme->sizes->len > 0)
565
 
      size = g_array_index (theme->sizes, gint, 0);
566
 
    else
567
 
      size = 18;
568
 
  }
569
 
 
570
 
  if (size != gconf_size)
571
 
    cursor_size_changed_cb (size, data);
572
 
#endif
573
 
}
574
 
 
575
 
static void
576
 
cursor_theme_changed (GConfPropertyEditor *peditor,
577
 
                    const gchar *key,
578
 
                    const GConfValue *value,
579
 
                    AppearanceData *data)
580
 
{
581
 
  GnomeThemeCursorInfo *theme = NULL;
582
 
  const gchar *name;
583
 
 
584
 
  if (value && (name = gconf_value_get_string (value)))
585
 
    theme = gnome_theme_cursor_info_find (name);
586
 
 
587
 
  update_cursor_size_scale (theme, data);
588
 
 
589
 
  gtk_widget_set_sensitive (appearance_capplet_get_widget (data, "cursor_themes_delete"),
590
 
                            theme_is_writable (theme));
591
 
 
592
 
}
593
 
 
594
 
static void
595
 
generic_theme_delete (const gchar *tv_name, ThemeType type, AppearanceData *data)
596
 
{
597
 
  GtkTreeView *treeview = GTK_TREE_VIEW (appearance_capplet_get_widget (data, tv_name));
598
 
  GtkTreeSelection *selection = gtk_tree_view_get_selection (treeview);
599
 
  GtkTreeModel *model;
600
 
  GtkTreeIter iter;
601
 
 
602
 
  if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
603
 
    gchar *name;
604
 
 
605
 
    gtk_tree_model_get (model, &iter, COL_NAME, &name, -1);
606
 
 
607
 
    if (name != NULL && theme_delete (name, type)) {
608
 
      /* remove theme from the model, too */
609
 
      GtkTreeIter child;
610
 
      GtkTreePath *path;
611
 
 
612
 
      path = gtk_tree_model_get_path (model, &iter);
613
 
      gtk_tree_model_sort_convert_iter_to_child_iter (
614
 
          GTK_TREE_MODEL_SORT (model), &child, &iter);
615
 
      gtk_list_store_remove (GTK_LIST_STORE (
616
 
          gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (model))), &child);
617
 
 
618
 
      if (gtk_tree_model_get_iter (model, &iter, path) ||
619
 
          theme_model_iter_last (model, &iter)) {
620
 
        gtk_tree_path_free (path);
621
 
        path = gtk_tree_model_get_path (model, &iter);
622
 
        gtk_tree_selection_select_path (selection, path);
623
 
        gtk_tree_view_scroll_to_cell (treeview, path, NULL, FALSE, 0, 0);
624
 
      }
625
 
      gtk_tree_path_free (path);
626
 
    }
627
 
    g_free (name);
628
 
  }
629
 
}
630
 
 
631
 
static void
632
 
gtk_theme_delete_cb (GtkWidget *button, AppearanceData *data)
633
 
{
634
 
  generic_theme_delete ("gtk_themes_list", THEME_TYPE_GTK, data);
635
 
}
636
 
 
637
 
static void
638
 
window_theme_delete_cb (GtkWidget *button, AppearanceData *data)
639
 
{
640
 
  generic_theme_delete ("window_themes_list", THEME_TYPE_WINDOW, data);
641
 
}
642
 
 
643
 
static void
644
 
icon_theme_delete_cb (GtkWidget *button, AppearanceData *data)
645
 
{
646
 
  generic_theme_delete ("icon_themes_list", THEME_TYPE_ICON, data);
647
 
}
648
 
 
649
 
static void
650
 
cursor_theme_delete_cb (GtkWidget *button, AppearanceData *data)
651
 
{
652
 
  generic_theme_delete ("cursor_themes_list", THEME_TYPE_CURSOR, data);
653
 
}
654
 
 
655
 
static void
656
 
add_to_treeview (const gchar *tv_name,
657
 
                 const gchar *theme_name,
658
 
                 const gchar *theme_label,
659
 
                 GdkPixbuf *theme_thumbnail,
660
 
                 AppearanceData *data)
661
 
{
662
 
  GtkTreeView *treeview;
663
 
  GtkListStore *model;
664
 
 
665
 
  treeview = GTK_TREE_VIEW (appearance_capplet_get_widget (data, tv_name));
666
 
  model = GTK_LIST_STORE (
667
 
          gtk_tree_model_sort_get_model (
668
 
          GTK_TREE_MODEL_SORT (gtk_tree_view_get_model (treeview))));
669
 
 
670
 
  gtk_list_store_insert_with_values (model, NULL, 0,
671
 
          COL_LABEL, theme_label,
672
 
          COL_NAME, theme_name,
673
 
          COL_THUMBNAIL, theme_thumbnail,
674
 
          -1);
675
 
}
676
 
 
677
 
static void
678
 
remove_from_treeview (const gchar *tv_name,
679
 
                      const gchar *theme_name,
680
 
                      AppearanceData *data)
681
 
{
682
 
  GtkTreeView *treeview;
683
 
  GtkListStore *model;
684
 
  GtkTreeIter iter;
685
 
 
686
 
  treeview = GTK_TREE_VIEW (appearance_capplet_get_widget (data, tv_name));
687
 
  model = GTK_LIST_STORE (
688
 
          gtk_tree_model_sort_get_model (
689
 
          GTK_TREE_MODEL_SORT (gtk_tree_view_get_model (treeview))));
690
 
 
691
 
  if (theme_find_in_model (GTK_TREE_MODEL (model), theme_name, &iter))
692
 
    gtk_list_store_remove (model, &iter);
693
 
}
694
 
 
695
 
static void
696
 
update_in_treeview (const gchar *tv_name,
697
 
                    const gchar *theme_name,
698
 
                    const gchar *theme_label,
699
 
                    AppearanceData *data)
700
 
{
701
 
  GtkTreeView *treeview;
702
 
  GtkListStore *model;
703
 
  GtkTreeIter iter;
704
 
 
705
 
  treeview = GTK_TREE_VIEW (appearance_capplet_get_widget (data, tv_name));
706
 
  model = GTK_LIST_STORE (
707
 
          gtk_tree_model_sort_get_model (
708
 
          GTK_TREE_MODEL_SORT (gtk_tree_view_get_model (treeview))));
709
 
 
710
 
  if (theme_find_in_model (GTK_TREE_MODEL (model), theme_name, &iter)) {
711
 
    gtk_list_store_set (model, &iter,
712
 
          COL_LABEL, theme_label,
713
 
          COL_NAME, theme_name,
714
 
          -1);
715
 
  }
716
 
}
717
 
 
718
 
static void
719
 
update_thumbnail_in_treeview (const gchar *tv_name,
720
 
                    const gchar *theme_name,
721
 
                    GdkPixbuf *theme_thumbnail,
722
 
                    AppearanceData *data)
723
 
{
724
 
  GtkTreeView *treeview;
725
 
  GtkListStore *model;
726
 
  GtkTreeIter iter;
727
 
 
728
 
  if (theme_thumbnail == NULL)
729
 
    return;
730
 
 
731
 
  treeview = GTK_TREE_VIEW (appearance_capplet_get_widget (data, tv_name));
732
 
  model = GTK_LIST_STORE (
733
 
          gtk_tree_model_sort_get_model (
734
 
          GTK_TREE_MODEL_SORT (gtk_tree_view_get_model (treeview))));
735
 
 
736
 
  if (theme_find_in_model (GTK_TREE_MODEL (model), theme_name, &iter)) {
737
 
    gtk_list_store_set (model, &iter,
738
 
          COL_THUMBNAIL, theme_thumbnail,
739
 
          -1);
740
 
  }
741
 
}
742
 
 
743
 
static void
744
 
gtk_theme_thumbnail_cb (GdkPixbuf *pixbuf,
745
 
                        gchar *theme_name,
746
 
                        AppearanceData *data)
747
 
{
748
 
  update_thumbnail_in_treeview ("gtk_themes_list", theme_name, pixbuf, data);
749
 
}
750
 
 
751
 
static void
752
 
metacity_theme_thumbnail_cb (GdkPixbuf *pixbuf,
753
 
                             gchar *theme_name,
754
 
                             AppearanceData *data)
755
 
{
756
 
  update_thumbnail_in_treeview ("window_themes_list", theme_name, pixbuf, data);
757
 
}
758
 
 
759
 
static void
760
 
icon_theme_thumbnail_cb (GdkPixbuf *pixbuf,
761
 
                         gchar *theme_name,
762
 
                         AppearanceData *data)
763
 
{
764
 
  update_thumbnail_in_treeview ("icon_themes_list", theme_name, pixbuf, data);
765
 
}
766
 
 
767
 
static void
768
 
create_thumbnail (const gchar *name, GdkPixbuf *default_thumb, AppearanceData *data)
769
 
{
770
 
  if (default_thumb == data->icon_theme_icon) {
771
 
    GnomeThemeIconInfo *info;
772
 
    info = gnome_theme_icon_info_find (name);
773
 
    if (info != NULL) {
774
 
      generate_icon_theme_thumbnail_async (info,
775
 
          (ThemeThumbnailFunc) icon_theme_thumbnail_cb, data, NULL);
776
 
    }
777
 
  } else if (default_thumb == data->gtk_theme_icon) {
778
 
    GnomeThemeInfo *info;
779
 
    info = gnome_theme_info_find (name);
780
 
    if (info != NULL && info->has_gtk) {
781
 
      generate_gtk_theme_thumbnail_async (info,
782
 
          (ThemeThumbnailFunc) gtk_theme_thumbnail_cb, data, NULL);
783
 
    }
784
 
  } else if (default_thumb == data->window_theme_icon) {
785
 
    GnomeThemeInfo *info;
786
 
    info = gnome_theme_info_find (name);
787
 
    if (info != NULL && info->has_metacity) {
788
 
      generate_metacity_theme_thumbnail_async (info,
789
 
          (ThemeThumbnailFunc) metacity_theme_thumbnail_cb, data, NULL);
790
 
    }
791
 
  }
792
 
}
793
 
 
794
 
static void
795
 
changed_on_disk_cb (GnomeThemeCommonInfo *theme,
796
 
                    GnomeThemeChangeType  change_type,
797
 
                    GnomeThemeElement     element_type,
798
 
                    AppearanceData       *data)
799
 
{
800
 
  if (theme->type == GNOME_THEME_TYPE_REGULAR) {
801
 
    GnomeThemeInfo *info = (GnomeThemeInfo *) theme;
802
 
 
803
 
    if (change_type == GNOME_THEME_CHANGE_DELETED) {
804
 
      if (element_type & GNOME_THEME_GTK_2)
805
 
        remove_from_treeview ("gtk_themes_list", info->name, data);
806
 
      if (element_type & GNOME_THEME_METACITY)
807
 
        remove_from_treeview ("window_themes_list", info->name, data);
808
 
 
809
 
    } else {
810
 
      if (element_type & GNOME_THEME_GTK_2) {
811
 
        if (change_type == GNOME_THEME_CHANGE_CREATED)
812
 
          add_to_treeview ("gtk_themes_list", info->name, info->name, data->gtk_theme_icon, data);
813
 
        else if (change_type == GNOME_THEME_CHANGE_CHANGED)
814
 
          update_in_treeview ("gtk_themes_list", info->name, info->name, data);
815
 
 
816
 
        generate_gtk_theme_thumbnail_async (info,
817
 
            (ThemeThumbnailFunc) gtk_theme_thumbnail_cb, data, NULL);
818
 
      }
819
 
 
820
 
      if (element_type & GNOME_THEME_METACITY) {
821
 
        if (change_type == GNOME_THEME_CHANGE_CREATED)
822
 
          add_to_treeview ("window_themes_list", info->name, info->name, data->window_theme_icon, data);
823
 
        else if (change_type == GNOME_THEME_CHANGE_CHANGED)
824
 
          update_in_treeview ("window_themes_list", info->name, info->name, data);
825
 
 
826
 
        generate_metacity_theme_thumbnail_async (info,
827
 
            (ThemeThumbnailFunc) metacity_theme_thumbnail_cb, data, NULL);
828
 
      }
829
 
    }
830
 
 
831
 
  } else if (theme->type == GNOME_THEME_TYPE_ICON) {
832
 
    GnomeThemeIconInfo *info = (GnomeThemeIconInfo *) theme;
833
 
 
834
 
    if (change_type == GNOME_THEME_CHANGE_DELETED) {
835
 
      remove_from_treeview ("icon_themes_list", info->name, data);
836
 
    } else {
837
 
      if (change_type == GNOME_THEME_CHANGE_CREATED)
838
 
        add_to_treeview ("icon_themes_list", info->name, info->readable_name, data->icon_theme_icon, data);
839
 
      else if (change_type == GNOME_THEME_CHANGE_CHANGED)
840
 
        update_in_treeview ("icon_themes_list", info->name, info->readable_name, data);
841
 
 
842
 
      generate_icon_theme_thumbnail_async (info,
843
 
          (ThemeThumbnailFunc) icon_theme_thumbnail_cb, data, NULL);
844
 
    }
845
 
 
846
 
  } else if (theme->type == GNOME_THEME_TYPE_CURSOR) {
847
 
    GnomeThemeCursorInfo *info = (GnomeThemeCursorInfo *) theme;
848
 
 
849
 
    if (change_type == GNOME_THEME_CHANGE_DELETED) {
850
 
      remove_from_treeview ("cursor_themes_list", info->name, data);
851
 
    } else {
852
 
      if (change_type == GNOME_THEME_CHANGE_CREATED)
853
 
        add_to_treeview ("cursor_themes_list", info->name, info->readable_name, info->thumbnail, data);
854
 
      else if (change_type == GNOME_THEME_CHANGE_CHANGED)
855
 
        update_in_treeview ("cursor_themes_list", info->name, info->readable_name, data);
856
 
    }
857
 
  }
858
 
}
859
 
 
860
 
static void
861
 
prepare_list (AppearanceData *data, GtkWidget *list, ThemeType type, GCallback callback)
862
 
{
863
 
  GtkListStore *store;
864
 
  GList *l, *themes = NULL;
865
 
  GtkCellRenderer *renderer;
866
 
  GtkTreeViewColumn *column;
867
 
  GtkTreeModel *sort_model;
868
 
  GdkPixbuf *thumbnail;
869
 
  const gchar *key;
870
 
  GObject *peditor;
871
 
  GConfValue *value;
872
 
  ThumbnailGenFunc generator;
873
 
  ThemeThumbnailFunc thumb_cb;
874
 
  PEditorConvData *conv_data;
875
 
 
876
 
  switch (type)
877
 
  {
878
 
    case THEME_TYPE_GTK:
879
 
      themes = gnome_theme_info_find_by_type (GNOME_THEME_GTK_2);
880
 
      thumbnail = data->gtk_theme_icon;
881
 
      key = GTK_THEME_KEY;
882
 
      generator = (ThumbnailGenFunc) generate_gtk_theme_thumbnail_async;
883
 
      thumb_cb = (ThemeThumbnailFunc) gtk_theme_thumbnail_cb;
884
 
      break;
885
 
 
886
 
    case THEME_TYPE_WINDOW:
887
 
      themes = gnome_theme_info_find_by_type (GNOME_THEME_METACITY);
888
 
      thumbnail = data->window_theme_icon;
889
 
      key = METACITY_THEME_KEY;
890
 
      generator = (ThumbnailGenFunc) generate_metacity_theme_thumbnail_async;
891
 
      thumb_cb = (ThemeThumbnailFunc) metacity_theme_thumbnail_cb;
892
 
      break;
893
 
 
894
 
    case THEME_TYPE_ICON:
895
 
      themes = gnome_theme_icon_info_find_all ();
896
 
      thumbnail = data->icon_theme_icon;
897
 
      key = ICON_THEME_KEY;
898
 
      generator = (ThumbnailGenFunc) generate_icon_theme_thumbnail_async;
899
 
      thumb_cb = (ThemeThumbnailFunc) icon_theme_thumbnail_cb;
900
 
      break;
901
 
 
902
 
    case THEME_TYPE_CURSOR:
903
 
      themes = gnome_theme_cursor_info_find_all ();
904
 
      thumbnail = NULL;
905
 
      key = CURSOR_THEME_KEY;
906
 
      generator = NULL;
907
 
      thumb_cb = NULL;
908
 
      break;
909
 
 
910
 
    default:
911
 
      /* we don't deal with any other type of themes here */
912
 
      return;
913
 
  }
914
 
 
915
 
  store = gtk_list_store_new (NUM_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING);
916
 
 
917
 
  for (l = themes; l; l = g_list_next (l))
918
 
  {
919
 
    GnomeThemeCommonInfo *theme = (GnomeThemeCommonInfo *) l->data;
920
 
    GtkTreeIter i;
921
 
 
922
 
    if (type == THEME_TYPE_CURSOR) {
923
 
      thumbnail = ((GnomeThemeCursorInfo *) theme)->thumbnail;
924
 
    } else {
925
 
      generator (theme, thumb_cb, data, NULL);
926
 
    }
927
 
 
928
 
    gtk_list_store_insert_with_values (store, &i, 0,
929
 
                                       COL_LABEL, theme->readable_name,
930
 
                                       COL_NAME, theme->name,
931
 
                                       COL_THUMBNAIL, thumbnail,
932
 
                                       -1);
933
 
 
934
 
    if (type == THEME_TYPE_CURSOR && thumbnail) {
935
 
      g_object_unref (thumbnail);
936
 
      thumbnail = NULL;
937
 
    }
938
 
  }
939
 
  g_list_free (themes);
940
 
 
941
 
  sort_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (store));
942
 
  gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
943
 
                                        COL_LABEL, GTK_SORT_ASCENDING);
944
 
 
945
 
  if (type == THEME_TYPE_CURSOR)
946
 
    gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort_model), COL_LABEL,
947
 
                                     (GtkTreeIterCompareFunc) cursor_theme_sort_func,
948
 
                                     NULL, NULL);
949
 
 
950
 
  gtk_tree_view_set_model (GTK_TREE_VIEW (list), GTK_TREE_MODEL (sort_model));
951
 
 
952
 
  renderer = gtk_cell_renderer_pixbuf_new ();
953
 
  g_object_set (renderer, "xpad", 3, "ypad", 3, NULL);
954
 
 
955
 
  column = gtk_tree_view_column_new ();
956
 
  gtk_tree_view_column_pack_start (column, renderer, FALSE);
957
 
  gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", COL_THUMBNAIL);
958
 
  gtk_tree_view_append_column (GTK_TREE_VIEW (list), column);
959
 
 
960
 
  renderer = gtk_cell_renderer_text_new ();
961
 
 
962
 
  column = gtk_tree_view_column_new ();
963
 
  gtk_tree_view_column_pack_start (column, renderer, FALSE);
964
 
  gtk_tree_view_column_add_attribute (column, renderer, "text", COL_LABEL);
965
 
  gtk_tree_view_append_column (GTK_TREE_VIEW (list), column);
966
 
 
967
 
  conv_data = g_new (PEditorConvData, 1);
968
 
  conv_data->data = data;
969
 
  conv_data->thumbnail = thumbnail;
970
 
  peditor = gconf_peditor_new_tree_view (NULL, key, list,
971
 
      "conv-to-widget-cb", conv_to_widget_cb,
972
 
      "conv-from-widget-cb", conv_from_widget_cb,
973
 
      "data", conv_data,
974
 
      "data-free-cb", g_free,
975
 
      NULL);
976
 
  g_signal_connect (peditor, "value-changed", callback, data);
977
 
 
978
 
  /* init the delete buttons */
979
 
  value = gconf_client_get (data->client, key, NULL);
980
 
  (*((void (*) (GConfPropertyEditor *, const gchar *, const GConfValue *, gpointer)) callback))
981
 
      (GCONF_PROPERTY_EDITOR (peditor), key, value, data);
982
 
  if (value)
983
 
    gconf_value_free (value);
984
 
}
985
 
 
986
 
void
987
 
style_init (AppearanceData *data)
988
 
{
989
 
  GtkSettings *settings;
990
 
  GtkWidget *w;
991
 
  gchar *label;
992
 
  gint i;
993
 
 
994
 
  data->gtk_theme_icon = gdk_pixbuf_new_from_file (GNOMECC_PIXMAP_DIR "/gtk-theme-thumbnailing.png", NULL);
995
 
  data->window_theme_icon = gdk_pixbuf_new_from_file (GNOMECC_PIXMAP_DIR "/window-theme-thumbnailing.png", NULL);
996
 
  data->icon_theme_icon = gdk_pixbuf_new_from_file (GNOMECC_PIXMAP_DIR "/icon-theme-thumbnailing.png", NULL);
997
 
  data->style_message_area = NULL;
998
 
  data->style_message_label = NULL;
999
 
  data->style_install_button = NULL;
1000
 
 
1001
 
  w = appearance_capplet_get_widget (data, "theme_details");
1002
 
  g_signal_connect (w, "response", (GCallback) style_response_cb, NULL);
1003
 
  g_signal_connect (w, "delete_event", (GCallback) gtk_true, NULL);
1004
 
 
1005
 
  prepare_list (data, appearance_capplet_get_widget (data, "window_themes_list"), THEME_TYPE_WINDOW, (GCallback) window_theme_changed);
1006
 
  prepare_list (data, appearance_capplet_get_widget (data, "gtk_themes_list"), THEME_TYPE_GTK, (GCallback) gtk_theme_changed);
1007
 
  prepare_list (data, appearance_capplet_get_widget (data, "icon_themes_list"), THEME_TYPE_ICON, (GCallback) icon_theme_changed);
1008
 
  prepare_list (data, appearance_capplet_get_widget (data, "cursor_themes_list"), THEME_TYPE_CURSOR, (GCallback) cursor_theme_changed);
1009
 
 
1010
 
  w = appearance_capplet_get_widget (data, "color_scheme_message_hbox");
1011
 
  gtk_widget_set_no_show_all (w, TRUE);
1012
 
 
1013
 
  w = appearance_capplet_get_widget (data, "color_scheme_defaults_button");
1014
 
  gtk_button_set_image (GTK_BUTTON (w),
1015
 
                        gtk_image_new_from_stock (GTK_STOCK_REVERT_TO_SAVED,
1016
 
                                                  GTK_ICON_SIZE_BUTTON));
1017
 
 
1018
 
  settings = gtk_settings_get_default ();
1019
 
  g_signal_connect (settings, "notify::gtk-color-scheme", (GCallback) color_scheme_changed, data);
1020
 
 
1021
 
#ifdef HAVE_XCURSOR
1022
 
  w = appearance_capplet_get_widget (data, "cursor_size_scale");
1023
 
  g_signal_connect (w, "value-changed", (GCallback) cursor_size_scale_value_changed_cb, data);
1024
 
 
1025
 
  w = appearance_capplet_get_widget (data, "cursor_size_small_label");
1026
 
  label = g_strdup_printf ("<small><i>%s</i></small>", gtk_label_get_text (GTK_LABEL (w)));
1027
 
  gtk_label_set_markup (GTK_LABEL (w), label);
1028
 
  g_free (label);
1029
 
 
1030
 
  w = appearance_capplet_get_widget (data, "cursor_size_large_label");
1031
 
  label = g_strdup_printf ("<small><i>%s</i></small>", gtk_label_get_text (GTK_LABEL (w)));
1032
 
  gtk_label_set_markup (GTK_LABEL (w), label);
1033
 
  g_free (label);
1034
 
#else
1035
 
  w = appearance_capplet_get_widget (data, "cursor_size_hbox");
1036
 
  gtk_widget_set_no_show_all (w, TRUE);
1037
 
  gtk_widget_hide (w);
1038
 
  gtk_widget_show (appearance_capplet_get_widget (data, "cursor_message_hbox"));
1039
 
  gtk_box_set_spacing (GTK_BOX (appearance_capplet_get_widget (data, "cursor_vbox")), 12);
1040
 
#endif
1041
 
 
1042
 
  /* connect signals */
1043
 
  /* color buttons */
1044
 
  for (i = 0; i < NUM_SYMBOLIC_COLORS; ++i)
1045
 
    g_signal_connect (appearance_capplet_get_widget (data, symbolic_names[i]), "color-set", (GCallback) color_button_clicked_cb, data);
1046
 
 
1047
 
  /* revert button */
1048
 
  g_signal_connect (appearance_capplet_get_widget (data, "color_scheme_defaults_button"), "clicked", (GCallback) color_scheme_defaults_button_clicked_cb, data);
1049
 
  /* delete buttons */
1050
 
  g_signal_connect (appearance_capplet_get_widget (data, "gtk_themes_delete"), "clicked", (GCallback) gtk_theme_delete_cb, data);
1051
 
  g_signal_connect (appearance_capplet_get_widget (data, "window_themes_delete"), "clicked", (GCallback) window_theme_delete_cb, data);
1052
 
  g_signal_connect (appearance_capplet_get_widget (data, "icon_themes_delete"), "clicked", (GCallback) icon_theme_delete_cb, data);
1053
 
  g_signal_connect (appearance_capplet_get_widget (data, "cursor_themes_delete"), "clicked", (GCallback) cursor_theme_delete_cb, data);
1054
 
 
1055
 
  update_message_area (data);
1056
 
  gnome_theme_info_register_theme_change ((ThemeChangedCallback) changed_on_disk_cb, data);
1057
 
}
1058
 
 
1059
 
void
1060
 
style_shutdown (AppearanceData *data)
1061
 
{
1062
 
  if (data->gtk_theme_icon)
1063
 
    g_object_unref (data->gtk_theme_icon);
1064
 
  if (data->window_theme_icon)
1065
 
    g_object_unref (data->window_theme_icon);
1066
 
  if (data->icon_theme_icon)
1067
 
    g_object_unref (data->icon_theme_icon);
1068
 
}