← 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-desktop.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-desktop.c
1
 
/*
2
 
 * Copyright (C) 2007,2008 The GNOME Foundation
3
 
 * Written by Rodney Dawes <dobey@ximian.com>
4
 
 *            Denis Washington <denisw@svn.gnome.org>
5
 
 *            Thomas Wood <thos@gnome.org>
6
 
 * All Rights Reserved
7
 
 *
8
 
 * This program is free software; you can redistribute it and/or modify
9
 
 * it under the terms of the GNU General Public License as published by
10
 
 * the Free Software Foundation; either version 2 of the License, or
11
 
 * (at your option) any later version.
12
 
 *
13
 
 * This program is distributed in the hope that it will be useful,
14
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
 
 * GNU General Public License for more details.
17
 
 *
18
 
 * You should have received a copy of the GNU General Public License along
19
 
 * with this program; if not, write to the Free Software Foundation, Inc.,
20
 
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21
 
 */
22
 
 
23
 
#include "appearance.h"
24
 
#include "gnome-wp-info.h"
25
 
#include "gnome-wp-item.h"
26
 
#include "gnome-wp-xml.h"
27
 
#include <glib/gi18n.h>
28
 
#include <gio/gio.h>
29
 
#include <string.h>
30
 
#include <gconf/gconf-client.h>
31
 
#include <libgnomeui/gnome-desktop-thumbnail.h>
32
 
#include <libgnomeui/gnome-bg.h>
33
 
 
34
 
enum {
35
 
  TARGET_URI_LIST,
36
 
  TARGET_BGIMAGE
37
 
};
38
 
 
39
 
static const GtkTargetEntry drop_types[] = {
40
 
  { "text/uri-list", 0, TARGET_URI_LIST },
41
 
  { "property/bgimage", 0, TARGET_BGIMAGE }
42
 
};
43
 
 
44
 
static const GtkTargetEntry drag_types[] = {
45
 
  {"text/uri-list", GTK_TARGET_OTHER_WIDGET, TARGET_URI_LIST}
46
 
};
47
 
 
48
 
 
49
 
static void wp_update_preview (GtkFileChooser *chooser, AppearanceData *data);
50
 
 
51
 
static void
52
 
select_item (AppearanceData *data,
53
 
             GnomeWPItem * item,
54
 
             gboolean scroll)
55
 
{
56
 
  GtkTreePath *path;
57
 
 
58
 
  g_return_if_fail (data != NULL);
59
 
 
60
 
  if (item == NULL)
61
 
    return;
62
 
 
63
 
  path = gtk_tree_row_reference_get_path (item->rowref);
64
 
 
65
 
  gtk_icon_view_select_path (data->wp_view, path);
66
 
 
67
 
  if (scroll)
68
 
    gtk_icon_view_scroll_to_path (data->wp_view, path, FALSE, 0.5, 0.0);
69
 
 
70
 
  gtk_tree_path_free (path);
71
 
}
72
 
 
73
 
static GnomeWPItem *
74
 
get_selected_item (AppearanceData *data,
75
 
                   GtkTreeIter *iter)
76
 
{
77
 
  GnomeWPItem *item = NULL;
78
 
  GList *selected;
79
 
 
80
 
  selected = gtk_icon_view_get_selected_items (data->wp_view);
81
 
 
82
 
  if (selected != NULL)
83
 
  {
84
 
    GtkTreeIter sel_iter;
85
 
 
86
 
    gtk_tree_model_get_iter (data->wp_model, &sel_iter,
87
 
                             selected->data);
88
 
 
89
 
    g_list_foreach (selected, (GFunc) gtk_tree_path_free, NULL);
90
 
    g_list_free (selected);
91
 
 
92
 
    if (iter)
93
 
      *iter = sel_iter;
94
 
 
95
 
    gtk_tree_model_get (data->wp_model, &sel_iter, 1, &item, -1);
96
 
  }
97
 
 
98
 
  return item;
99
 
}
100
 
 
101
 
static gboolean predicate (gpointer key, gpointer value, gpointer data)
102
 
{
103
 
  GnomeBG *bg = data;
104
 
  GnomeWPItem *item = value;
105
 
 
106
 
  return item->bg == bg;
107
 
}
108
 
 
109
 
static void on_item_changed (GnomeBG *bg, AppearanceData *data) {
110
 
  GtkTreeModel *model;
111
 
  GtkTreeIter iter;
112
 
  GtkTreePath *path;
113
 
  GnomeWPItem *item;
114
 
 
115
 
  item = g_hash_table_find (data->wp_hash, predicate, bg);
116
 
 
117
 
  if (!item)
118
 
    return;
119
 
 
120
 
  model = gtk_tree_row_reference_get_model (item->rowref);
121
 
  path = gtk_tree_row_reference_get_path (item->rowref);
122
 
 
123
 
  if (gtk_tree_model_get_iter (model, &iter, path)) {
124
 
    GdkPixbuf *pixbuf;
125
 
 
126
 
    g_signal_handlers_block_by_func (bg, G_CALLBACK (on_item_changed), data);
127
 
 
128
 
    pixbuf = gnome_wp_item_get_thumbnail (item,
129
 
                                          data->thumb_factory,
130
 
                                          data->thumb_width,
131
 
                                          data->thumb_height);
132
 
    if (pixbuf) {
133
 
      gtk_list_store_set (GTK_LIST_STORE (data->wp_model), &iter, 0, pixbuf, -1);
134
 
      g_object_unref (pixbuf);
135
 
    }
136
 
 
137
 
    g_signal_handlers_unblock_by_func (bg, G_CALLBACK (on_item_changed), data);
138
 
  }
139
 
}
140
 
 
141
 
static void
142
 
wp_props_load_wallpaper (gchar *key,
143
 
                         GnomeWPItem *item,
144
 
                         AppearanceData *data)
145
 
{
146
 
  GtkTreeIter iter;
147
 
  GtkTreePath *path;
148
 
  GdkPixbuf *pixbuf;
149
 
 
150
 
  if (item->deleted == TRUE)
151
 
    return;
152
 
 
153
 
  gtk_list_store_append (GTK_LIST_STORE (data->wp_model), &iter);
154
 
 
155
 
  pixbuf = gnome_wp_item_get_thumbnail (item, data->thumb_factory,
156
 
                                        data->thumb_width,
157
 
                                        data->thumb_height);
158
 
  gnome_wp_item_update_description (item);
159
 
 
160
 
  gtk_list_store_set (GTK_LIST_STORE (data->wp_model), &iter,
161
 
                      0, pixbuf,
162
 
                      1, item,
163
 
                      -1);
164
 
 
165
 
  if (pixbuf != NULL)
166
 
    g_object_unref (pixbuf);
167
 
 
168
 
  path = gtk_tree_model_get_path (data->wp_model, &iter);
169
 
  item->rowref = gtk_tree_row_reference_new (data->wp_model, path);
170
 
  g_signal_connect (item->bg, "changed", G_CALLBACK (on_item_changed), data);
171
 
  gtk_tree_path_free (path);
172
 
}
173
 
 
174
 
static GnomeWPItem *
175
 
wp_add_image (AppearanceData *data,
176
 
              const gchar *filename)
177
 
{
178
 
  GnomeWPItem *item;
179
 
 
180
 
  if (!filename)
181
 
    return NULL;
182
 
 
183
 
  item = g_hash_table_lookup (data->wp_hash, filename);
184
 
 
185
 
  if (item != NULL)
186
 
  {
187
 
    if (item->deleted)
188
 
    {
189
 
      item->deleted = FALSE;
190
 
      wp_props_load_wallpaper (item->filename, item, data);
191
 
    }
192
 
  }
193
 
  else
194
 
  {
195
 
    item = gnome_wp_item_new (filename, data->wp_hash, data->thumb_factory);
196
 
 
197
 
    if (item != NULL)
198
 
    {
199
 
      wp_props_load_wallpaper (item->filename, item, data);
200
 
    }
201
 
  }
202
 
 
203
 
  return item;
204
 
}
205
 
 
206
 
static void
207
 
wp_add_images (AppearanceData *data,
208
 
               GSList *images)
209
 
{
210
 
  GdkWindow *window;
211
 
  GtkWidget *w;
212
 
  GdkCursor *cursor;
213
 
  GnomeWPItem *item;
214
 
 
215
 
  w = appearance_capplet_get_widget (data, "appearance_window");
216
 
  window = gtk_widget_get_window (w);
217
 
 
218
 
  item = NULL;
219
 
  cursor = gdk_cursor_new_for_display (gdk_display_get_default (),
220
 
                                       GDK_WATCH);
221
 
  gdk_window_set_cursor (window, cursor);
222
 
  gdk_cursor_unref (cursor);
223
 
 
224
 
  while (images != NULL)
225
 
  {
226
 
    gchar *uri = images->data;
227
 
 
228
 
    item = wp_add_image (data, uri);
229
 
    images = g_slist_remove (images, uri);
230
 
    g_free (uri);
231
 
  }
232
 
 
233
 
  gdk_window_set_cursor (window, NULL);
234
 
 
235
 
  if (item != NULL)
236
 
  {
237
 
    select_item (data, item, TRUE);
238
 
  }
239
 
}
240
 
 
241
 
static void
242
 
wp_option_menu_set (AppearanceData *data,
243
 
                    int value,
244
 
                    gboolean shade_type)
245
 
{
246
 
  if (shade_type)
247
 
  {
248
 
    gtk_combo_box_set_active (GTK_COMBO_BOX (data->wp_color_menu),
249
 
                              value);
250
 
 
251
 
    if (value == GNOME_BG_COLOR_SOLID)
252
 
      gtk_widget_hide (data->wp_scpicker);
253
 
    else
254
 
      gtk_widget_show (data->wp_scpicker);
255
 
  }
256
 
  else
257
 
  {
258
 
    gtk_combo_box_set_active (GTK_COMBO_BOX (data->wp_style_menu),
259
 
                              value);
260
 
  }
261
 
}
262
 
 
263
 
static void
264
 
wp_set_sensitivities (AppearanceData *data)
265
 
{
266
 
  GnomeWPItem *item;
267
 
  gchar *filename = NULL;
268
 
 
269
 
  item = get_selected_item (data, NULL);
270
 
 
271
 
  if (item != NULL)
272
 
    filename = item->filename;
273
 
 
274
 
  if (!gconf_client_key_is_writable (data->client, WP_OPTIONS_KEY, NULL)
275
 
      || (filename && !strcmp (filename, "(none)")))
276
 
    gtk_widget_set_sensitive (data->wp_style_menu, FALSE);
277
 
  else
278
 
    gtk_widget_set_sensitive (data->wp_style_menu, TRUE);
279
 
 
280
 
  if (!gconf_client_key_is_writable (data->client, WP_SHADING_KEY, NULL))
281
 
    gtk_widget_set_sensitive (data->wp_color_menu, FALSE);
282
 
  else
283
 
    gtk_widget_set_sensitive (data->wp_color_menu, TRUE);
284
 
 
285
 
  if (!gconf_client_key_is_writable (data->client, WP_PCOLOR_KEY, NULL))
286
 
    gtk_widget_set_sensitive (data->wp_pcpicker, FALSE);
287
 
  else
288
 
    gtk_widget_set_sensitive (data->wp_pcpicker, TRUE);
289
 
 
290
 
  if (!gconf_client_key_is_writable (data->client, WP_SCOLOR_KEY, NULL))
291
 
    gtk_widget_set_sensitive (data->wp_scpicker, FALSE);
292
 
  else
293
 
    gtk_widget_set_sensitive (data->wp_scpicker, TRUE);
294
 
 
295
 
  if (!filename || !strcmp (filename, "(none)"))
296
 
    gtk_widget_set_sensitive (data->wp_rem_button, FALSE);
297
 
  else
298
 
    gtk_widget_set_sensitive (data->wp_rem_button, TRUE);
299
 
}
300
 
 
301
 
static void
302
 
wp_scale_type_changed (GtkComboBox *combobox,
303
 
                       AppearanceData *data)
304
 
{
305
 
  GnomeWPItem *item;
306
 
  GtkTreeIter iter;
307
 
  GdkPixbuf *pixbuf;
308
 
 
309
 
  item = get_selected_item (data, &iter);
310
 
 
311
 
  if (item == NULL)
312
 
    return;
313
 
 
314
 
  item->options = gtk_combo_box_get_active (GTK_COMBO_BOX (data->wp_style_menu));
315
 
 
316
 
  pixbuf = gnome_wp_item_get_thumbnail (item, data->thumb_factory,
317
 
                                        data->thumb_width,
318
 
                                        data->thumb_height);
319
 
  gtk_list_store_set (GTK_LIST_STORE (data->wp_model), &iter, 0, pixbuf, -1);
320
 
  if (pixbuf != NULL)
321
 
    g_object_unref (pixbuf);
322
 
 
323
 
  if (gconf_client_key_is_writable (data->client, WP_OPTIONS_KEY, NULL))
324
 
    gconf_client_set_string (data->client, WP_OPTIONS_KEY,
325
 
                             wp_item_option_to_string (item->options), NULL);
326
 
}
327
 
 
328
 
static void
329
 
wp_shade_type_changed (GtkWidget *combobox,
330
 
                       AppearanceData *data)
331
 
{
332
 
  GnomeWPItem *item;
333
 
  GtkTreeIter iter;
334
 
  GdkPixbuf *pixbuf;
335
 
 
336
 
  item = get_selected_item (data, &iter);
337
 
 
338
 
  if (item == NULL)
339
 
    return;
340
 
 
341
 
  item->shade_type = gtk_combo_box_get_active (GTK_COMBO_BOX (data->wp_color_menu));
342
 
 
343
 
  pixbuf = gnome_wp_item_get_thumbnail (item, data->thumb_factory,
344
 
                                        data->thumb_width,
345
 
                                        data->thumb_height);
346
 
  gtk_list_store_set (GTK_LIST_STORE (data->wp_model), &iter, 0, pixbuf, -1);
347
 
  if (pixbuf != NULL)
348
 
    g_object_unref (pixbuf);
349
 
 
350
 
  if (gconf_client_key_is_writable (data->client, WP_SHADING_KEY, NULL))
351
 
    gconf_client_set_string (data->client, WP_SHADING_KEY,
352
 
                             wp_item_shading_to_string (item->shade_type), NULL);
353
 
}
354
 
 
355
 
static void
356
 
wp_color_changed (AppearanceData *data,
357
 
                  gboolean update)
358
 
{
359
 
  GnomeWPItem *item;
360
 
 
361
 
  item = get_selected_item (data, NULL);
362
 
 
363
 
  if (item == NULL)
364
 
    return;
365
 
 
366
 
  gtk_color_button_get_color (GTK_COLOR_BUTTON (data->wp_pcpicker), item->pcolor);
367
 
  gtk_color_button_get_color (GTK_COLOR_BUTTON (data->wp_scpicker), item->scolor);
368
 
 
369
 
  if (update)
370
 
  {
371
 
    gchar *pcolor, *scolor;
372
 
 
373
 
    pcolor = gdk_color_to_string (item->pcolor);
374
 
    scolor = gdk_color_to_string (item->scolor);
375
 
    gconf_client_set_string (data->client, WP_PCOLOR_KEY, pcolor, NULL);
376
 
    gconf_client_set_string (data->client, WP_SCOLOR_KEY, scolor, NULL);
377
 
    g_free (pcolor);
378
 
    g_free (scolor);
379
 
  }
380
 
 
381
 
  wp_shade_type_changed (NULL, data);
382
 
}
383
 
 
384
 
static void
385
 
wp_scolor_changed (GtkWidget *widget,
386
 
                   AppearanceData *data)
387
 
{
388
 
  wp_color_changed (data, TRUE);
389
 
}
390
 
 
391
 
static void
392
 
wp_remove_wallpaper (GtkWidget *widget,
393
 
                     AppearanceData *data)
394
 
{
395
 
  GnomeWPItem *item;
396
 
  GtkTreeIter iter;
397
 
  GtkTreePath *path;
398
 
 
399
 
  item = get_selected_item (data, &iter);
400
 
 
401
 
  if (item)
402
 
  {
403
 
    item->deleted = TRUE;
404
 
 
405
 
    if (gtk_list_store_remove (GTK_LIST_STORE (data->wp_model), &iter))
406
 
      path = gtk_tree_model_get_path (data->wp_model, &iter);
407
 
    else
408
 
      path = gtk_tree_path_new_first ();
409
 
 
410
 
    gtk_icon_view_select_path (data->wp_view, path);
411
 
    gtk_icon_view_set_cursor (data->wp_view, path, NULL, FALSE);
412
 
    gtk_tree_path_free (path);
413
 
  }
414
 
}
415
 
 
416
 
static void
417
 
wp_uri_changed (const gchar *uri,
418
 
                AppearanceData *data)
419
 
{
420
 
  GnomeWPItem *item, *selected;
421
 
 
422
 
  item = g_hash_table_lookup (data->wp_hash, uri);
423
 
  selected = get_selected_item (data, NULL);
424
 
 
425
 
  if (selected != NULL && strcmp (selected->filename, uri) != 0)
426
 
  {
427
 
    if (item == NULL)
428
 
      item = wp_add_image (data, uri);
429
 
 
430
 
    if (item)
431
 
      select_item (data, item, TRUE);
432
 
  }
433
 
}
434
 
 
435
 
static void
436
 
wp_file_changed (GConfClient *client, guint id,
437
 
                 GConfEntry *entry,
438
 
                 AppearanceData *data)
439
 
{
440
 
  const gchar *uri;
441
 
  gchar *wpfile;
442
 
 
443
 
  uri = gconf_value_get_string (entry->value);
444
 
 
445
 
  if (g_utf8_validate (uri, -1, NULL) && g_file_test (uri, G_FILE_TEST_EXISTS))
446
 
    wpfile = g_strdup (uri);
447
 
  else
448
 
    wpfile = g_filename_from_utf8 (uri, -1, NULL, NULL, NULL);
449
 
 
450
 
  wp_uri_changed (wpfile, data);
451
 
 
452
 
  g_free (wpfile);
453
 
}
454
 
 
455
 
static void
456
 
wp_options_changed (GConfClient *client, guint id,
457
 
                    GConfEntry *entry,
458
 
                    AppearanceData *data)
459
 
{
460
 
  GnomeWPItem *item;
461
 
  const gchar *option;
462
 
 
463
 
  option = gconf_value_get_string (entry->value);
464
 
 
465
 
  /* "none" means we don't use a background image */
466
 
  if (option == NULL || !strcmp (option, "none"))
467
 
  {
468
 
    /* temporarily disconnect so we don't override settings when
469
 
     * updating the selection */
470
 
    data->wp_update_gconf = FALSE;
471
 
    wp_uri_changed ("(none)", data);
472
 
    data->wp_update_gconf = TRUE;
473
 
    return;
474
 
  }
475
 
 
476
 
  item = get_selected_item (data, NULL);
477
 
 
478
 
  if (item != NULL)
479
 
  {
480
 
    item->options = wp_item_string_to_option (option);
481
 
    wp_option_menu_set (data, item->options, FALSE);
482
 
  }
483
 
}
484
 
 
485
 
static void
486
 
wp_shading_changed (GConfClient *client, guint id,
487
 
                    GConfEntry *entry,
488
 
                    AppearanceData *data)
489
 
{
490
 
  GnomeWPItem *item;
491
 
 
492
 
  wp_set_sensitivities (data);
493
 
 
494
 
  item = get_selected_item (data, NULL);
495
 
 
496
 
  if (item != NULL)
497
 
  {
498
 
    item->shade_type = wp_item_string_to_shading (gconf_value_get_string (entry->value));
499
 
    wp_option_menu_set (data, item->shade_type, TRUE);
500
 
  }
501
 
}
502
 
 
503
 
static void
504
 
wp_color1_changed (GConfClient *client, guint id,
505
 
                   GConfEntry *entry,
506
 
                   AppearanceData *data)
507
 
{
508
 
  GdkColor color;
509
 
  const gchar *colorhex;
510
 
 
511
 
  colorhex = gconf_value_get_string (entry->value);
512
 
 
513
 
  gdk_color_parse (colorhex, &color);
514
 
 
515
 
  gtk_color_button_set_color (GTK_COLOR_BUTTON (data->wp_pcpicker), &color);
516
 
 
517
 
  wp_color_changed (data, FALSE);
518
 
}
519
 
 
520
 
static void
521
 
wp_color2_changed (GConfClient *client, guint id,
522
 
                   GConfEntry *entry,
523
 
                   AppearanceData *data)
524
 
{
525
 
  GdkColor color;
526
 
  const gchar *colorhex;
527
 
 
528
 
  wp_set_sensitivities (data);
529
 
 
530
 
  colorhex = gconf_value_get_string (entry->value);
531
 
 
532
 
  gdk_color_parse (colorhex, &color);
533
 
 
534
 
  gtk_color_button_set_color (GTK_COLOR_BUTTON (data->wp_scpicker), &color);
535
 
 
536
 
  wp_color_changed (data, FALSE);
537
 
}
538
 
 
539
 
static gboolean
540
 
wp_props_wp_set (AppearanceData *data, GnomeWPItem *item)
541
 
{
542
 
  GConfChangeSet *cs;
543
 
  gchar *pcolor, *scolor;
544
 
 
545
 
  cs = gconf_change_set_new ();
546
 
 
547
 
  if (!strcmp (item->filename, "(none)"))
548
 
  {
549
 
    gconf_change_set_set_string (cs, WP_OPTIONS_KEY, "none");
550
 
    gconf_change_set_set_string (cs, WP_FILE_KEY, "");
551
 
  }
552
 
  else
553
 
  {
554
 
    gchar *uri;
555
 
 
556
 
    if (g_utf8_validate (item->filename, -1, NULL))
557
 
      uri = g_strdup (item->filename);
558
 
    else
559
 
      uri = g_filename_to_utf8 (item->filename, -1, NULL, NULL, NULL);
560
 
 
561
 
    if (uri == NULL) {
562
 
      g_warning ("Failed to convert filename to UTF-8: %s", item->filename);
563
 
    } else {
564
 
      gconf_change_set_set_string (cs, WP_FILE_KEY, uri);
565
 
      g_free (uri);
566
 
    }
567
 
 
568
 
    gconf_change_set_set_string (cs, WP_OPTIONS_KEY,
569
 
                                 wp_item_option_to_string (item->options));
570
 
  }
571
 
 
572
 
  gconf_change_set_set_string (cs, WP_SHADING_KEY,
573
 
                               wp_item_shading_to_string (item->shade_type));
574
 
 
575
 
  pcolor = gdk_color_to_string (item->pcolor);
576
 
  scolor = gdk_color_to_string (item->scolor);
577
 
  gconf_change_set_set_string (cs, WP_PCOLOR_KEY, pcolor);
578
 
  gconf_change_set_set_string (cs, WP_SCOLOR_KEY, scolor);
579
 
  g_free (pcolor);
580
 
  g_free (scolor);
581
 
 
582
 
  gconf_client_commit_change_set (data->client, cs, TRUE, NULL);
583
 
 
584
 
  gconf_change_set_unref (cs);
585
 
 
586
 
  return FALSE;
587
 
}
588
 
 
589
 
static void
590
 
wp_props_wp_selected (GtkTreeSelection *selection,
591
 
                      AppearanceData *data)
592
 
{
593
 
  GnomeWPItem *item;
594
 
 
595
 
  item = get_selected_item (data, NULL);
596
 
 
597
 
  if (item != NULL)
598
 
  {
599
 
    wp_set_sensitivities (data);
600
 
 
601
 
    if (strcmp (item->filename, "(none)") != 0)
602
 
      wp_option_menu_set (data, item->options, FALSE);
603
 
 
604
 
    wp_option_menu_set (data, item->shade_type, TRUE);
605
 
 
606
 
    gtk_color_button_set_color (GTK_COLOR_BUTTON (data->wp_pcpicker),
607
 
                                item->pcolor);
608
 
    gtk_color_button_set_color (GTK_COLOR_BUTTON (data->wp_scpicker),
609
 
                                item->scolor);
610
 
 
611
 
    if (data->wp_update_gconf)
612
 
      wp_props_wp_set (data, item);
613
 
  }
614
 
  else
615
 
  {
616
 
    gtk_widget_set_sensitive (data->wp_rem_button, FALSE);
617
 
  }
618
 
}
619
 
 
620
 
void
621
 
wp_create_filechooser (AppearanceData *data)
622
 
{
623
 
  const char *start_dir, *pictures = NULL;
624
 
  GtkFileFilter *filter;
625
 
 
626
 
  data->wp_filesel = GTK_FILE_CHOOSER (
627
 
                     gtk_file_chooser_dialog_new (_("Add Wallpaper"),
628
 
                     GTK_WINDOW (appearance_capplet_get_widget (data, "appearance_window")),
629
 
                     GTK_FILE_CHOOSER_ACTION_OPEN,
630
 
                     GTK_STOCK_CANCEL,
631
 
                     GTK_RESPONSE_CANCEL,
632
 
                     GTK_STOCK_OPEN,
633
 
                     GTK_RESPONSE_OK,
634
 
                     NULL));
635
 
 
636
 
  gtk_dialog_set_default_response (GTK_DIALOG (data->wp_filesel), GTK_RESPONSE_OK);
637
 
  gtk_file_chooser_set_select_multiple (data->wp_filesel, TRUE);
638
 
  gtk_file_chooser_set_use_preview_label (data->wp_filesel, FALSE);
639
 
 
640
 
  start_dir = g_get_home_dir ();
641
 
 
642
 
  if (g_file_test ("/usr/share/backgrounds", G_FILE_TEST_IS_DIR)) {
643
 
    gtk_file_chooser_add_shortcut_folder (data->wp_filesel,
644
 
                                          "/usr/share/backgrounds", NULL);
645
 
    start_dir = "/usr/share/backgrounds";
646
 
  }
647
 
 
648
 
  pictures = g_get_user_special_dir (G_USER_DIRECTORY_PICTURES);
649
 
  if (pictures != NULL && g_file_test (pictures, G_FILE_TEST_IS_DIR)) {
650
 
    gtk_file_chooser_add_shortcut_folder (data->wp_filesel, pictures, NULL);
651
 
    start_dir = pictures;
652
 
  }
653
 
 
654
 
  gtk_file_chooser_set_current_folder (data->wp_filesel, start_dir);
655
 
 
656
 
  filter = gtk_file_filter_new ();
657
 
  gtk_file_filter_add_pixbuf_formats (filter);
658
 
  gtk_file_filter_set_name (filter, _("Images"));
659
 
  gtk_file_chooser_add_filter (data->wp_filesel, filter);
660
 
 
661
 
  filter = gtk_file_filter_new ();
662
 
  gtk_file_filter_set_name (filter, _("All files"));
663
 
  gtk_file_filter_add_pattern (filter, "*");
664
 
  gtk_file_chooser_add_filter (data->wp_filesel, filter);
665
 
 
666
 
  data->wp_image = gtk_image_new ();
667
 
  gtk_file_chooser_set_preview_widget (data->wp_filesel, data->wp_image);
668
 
  gtk_widget_set_size_request (data->wp_image, 128, -1);
669
 
 
670
 
  gtk_widget_show (data->wp_image);
671
 
 
672
 
  g_signal_connect (data->wp_filesel, "update-preview",
673
 
                    (GCallback) wp_update_preview, data);
674
 
}
675
 
 
676
 
static void
677
 
wp_file_open_dialog (GtkWidget *widget,
678
 
                     AppearanceData *data)
679
 
{
680
 
  GSList *files;
681
 
 
682
 
  if (!data->wp_filesel)
683
 
    wp_create_filechooser (data);
684
 
 
685
 
  switch (gtk_dialog_run (GTK_DIALOG (data->wp_filesel)))
686
 
  {
687
 
  case GTK_RESPONSE_OK:
688
 
    files = gtk_file_chooser_get_filenames (data->wp_filesel);
689
 
    wp_add_images (data, files);
690
 
  case GTK_RESPONSE_CANCEL:
691
 
  default:
692
 
    gtk_widget_hide (GTK_WIDGET (data->wp_filesel));
693
 
    break;
694
 
  }
695
 
}
696
 
 
697
 
static void
698
 
wp_drag_received (GtkWidget *widget,
699
 
                  GdkDragContext *context,
700
 
                  gint x, gint y,
701
 
                  GtkSelectionData *selection_data,
702
 
                  guint info, guint time,
703
 
                  AppearanceData *data)
704
 
{
705
 
  if (info == TARGET_URI_LIST || info == TARGET_BGIMAGE)
706
 
  {
707
 
    GSList *realuris = NULL;
708
 
    gchar **uris;
709
 
 
710
 
    uris = g_uri_list_extract_uris ((gchar *) gtk_selection_data_get_data (selection_data));
711
 
    if (uris != NULL)
712
 
    {
713
 
      GtkWidget *w;
714
 
      GdkWindow *window;
715
 
      GdkCursor *cursor;
716
 
      gchar **uri;
717
 
 
718
 
      w = appearance_capplet_get_widget (data, "appearance_window");
719
 
      window = gtk_widget_get_window (w);
720
 
 
721
 
      cursor = gdk_cursor_new_for_display (gdk_display_get_default (),
722
 
             GDK_WATCH);
723
 
      gdk_window_set_cursor (window, cursor);
724
 
      gdk_cursor_unref (cursor);
725
 
 
726
 
      for (uri = uris; *uri; ++uri)
727
 
      {
728
 
        GFile *f;
729
 
 
730
 
        f = g_file_new_for_uri (*uri);
731
 
        realuris = g_slist_append (realuris, g_file_get_path (f));
732
 
        g_object_unref (f);
733
 
      }
734
 
 
735
 
      wp_add_images (data, realuris);
736
 
      gdk_window_set_cursor (window, NULL);
737
 
 
738
 
      g_strfreev (uris);
739
 
    }
740
 
  }
741
 
}
742
 
 
743
 
static void
744
 
wp_drag_get_data (GtkWidget *widget,
745
 
                  GdkDragContext *context,
746
 
                  GtkSelectionData *selection_data,
747
 
                  guint type, guint time,
748
 
                  AppearanceData *data)
749
 
{
750
 
  if (type == TARGET_URI_LIST) {
751
 
    GnomeWPItem *item = get_selected_item (data, NULL);
752
 
 
753
 
    if (item != NULL) {
754
 
      char *uris[2];
755
 
 
756
 
      uris[0] = g_filename_to_uri (item->filename, NULL, NULL);
757
 
      uris[1] = NULL;
758
 
 
759
 
      gtk_selection_data_set_uris (selection_data, uris);
760
 
 
761
 
      g_free (uris[0]);
762
 
    }
763
 
  }
764
 
}
765
 
 
766
 
static gboolean
767
 
wp_view_tooltip_cb (GtkWidget  *widget,
768
 
                    gint x,
769
 
                    gint y,
770
 
                    gboolean keyboard_mode,
771
 
                    GtkTooltip *tooltip,
772
 
                    AppearanceData *data)
773
 
{
774
 
  GtkTreeIter iter;
775
 
  GnomeWPItem *item;
776
 
 
777
 
  if (gtk_icon_view_get_tooltip_context (data->wp_view,
778
 
                                         &x, &y,
779
 
                                         keyboard_mode,
780
 
                                         NULL,
781
 
                                         NULL,
782
 
                                         &iter))
783
 
    {
784
 
      gtk_tree_model_get (data->wp_model, &iter, 1, &item, -1);
785
 
      gtk_tooltip_set_markup (tooltip, item->description);
786
 
 
787
 
      return TRUE;
788
 
    }
789
 
 
790
 
  return FALSE;
791
 
}
792
 
 
793
 
static gint
794
 
wp_list_sort (GtkTreeModel *model,
795
 
              GtkTreeIter *a, GtkTreeIter *b,
796
 
              AppearanceData *data)
797
 
{
798
 
  GnomeWPItem *itema, *itemb;
799
 
  gint retval;
800
 
 
801
 
  gtk_tree_model_get (model, a, 1, &itema, -1);
802
 
  gtk_tree_model_get (model, b, 1, &itemb, -1);
803
 
 
804
 
  if (!strcmp (itema->filename, "(none)"))
805
 
  {
806
 
    retval =  -1;
807
 
  }
808
 
  else if (!strcmp (itemb->filename, "(none)"))
809
 
  {
810
 
    retval =  1;
811
 
  }
812
 
  else
813
 
  {
814
 
    retval = g_utf8_collate (itema->description, itemb->description);
815
 
  }
816
 
 
817
 
  return retval;
818
 
}
819
 
 
820
 
static void
821
 
wp_update_preview (GtkFileChooser *chooser,
822
 
                   AppearanceData *data)
823
 
{
824
 
  gchar *uri;
825
 
 
826
 
  uri = gtk_file_chooser_get_preview_uri (chooser);
827
 
 
828
 
  if (uri)
829
 
  {
830
 
    GdkPixbuf *pixbuf = NULL;
831
 
    const gchar *mime_type = NULL;
832
 
    GFile *file;
833
 
    GFileInfo *file_info;
834
 
 
835
 
    file = g_file_new_for_uri (uri);
836
 
    file_info = g_file_query_info (file,
837
 
                                   G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
838
 
                                   G_FILE_QUERY_INFO_NONE,
839
 
                                   NULL, NULL);
840
 
    g_object_unref (file);
841
 
 
842
 
    if (file_info != NULL)
843
 
    {
844
 
      mime_type = g_file_info_get_content_type (file_info);
845
 
      g_object_unref (file_info);
846
 
    }
847
 
 
848
 
    if (mime_type)
849
 
    {
850
 
      pixbuf = gnome_desktop_thumbnail_factory_generate_thumbnail (data->thumb_factory,
851
 
                                                                   uri,
852
 
                                                                   mime_type);
853
 
    }
854
 
 
855
 
    if (pixbuf != NULL)
856
 
    {
857
 
      gtk_image_set_from_pixbuf (GTK_IMAGE (data->wp_image), pixbuf);
858
 
      g_object_unref (pixbuf);
859
 
    }
860
 
    else
861
 
    {
862
 
      gtk_image_set_from_stock (GTK_IMAGE (data->wp_image),
863
 
                                "gtk-dialog-question",
864
 
                                GTK_ICON_SIZE_DIALOG);
865
 
    }
866
 
  }
867
 
 
868
 
  gtk_file_chooser_set_preview_widget_active (chooser, TRUE);
869
 
}
870
 
 
871
 
static gboolean
872
 
reload_item (GtkTreeModel *model,
873
 
             GtkTreePath *path,
874
 
             GtkTreeIter *iter,
875
 
             AppearanceData *data)
876
 
{
877
 
  GnomeWPItem *item;
878
 
  GdkPixbuf *pixbuf;
879
 
 
880
 
  gtk_tree_model_get (model, iter, 1, &item, -1);
881
 
 
882
 
  pixbuf = gnome_wp_item_get_thumbnail (item,
883
 
                                        data->thumb_factory,
884
 
                                        data->thumb_width,
885
 
                                        data->thumb_height);
886
 
  if (pixbuf) {
887
 
    gtk_list_store_set (GTK_LIST_STORE (data->wp_model), iter, 0, pixbuf, -1);
888
 
    g_object_unref (pixbuf);
889
 
  }
890
 
 
891
 
  return FALSE;
892
 
}
893
 
 
894
 
static gdouble
895
 
get_monitor_aspect_ratio_for_widget (GtkWidget *widget)
896
 
{
897
 
  gdouble aspect;
898
 
  gint monitor;
899
 
  GdkRectangle rect;
900
 
 
901
 
  monitor = gdk_screen_get_monitor_at_window (gtk_widget_get_screen (widget), gtk_widget_get_window (widget));
902
 
  gdk_screen_get_monitor_geometry (gtk_widget_get_screen (widget), monitor, &rect);
903
 
  aspect = rect.height / (gdouble)rect.width;
904
 
 
905
 
  return aspect;
906
 
}
907
 
 
908
 
#define LIST_IMAGE_SIZE 108
909
 
 
910
 
static void
911
 
compute_thumbnail_sizes (AppearanceData *data)
912
 
{
913
 
  gdouble aspect;
914
 
 
915
 
  aspect = get_monitor_aspect_ratio_for_widget (GTK_WIDGET (data->wp_view));
916
 
  if (aspect > 1) {
917
 
    /* portrait */
918
 
    data->thumb_width = LIST_IMAGE_SIZE / aspect;
919
 
    data->thumb_height = LIST_IMAGE_SIZE;
920
 
  } else {
921
 
    data->thumb_width = LIST_IMAGE_SIZE;
922
 
    data->thumb_height = LIST_IMAGE_SIZE * aspect;
923
 
  }
924
 
}
925
 
 
926
 
static void
927
 
reload_wallpapers (AppearanceData *data)
928
 
{
929
 
  compute_thumbnail_sizes (data);
930
 
  gtk_tree_model_foreach (data->wp_model, (GtkTreeModelForeachFunc)reload_item, data);
931
 
}
932
 
 
933
 
static gboolean
934
 
wp_load_stuffs (void *user_data)
935
 
{
936
 
  AppearanceData *data;
937
 
  gchar *imagepath, *uri, *style;
938
 
  GnomeWPItem *item;
939
 
 
940
 
  data = (AppearanceData *) user_data;
941
 
 
942
 
  compute_thumbnail_sizes (data);
943
 
 
944
 
  gnome_wp_xml_load_list (data);
945
 
  g_hash_table_foreach (data->wp_hash, (GHFunc) wp_props_load_wallpaper,
946
 
                        data);
947
 
 
948
 
  style = gconf_client_get_string (data->client,
949
 
                                   WP_OPTIONS_KEY,
950
 
                                   NULL);
951
 
  if (style == NULL)
952
 
    style = g_strdup ("none");
953
 
 
954
 
  uri = gconf_client_get_string (data->client,
955
 
                                 WP_FILE_KEY,
956
 
                                 NULL);
957
 
 
958
 
  if (uri && *uri == '\0')
959
 
  {
960
 
    g_free (uri);
961
 
    uri = NULL;
962
 
  }
963
 
 
964
 
  if (uri == NULL)
965
 
    uri = g_strdup ("(none)");
966
 
 
967
 
  if (g_utf8_validate (uri, -1, NULL) && g_file_test (uri, G_FILE_TEST_EXISTS))
968
 
    imagepath = g_strdup (uri);
969
 
  else
970
 
    imagepath = g_filename_from_utf8 (uri, -1, NULL, NULL, NULL);
971
 
 
972
 
  g_free (uri);
973
 
 
974
 
  item = g_hash_table_lookup (data->wp_hash, imagepath);
975
 
 
976
 
  if (item != NULL)
977
 
  {
978
 
    /* update with the current gconf settings */
979
 
    gnome_wp_item_update (item);
980
 
 
981
 
    if (strcmp (style, "none") != 0)
982
 
    {
983
 
      if (item->deleted == TRUE)
984
 
      {
985
 
        item->deleted = FALSE;
986
 
        wp_props_load_wallpaper (item->filename, item, data);
987
 
      }
988
 
 
989
 
      select_item (data, item, FALSE);
990
 
    }
991
 
  }
992
 
  else if (strcmp (style, "none") != 0)
993
 
  {
994
 
    item = wp_add_image (data, imagepath);
995
 
    if (item)
996
 
      select_item (data, item, FALSE);
997
 
  }
998
 
 
999
 
  item = g_hash_table_lookup (data->wp_hash, "(none)");
1000
 
  if (item == NULL)
1001
 
  {
1002
 
    item = gnome_wp_item_new ("(none)", data->wp_hash, data->thumb_factory);
1003
 
    if (item != NULL)
1004
 
    {
1005
 
      wp_props_load_wallpaper (item->filename, item, data);
1006
 
    }
1007
 
  }
1008
 
  else
1009
 
  {
1010
 
    if (item->deleted == TRUE)
1011
 
    {
1012
 
      item->deleted = FALSE;
1013
 
      wp_props_load_wallpaper (item->filename, item, data);
1014
 
    }
1015
 
 
1016
 
    if (!strcmp (style, "none"))
1017
 
    {
1018
 
      select_item (data, item, FALSE);
1019
 
      wp_option_menu_set (data, GNOME_BG_PLACEMENT_SCALED, FALSE);
1020
 
    }
1021
 
  }
1022
 
  g_free (imagepath);
1023
 
  g_free (style);
1024
 
 
1025
 
  if (data->wp_uris) {
1026
 
    wp_add_images (data, data->wp_uris);
1027
 
    data->wp_uris = NULL;
1028
 
  }
1029
 
 
1030
 
  return FALSE;
1031
 
}
1032
 
 
1033
 
static void
1034
 
wp_select_after_realize (GtkWidget *widget,
1035
 
                         AppearanceData *data)
1036
 
{
1037
 
  GnomeWPItem *item;
1038
 
 
1039
 
  g_idle_add (wp_load_stuffs, data);
1040
 
 
1041
 
  item = get_selected_item (data, NULL);
1042
 
  if (item == NULL)
1043
 
    item = g_hash_table_lookup (data->wp_hash, "(none)");
1044
 
 
1045
 
  select_item (data, item, TRUE);
1046
 
}
1047
 
 
1048
 
static GdkPixbuf *buttons[3];
1049
 
 
1050
 
static void
1051
 
create_button_images (AppearanceData  *data)
1052
 
{
1053
 
  GtkWidget *widget = (GtkWidget*)data->wp_view;
1054
 
  GtkStyle *style = gtk_widget_get_style (widget);
1055
 
  GtkIconSet *icon_set;
1056
 
  GdkPixbuf *pixbuf, *pb, *pb2;
1057
 
  gint i, w, h;
1058
 
 
1059
 
  icon_set = gtk_style_lookup_icon_set (style, "gtk-media-play");
1060
 
  pb = gtk_icon_set_render_icon (icon_set,
1061
 
                                 style,
1062
 
                                 GTK_TEXT_DIR_RTL,
1063
 
                                 GTK_STATE_NORMAL,
1064
 
                                 GTK_ICON_SIZE_MENU,
1065
 
                                 widget,
1066
 
                                 NULL);
1067
 
  pb2 = gtk_icon_set_render_icon (icon_set,
1068
 
                                  style,
1069
 
                                  GTK_TEXT_DIR_LTR,
1070
 
                                  GTK_STATE_NORMAL,
1071
 
                                  GTK_ICON_SIZE_MENU,
1072
 
                                  widget,
1073
 
                                  NULL);
1074
 
  w = gdk_pixbuf_get_width (pb);
1075
 
  h = gdk_pixbuf_get_height (pb);
1076
 
 
1077
 
  for (i = 0; i < 3; i++) {
1078
 
    pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, 2 * w, h);
1079
 
    gdk_pixbuf_fill (pixbuf, 0);
1080
 
    if (i > 0)
1081
 
      gdk_pixbuf_composite (pb, pixbuf, 0, 0, w, h, 0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
1082
 
    if (i < 2)
1083
 
      gdk_pixbuf_composite (pb2, pixbuf, w, 0, w, h, w, 0, 1, 1, GDK_INTERP_NEAREST, 255);
1084
 
 
1085
 
    buttons[i] = pixbuf;
1086
 
  }
1087
 
 
1088
 
  g_object_unref (pb);
1089
 
  g_object_unref (pb2);
1090
 
}
1091
 
 
1092
 
static void
1093
 
next_frame (AppearanceData  *data,
1094
 
            GtkCellRenderer *cr,
1095
 
            gint             direction)
1096
 
{
1097
 
  GnomeWPItem *item;
1098
 
  GtkTreeIter iter;
1099
 
  GdkPixbuf *pixbuf, *pb;
1100
 
  gint frame;
1101
 
 
1102
 
  pixbuf = NULL;
1103
 
 
1104
 
  frame = data->frame + direction;
1105
 
  item = get_selected_item (data, &iter);
1106
 
 
1107
 
  if (frame >= 0)
1108
 
    pixbuf = gnome_wp_item_get_frame_thumbnail (item,
1109
 
                                                data->thumb_factory,
1110
 
                                                data->thumb_width,
1111
 
                                                data->thumb_height,
1112
 
                                                frame);
1113
 
  if (pixbuf) {
1114
 
    gtk_list_store_set (GTK_LIST_STORE (data->wp_model), &iter, 0, pixbuf, -1);
1115
 
    g_object_unref (pixbuf);
1116
 
    data->frame = frame;
1117
 
  }
1118
 
 
1119
 
  pb = buttons[1];
1120
 
  if (direction < 0) {
1121
 
    if (frame == 0)
1122
 
      pb = buttons[0];
1123
 
  }
1124
 
  else {
1125
 
    pixbuf = gnome_wp_item_get_frame_thumbnail (item,
1126
 
                                                data->thumb_factory,
1127
 
                                                data->thumb_width,
1128
 
                                                data->thumb_height,
1129
 
                                                frame + 1);
1130
 
    if (pixbuf)
1131
 
      g_object_unref (pixbuf);
1132
 
    else
1133
 
      pb = buttons[2];
1134
 
  }
1135
 
  g_object_set (cr, "pixbuf", pb, NULL);
1136
 
}
1137
 
 
1138
 
static gboolean
1139
 
wp_button_press_cb (GtkWidget      *widget,
1140
 
                    GdkEventButton *event,
1141
 
                    AppearanceData *data)
1142
 
{
1143
 
  GtkCellRenderer *cell;
1144
 
  GdkEventButton *button_event = (GdkEventButton *) event;
1145
 
 
1146
 
  if (event->type != GDK_BUTTON_PRESS)
1147
 
    return FALSE;
1148
 
 
1149
 
  if (gtk_icon_view_get_item_at_pos (GTK_ICON_VIEW (widget),
1150
 
                                     button_event->x, button_event->y,
1151
 
                                     NULL, &cell)) {
1152
 
    if (g_object_get_data (G_OBJECT (cell), "buttons")) {
1153
 
      gint w, h;
1154
 
      GtkCellRenderer *cell2 = NULL;
1155
 
      gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
1156
 
      if (gtk_icon_view_get_item_at_pos (GTK_ICON_VIEW (widget),
1157
 
                                         button_event->x + w, button_event->y,
1158
 
                                         NULL, &cell2) && cell == cell2)
1159
 
        next_frame (data, cell, -1);
1160
 
      else
1161
 
        next_frame (data, cell, 1);
1162
 
      return TRUE;
1163
 
    }
1164
 
  }
1165
 
 
1166
 
  return FALSE;
1167
 
}
1168
 
 
1169
 
static void
1170
 
wp_selected_changed_cb (GtkIconView    *view,
1171
 
                        AppearanceData *data)
1172
 
{
1173
 
  GtkCellRenderer *cr;
1174
 
  GList *cells, *l;
1175
 
 
1176
 
  data->frame = -1;
1177
 
 
1178
 
  cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (data->wp_view));
1179
 
  for (l = cells; l; l = l->next) {
1180
 
    cr = l->data;
1181
 
    if (g_object_get_data (G_OBJECT (cr), "buttons"))
1182
 
      g_object_set (cr, "pixbuf", buttons[0], NULL);
1183
 
  }
1184
 
  g_list_free (cells);
1185
 
}
1186
 
 
1187
 
static void
1188
 
buttons_cell_data_func (GtkCellLayout   *layout,
1189
 
                        GtkCellRenderer *cell,
1190
 
                        GtkTreeModel    *model,
1191
 
                        GtkTreeIter     *iter,
1192
 
                        gpointer         user_data)
1193
 
{
1194
 
  AppearanceData *data = user_data;
1195
 
  GtkTreePath *path;
1196
 
  GnomeWPItem *item;
1197
 
  gboolean visible;
1198
 
 
1199
 
  path = gtk_tree_model_get_path (model, iter);
1200
 
 
1201
 
  if (gtk_icon_view_path_is_selected (GTK_ICON_VIEW (layout), path)) {
1202
 
    item = get_selected_item (data, NULL);
1203
 
    visible = gnome_bg_changes_with_time (item->bg);
1204
 
  }
1205
 
  else
1206
 
    visible = FALSE;
1207
 
 
1208
 
  g_object_set (G_OBJECT (cell), "visible", visible, NULL);
1209
 
 
1210
 
  gtk_tree_path_free (path);
1211
 
}
1212
 
 
1213
 
static void
1214
 
screen_monitors_changed (GdkScreen *screen,
1215
 
                         AppearanceData *data)
1216
 
{
1217
 
  reload_wallpapers (data);
1218
 
}
1219
 
 
1220
 
void
1221
 
desktop_init (AppearanceData *data,
1222
 
              const gchar **uris)
1223
 
{
1224
 
  GtkWidget *add_button, *w;
1225
 
  GtkCellRenderer *cr;
1226
 
  char *url;
1227
 
 
1228
 
  data->wp_update_gconf = TRUE;
1229
 
 
1230
 
  data->wp_uris = NULL;
1231
 
  if (uris != NULL) {
1232
 
    while (*uris != NULL) {
1233
 
      data->wp_uris = g_slist_append (data->wp_uris, g_strdup (*uris));
1234
 
      uris++;
1235
 
    }
1236
 
  }
1237
 
 
1238
 
  w = appearance_capplet_get_widget (data, "more_backgrounds_linkbutton");
1239
 
  url = gconf_client_get_string (data->client, MORE_BACKGROUNDS_URL_KEY, NULL);
1240
 
  if (url != NULL && url[0] != '\0') {
1241
 
    gtk_link_button_set_uri (GTK_LINK_BUTTON (w), url);
1242
 
    gtk_widget_show (w);
1243
 
  } else {
1244
 
    gtk_widget_hide (w);
1245
 
  }
1246
 
  g_free (url);
1247
 
 
1248
 
  data->wp_hash = g_hash_table_new (g_str_hash, g_str_equal);
1249
 
 
1250
 
  gconf_client_add_dir (data->client, WP_PATH_KEY,
1251
 
      GCONF_CLIENT_PRELOAD_ONELEVEL, NULL);
1252
 
 
1253
 
  gconf_client_notify_add (data->client,
1254
 
                           WP_FILE_KEY,
1255
 
                           (GConfClientNotifyFunc) wp_file_changed,
1256
 
                           data, NULL, NULL);
1257
 
  gconf_client_notify_add (data->client,
1258
 
                           WP_OPTIONS_KEY,
1259
 
                           (GConfClientNotifyFunc) wp_options_changed,
1260
 
                           data, NULL, NULL);
1261
 
  gconf_client_notify_add (data->client,
1262
 
                           WP_SHADING_KEY,
1263
 
                           (GConfClientNotifyFunc) wp_shading_changed,
1264
 
                           data, NULL, NULL);
1265
 
  gconf_client_notify_add (data->client,
1266
 
                           WP_PCOLOR_KEY,
1267
 
                           (GConfClientNotifyFunc) wp_color1_changed,
1268
 
                           data, NULL, NULL);
1269
 
  gconf_client_notify_add (data->client,
1270
 
                           WP_SCOLOR_KEY,
1271
 
                           (GConfClientNotifyFunc) wp_color2_changed,
1272
 
                           data, NULL, NULL);
1273
 
 
1274
 
  data->wp_model = GTK_TREE_MODEL (gtk_list_store_new (2, GDK_TYPE_PIXBUF,
1275
 
                                                       G_TYPE_POINTER));
1276
 
 
1277
 
  data->wp_view = GTK_ICON_VIEW (appearance_capplet_get_widget (data, "wp_view"));
1278
 
  gtk_icon_view_set_model (data->wp_view, GTK_TREE_MODEL (data->wp_model));
1279
 
 
1280
 
  g_signal_connect_after (data->wp_view, "realize",
1281
 
                          (GCallback) wp_select_after_realize, data);
1282
 
 
1283
 
  gtk_cell_layout_clear (GTK_CELL_LAYOUT (data->wp_view));
1284
 
 
1285
 
  cr = gtk_cell_renderer_pixbuf_new ();
1286
 
  g_object_set (cr, "xpad", 5, "ypad", 5, NULL);
1287
 
 
1288
 
  gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->wp_view), cr, TRUE);
1289
 
  gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->wp_view), cr,
1290
 
                                  "pixbuf", 0,
1291
 
                                  NULL);
1292
 
 
1293
 
  cr = gtk_cell_renderer_pixbuf_new ();
1294
 
  create_button_images (data);
1295
 
  g_object_set (cr,
1296
 
                "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE,
1297
 
                "pixbuf", buttons[0],
1298
 
                NULL);
1299
 
  g_object_set_data (G_OBJECT (cr), "buttons", GINT_TO_POINTER (TRUE));
1300
 
 
1301
 
  gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->wp_view), cr, FALSE);
1302
 
  gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (data->wp_view), cr,
1303
 
                                      buttons_cell_data_func, data, NULL);
1304
 
  g_signal_connect (data->wp_view, "selection-changed",
1305
 
                    (GCallback) wp_selected_changed_cb, data);
1306
 
  g_signal_connect (data->wp_view, "button-press-event",
1307
 
                    G_CALLBACK (wp_button_press_cb), data);
1308
 
 
1309
 
  data->frame = -1;
1310
 
 
1311
 
  gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (data->wp_model), 1,
1312
 
                                   (GtkTreeIterCompareFunc) wp_list_sort,
1313
 
                                   data, NULL);
1314
 
 
1315
 
  gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->wp_model),
1316
 
                                        1, GTK_SORT_ASCENDING);
1317
 
 
1318
 
  gtk_drag_dest_set (GTK_WIDGET (data->wp_view), GTK_DEST_DEFAULT_ALL, drop_types,
1319
 
                     G_N_ELEMENTS (drop_types), GDK_ACTION_COPY | GDK_ACTION_MOVE);
1320
 
  g_signal_connect (data->wp_view, "drag_data_received",
1321
 
                    (GCallback) wp_drag_received, data);
1322
 
 
1323
 
  gtk_drag_source_set (GTK_WIDGET (data->wp_view), GDK_BUTTON1_MASK,
1324
 
                       drag_types, G_N_ELEMENTS (drag_types), GDK_ACTION_COPY);
1325
 
  g_signal_connect (data->wp_view, "drag-data-get",
1326
 
                    (GCallback) wp_drag_get_data, data);
1327
 
 
1328
 
  data->wp_style_menu = appearance_capplet_get_widget (data, "wp_style_menu");
1329
 
 
1330
 
  g_signal_connect (data->wp_style_menu, "changed",
1331
 
                    (GCallback) wp_scale_type_changed, data);
1332
 
 
1333
 
  data->wp_color_menu = appearance_capplet_get_widget (data, "wp_color_menu");
1334
 
 
1335
 
  g_signal_connect (data->wp_color_menu, "changed",
1336
 
                    (GCallback) wp_shade_type_changed, data);
1337
 
 
1338
 
  data->wp_scpicker = appearance_capplet_get_widget (data, "wp_scpicker");
1339
 
 
1340
 
  g_signal_connect (data->wp_scpicker, "color-set",
1341
 
                    (GCallback) wp_scolor_changed, data);
1342
 
 
1343
 
  data->wp_pcpicker = appearance_capplet_get_widget (data, "wp_pcpicker");
1344
 
 
1345
 
  g_signal_connect (data->wp_pcpicker, "color-set",
1346
 
                    (GCallback) wp_scolor_changed, data);
1347
 
 
1348
 
  add_button = appearance_capplet_get_widget (data, "wp_add_button");
1349
 
  gtk_button_set_image (GTK_BUTTON (add_button),
1350
 
                        gtk_image_new_from_stock ("gtk-add", GTK_ICON_SIZE_BUTTON));
1351
 
 
1352
 
  g_signal_connect (add_button, "clicked",
1353
 
                    (GCallback) wp_file_open_dialog, data);
1354
 
 
1355
 
  data->wp_rem_button = appearance_capplet_get_widget (data, "wp_rem_button");
1356
 
 
1357
 
  g_signal_connect (data->wp_rem_button, "clicked",
1358
 
                    (GCallback) wp_remove_wallpaper, data);
1359
 
  data->screen_monitors_handler = g_signal_connect (gtk_widget_get_screen (GTK_WIDGET (data->wp_view)),
1360
 
                                                    "monitors-changed",
1361
 
                                                    G_CALLBACK (screen_monitors_changed),
1362
 
                                                    data);
1363
 
  data->screen_size_handler = g_signal_connect (gtk_widget_get_screen (GTK_WIDGET (data->wp_view)),
1364
 
                                                    "size-changed",
1365
 
                                                    G_CALLBACK (screen_monitors_changed),
1366
 
                                                    data);
1367
 
 
1368
 
  g_signal_connect (data->wp_view, "selection-changed",
1369
 
                    (GCallback) wp_props_wp_selected, data);
1370
 
  g_signal_connect (data->wp_view, "query-tooltip",
1371
 
                    (GCallback) wp_view_tooltip_cb, data);
1372
 
  gtk_widget_set_has_tooltip (GTK_WIDGET (data->wp_view), TRUE);
1373
 
 
1374
 
  wp_set_sensitivities (data);
1375
 
 
1376
 
  /* create the file selector later to save time on startup */
1377
 
  data->wp_filesel = NULL;
1378
 
 
1379
 
}
1380
 
 
1381
 
void
1382
 
desktop_shutdown (AppearanceData *data)
1383
 
{
1384
 
  gnome_wp_xml_save_list (data);
1385
 
 
1386
 
  if (data->screen_monitors_handler > 0) {
1387
 
    g_signal_handler_disconnect (gtk_widget_get_screen (GTK_WIDGET (data->wp_view)),
1388
 
                                 data->screen_monitors_handler);
1389
 
    data->screen_monitors_handler = 0;
1390
 
  }
1391
 
  if (data->screen_size_handler > 0) {
1392
 
    g_signal_handler_disconnect (gtk_widget_get_screen (GTK_WIDGET (data->wp_view)),
1393
 
                                 data->screen_size_handler);
1394
 
    data->screen_size_handler = 0;
1395
 
  }
1396
 
 
1397
 
  g_slist_foreach (data->wp_uris, (GFunc) g_free, NULL);
1398
 
  g_slist_free (data->wp_uris);
1399
 
  if (data->wp_filesel)
1400
 
  {
1401
 
    g_object_ref_sink (data->wp_filesel);
1402
 
    g_object_unref (data->wp_filesel);
1403
 
  }
1404
 
}