← Back to branch summary

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

« back to all changes in this revision

Viewing changes to .pc/16_compiz_workspace_switcher.patch/applets/wncklet/workspace-switcher.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher, Sebastien Bacher, Jeremy Bicha
  • Date: 2011-05-30 11:04:49 UTC
  • mfrom: (1.13.10 upstream) (2.2.5 experimental)
  • Revision ID: james.westby@ubuntu.com-20110530110449-hinl17kxkcefjw6x
Tags: 1:3.0.2-0ubuntu1
[ Sebastien Bacher ]
* New upstream version
* debian/control.in:
  - the new libgweather version is in oneiric, use it
  - drop the python and python-gconf depends, 
    they were added for gnome-panel-add which is still using gconf and buggy
* debian/gnome-panel-data.install:
  - don't install the apport hook, it's only getting gconf datas which 
    doesn't work since gnome-panel uses gsettings
* debian/patches/90_build_fixes.patch:
  - restore build fix from git not applied in the new serie
* debian/patches/01_panel_submenus.patch:
  - don't take that Debian diff, the .menus use the upstream naming in Ubuntu
* debian/patches/06_no_resize_grip.patch:
  - dropped, the issue is fixed in the new version
* debian/patches/50_fix-potfiles.patch:
  - dropped, the issue is fixed in the new version
* debian/watch:
  - track unstable series as well

Drop those delta, since gnome-panel is not the default Ubuntu session now we
can go back to an experience closer to the upstream one: 
* debian/control.in:
  - drop the indicators recommends, unity-2d is the ubuntu fallback session
    so we can get back to use an upstream config for gnome-panel and reduce
    the delta we carry
* debian/patches/04_default_panel_config.patch:
  - don't modify the upstream layout
* debian/patches/05_no_session_delay.patch:
  - no need to tweak the upstream session to optimize it
* debian/patches/16_compiz_workspace_switcher.patch:
  - go back to the upstream switcher behaviour    
* debian/patches/25_dynamic_fusa_detection.patch:
  - not needed since we use the upstream layout, could be ported if someone
    is wanting to do the work though
* debian/patches/30_disable-initial-animation.patch, debian/rules:
  - drop the --disable-initial-animation, that was some login optimization
    but since it's not the default desktop you should go back to the 
    upstream behaviour

[ Jeremy Bicha ]   
* New upstream version
* Merge from Debian experimental, remaining Ubuntu changes:
* debian/control:
  - Recommends gnome-settings-daemon which has the timezone polkit service
* debian/rules:
  - Update translations template.
* debian/gnome-panel-data.install:
  - Install apport hook
  - Install the "About Ubuntu" menu item.
* debian/patches/01_layout.patch:
  - Disabled, Help & About Ubuntu don't fit as well in Gnome Panel 3
* debian/patches/01_panel_submenus.patch.
  - Dropped
* debian/patches/03_dnd_places_link.patch:
  - Disabled, when using Drag'n'Drop from Places menu, install a link launcher
    (.desktop file) instead of copying the entire directory.
* debian/patches/17_about-ubuntu-translation.patch:
  - List ubuntu-about.desktop for translation.
* debian/patches/40_unset_menuproxy.patch:
  - Make sure gnome-panel and the applets don't pick up menu proxies.
* debian/patches/50_fix-potfiles.patch
  - Fix i18n
* debian/patches/85_disable_shutdown_on_ltsp.patch:
  - Suppress the shutdown option in the panel if LTSP_CLIENT is set.
* debian/patches/71_change_bookmark_submenu_limit_value.patch
  - Dropped, picked up by Debian
* debian/patches/18_lockdown_lock_editor.patch:
* debian/patches/90_git_wnck_show_realize.patch:
* debian/patches/90_fix_linking_DSO_link.patch:
* debian/patches/91_gir_annotations.patch
* debian/patches/92_git_calendar_day.patch
* debian/patches/92_git_fix_applets_in_multiscreen.patch:
  - Dropped, applied upstream
* debian/watch:
  - watch unstable versions

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/16_compiz_workspace_switcher.patch/applets/wncklet/workspace-switcher.c
1
 
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
2
 
/*
3
 
 * libwnck based pager applet.
4
 
 * (C) 2001 Alexander Larsson 
5
 
 * (C) 2001 Red Hat, Inc
6
 
 *
7
 
 * Authors: Alexander Larsson
8
 
 *
9
 
 */
10
 
 
11
 
#define WNCK_I_KNOW_THIS_IS_UNSTABLE 1
12
 
 
13
 
#ifdef HAVE_CONFIG_H
14
 
#include <config.h>
15
 
#endif
16
 
 
17
 
#include <string.h>
18
 
 
19
 
#include <panel-applet.h>
20
 
#include <panel-applet-gconf.h>
21
 
 
22
 
#include <stdlib.h>
23
 
 
24
 
#include <glib/gi18n.h>
25
 
#include <gtk/gtk.h>
26
 
#include <libwnck/libwnck.h>
27
 
#include <gconf/gconf-client.h>
28
 
 
29
 
#include "workspace-switcher.h"
30
 
 
31
 
#include "wncklet.h"
32
 
 
33
 
/* even 16 is pretty darn dubious. */
34
 
#define MAX_REASONABLE_ROWS 16
35
 
#define DEFAULT_ROWS 1
36
 
 
37
 
#define NEVER_SENSITIVE "never_sensitive"
38
 
#define NUM_WORKSPACES "/apps/metacity/general/num_workspaces"
39
 
#define WORKSPACE_NAME "/apps/metacity/workspace_names/name_1"
40
 
 
41
 
#define WORKSPACE_SWITCHER_ICON "gnome-panel-workspace-switcher"
42
 
 
43
 
typedef enum {
44
 
        PAGER_WM_METACITY,
45
 
        PAGER_WM_COMPIZ,
46
 
        PAGER_WM_UNKNOWN
47
 
} PagerWM;
48
 
 
49
 
typedef struct {
50
 
        GtkWidget *applet;
51
 
 
52
 
        GtkWidget *pager;
53
 
        
54
 
        WnckScreen *screen;
55
 
        PagerWM     wm;
56
 
 
57
 
        /* Properties: */
58
 
        GtkWidget *properties_dialog;
59
 
        GtkWidget *workspaces_frame;
60
 
        GtkWidget *workspace_names_label;
61
 
        GtkWidget *workspace_names_scroll;
62
 
        GtkWidget *display_workspaces_toggle;
63
 
        GtkWidget *all_workspaces_radio;
64
 
        GtkWidget *current_only_radio;
65
 
        GtkWidget *num_rows_spin;              /* for vertical layout this is cols */
66
 
        GtkWidget *label_row_col;
67
 
        GtkWidget *num_workspaces_spin;
68
 
        GtkWidget *workspaces_tree;
69
 
        GtkListStore *workspaces_store;
70
 
 
71
 
        GtkWidget *about;
72
 
        
73
 
        GtkOrientation orientation;
74
 
        int n_rows;                             /* for vertical layout this is cols */
75
 
        WnckPagerDisplayMode display_mode;
76
 
        gboolean display_all;
77
 
 
78
 
        /* gconf listeners id */
79
 
        guint listeners [3];
80
 
} PagerData;
81
 
 
82
 
static void display_properties_dialog (GtkAction *action,
83
 
                                       PagerData *pager);
84
 
static void display_help_dialog       (GtkAction *action,
85
 
                                       PagerData *pager);
86
 
static void display_about_dialog      (GtkAction *action,
87
 
                                       PagerData *pager);
88
 
 
89
 
static void
90
 
pager_update (PagerData *pager)
91
 
{
92
 
        wnck_pager_set_orientation (WNCK_PAGER (pager->pager),
93
 
                                    pager->orientation);
94
 
        wnck_pager_set_n_rows (WNCK_PAGER (pager->pager),
95
 
                               pager->n_rows);
96
 
        wnck_pager_set_show_all (WNCK_PAGER (pager->pager),
97
 
                                 pager->display_all);
98
 
 
99
 
        if (pager->wm == PAGER_WM_METACITY)
100
 
                wnck_pager_set_display_mode (WNCK_PAGER (pager->pager),
101
 
                                             pager->display_mode);
102
 
        else
103
 
                wnck_pager_set_display_mode (WNCK_PAGER (pager->pager),
104
 
                                             WNCK_PAGER_DISPLAY_CONTENT);
105
 
}
106
 
 
107
 
static void
108
 
update_properties_for_wm (PagerData *pager)
109
 
{
110
 
        switch (pager->wm) {
111
 
        case PAGER_WM_METACITY:
112
 
                if (pager->workspaces_frame)
113
 
                        gtk_widget_show (pager->workspaces_frame);
114
 
                if (pager->workspace_names_label)
115
 
                        gtk_widget_show (pager->workspace_names_label);
116
 
                if (pager->workspace_names_scroll)
117
 
                        gtk_widget_show (pager->workspace_names_scroll);
118
 
                if (pager->display_workspaces_toggle)
119
 
                        gtk_widget_show (pager->display_workspaces_toggle);
120
 
                break;
121
 
        case PAGER_WM_COMPIZ:
122
 
                if (pager->workspaces_frame)
123
 
                        gtk_widget_show (pager->workspaces_frame);
124
 
                if (pager->workspace_names_label)
125
 
                        gtk_widget_hide (pager->workspace_names_label);
126
 
                if (pager->workspace_names_scroll)
127
 
                        gtk_widget_hide (pager->workspace_names_scroll);
128
 
                if (pager->display_workspaces_toggle)
129
 
                        gtk_widget_hide (pager->display_workspaces_toggle);
130
 
                break;
131
 
        case PAGER_WM_UNKNOWN:
132
 
                if (pager->workspaces_frame)
133
 
                        gtk_widget_hide (pager->workspaces_frame);
134
 
                break;
135
 
        default:
136
 
                g_assert_not_reached ();
137
 
        }
138
 
 
139
 
        if (pager->properties_dialog)
140
 
                gtk_window_reshow_with_initial_size (GTK_WINDOW (pager->properties_dialog));
141
 
}
142
 
 
143
 
static void
144
 
window_manager_changed (WnckScreen *screen,
145
 
                        PagerData  *pager)
146
 
{
147
 
        const char *wm_name;
148
 
 
149
 
        wm_name = wnck_screen_get_window_manager_name (screen);
150
 
 
151
 
        if (!wm_name)
152
 
                pager->wm = PAGER_WM_UNKNOWN;
153
 
        else if (strcmp (wm_name, "Metacity") == 0)
154
 
                pager->wm = PAGER_WM_METACITY;
155
 
        else if (strcmp (wm_name, "Compiz") == 0)
156
 
                pager->wm = PAGER_WM_COMPIZ;
157
 
        else
158
 
                pager->wm = PAGER_WM_UNKNOWN;
159
 
 
160
 
        update_properties_for_wm (pager);
161
 
        pager_update (pager);
162
 
}
163
 
 
164
 
static void
165
 
applet_realized (PanelApplet *applet,
166
 
                 PagerData   *pager)
167
 
{
168
 
        pager->screen = wncklet_get_screen (GTK_WIDGET (applet));
169
 
 
170
 
        window_manager_changed (pager->screen, pager);
171
 
        wncklet_connect_while_alive (pager->screen, "window_manager_changed",
172
 
                                     G_CALLBACK (window_manager_changed),
173
 
                                     pager,
174
 
                                     pager->applet);
175
 
}
176
 
 
177
 
static void
178
 
applet_unrealized (PanelApplet *applet,
179
 
                   PagerData   *pager)
180
 
{
181
 
        pager->screen = NULL;
182
 
        pager->wm = PAGER_WM_UNKNOWN;
183
 
}
184
 
 
185
 
 
186
 
static void
187
 
applet_change_orient (PanelApplet       *applet,
188
 
                      PanelAppletOrient  orient,
189
 
                      PagerData         *pager)
190
 
{
191
 
        GtkOrientation new_orient;
192
 
  
193
 
        switch (orient) {
194
 
        case PANEL_APPLET_ORIENT_LEFT:
195
 
        case PANEL_APPLET_ORIENT_RIGHT:
196
 
                new_orient = GTK_ORIENTATION_VERTICAL;
197
 
                break;
198
 
        case PANEL_APPLET_ORIENT_UP:
199
 
        case PANEL_APPLET_ORIENT_DOWN:
200
 
        default:
201
 
                new_orient = GTK_ORIENTATION_HORIZONTAL;
202
 
                break;
203
 
        }
204
 
 
205
 
        if (new_orient == pager->orientation)
206
 
                return;
207
 
  
208
 
        pager->orientation = new_orient;
209
 
        pager_update (pager);
210
 
        if (pager->label_row_col) 
211
 
                gtk_label_set_text (GTK_LABEL (pager->label_row_col), pager->orientation == GTK_ORIENTATION_HORIZONTAL ? _("rows") : _("columns"));     
212
 
}
213
 
 
214
 
static void
215
 
applet_change_background (PanelApplet               *applet,
216
 
                          PanelAppletBackgroundType  type,
217
 
                          GdkColor                  *color,
218
 
                          GdkPixmap                 *pixmap,
219
 
                          PagerData                 *pager)
220
 
{
221
 
        switch (type) {
222
 
        case PANEL_NO_BACKGROUND:
223
 
                wnck_pager_set_shadow_type (WNCK_PAGER (pager->pager),
224
 
                                            GTK_SHADOW_IN);
225
 
                break;
226
 
        case PANEL_COLOR_BACKGROUND:
227
 
                wnck_pager_set_shadow_type (WNCK_PAGER (pager->pager),
228
 
                                            GTK_SHADOW_NONE);
229
 
                break;
230
 
        case PANEL_PIXMAP_BACKGROUND:
231
 
                wnck_pager_set_shadow_type (WNCK_PAGER (pager->pager),
232
 
                                            GTK_SHADOW_NONE);
233
 
                break;
234
 
        }
235
 
}
236
 
 
237
 
static gboolean
238
 
applet_scroll (PanelApplet    *applet,
239
 
               GdkEventScroll *event,
240
 
               PagerData      *pager)
241
 
{
242
 
        GdkScrollDirection absolute_direction;
243
 
        int                index;
244
 
        int                n_workspaces;
245
 
        int                n_columns;
246
 
        int                in_last_row;
247
 
        
248
 
        if (event->type != GDK_SCROLL)
249
 
                return FALSE;
250
 
 
251
 
        index          = wnck_workspace_get_number (wnck_screen_get_active_workspace (pager->screen));
252
 
        n_workspaces   = wnck_screen_get_workspace_count (pager->screen);
253
 
        n_columns      = n_workspaces / pager->n_rows;
254
 
        if (n_workspaces % pager->n_rows != 0)
255
 
                n_columns++;
256
 
        in_last_row    = n_workspaces % n_columns;
257
 
        
258
 
        absolute_direction = event->direction;
259
 
        if (gtk_widget_get_direction (GTK_WIDGET (applet)) == GTK_TEXT_DIR_RTL) {
260
 
                switch (event->direction) {
261
 
                case GDK_SCROLL_DOWN:
262
 
                case GDK_SCROLL_UP:
263
 
                        break;
264
 
                case GDK_SCROLL_RIGHT:
265
 
                        absolute_direction = GDK_SCROLL_LEFT;
266
 
                        break;
267
 
                case GDK_SCROLL_LEFT:
268
 
                        absolute_direction = GDK_SCROLL_RIGHT;
269
 
                        break;
270
 
                }
271
 
        }
272
 
 
273
 
        switch (absolute_direction) {
274
 
        case GDK_SCROLL_DOWN:
275
 
                if (index + n_columns < n_workspaces)
276
 
                        index += n_columns;
277
 
                else if ((index < n_workspaces - 1
278
 
                          && index + in_last_row != n_workspaces - 1) ||
279
 
                         (index == n_workspaces - 1
280
 
                          && in_last_row != 0))
281
 
                        index = (index % n_columns) + 1;
282
 
                break;
283
 
                
284
 
        case GDK_SCROLL_RIGHT:
285
 
                if (index < n_workspaces - 1)
286
 
                        index++;
287
 
                break;
288
 
                
289
 
        case GDK_SCROLL_UP:
290
 
                if (index - n_columns >= 0)
291
 
                        index -= n_columns;
292
 
                else if (index > 0)
293
 
                        index = ((pager->n_rows - 1) * n_columns) + (index % n_columns) - 1;
294
 
                        if (index >= n_workspaces)
295
 
                                index -= n_columns;
296
 
                break;
297
 
 
298
 
        case GDK_SCROLL_LEFT:
299
 
                if (index > 0)
300
 
                        index--;
301
 
                break;
302
 
        default:
303
 
                g_assert_not_reached ();
304
 
                break;
305
 
        }
306
 
 
307
 
        wnck_workspace_activate (wnck_screen_get_workspace (pager->screen,
308
 
                                                            index),
309
 
                                 event->time);
310
 
        
311
 
        return TRUE;
312
 
}
313
 
 
314
 
static void
315
 
destroy_pager(GtkWidget * widget, PagerData *pager)
316
 
{
317
 
        GConfClient *client = gconf_client_get_default ();
318
 
 
319
 
        gconf_client_notify_remove (client, pager->listeners[0]);
320
 
        gconf_client_notify_remove (client, pager->listeners[1]);
321
 
        gconf_client_notify_remove (client, pager->listeners[2]);
322
 
 
323
 
        g_object_unref (G_OBJECT (client));
324
 
 
325
 
        pager->listeners[0] = 0;
326
 
        pager->listeners[1] = 0;
327
 
        pager->listeners[2] = 0;
328
 
 
329
 
        if (pager->properties_dialog)
330
 
                gtk_widget_destroy (pager->properties_dialog);
331
 
 
332
 
        if (pager->about)
333
 
                gtk_widget_destroy (pager->about);
334
 
 
335
 
        g_free (pager);
336
 
}
337
 
 
338
 
static const GtkActionEntry pager_menu_actions [] = {
339
 
        { "PagerPreferences", GTK_STOCK_PROPERTIES, N_("_Preferences"),
340
 
          NULL, NULL,
341
 
          G_CALLBACK (display_properties_dialog) },
342
 
        { "PagerHelp", GTK_STOCK_HELP, N_("_Help"),
343
 
          NULL, NULL,
344
 
          G_CALLBACK (display_help_dialog) },
345
 
        { "PagerAbout", GTK_STOCK_ABOUT, N_("_About"),
346
 
          NULL, NULL,
347
 
          G_CALLBACK (display_about_dialog) }
348
 
};
349
 
 
350
 
static void
351
 
num_rows_changed (GConfClient *client,
352
 
                  guint        cnxn_id,
353
 
                  GConfEntry  *entry,
354
 
                  PagerData   *pager)
355
 
{
356
 
        int n_rows = DEFAULT_ROWS;
357
 
        
358
 
        if (entry->value != NULL &&
359
 
            entry->value->type == GCONF_VALUE_INT) {
360
 
                n_rows = gconf_value_get_int (entry->value);
361
 
        }
362
 
 
363
 
        n_rows = CLAMP (n_rows, 1, MAX_REASONABLE_ROWS);
364
 
        
365
 
        pager->n_rows = n_rows;
366
 
        pager_update (pager);
367
 
 
368
 
        if (pager->num_rows_spin &&
369
 
            gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pager->num_rows_spin)) != n_rows)
370
 
                gtk_spin_button_set_value (GTK_SPIN_BUTTON (pager->num_rows_spin), pager->n_rows);
371
 
}
372
 
 
373
 
static void
374
 
display_workspace_names_changed (GConfClient *client,
375
 
                                 guint        cnxn_id,
376
 
                                 GConfEntry  *entry,
377
 
                                 PagerData   *pager)
378
 
{
379
 
        gboolean value = FALSE; /* Default value */
380
 
        
381
 
        if (entry->value != NULL &&
382
 
            entry->value->type == GCONF_VALUE_BOOL) {
383
 
                value = gconf_value_get_bool (entry->value);
384
 
        }
385
 
 
386
 
        if (value) {
387
 
                pager->display_mode = WNCK_PAGER_DISPLAY_NAME;
388
 
        } else {
389
 
                pager->display_mode = WNCK_PAGER_DISPLAY_CONTENT;
390
 
        }
391
 
        pager_update (pager);
392
 
        
393
 
        if (pager->display_workspaces_toggle &&
394
 
            gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pager->display_workspaces_toggle)) != value) {
395
 
                gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pager->display_workspaces_toggle),
396
 
                                              value);
397
 
        }
398
 
}
399
 
 
400
 
 
401
 
static void
402
 
all_workspaces_changed (GConfClient *client,
403
 
                        guint        cnxn_id,
404
 
                        GConfEntry  *entry,
405
 
                        PagerData   *pager)
406
 
{
407
 
        gboolean value = TRUE; /* Default value */
408
 
        
409
 
        if (entry->value != NULL &&
410
 
            entry->value->type == GCONF_VALUE_BOOL) {
411
 
                value = gconf_value_get_bool (entry->value);
412
 
        }
413
 
 
414
 
        pager->display_all = value;
415
 
        pager_update (pager);
416
 
 
417
 
        if (pager->all_workspaces_radio){
418
 
                if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pager->all_workspaces_radio)) != value) {
419
 
                        if (value) {
420
 
                                gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pager->all_workspaces_radio), TRUE);
421
 
                        } else {
422
 
                                gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pager->current_only_radio), TRUE);
423
 
                        }
424
 
                }
425
 
                if ( ! g_object_get_data (G_OBJECT (pager->num_rows_spin), NEVER_SENSITIVE))
426
 
                        gtk_widget_set_sensitive (pager->num_rows_spin, value);
427
 
        }
428
 
}
429
 
 
430
 
static void
431
 
setup_gconf (PagerData *pager)
432
 
{
433
 
        GConfClient *client;
434
 
        char *key;
435
 
 
436
 
        client = gconf_client_get_default ();
437
 
 
438
 
        key = panel_applet_gconf_get_full_key (PANEL_APPLET (pager->applet),
439
 
                                               "num_rows");
440
 
        pager->listeners[0] = gconf_client_notify_add(client, key,
441
 
                                (GConfClientNotifyFunc)num_rows_changed,
442
 
                                pager,
443
 
                                NULL, NULL);
444
 
                
445
 
        g_free (key);
446
 
 
447
 
 
448
 
        key = panel_applet_gconf_get_full_key (PANEL_APPLET (pager->applet),
449
 
                                               "display_workspace_names");
450
 
        pager->listeners[1] = gconf_client_notify_add(client, key,
451
 
                                (GConfClientNotifyFunc)display_workspace_names_changed,
452
 
                                pager,
453
 
                                NULL, NULL);
454
 
                
455
 
        g_free (key);
456
 
 
457
 
        key = panel_applet_gconf_get_full_key (PANEL_APPLET (pager->applet),
458
 
                                               "display_all_workspaces");
459
 
        pager->listeners[2] = gconf_client_notify_add(client, key,
460
 
                                (GConfClientNotifyFunc)all_workspaces_changed,
461
 
                                pager,
462
 
                                NULL, NULL);
463
 
                
464
 
        g_free (key);
465
 
 
466
 
        g_object_unref (G_OBJECT (client));
467
 
 
468
 
}
469
 
 
470
 
gboolean
471
 
workspace_switcher_applet_fill (PanelApplet *applet)
472
 
{
473
 
        PagerData *pager;
474
 
        GtkActionGroup *action_group;
475
 
        gchar *ui_path;
476
 
        GError *error;
477
 
        gboolean display_names;
478
 
        
479
 
        panel_applet_add_preferences (applet, "/schemas/apps/workspace_switcher_applet/prefs", NULL);
480
 
        
481
 
        pager = g_new0 (PagerData, 1);
482
 
 
483
 
        pager->applet = GTK_WIDGET (applet);
484
 
 
485
 
        panel_applet_set_flags (PANEL_APPLET (pager->applet), PANEL_APPLET_EXPAND_MINOR);
486
 
 
487
 
        setup_gconf (pager);
488
 
        
489
 
        error = NULL;
490
 
        pager->n_rows = panel_applet_gconf_get_int (applet, "num_rows", &error);
491
 
        if (error) {
492
 
                g_printerr (_("Error loading num_rows value for Workspace Switcher: %s\n"),
493
 
                            error->message);
494
 
                g_error_free (error);
495
 
                /* leave current value */
496
 
        }
497
 
 
498
 
        pager->n_rows = CLAMP (pager->n_rows, 1, MAX_REASONABLE_ROWS);
499
 
 
500
 
        error = NULL;
501
 
        display_names = panel_applet_gconf_get_bool (applet, "display_workspace_names", &error);
502
 
        if (error) {
503
 
                g_printerr (_("Error loading display_workspace_names value for Workspace Switcher: %s\n"),
504
 
                            error->message);
505
 
                g_error_free (error);
506
 
                /* leave current value */
507
 
        }
508
 
 
509
 
        if (display_names) {
510
 
                pager->display_mode = WNCK_PAGER_DISPLAY_NAME;
511
 
        } else {
512
 
                pager->display_mode = WNCK_PAGER_DISPLAY_CONTENT;
513
 
        }
514
 
 
515
 
        error = NULL;
516
 
        pager->display_all = panel_applet_gconf_get_bool (applet, "display_all_workspaces", &error);
517
 
        if (error) {
518
 
                g_printerr (_("Error loading display_all_workspaces value for Workspace Switcher: %s\n"),
519
 
                            error->message);
520
 
                g_error_free (error);
521
 
                /* leave current value */
522
 
        }
523
 
        
524
 
        switch (panel_applet_get_orient (applet)) {
525
 
        case PANEL_APPLET_ORIENT_LEFT:
526
 
        case PANEL_APPLET_ORIENT_RIGHT:
527
 
                pager->orientation = GTK_ORIENTATION_VERTICAL;
528
 
                break;
529
 
        case PANEL_APPLET_ORIENT_UP:
530
 
        case PANEL_APPLET_ORIENT_DOWN:
531
 
        default:
532
 
                pager->orientation = GTK_ORIENTATION_HORIZONTAL;
533
 
                break;
534
 
        }
535
 
 
536
 
        pager->pager = wnck_pager_new (NULL);
537
 
        pager->screen = NULL;
538
 
        pager->wm = PAGER_WM_UNKNOWN;
539
 
        wnck_pager_set_shadow_type (WNCK_PAGER (pager->pager), GTK_SHADOW_IN);
540
 
 
541
 
        g_signal_connect (G_OBJECT (pager->pager), "destroy",
542
 
                          G_CALLBACK (destroy_pager),
543
 
                          pager);
544
 
        
545
 
        gtk_container_add (GTK_CONTAINER (pager->applet), pager->pager);
546
 
        gtk_widget_show (pager->pager);
547
 
 
548
 
        g_signal_connect (G_OBJECT (pager->applet),
549
 
                          "realize",
550
 
                          G_CALLBACK (applet_realized),
551
 
                          pager);
552
 
        g_signal_connect (G_OBJECT (pager->applet),
553
 
                          "unrealize",
554
 
                          G_CALLBACK (applet_unrealized),
555
 
                          pager);
556
 
        g_signal_connect (G_OBJECT (pager->applet),
557
 
                          "change_orient",
558
 
                          G_CALLBACK (applet_change_orient),
559
 
                          pager);
560
 
        g_signal_connect (G_OBJECT (pager->applet),
561
 
                          "scroll-event",
562
 
                          G_CALLBACK (applet_scroll),
563
 
                          pager);
564
 
        g_signal_connect (G_OBJECT (pager->applet),
565
 
                          "change_background",
566
 
                          G_CALLBACK (applet_change_background),
567
 
                          pager);
568
 
 
569
 
        gtk_widget_show (pager->applet);
570
 
 
571
 
        panel_applet_set_background_widget (PANEL_APPLET (pager->applet),
572
 
                                            GTK_WIDGET (pager->applet));
573
 
 
574
 
        action_group = gtk_action_group_new ("WorkspaceSwitcher Applet Actions");
575
 
        gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
576
 
        gtk_action_group_add_actions (action_group,
577
 
                                      pager_menu_actions,
578
 
                                      G_N_ELEMENTS (pager_menu_actions),
579
 
                                      pager);
580
 
        ui_path = g_build_filename (WNCK_MENU_UI_DIR, "workspace-switcher-menu.xml", NULL);
581
 
        panel_applet_setup_menu_from_file (PANEL_APPLET (pager->applet),
582
 
                                           ui_path, action_group);
583
 
        g_free (ui_path);
584
 
 
585
 
        if (panel_applet_get_locked_down (PANEL_APPLET (pager->applet))) {
586
 
                GtkAction *action;
587
 
 
588
 
                action = gtk_action_group_get_action (action_group, "PagerPreferences");
589
 
                gtk_action_set_visible (action, FALSE);
590
 
        }
591
 
        g_object_unref (action_group);
592
 
 
593
 
        return TRUE;
594
 
}
595
 
 
596
 
 
597
 
static void
598
 
display_help_dialog (GtkAction *action,
599
 
                     PagerData *pager)
600
 
{
601
 
        wncklet_display_help (pager->applet, "user-guide",
602
 
                              "overview-workspaces", WORKSPACE_SWITCHER_ICON);
603
 
}
604
 
 
605
 
static void
606
 
display_about_dialog (GtkAction *action,
607
 
                      PagerData *pager)
608
 
{
609
 
        static const gchar *authors[] =
610
 
        {
611
 
                "Alexander Larsson <alla@lysator.liu.se>",
612
 
                NULL
613
 
        };
614
 
        const char *documenters [] = {
615
 
                "John Fleck <jfleck@inkstain.net>",
616
 
                "Sun GNOME Documentation Team <gdocteam@sun.com>",
617
 
                NULL
618
 
        };
619
 
        const char *translator_credits = _("translator-credits");
620
 
 
621
 
        wncklet_display_about (pager->applet, &pager->about,
622
 
                               _("Workspace Switcher"),
623
 
                               "Copyright \xc2\xa9 2001-2002 Red Hat, Inc.",
624
 
                               _("The Workspace Switcher shows you a small version of your workspaces that lets you manage your windows."),
625
 
                               authors,
626
 
                               documenters,
627
 
                               translator_credits,
628
 
                               WORKSPACE_SWITCHER_ICON,
629
 
                               "pager",
630
 
                               "Pager");
631
 
}
632
 
 
633
 
 
634
 
static void
635
 
display_workspace_names_toggled (GtkToggleButton *button,
636
 
                                 PagerData       *pager)
637
 
{
638
 
        panel_applet_gconf_set_bool (PANEL_APPLET (pager->applet),
639
 
                                     "display_workspace_names",
640
 
                                     gtk_toggle_button_get_active (button),
641
 
                                     NULL);
642
 
}
643
 
 
644
 
static void
645
 
all_workspaces_toggled (GtkToggleButton *button,
646
 
                        PagerData       *pager)
647
 
{
648
 
        panel_applet_gconf_set_bool (PANEL_APPLET (pager->applet),
649
 
                                     "display_all_workspaces",
650
 
                                     gtk_toggle_button_get_active (button),
651
 
                                     NULL);
652
 
}
653
 
 
654
 
static void
655
 
num_rows_value_changed (GtkSpinButton *button,
656
 
                        PagerData       *pager)
657
 
{
658
 
        panel_applet_gconf_set_int (PANEL_APPLET (pager->applet),
659
 
                                    "num_rows",
660
 
                                    gtk_spin_button_get_value_as_int (button),
661
 
                                    NULL);
662
 
}
663
 
 
664
 
static void
665
 
update_workspaces_model (PagerData *pager)
666
 
{
667
 
        int nr_ws, i;
668
 
        WnckWorkspace *workspace;
669
 
        GtkTreeIter iter;
670
 
 
671
 
        nr_ws = wnck_screen_get_workspace_count (pager->screen);
672
 
        
673
 
        if (pager->properties_dialog) {
674
 
                if (nr_ws != gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pager->num_workspaces_spin)))
675
 
                        gtk_spin_button_set_value (GTK_SPIN_BUTTON (pager->num_workspaces_spin), nr_ws);
676
 
 
677
 
                gtk_list_store_clear (pager->workspaces_store);
678
 
                for (i = 0; i < nr_ws; i++) {
679
 
                        workspace = wnck_screen_get_workspace (pager->screen, i);
680
 
                        gtk_list_store_append (pager->workspaces_store, &iter);
681
 
                        gtk_list_store_set (pager->workspaces_store,
682
 
                                            &iter,
683
 
                                            0, wnck_workspace_get_name (workspace),
684
 
                                            -1);
685
 
                }
686
 
        }
687
 
}
688
 
 
689
 
static void
690
 
workspace_renamed (WnckWorkspace *space,
691
 
                   PagerData     *pager)
692
 
{
693
 
        int         i;
694
 
        GtkTreeIter iter;
695
 
 
696
 
        i = wnck_workspace_get_number (space);
697
 
        if (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (pager->workspaces_store),
698
 
                                           &iter, NULL, i))
699
 
                gtk_list_store_set (pager->workspaces_store,
700
 
                                    &iter,
701
 
                                    0, wnck_workspace_get_name (space),
702
 
                                    -1);
703
 
}
704
 
 
705
 
static void
706
 
workspace_created (WnckScreen    *screen,
707
 
                   WnckWorkspace *space,
708
 
                   PagerData     *pager)
709
 
{
710
 
        g_return_if_fail (WNCK_IS_SCREEN (screen));
711
 
        
712
 
        update_workspaces_model (pager);
713
 
 
714
 
        wncklet_connect_while_alive (space, "name_changed",
715
 
                                     G_CALLBACK(workspace_renamed),
716
 
                                     pager,
717
 
                                     pager->properties_dialog);
718
 
 
719
 
}
720
 
 
721
 
static void
722
 
workspace_destroyed (WnckScreen    *screen,
723
 
                     WnckWorkspace *space,
724
 
                     PagerData     *pager)
725
 
{
726
 
        g_return_if_fail (WNCK_IS_SCREEN (screen));
727
 
        update_workspaces_model (pager);
728
 
}
729
 
 
730
 
static void
731
 
num_workspaces_value_changed (GtkSpinButton *button,
732
 
                              PagerData     *pager)
733
 
{
734
 
        /* Slow down a bit after the first change, since it's moving really to
735
 
         * fast. See bug #336731 for background.
736
 
         * FIXME: remove this if bug 410520 gets fixed. */
737
 
        button->timer_step = 0.2;
738
 
 
739
 
        wnck_screen_change_workspace_count (pager->screen,
740
 
                                            gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pager->num_workspaces_spin)));
741
 
}
742
 
 
743
 
static gboolean
744
 
workspaces_tree_focused_out (GtkTreeView   *treeview,
745
 
                             GdkEventFocus *event,
746
 
                             PagerData     *pager)
747
 
{
748
 
        GtkTreeSelection *selection;
749
 
 
750
 
        selection = gtk_tree_view_get_selection (treeview);
751
 
        gtk_tree_selection_unselect_all (selection);
752
 
        return TRUE;
753
 
}
754
 
 
755
 
static void 
756
 
workspace_name_edited (GtkCellRendererText *cell_renderer_text,
757
 
                       const gchar         *path,
758
 
                       const gchar         *new_text,
759
 
                       PagerData           *pager)
760
 
{
761
 
        const gint *indices;
762
 
        WnckWorkspace *workspace;
763
 
        GtkTreePath *p;
764
 
 
765
 
        p = gtk_tree_path_new_from_string (path);
766
 
        indices = gtk_tree_path_get_indices (p);
767
 
        workspace = wnck_screen_get_workspace (pager->screen,
768
 
                                               indices[0]);
769
 
        if (workspace != NULL) {
770
 
                gchar* temp_name = g_strdup(new_text);
771
 
 
772
 
                wnck_workspace_change_name (workspace,
773
 
                                            g_strstrip(temp_name));
774
 
                g_free (temp_name);
775
 
        }
776
 
        else
777
 
                g_warning ("Edited name of workspace %d which no longer exists",
778
 
                           indices[0]);
779
 
 
780
 
        gtk_tree_path_free (p);
781
 
}
782
 
 
783
 
static void
784
 
properties_dialog_destroyed (GtkWidget *widget,
785
 
                             PagerData *pager)
786
 
{
787
 
        pager->properties_dialog = NULL;
788
 
        pager->workspaces_frame = NULL;
789
 
        pager->workspace_names_label = NULL;
790
 
        pager->workspace_names_scroll = NULL;
791
 
        pager->display_workspaces_toggle = NULL;
792
 
        pager->all_workspaces_radio = NULL;
793
 
        pager->current_only_radio = NULL;
794
 
        pager->num_rows_spin = NULL;
795
 
        pager->label_row_col = NULL;
796
 
        pager->num_workspaces_spin = NULL;
797
 
        pager->workspaces_tree = NULL;
798
 
        pager->workspaces_store = NULL;
799
 
}
800
 
 
801
 
static gboolean
802
 
delete_event (GtkWidget *widget, gpointer data)
803
 
{
804
 
        gtk_widget_destroy (widget);
805
 
        return TRUE;
806
 
}
807
 
 
808
 
static void 
809
 
response_cb (GtkWidget *widget,
810
 
             int        id,
811
 
             PagerData *pager)
812
 
{
813
 
        if (id == GTK_RESPONSE_HELP)
814
 
                wncklet_display_help (widget, "user-guide",
815
 
                                      "overview-workspaces",
816
 
                                      WORKSPACE_SWITCHER_ICON);
817
 
        else
818
 
                gtk_widget_destroy (widget);
819
 
}
820
 
 
821
 
static void
822
 
close_dialog (GtkWidget *button,
823
 
              gpointer data)
824
 
{
825
 
        PagerData *pager = data;
826
 
        GtkTreeViewColumn *col;
827
 
 
828
 
        /* This is a hack. The "editable" signal for GtkCellRenderer is emitted
829
 
        only on button press or focus cycle. Hence when the user changes the
830
 
        name and closes the preferences dialog without a button-press he would
831
 
        lose the name changes. So, we call the gtk_cell_editable_editing_done
832
 
        to stop the editing. Thanks to Paolo for a better crack than the one I had.
833
 
        */
834
 
 
835
 
        col = gtk_tree_view_get_column(GTK_TREE_VIEW (pager->workspaces_tree),0);
836
 
        if (col->editable_widget != NULL && GTK_IS_CELL_EDITABLE (col->editable_widget))
837
 
            gtk_cell_editable_editing_done(col->editable_widget);
838
 
 
839
 
        gtk_widget_destroy (pager->properties_dialog);
840
 
}
841
 
 
842
 
#define WID(s) GTK_WIDGET (gtk_builder_get_object (builder, s))
843
 
 
844
 
static void
845
 
setup_sensitivity (PagerData *pager,
846
 
                   GtkBuilder *builder,
847
 
                   const char *wid1,
848
 
                   const char *wid2,
849
 
                   const char *wid3,
850
 
                   const char *key)
851
 
{
852
 
        PanelApplet *applet = PANEL_APPLET (pager->applet);
853
 
        GConfClient *client = gconf_client_get_default ();
854
 
        char *fullkey;
855
 
        GtkWidget *w;
856
 
 
857
 
        if (key[0] == '/')
858
 
                fullkey = g_strdup (key);
859
 
        else
860
 
                fullkey = panel_applet_gconf_get_full_key (applet, key);
861
 
 
862
 
        if (gconf_client_key_is_writable (client, fullkey, NULL)) {
863
 
                g_object_unref (G_OBJECT (client));
864
 
                g_free (fullkey);
865
 
                return;
866
 
        }
867
 
        g_object_unref (G_OBJECT (client));
868
 
        g_free (fullkey);
869
 
 
870
 
        w = WID (wid1);
871
 
        g_assert (w != NULL);
872
 
        g_object_set_data (G_OBJECT (w), NEVER_SENSITIVE,
873
 
                           GINT_TO_POINTER (1));
874
 
        gtk_widget_set_sensitive (w, FALSE);
875
 
 
876
 
        if (wid2 != NULL) {
877
 
                w = WID (wid2);
878
 
                g_assert (w != NULL);
879
 
                g_object_set_data (G_OBJECT (w), NEVER_SENSITIVE,
880
 
                                   GINT_TO_POINTER (1));
881
 
                gtk_widget_set_sensitive (w, FALSE);
882
 
        }
883
 
        if (wid3 != NULL) {
884
 
                w = WID (wid3);
885
 
                g_assert (w != NULL);
886
 
                g_object_set_data (G_OBJECT (w), NEVER_SENSITIVE,
887
 
                                   GINT_TO_POINTER (1));
888
 
                gtk_widget_set_sensitive (w, FALSE);
889
 
        }
890
 
 
891
 
}
892
 
 
893
 
static void
894
 
setup_dialog (GtkBuilder *builder,
895
 
              PagerData  *pager)
896
 
{
897
 
        gboolean value;
898
 
        GtkTreeViewColumn *column;
899
 
        GtkCellRenderer *cell;
900
 
        int nr_ws, i;
901
 
        
902
 
        pager->workspaces_frame = WID ("workspaces_frame");
903
 
        pager->workspace_names_label = WID ("workspace_names_label");
904
 
        pager->workspace_names_scroll = WID ("workspace_names_scroll");
905
 
 
906
 
        pager->display_workspaces_toggle = WID ("workspace_name_toggle");
907
 
        setup_sensitivity (pager, builder,
908
 
                           "workspace_name_toggle",
909
 
                           NULL,
910
 
                           NULL,
911
 
                           "display_workspace_names" /* key */);
912
 
 
913
 
        pager->all_workspaces_radio = WID ("all_workspaces_radio");
914
 
        pager->current_only_radio = WID ("current_only_radio");
915
 
        setup_sensitivity (pager, builder,
916
 
                           "all_workspaces_radio",
917
 
                           "current_only_radio",
918
 
                           "label_row_col",
919
 
                           "display_all_workspaces" /* key */);
920
 
 
921
 
        pager->num_rows_spin = WID ("num_rows_spin");
922
 
        pager->label_row_col = WID("label_row_col");
923
 
        setup_sensitivity (pager, builder,
924
 
                           "num_rows_spin",
925
 
                           NULL,
926
 
                           NULL,
927
 
                           "num_rows" /* key */);
928
 
 
929
 
        pager->num_workspaces_spin = WID ("num_workspaces_spin");
930
 
        setup_sensitivity (pager, builder,
931
 
                           "num_workspaces_spin",
932
 
                           NULL,
933
 
                           NULL,
934
 
                           NUM_WORKSPACES /* key */);
935
 
 
936
 
        pager->workspaces_tree = WID ("workspaces_tree_view");
937
 
        setup_sensitivity (pager, builder,
938
 
                           "workspaces_tree_view",
939
 
                           NULL,
940
 
                           NULL,
941
 
                           WORKSPACE_NAME /* key */);
942
 
 
943
 
        /* Display workspace names: */
944
 
        
945
 
        g_signal_connect (G_OBJECT (pager->display_workspaces_toggle), "toggled",
946
 
                          (GCallback) display_workspace_names_toggled, pager);
947
 
 
948
 
        if (pager->display_mode == WNCK_PAGER_DISPLAY_NAME) {
949
 
                value = TRUE;
950
 
        } else {
951
 
                value = FALSE;
952
 
        }
953
 
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pager->display_workspaces_toggle),
954
 
                                      value);
955
 
 
956
 
        /* Display all workspaces: */
957
 
        g_signal_connect (G_OBJECT (pager->all_workspaces_radio), "toggled",
958
 
                          (GCallback) all_workspaces_toggled, pager);
959
 
 
960
 
        if (pager->display_all) {
961
 
                gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pager->all_workspaces_radio), TRUE);
962
 
                if ( ! g_object_get_data (G_OBJECT (pager->num_rows_spin), NEVER_SENSITIVE))
963
 
                        gtk_widget_set_sensitive (pager->num_rows_spin, TRUE);
964
 
        } else {
965
 
                gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pager->current_only_radio), TRUE);
966
 
                gtk_widget_set_sensitive (pager->num_rows_spin, FALSE);
967
 
        }
968
 
                
969
 
        /* Num rows: */
970
 
        g_signal_connect (G_OBJECT (pager->num_rows_spin), "value_changed",
971
 
                          (GCallback) num_rows_value_changed, pager);
972
 
 
973
 
        gtk_spin_button_set_value (GTK_SPIN_BUTTON (pager->num_rows_spin), pager->n_rows);
974
 
        gtk_label_set_text (GTK_LABEL (pager->label_row_col), pager->orientation == GTK_ORIENTATION_HORIZONTAL ? _("rows") : _("columns"));
975
 
 
976
 
        g_signal_connect (pager->properties_dialog, "destroy",
977
 
                          G_CALLBACK (properties_dialog_destroyed),
978
 
                          pager);
979
 
        g_signal_connect (pager->properties_dialog, "delete_event",
980
 
                          G_CALLBACK (delete_event),
981
 
                          pager);
982
 
        g_signal_connect (pager->properties_dialog, "response",
983
 
                          G_CALLBACK (response_cb),
984
 
                          pager);
985
 
        
986
 
        g_signal_connect (WID ("done_button"), "clicked",
987
 
                          (GCallback) close_dialog, pager);
988
 
 
989
 
        gtk_spin_button_set_value (GTK_SPIN_BUTTON (pager->num_workspaces_spin),
990
 
                                   wnck_screen_get_workspace_count (pager->screen));
991
 
        g_signal_connect (G_OBJECT (pager->num_workspaces_spin), "value_changed",
992
 
                          (GCallback) num_workspaces_value_changed, pager);
993
 
        
994
 
        wncklet_connect_while_alive (pager->screen, "workspace_created",
995
 
                                     G_CALLBACK(workspace_created),
996
 
                                     pager,
997
 
                                     pager->properties_dialog);
998
 
 
999
 
        wncklet_connect_while_alive (pager->screen, "workspace_destroyed",
1000
 
                                     G_CALLBACK(workspace_destroyed),
1001
 
                                     pager,
1002
 
                                     pager->properties_dialog);
1003
 
 
1004
 
        g_signal_connect (G_OBJECT (pager->workspaces_tree), "focus_out_event",
1005
 
                          (GCallback) workspaces_tree_focused_out, pager);
1006
 
 
1007
 
        pager->workspaces_store = gtk_list_store_new (1, G_TYPE_STRING, NULL);
1008
 
        update_workspaces_model (pager);
1009
 
        gtk_tree_view_set_model (GTK_TREE_VIEW (pager->workspaces_tree), GTK_TREE_MODEL (pager->workspaces_store));
1010
 
 
1011
 
        g_object_unref (pager->workspaces_store);
1012
 
 
1013
 
        cell = g_object_new (GTK_TYPE_CELL_RENDERER_TEXT, "editable", TRUE, NULL);
1014
 
        column = gtk_tree_view_column_new_with_attributes ("workspace",
1015
 
                                                           cell,
1016
 
                                                           "text", 0,
1017
 
                                                           NULL);
1018
 
        gtk_tree_view_append_column (GTK_TREE_VIEW (pager->workspaces_tree), column);
1019
 
        g_signal_connect (cell, "edited",
1020
 
                          (GCallback) workspace_name_edited, pager);
1021
 
        
1022
 
        nr_ws = wnck_screen_get_workspace_count (pager->screen);
1023
 
        for (i = 0; i < nr_ws; i++) {
1024
 
                wncklet_connect_while_alive (
1025
 
                                G_OBJECT (wnck_screen_get_workspace (pager->screen, i)),
1026
 
                                "name_changed",
1027
 
                                G_CALLBACK(workspace_renamed),
1028
 
                                pager,
1029
 
                                pager->properties_dialog);
1030
 
        }
1031
 
 
1032
 
        update_properties_for_wm (pager);
1033
 
}
1034
 
 
1035
 
static void 
1036
 
display_properties_dialog (GtkAction *action,
1037
 
                           PagerData *pager)
1038
 
{
1039
 
        if (pager->properties_dialog == NULL) {
1040
 
                GtkBuilder *builder;
1041
 
                GError     *error;
1042
 
 
1043
 
                builder = gtk_builder_new ();
1044
 
                gtk_builder_set_translation_domain (builder, GETTEXT_PACKAGE);
1045
 
 
1046
 
                error = NULL;
1047
 
                gtk_builder_add_from_file (builder, PAGER_BUILDERDIR "/workspace-switcher.ui", &error);
1048
 
                if (error) {
1049
 
                        g_warning ("Error loading preferences: %s", error->message);
1050
 
                        g_error_free (error);
1051
 
                        return;
1052
 
                }
1053
 
 
1054
 
                pager->properties_dialog = WID ("pager_properties_dialog");
1055
 
 
1056
 
                g_object_add_weak_pointer (G_OBJECT (pager->properties_dialog), 
1057
 
                                           (gpointer *) &pager->properties_dialog);
1058
 
 
1059
 
                setup_dialog (builder, pager);
1060
 
                
1061
 
                g_object_unref (builder);
1062
 
        }
1063
 
 
1064
 
        gtk_window_set_icon_name (GTK_WINDOW (pager->properties_dialog),
1065
 
                                  WORKSPACE_SWITCHER_ICON);
1066
 
        gtk_window_set_screen (GTK_WINDOW (pager->properties_dialog),
1067
 
                               gtk_widget_get_screen (pager->applet));
1068
 
        gtk_window_present (GTK_WINDOW (pager->properties_dialog));
1069
 
}