← Back to branch summary

~ubuntu-branches/ubuntu/precise/xfwm4/precise-updates

« back to all changes in this revision

Viewing changes to mcs-plugin/xfwm4_plugin.c

  • Committer: Bazaar Package Importer
  • Author(s): Jérôme Guelfucci, Jérôme Guelfucci, Lionel Le Folgoc
  • Date: 2009-01-30 18:28:59 UTC
  • mfrom: (1.1.21 upstream)
  • Revision ID: james.westby@ubuntu.com-20090130182859-1tci3n1f1hhppvc2
Tags: 4.5.99.1-0ubuntu1
https://launchpad.net/bugs/250101
[ Jérôme Guelfucci ]
* Merge with Debian Xfce UNRELEASED, remaining Ubuntu changes:
  - debian/xfwm4.1: update bug reporting address (LP instead of Debian BTS).

[ Lionel Le Folgoc ]
* debian/control: use our Vcs-* fields.
* Bugs fixed by this new release:
  - "User interface of focused application is covered by another application's
    new window in Xfce" (LP: #250101)

Show diffs side-by-side

added added

removed removed

Lines of Context:
mcs-plugin/xfwm4_plugin.c
1
 
/*      $Id: xfwm4_plugin.c 25160 2007-03-13 21:44:34Z olivier $
2
 
 
3
 
        This program is free software; you can redistribute it and/or modify
4
 
        it under the terms of the GNU General Public License as published by
5
 
        the Free Software Foundation; either version 2, or (at your option)
6
 
        any later version.
7
 
 
8
 
        This program is distributed in the hope that it will be useful,
9
 
        but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
        GNU General Public License for more details.
12
 
 
13
 
        You should have received a copy of the GNU General Public License
14
 
        along with this program; if not, write to the Free Software
15
 
        Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
16
 
 
17
 
        xfce4 mcs plugin   - (c) 2002-2006 Olivier Fourdan
18
 
        Buttons DnD inspired by Michael Terry's implementation for xpad
19
 
 */
20
 
 
21
 
#ifdef HAVE_CONFIG_H
22
 
#include <config.h>
23
 
#endif
24
 
 
25
 
#include <string.h>
26
 
#include <errno.h>
27
 
#include <sys/types.h>
28
 
#include <sys/stat.h>
29
 
#include <dirent.h>
30
 
#include <unistd.h>
31
 
#include <string.h>
32
 
#include <stdlib.h>
33
 
#include <stdio.h>
34
 
#include <fcntl.h>
35
 
 
36
 
#include <gtk/gtk.h>
37
 
#include <gdk/gdk.h>
38
 
#include <gdk/gdkx.h>
39
 
#include <X11/Xlib.h>
40
 
 
41
 
#include <libxfce4mcs/mcs-common.h>
42
 
#include <libxfce4mcs/mcs-manager.h>
43
 
#include <libxfce4util/libxfce4util.h>
44
 
#include <libxfcegui4/libxfcegui4.h>
45
 
#include <xfce-mcs-manager/manager-plugin.h>
46
 
 
47
 
#include "xfwm4_plugin.h"
48
 
#include "xfwm4_shortcuteditor.h"
49
 
 
50
 
#define INDICATOR_SIZE 11
51
 
 
52
 
typedef struct _MenuTmpl MenuTmpl;
53
 
struct _MenuTmpl
54
 
{
55
 
    gchar *label;
56
 
    gchar *action;
57
 
};
58
 
 
59
 
typedef struct _TitleButton TitleButton;
60
 
struct _TitleButton
61
 
{
62
 
    gchar *key;
63
 
    gchar *desc;
64
 
    gchar *stock_icon;
65
 
};
66
 
 
67
 
static const TitleButton title_button[] = {
68
 
    {"O", N_("Menu"), "gtk-index"},
69
 
    {"T", N_("Stick"), "gtk-add"},
70
 
    {"S", N_("Shade"), "gtk-goto-top"},
71
 
    {"H", N_("Hide"), "gtk-undo"},
72
 
    {"M", N_("Maximize"), "gtk-zoom-100"},
73
 
    {"C", N_("Close"), "gtk-close"}
74
 
};
75
 
#define BUTTON_COUNT 6
76
 
 
77
 
 
78
 
static const MenuTmpl dbl_click_values[] = {
79
 
    {N_("Shade window"), "shade"},
80
 
    {N_("Hide window"), "hide"},
81
 
    {N_("Maximize window"), "maximize"},
82
 
    {N_("Nothing"), "none"},
83
 
    {NULL, NULL}
84
 
};
85
 
 
86
 
static const MenuTmpl title_align_values[] = {
87
 
    {N_("Left"), "left"},
88
 
    {N_("Center"), "center"},
89
 
    {N_("Right"), "right"},
90
 
    {NULL, NULL}
91
 
};
92
 
 
93
 
static void xfwm4_create_channel (McsPlugin * mcs_plugin);
94
 
static void run_dialog (McsPlugin * mcs_plugin);
95
 
 
96
 
static gboolean setting_model = FALSE;
97
 
static gboolean is_running = FALSE;
98
 
 
99
 
static gchar *current_theme = NULL;
100
 
static gchar *current_layout = NULL;
101
 
static gchar *current_font = NULL;
102
 
static gchar *dbl_click_action = NULL;
103
 
static gchar *title_align = NULL;
104
 
static gboolean click_to_focus = TRUE;
105
 
static gboolean focus_new = TRUE;
106
 
static gboolean focus_raise = FALSE;
107
 
static gboolean raise_on_click = TRUE;
108
 
static gboolean snap_to_border = TRUE;
109
 
static gboolean snap_to_windows = FALSE;
110
 
static gboolean wrap_workspaces = FALSE;
111
 
static gboolean wrap_windows = TRUE;
112
 
static gboolean box_move = FALSE;
113
 
static gboolean box_resize = FALSE;
114
 
static int raise_delay;
115
 
static int snap_width;
116
 
static int wrap_resistance;
117
 
gchar *xfwm4_plugin_current_key_theme = NULL;
118
 
 
119
 
static GList *decoration_theme_list = NULL;
120
 
GList *keybinding_theme_list = NULL;
121
 
 
122
 
static void
123
 
sensitive_cb (GtkWidget * widget, gpointer user_data)
124
 
{
125
 
    gtk_widget_set_sensitive (widget, (gboolean) GPOINTER_TO_INT (user_data));
126
 
}
127
 
 
128
 
static GtkWidget *
129
 
create_check_button_with_mnemonic (const gchar * label)
130
 
{
131
 
    GtkWidget *check_button;
132
 
    GtkWidget *label_widget;
133
 
 
134
 
    label_widget = gtk_label_new_with_mnemonic (label);
135
 
    gtk_label_set_line_wrap (GTK_LABEL (label_widget), TRUE);
136
 
    gtk_widget_show (label_widget);
137
 
 
138
 
    check_button = gtk_check_button_new ();
139
 
    gtk_container_add (GTK_CONTAINER (check_button), label_widget);
140
 
 
141
 
    return check_button;
142
 
}
143
 
 
144
 
static void
145
 
delete_motion_indicator (GtkWidget * widget)
146
 
{
147
 
    GdkWindow *indicator = NULL;
148
 
 
149
 
    indicator = g_object_get_data (G_OBJECT (widget), "indicator_window");
150
 
    if (indicator)
151
 
    {
152
 
        gdk_window_destroy (indicator);
153
 
        g_object_set_data (G_OBJECT (widget), "indicator_window", NULL);
154
 
    }
155
 
}
156
 
 
157
 
static GdkWindow *
158
 
create_motion_indicator (GtkWidget * widget, gint x, gint y, gint width, gint height)
159
 
{
160
 
    GdkWindow *win;
161
 
    GdkWindowAttr attributes;
162
 
    GdkBitmap *mask = NULL;
163
 
    guint attributes_mask;
164
 
    gint i, j = 1;
165
 
    GdkGC *gc;
166
 
    GdkColor col;
167
 
 
168
 
    delete_motion_indicator (widget);
169
 
    attributes.window_type = GDK_WINDOW_CHILD;
170
 
    attributes.wclass = GDK_INPUT_OUTPUT;
171
 
    attributes.visual = gtk_widget_get_visual (GTK_WIDGET (widget));
172
 
    attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET (widget));
173
 
    attributes.event_mask = 0;
174
 
    attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
175
 
    attributes.width = width;
176
 
    attributes.height = height;
177
 
    win = gdk_window_new (GDK_WINDOW (widget->window), &attributes, attributes_mask);
178
 
    gdk_window_set_user_data (win, GTK_WIDGET (widget));
179
 
    g_object_set_data (G_OBJECT (widget), "indicator_window", win);
180
 
 
181
 
    mask = gdk_pixmap_new (win, width, height, 1);
182
 
    gc = gdk_gc_new (mask);
183
 
    col.pixel = 1;
184
 
    gdk_gc_set_foreground (gc, &col);
185
 
    gdk_draw_rectangle (mask, gc, TRUE, 0, 0, width, height);
186
 
 
187
 
    col.pixel = 0;
188
 
    gdk_gc_set_foreground (gc, &col);
189
 
    for (i = 0; i < width; i++)
190
 
    {
191
 
        if (i == (width / 2 - 1))
192
 
        {
193
 
            continue;
194
 
        }
195
 
        gdk_draw_line (mask, gc, i, j, i, height - j);
196
 
        if (i < (width / 2 - 1))
197
 
        {
198
 
            j++;
199
 
        }
200
 
        else
201
 
        {
202
 
            j--;
203
 
        }
204
 
    }
205
 
    g_object_unref (gc);
206
 
    gdk_window_shape_combine_mask (win, mask, 0, 0);
207
 
    if (mask)
208
 
        g_object_unref (mask);
209
 
 
210
 
    gdk_window_move (win, x, y);
211
 
    gdk_window_show (win);
212
 
    gdk_window_raise (win);
213
 
 
214
 
    return win;
215
 
}
216
 
 
217
 
GdkPixbuf *
218
 
create_icon_from_widget (GtkWidget * widget)
219
 
{
220
 
    GdkPixbuf *dest, *src;
221
 
 
222
 
    dest =
223
 
        gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, widget->allocation.width,
224
 
        widget->allocation.height);
225
 
 
226
 
    src = gdk_pixbuf_get_from_drawable (NULL, GDK_DRAWABLE (widget->window), NULL,
227
 
        widget->allocation.x, widget->allocation.y, 0, 0, widget->allocation.width,
228
 
        widget->allocation.height);
229
 
    gdk_pixbuf_copy_area (src, 0, 0, widget->allocation.width, widget->allocation.height, dest, 0,
230
 
        0);
231
 
 
232
 
    g_object_unref (G_OBJECT (src));
233
 
 
234
 
    return dest;
235
 
}
236
 
 
237
 
 
238
 
static void
239
 
button_drag_begin (GtkWidget * widget, GdkDragContext * context, gpointer data)
240
 
{
241
 
    GdkPixbuf *pixbuf;
242
 
 
243
 
    pixbuf = create_icon_from_widget (widget);
244
 
    gtk_drag_source_set_icon_pixbuf (widget, pixbuf);
245
 
    g_object_unref (G_OBJECT (pixbuf));
246
 
    gtk_widget_hide (widget);
247
 
}
248
 
 
249
 
static void
250
 
button_drag_end (GtkWidget * widget, GdkDragContext * context, gpointer data)
251
 
{
252
 
    gtk_widget_show (GTK_WIDGET (widget));
253
 
}
254
 
 
255
 
static gboolean
256
 
signal_blocker (GtkWidget * widget, gpointer data)
257
 
{
258
 
    return TRUE;
259
 
}
260
 
 
261
 
static gboolean
262
 
layout_drag_motion (GtkWidget * widget, GdkDragContext * context, gint x, gint y, guint time,
263
 
    gpointer user_data)
264
 
{
265
 
    GtkWidget *child;
266
 
    GList *children, *item;
267
 
    gint posx, posy, delta;
268
 
    gint ix, iy, iwidth, iheight;
269
 
    GdkWindow *indicator = NULL;
270
 
 
271
 
    g_return_val_if_fail (GTK_IS_WIDGET (user_data), FALSE);
272
 
 
273
 
    children = gtk_container_get_children (GTK_CONTAINER (user_data));
274
 
    item = children;
275
 
    child = GTK_WIDGET (item->data);
276
 
    delta = widget->allocation.x;
277
 
    posx = child->allocation.x;
278
 
    posy = child->allocation.y;
279
 
 
280
 
    while (item)
281
 
    {
282
 
        gint total_x;
283
 
 
284
 
        child = GTK_WIDGET (item->data);
285
 
        if (GTK_WIDGET_VISIBLE (child))
286
 
        {
287
 
            total_x = child->allocation.x + (child->allocation.width / 2) - delta;
288
 
            posx = child->allocation.x;
289
 
            if (x < total_x)
290
 
            {
291
 
                break;
292
 
            }
293
 
 
294
 
            posx = child->allocation.x + child->allocation.width;
295
 
        }
296
 
        item = g_list_next (item);
297
 
    }
298
 
    g_list_free (children);
299
 
 
300
 
    ix = posx - (INDICATOR_SIZE / 2);
301
 
    iy = posy - (INDICATOR_SIZE / 2);
302
 
    iwidth = INDICATOR_SIZE;
303
 
    iheight = child->allocation.height + INDICATOR_SIZE;
304
 
 
305
 
    indicator = g_object_get_data (G_OBJECT (user_data), "indicator_window");
306
 
    if (!indicator)
307
 
    {
308
 
        create_motion_indicator (GTK_WIDGET (user_data), ix, iy, iwidth, iheight);
309
 
    }
310
 
    else
311
 
    {
312
 
        gdk_window_move (indicator, ix, iy);
313
 
    }
314
 
 
315
 
    return FALSE;
316
 
}
317
 
 
318
 
static gboolean
319
 
layout_drag_leave (GtkWidget * widget, GdkDragContext * context, guint time, gpointer user_data)
320
 
{
321
 
    g_return_val_if_fail (GTK_IS_WIDGET (user_data), FALSE);
322
 
 
323
 
    delete_motion_indicator (GTK_WIDGET (user_data));
324
 
 
325
 
    return FALSE;
326
 
}
327
 
 
328
 
static void
329
 
data_get (GtkWidget * widget, GdkDragContext * drag_context, GtkSelectionData * data, guint info,
330
 
    guint time, gpointer user_data)
331
 
{
332
 
    gtk_selection_data_set (data, gdk_atom_intern ("_XFWM4_BUTTON", FALSE), 8, (const guchar *) "",
333
 
        0);
334
 
}
335
 
 
336
 
static void
337
 
title_data_get (GtkWidget * widget, GdkDragContext * drag_context, GtkSelectionData * data, guint info,
338
 
    guint time, gpointer user_data)
339
 
{
340
 
    gtk_selection_data_set (data, gdk_atom_intern ("_XFWM4_TITLE", FALSE), 8, (const guchar *) "",
341
 
        0);
342
 
}
343
 
 
344
 
static gchar *
345
 
layout_get_semantic (GtkWidget * container)
346
 
{
347
 
    GList *children, *item;
348
 
    gchar *sem;
349
 
    gint p = 0;
350
 
 
351
 
    children = gtk_container_get_children (GTK_CONTAINER (container));
352
 
    sem = g_new0 (gchar, BUTTON_COUNT + 2);
353
 
    item = children;
354
 
    while (item)
355
 
    {
356
 
        GtkWidget *child;
357
 
        gchar *key;
358
 
 
359
 
        child = GTK_WIDGET (item->data);
360
 
        key = g_object_get_data (G_OBJECT (child), "key_char");
361
 
        if (key)
362
 
        {
363
 
            sem[p++] = *key;
364
 
            if (p >= BUTTON_COUNT + 1)
365
 
            {
366
 
                g_list_free (children);
367
 
                return (sem);
368
 
            }
369
 
        }
370
 
        item = g_list_next (item);
371
 
    }
372
 
    g_list_free (children);
373
 
    return (sem);
374
 
}
375
 
 
376
 
static void
377
 
layout_reorder_buttons (GtkWidget * container, GtkWidget * widget, gint drop_x)
378
 
{
379
 
    GList *children, *item;
380
 
    gint position, delta;
381
 
 
382
 
    children = gtk_container_get_children (GTK_CONTAINER (container));
383
 
    item = children;
384
 
    position = 0;
385
 
    delta = container->allocation.x;
386
 
 
387
 
    while (item)
388
 
    {
389
 
        GtkWidget *child;
390
 
        gint total_x;
391
 
 
392
 
        child = GTK_WIDGET (item->data);
393
 
        if (GTK_WIDGET_VISIBLE (child))
394
 
        {
395
 
            total_x = child->allocation.x + (child->allocation.width / 2) - delta;
396
 
            if (drop_x <= total_x)
397
 
            {
398
 
                gtk_box_reorder_child (GTK_BOX (container), widget, position);
399
 
                g_list_free (children);
400
 
                return;
401
 
            }
402
 
            position++;
403
 
        }
404
 
        item = g_list_next (item);
405
 
    }
406
 
    gtk_box_reorder_child (GTK_BOX (container), widget, position);
407
 
    g_list_free (children);
408
 
}
409
 
 
410
 
static void
411
 
layout_set_value (GtkWidget * layout, GtkWidget * hidden, gchar * semantic)
412
 
{
413
 
    GList *children, *item;
414
 
    GtkWidget *title;
415
 
    gchar *sem;
416
 
 
417
 
    /* 
418
 
     * 1) Block redraw on boxes 
419
 
     */
420
 
    gtk_widget_set_app_paintable (layout, FALSE);
421
 
    gtk_widget_set_app_paintable (hidden, FALSE);
422
 
 
423
 
    /* 
424
 
     * 2) Send all buttons but the title back to the hidden frame 
425
 
     */
426
 
    children = gtk_container_get_children (GTK_CONTAINER (layout));
427
 
    title = NULL;
428
 
    item = children;
429
 
    while (item)
430
 
    {
431
 
        GtkWidget *child;
432
 
        gchar *key;
433
 
 
434
 
        child = GTK_WIDGET (item->data);
435
 
        key = g_object_get_data (G_OBJECT (child), "key_char");
436
 
        if (*key != '|')
437
 
        {
438
 
            gtk_widget_ref (child);
439
 
            gtk_container_remove (GTK_CONTAINER (layout), child);
440
 
            gtk_box_pack_start (GTK_BOX (hidden), child, FALSE, FALSE, 0);
441
 
            gtk_widget_unref (child);
442
 
        }
443
 
        else
444
 
        {
445
 
            title = child;
446
 
        }
447
 
        item = g_list_next (item);
448
 
    }
449
 
    g_list_free (children);
450
 
 
451
 
    /* 
452
 
     * 3) Move choosen buttons to the layout box in correct order
453
 
     */
454
 
    children = gtk_container_get_children (GTK_CONTAINER (hidden));
455
 
    sem = semantic;
456
 
    while (*sem)
457
 
    {
458
 
        item = children;
459
 
        if (*sem != '|')
460
 
        {
461
 
            while (item)
462
 
            {
463
 
                GtkWidget *child;
464
 
                gchar *key;
465
 
 
466
 
                child = GTK_WIDGET (item->data);
467
 
                key = g_object_get_data (G_OBJECT (child), "key_char");
468
 
                if (*key == *sem)
469
 
                {
470
 
                    gtk_widget_ref (child);
471
 
                    gtk_container_remove (GTK_CONTAINER (hidden), child);
472
 
                    gtk_box_pack_start (GTK_BOX (layout), child, FALSE, FALSE, 0);
473
 
                    gtk_widget_unref (child);
474
 
                }
475
 
                item = g_list_next (item);
476
 
            }
477
 
        }
478
 
        else if (title)
479
 
        {
480
 
            gtk_widget_ref (title);
481
 
            gtk_container_remove (GTK_CONTAINER (layout), title);
482
 
            gtk_box_pack_start (GTK_BOX (layout), title, FALSE, FALSE, 0);
483
 
            gtk_widget_unref (title);
484
 
        }
485
 
 
486
 
        sem++;
487
 
    }
488
 
    g_list_free (children);
489
 
 
490
 
    /* 
491
 
     * 4) Unblock redraw on boxes 
492
 
     */
493
 
    gtk_widget_set_app_paintable (layout, TRUE);
494
 
    gtk_widget_set_app_paintable (hidden, TRUE);
495
 
}
496
 
 
497
 
static void
498
 
hidden_data_receive (GtkWidget * widget, GdkDragContext * drag_context, gint x, gint y,
499
 
    GtkSelectionData * data, guint info, guint time, gpointer user_data)
500
 
{
501
 
    GtkWidget *source = gtk_drag_get_source_widget (drag_context);
502
 
    GtkWidget *parent = gtk_widget_get_parent (source);
503
 
    McsPlugin *mcs_plugin = NULL;
504
 
 
505
 
    g_return_if_fail (GTK_IS_WIDGET (user_data));
506
 
 
507
 
    mcs_plugin = (McsPlugin *) g_object_get_data (G_OBJECT (user_data), "mcs");
508
 
    gtk_widget_ref (source);
509
 
    gtk_container_remove (GTK_CONTAINER (parent), source);
510
 
    gtk_box_pack_start (GTK_BOX (user_data), source, FALSE, FALSE, 0);
511
 
    gtk_widget_unref (source);
512
 
 
513
 
    if (parent == GTK_WIDGET (user_data))
514
 
    {
515
 
        return;
516
 
    }
517
 
 
518
 
    if (current_layout)
519
 
    {
520
 
        g_free (current_layout);
521
 
    }
522
 
 
523
 
    current_layout = layout_get_semantic (parent);
524
 
    mcs_manager_set_string (mcs_plugin->manager, "Xfwm/ButtonLayout", CHANNEL1, current_layout);
525
 
    mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
526
 
    xfwm4_plugin_write_options (mcs_plugin);
527
 
}
528
 
 
529
 
static void
530
 
layout_data_receive (GtkWidget * widget, GdkDragContext * drag_context, gint x, gint y,
531
 
    GtkSelectionData * data, guint info, guint time, gpointer user_data)
532
 
{
533
 
    GtkWidget *source = gtk_drag_get_source_widget (drag_context);
534
 
    GtkWidget *parent = gtk_widget_get_parent (source);
535
 
    McsPlugin *mcs_plugin = NULL;
536
 
 
537
 
    g_return_if_fail (GTK_IS_WIDGET (user_data));
538
 
 
539
 
    mcs_plugin = (McsPlugin *) g_object_get_data (G_OBJECT (user_data), "mcs");
540
 
 
541
 
    gtk_widget_set_app_paintable (GTK_WIDGET (user_data), FALSE);
542
 
    gtk_widget_ref (source);
543
 
    gtk_container_remove (GTK_CONTAINER (parent), source);
544
 
    gtk_box_pack_start (GTK_BOX (user_data), source, FALSE, FALSE, 0);
545
 
    gtk_widget_unref (source);
546
 
    delete_motion_indicator (GTK_WIDGET (user_data));
547
 
    layout_reorder_buttons (user_data, source, x);
548
 
    gtk_widget_set_app_paintable (GTK_WIDGET (user_data), TRUE);
549
 
 
550
 
    if (current_layout)
551
 
    {
552
 
        g_free (current_layout);
553
 
    }
554
 
 
555
 
    current_layout = layout_get_semantic (user_data);
556
 
    mcs_manager_set_string (mcs_plugin->manager, "Xfwm/ButtonLayout", CHANNEL1, current_layout);
557
 
    mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
558
 
    xfwm4_plugin_write_options (mcs_plugin);
559
 
}
560
 
 
561
 
static GtkWidget *
562
 
create_layout_buttons (gchar * layout, gpointer user_data)
563
 
{
564
 
    GtkWidget *vbox;
565
 
    GtkWidget *layout_frame;
566
 
    GtkWidget *hidden_frame;
567
 
    GtkWidget *layout_box;
568
 
    GtkWidget *hidden_box;
569
 
    GtkWidget *title;
570
 
    GtkWidget *label;
571
 
    GtkTargetEntry entry[2];
572
 
    GtkTooltips *tooltips;
573
 
    gint i;
574
 
 
575
 
    entry[0].target = "_XFWM4_BUTTON";
576
 
    entry[0].flags = GTK_TARGET_SAME_APP;
577
 
    entry[0].info = 2;
578
 
 
579
 
    entry[1].target = "_XFWM4_TITLE";
580
 
    entry[1].flags = GTK_TARGET_SAME_APP;
581
 
    entry[1].info = 3;
582
 
 
583
 
    tooltips = gtk_tooltips_new ();
584
 
 
585
 
    vbox = gtk_vbox_new (TRUE, 0);
586
 
 
587
 
    label = gtk_label_new (_("Click and drag buttons to change the layout"));
588
 
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
589
 
    gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
590
 
    gtk_widget_show (label);
591
 
 
592
 
    layout_frame = gtk_frame_new (_("Active"));
593
 
    gtk_box_pack_start (GTK_BOX (vbox), layout_frame, TRUE, TRUE, 0);
594
 
    gtk_widget_show (layout_frame);
595
 
 
596
 
    layout_box = gtk_hbox_new (FALSE, 0);
597
 
    gtk_container_set_border_width (GTK_CONTAINER (layout_box), 5);
598
 
    gtk_container_add (GTK_CONTAINER (layout_frame), layout_box);
599
 
    g_object_set_data (G_OBJECT (layout_box), "mcs", user_data);
600
 
    g_object_set_data (G_OBJECT (layout_box), "indicator_window", NULL);
601
 
    gtk_widget_show (layout_box);
602
 
 
603
 
    title = gtk_button_new_with_label (_("Title"));
604
 
    gtk_tooltips_set_tip (tooltips, title, _("The window title, it cannot be removed"), NULL);
605
 
    g_object_set_data (G_OBJECT (title), "key_char", "|");
606
 
    gtk_drag_source_set (title, GDK_BUTTON1_MASK, &entry[1], 1, GDK_ACTION_MOVE);
607
 
    g_signal_connect (title, "drag-data-get", G_CALLBACK (title_data_get), NULL);
608
 
    g_signal_connect (title, "drag_begin", G_CALLBACK (button_drag_begin), NULL);
609
 
    g_signal_connect (title, "drag_end", G_CALLBACK (button_drag_end), NULL);
610
 
    g_signal_connect (title, "button_press_event", G_CALLBACK (signal_blocker), NULL);
611
 
    g_signal_connect (title, "enter_notify_event", G_CALLBACK (signal_blocker), NULL);
612
 
    g_signal_connect (title, "focus", G_CALLBACK (signal_blocker), NULL);
613
 
    gtk_box_pack_start (GTK_BOX (layout_box), title, FALSE, FALSE, 0);
614
 
    gtk_widget_show (title);
615
 
 
616
 
    hidden_frame = gtk_frame_new (_("Hidden"));
617
 
    gtk_box_pack_start (GTK_BOX (vbox), hidden_frame, TRUE, TRUE, 0);
618
 
    gtk_widget_show (hidden_frame);
619
 
 
620
 
    hidden_box = gtk_hbox_new (FALSE, 5);
621
 
    gtk_container_set_border_width (GTK_CONTAINER (hidden_box), 5);
622
 
    gtk_container_add (GTK_CONTAINER (hidden_frame), hidden_box);
623
 
    g_object_set_data (G_OBJECT (hidden_box), "mcs", user_data);
624
 
    gtk_widget_show (hidden_box);
625
 
 
626
 
    for (i = 0; i < BUTTON_COUNT; i++)
627
 
    {
628
 
        GtkWidget *button;
629
 
        GtkWidget *image;
630
 
 
631
 
        image = gtk_image_new_from_stock (title_button[i].stock_icon, GTK_ICON_SIZE_MENU);
632
 
        button = gtk_button_new ();
633
 
        gtk_container_add (GTK_CONTAINER (button), image);
634
 
        gtk_tooltips_set_tip (tooltips, button, _(title_button[i].desc), _(title_button[i].desc));
635
 
        gtk_drag_source_set (button, GDK_BUTTON1_MASK, entry, 1, GDK_ACTION_MOVE);
636
 
        g_signal_connect (button, "drag-data-get", G_CALLBACK (data_get), NULL);
637
 
        g_signal_connect (button, "drag_begin", G_CALLBACK (button_drag_begin), NULL);
638
 
        g_signal_connect (button, "drag_end", G_CALLBACK (button_drag_end), NULL);
639
 
        g_signal_connect (button, "button_press_event", G_CALLBACK (signal_blocker), NULL);
640
 
        g_signal_connect (button, "enter_notify_event", G_CALLBACK (signal_blocker), NULL);
641
 
        g_signal_connect (button, "focus", G_CALLBACK (signal_blocker), NULL);
642
 
        g_object_set_data (G_OBJECT (button), "key_char", title_button[i].key);
643
 
        gtk_box_pack_start (GTK_BOX (hidden_box), button, FALSE, FALSE, 0);
644
 
        gtk_widget_show_all (button);
645
 
    }
646
 
 
647
 
    layout_set_value (layout_box, hidden_box, layout);
648
 
    gtk_drag_dest_set (hidden_frame, GTK_DEST_DEFAULT_ALL, entry, 1, GDK_ACTION_MOVE);
649
 
    gtk_drag_dest_set (layout_frame, GTK_DEST_DEFAULT_ALL, entry, 2, GDK_ACTION_MOVE);
650
 
 
651
 
    g_signal_connect (hidden_frame, "drag_data_received", G_CALLBACK (hidden_data_receive),
652
 
        hidden_box);
653
 
    g_signal_connect (layout_frame, "drag_data_received", G_CALLBACK (layout_data_receive),
654
 
        layout_box);
655
 
    g_signal_connect (layout_frame, "drag_motion", G_CALLBACK (layout_drag_motion), layout_box);
656
 
    g_signal_connect (layout_frame, "drag_leave", G_CALLBACK (layout_drag_leave), layout_box);
657
 
 
658
 
    gtk_widget_show (vbox);
659
 
    return (vbox);
660
 
}
661
 
 
662
 
static GtkWidget *
663
 
create_option_menu_box (const MenuTmpl template[], guint size, gchar * display_label, gchar * value,
664
 
    GCallback handler, gpointer user_data)
665
 
{
666
 
    GtkWidget *hbox;
667
 
    GtkWidget *vbox;
668
 
    GtkWidget *omenu;
669
 
    guint n;
670
 
 
671
 
    vbox = gtk_vbox_new (FALSE, 0);
672
 
    gtk_widget_show (vbox);
673
 
 
674
 
    hbox = gtk_hbox_new (FALSE, 0);
675
 
    gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
676
 
    gtk_widget_show (hbox);
677
 
 
678
 
    omenu = gtk_combo_box_new_text ();
679
 
    gtk_box_pack_start (GTK_BOX (hbox), omenu, TRUE, TRUE, 0);
680
 
    gtk_widget_show (omenu);
681
 
 
682
 
    for (n = 0; n < size; n++)
683
 
    {
684
 
        gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), _(template[n].label));
685
 
 
686
 
        if (strcmp (value, template[n].action) == 0)
687
 
            gtk_combo_box_set_active (GTK_COMBO_BOX (omenu), n);
688
 
    }
689
 
 
690
 
    g_signal_connect (G_OBJECT (omenu), "changed", G_CALLBACK (handler), user_data);
691
 
 
692
 
    return (vbox);
693
 
}
694
 
 
695
 
void
696
 
xfwm4_plugin_theme_info_free (ThemeInfo * info)
697
 
{
698
 
    g_free (info->path);
699
 
    g_free (info->name);
700
 
    g_free (info);
701
 
}
702
 
 
703
 
ThemeInfo *
704
 
xfwm4_plugin_find_theme_info_by_name (const gchar * theme_name, GList * theme_list)
705
 
{
706
 
    GList *list;
707
 
 
708
 
    for (list = theme_list; list; list = list->next)
709
 
    {
710
 
        ThemeInfo *info = list->data;
711
 
 
712
 
        if (!strcmp (info->name, theme_name))
713
 
            return info;
714
 
    }
715
 
 
716
 
    return NULL;
717
 
}
718
 
 
719
 
static gboolean
720
 
parserc (const gchar * filename, gboolean * set_layout, gboolean * set_align, gboolean * set_font)
721
 
{
722
 
    gchar buf[80];
723
 
    gchar *lvalue, *rvalue;
724
 
    FILE *fp;
725
 
 
726
 
    *set_layout = FALSE;
727
 
    *set_align = FALSE;
728
 
    *set_font = FALSE;
729
 
 
730
 
    fp = fopen (filename, "r");
731
 
    if (!fp)
732
 
    {
733
 
        return FALSE;
734
 
    }
735
 
    while (fgets (buf, sizeof (buf), fp))
736
 
    {
737
 
        lvalue = strtok (buf, "=");
738
 
        rvalue = strtok (NULL, "\n");
739
 
        if ((lvalue) && (rvalue))
740
 
        {
741
 
            if (!g_ascii_strcasecmp (lvalue, "button_layout"))
742
 
            {
743
 
                *set_layout = TRUE;
744
 
            }
745
 
            else if (!g_ascii_strcasecmp (lvalue, "title_alignment"))
746
 
            {
747
 
                *set_align = TRUE;
748
 
            }
749
 
            else if (!g_ascii_strcasecmp (lvalue, "title_font"))
750
 
            {
751
 
                *set_font = TRUE;
752
 
            }
753
 
        }
754
 
 
755
 
    }
756
 
    fclose (fp);
757
 
    return TRUE;
758
 
}
759
 
 
760
 
static GList *
761
 
update_theme_dir (const gchar * theme_dir, GList * theme_list)
762
 
{
763
 
    ThemeInfo *info = NULL;
764
 
    gchar *theme_name;
765
 
    GList *list = theme_list;
766
 
    gboolean has_decoration = FALSE;
767
 
    gboolean has_keybinding = FALSE;
768
 
    gboolean set_layout = FALSE;
769
 
    gboolean set_align = FALSE;
770
 
    gboolean set_font = FALSE;
771
 
    gboolean user_writable = FALSE;
772
 
 
773
 
    gchar *tmp;
774
 
 
775
 
    tmp = g_build_filename (theme_dir, KEY_SUFFIX, KEYTHEMERC, NULL);
776
 
    if (g_file_test (tmp, G_FILE_TEST_IS_REGULAR)
777
 
        && parserc (tmp, &set_layout, &set_align, &set_font))
778
 
    {
779
 
        has_keybinding = TRUE;
780
 
        user_writable = (access (tmp, W_OK) == 0);
781
 
    }
782
 
    g_free (tmp);
783
 
 
784
 
    tmp = g_build_filename (theme_dir, SUFFIX, THEMERC, NULL);
785
 
    if (g_file_test (tmp, G_FILE_TEST_IS_REGULAR)
786
 
        && parserc (tmp, &set_layout, &set_align, &set_font))
787
 
    {
788
 
        has_decoration = TRUE;
789
 
    }
790
 
    g_free (tmp);
791
 
 
792
 
    theme_name = g_strdup (strrchr (theme_dir, G_DIR_SEPARATOR) + 1);
793
 
    info = xfwm4_plugin_find_theme_info_by_name (theme_name, list);
794
 
 
795
 
    if (info)
796
 
    {
797
 
        if (!strcmp (theme_dir, info->path))
798
 
        {
799
 
            if (!has_decoration && !has_keybinding)
800
 
            {
801
 
                TRACE ("Removing %s", theme_name);
802
 
                list = g_list_remove (list, info);
803
 
                xfwm4_plugin_theme_info_free (info);
804
 
            }
805
 
            else if ((info->has_keybinding != has_keybinding)
806
 
                || (info->has_decoration != has_decoration)
807
 
                || (info->set_layout != set_layout) || (info->set_align != set_align)
808
 
                || (info->set_font != set_font))
809
 
            {
810
 
                TRACE ("Updating %s", theme_name);
811
 
                info->has_keybinding = has_keybinding;
812
 
                info->has_decoration = has_decoration;
813
 
                info->set_layout = set_layout;
814
 
                info->set_align = set_align;
815
 
                info->set_font = set_font;
816
 
                info->user_writable = user_writable;
817
 
            }
818
 
        }
819
 
    }
820
 
    else
821
 
    {
822
 
        if (has_decoration || has_keybinding)
823
 
        {
824
 
            TRACE ("Adding %s", theme_name);
825
 
            info = g_new0 (ThemeInfo, 1);
826
 
            info->path = g_strdup (theme_dir);
827
 
            info->name = g_strdup (theme_name);
828
 
            info->has_decoration = has_decoration;
829
 
            info->has_keybinding = has_keybinding;
830
 
            info->set_layout = set_layout;
831
 
            info->set_align = set_align;
832
 
            info->set_font = set_font;
833
 
            info->user_writable = user_writable;
834
 
            list = g_list_prepend (list, info);
835
 
        }
836
 
    }
837
 
 
838
 
    g_free (theme_name);
839
 
    return list;
840
 
}
841
 
 
842
 
static GList *
843
 
themes_common_list_add_dir (const char *dirname, GList * theme_list)
844
 
{
845
 
#ifdef HAVE_OPENDIR
846
 
    struct dirent *de;
847
 
    gchar *tmp;
848
 
    DIR *dir;
849
 
 
850
 
    g_return_val_if_fail (dirname != NULL, theme_list);
851
 
    if ((dir = opendir (dirname)) != NULL)
852
 
    {
853
 
        while ((de = readdir (dir)))
854
 
        {
855
 
            if (de->d_name[0] == '.')
856
 
                continue;
857
 
 
858
 
            tmp = g_build_filename (dirname, de->d_name, NULL);
859
 
            theme_list = update_theme_dir (tmp, theme_list);
860
 
            g_free (tmp);
861
 
        }
862
 
 
863
 
        closedir (dir);
864
 
    }
865
 
#endif
866
 
 
867
 
    return (theme_list);
868
 
}
869
 
 
870
 
 
871
 
static GList *
872
 
theme_common_init (GList * theme_list)
873
 
{
874
 
    gchar **dirs, **d;
875
 
    GList *list = theme_list;
876
 
 
877
 
    xfce_resource_push_path (XFCE_RESOURCE_THEMES, DATADIR G_DIR_SEPARATOR_S "themes");
878
 
    dirs = xfce_resource_dirs (XFCE_RESOURCE_THEMES);
879
 
    xfce_resource_pop_path (XFCE_RESOURCE_THEMES);
880
 
 
881
 
    for (d = dirs; *d != NULL; ++d)
882
 
        list = themes_common_list_add_dir (*d, list);
883
 
 
884
 
    g_strfreev (dirs);
885
 
 
886
 
    return list;
887
 
}
888
 
 
889
 
static gboolean
890
 
dialog_update_from_theme (Itf * itf, const gchar * theme_name, GList * theme_list)
891
 
{
892
 
    ThemeInfo *info = NULL;
893
 
 
894
 
    g_return_val_if_fail (theme_name != NULL, FALSE);
895
 
    g_return_val_if_fail (theme_list != NULL, FALSE);
896
 
 
897
 
    info = xfwm4_plugin_find_theme_info_by_name (theme_name, theme_list);
898
 
    if (info)
899
 
    {
900
 
        gtk_container_foreach (GTK_CONTAINER (itf->frame_layout), sensitive_cb,
901
 
            GINT_TO_POINTER ((gint) ! (info->set_layout)));
902
 
        gtk_container_foreach (GTK_CONTAINER (itf->frame_align), sensitive_cb,
903
 
            GINT_TO_POINTER ((gint) ! (info->set_align)));
904
 
        gtk_widget_set_sensitive (itf->font_button, !(info->set_font));
905
 
        return TRUE;
906
 
    }
907
 
    return FALSE;
908
 
}
909
 
 
910
 
static void
911
 
decoration_selection_changed (GtkTreeSelection * selection, gpointer data)
912
 
{
913
 
    GtkTreeModel *model;
914
 
    gchar *new_theme;
915
 
    GtkTreeIter iter;
916
 
    Itf *itf;
917
 
    McsPlugin *mcs_plugin;
918
 
 
919
 
    g_return_if_fail (data != NULL);
920
 
 
921
 
    if (setting_model)
922
 
    {
923
 
        return;
924
 
    }
925
 
 
926
 
    itf = (Itf *) data;
927
 
    mcs_plugin = itf->mcs_plugin;
928
 
 
929
 
    if (gtk_tree_selection_get_selected (selection, &model, &iter))
930
 
    {
931
 
        gtk_tree_model_get (model, &iter, THEME_NAME_COLUMN, &new_theme, -1);
932
 
    }
933
 
    else
934
 
    {
935
 
        new_theme = NULL;
936
 
    }
937
 
 
938
 
    if (new_theme != NULL)
939
 
    {
940
 
        if (current_theme && strcmp (current_theme, new_theme))
941
 
        {
942
 
            g_free (current_theme);
943
 
            current_theme = new_theme;
944
 
            dialog_update_from_theme (itf, current_theme, decoration_theme_list);
945
 
            mcs_manager_set_string (mcs_plugin->manager, "Xfwm/ThemeName", CHANNEL1, current_theme);
946
 
            mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
947
 
            xfwm4_plugin_write_options (mcs_plugin);
948
 
        }
949
 
    }
950
 
}
951
 
 
952
 
static void
953
 
keybinding_selection_changed (GtkTreeSelection * selection, gpointer data)
954
 
{
955
 
    GtkTreeModel *model;
956
 
    gchar *new_key_theme;
957
 
    GtkTreeIter iter;
958
 
    Itf *itf;
959
 
    McsPlugin *mcs_plugin;
960
 
 
961
 
    g_return_if_fail (data != NULL);
962
 
 
963
 
    if (setting_model)
964
 
    {
965
 
        return;
966
 
    }
967
 
 
968
 
    itf = (Itf *) data;
969
 
    mcs_plugin = itf->mcs_plugin;
970
 
 
971
 
    if (gtk_tree_selection_get_selected (selection, &model, &iter))
972
 
    {
973
 
        gtk_tree_model_get (model, &iter, THEME_NAME_COLUMN, &new_key_theme, -1);
974
 
    }
975
 
    else
976
 
    {
977
 
        new_key_theme = NULL;
978
 
    }
979
 
 
980
 
    if (new_key_theme != NULL)
981
 
    {
982
 
        if (xfwm4_plugin_current_key_theme
983
 
            && strcmp (xfwm4_plugin_current_key_theme, new_key_theme))
984
 
        {
985
 
            ThemeInfo *ti;
986
 
 
987
 
            ti = xfwm4_plugin_find_theme_info_by_name (new_key_theme, keybinding_theme_list);
988
 
 
989
 
            if (ti)
990
 
            {
991
 
                gchar *theme_file;
992
 
 
993
 
                theme_file = g_build_filename (ti->path, KEY_SUFFIX, KEYTHEMERC, NULL);
994
 
                if (g_file_test (theme_file, G_FILE_TEST_EXISTS))
995
 
                {
996
 
                    g_free (xfwm4_plugin_current_key_theme);
997
 
                    xfwm4_plugin_current_key_theme = new_key_theme;
998
 
                    mcs_manager_set_string (mcs_plugin->manager, "Xfwm/KeyThemeName", CHANNEL2,
999
 
                        xfwm4_plugin_current_key_theme);
1000
 
                    mcs_manager_notify (mcs_plugin->manager, CHANNEL2);
1001
 
                    xfwm4_plugin_write_options (mcs_plugin);
1002
 
 
1003
 
                    loadtheme_in_treeview (ti, itf);
1004
 
                    gtk_widget_set_sensitive (itf->treeview3, ti->user_writable);
1005
 
                    gtk_widget_set_sensitive (itf->del_button, ti->user_writable);
1006
 
                }
1007
 
                else
1008
 
                {
1009
 
                    g_warning ("The keytheme file doesn't exist !");
1010
 
 
1011
 
                    /* refresh list */
1012
 
                    while (keybinding_theme_list)
1013
 
                    {
1014
 
                        xfwm4_plugin_theme_info_free ((ThemeInfo *) keybinding_theme_list->data);
1015
 
                        keybinding_theme_list = g_list_next (keybinding_theme_list);
1016
 
                    }
1017
 
                    g_list_free (keybinding_theme_list);
1018
 
 
1019
 
                    g_free (xfwm4_plugin_current_key_theme);
1020
 
                    xfwm4_plugin_current_key_theme = g_strdup ("Default");
1021
 
                    keybinding_theme_list = NULL;
1022
 
                    keybinding_theme_list =
1023
 
                        xfwm4_plugin_read_themes (keybinding_theme_list, itf->treeview2,
1024
 
                        itf->scrolledwindow2, KEYBINDING_THEMES, xfwm4_plugin_current_key_theme);
1025
 
                    gtk_widget_set_sensitive (itf->treeview3, FALSE);
1026
 
                    loadtheme_in_treeview (xfwm4_plugin_find_theme_info_by_name ("Default",
1027
 
                            keybinding_theme_list), itf);
1028
 
 
1029
 
                    /* tell it to the mcs manager */
1030
 
                    mcs_manager_set_string (itf->mcs_plugin->manager, "Xfwm/KeyThemeName", CHANNEL2,
1031
 
                        xfwm4_plugin_current_key_theme);
1032
 
                    mcs_manager_notify (itf->mcs_plugin->manager, CHANNEL2);
1033
 
                    xfwm4_plugin_write_options (itf->mcs_plugin);
1034
 
                }
1035
 
 
1036
 
                g_free (theme_file);
1037
 
            }
1038
 
            else
1039
 
                g_warning ("Cannot find the keytheme !!");
1040
 
        }
1041
 
    }
1042
 
}
1043
 
 
1044
 
GList *
1045
 
xfwm4_plugin_read_themes (GList * theme_list, GtkWidget * treeview, GtkWidget * swindow,
1046
 
    ThemeType type, gchar * current_value)
1047
 
{
1048
 
    GList *list;
1049
 
    GList *new_list = theme_list;
1050
 
    GtkTreeModel *model;
1051
 
    GtkTreeView *tree_view;
1052
 
    GtkTreePath *path;
1053
 
    GtkTreeIter iter;
1054
 
    GtkTreeIter iter_found;
1055
 
    gint i = 0;
1056
 
    gboolean current_value_found = FALSE;
1057
 
 
1058
 
    new_list = theme_common_init (new_list);
1059
 
    tree_view = GTK_TREE_VIEW (treeview);
1060
 
    model = gtk_tree_view_get_model (tree_view);
1061
 
 
1062
 
    setting_model = TRUE;
1063
 
    gtk_list_store_clear (GTK_LIST_STORE (model));
1064
 
 
1065
 
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_NEVER,
1066
 
        GTK_POLICY_NEVER);
1067
 
    gtk_widget_set_size_request (swindow, -1, -1);
1068
 
 
1069
 
    for (list = new_list; list; list = list->next)
1070
 
    {
1071
 
        ThemeInfo *info = list->data;
1072
 
        GtkTreeIter iter;
1073
 
 
1074
 
        if (((type == DECORATION_THEMES) && !(info->has_decoration)) || ((type == KEYBINDING_THEMES)
1075
 
                && !(info->has_keybinding)))
1076
 
            continue;
1077
 
 
1078
 
        gtk_list_store_prepend (GTK_LIST_STORE (model), &iter);
1079
 
        gtk_list_store_set (GTK_LIST_STORE (model), &iter, THEME_NAME_COLUMN, info->name, -1);
1080
 
 
1081
 
        if (strcmp (current_value, info->name) == 0)
1082
 
        {
1083
 
            current_value_found = TRUE;
1084
 
            iter_found = iter;
1085
 
        }
1086
 
 
1087
 
        if (i == MAX_ELEMENTS_BEFORE_SCROLLING)
1088
 
        {
1089
 
            GtkRequisition rectangle;
1090
 
            gtk_widget_size_request (GTK_WIDGET (tree_view), &rectangle);
1091
 
            gtk_widget_set_size_request (swindow, -1, rectangle.height);
1092
 
            gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_NEVER,
1093
 
                GTK_POLICY_AUTOMATIC);
1094
 
        }
1095
 
        i++;
1096
 
    }
1097
 
 
1098
 
    if (!current_value_found)
1099
 
    {
1100
 
        gtk_list_store_prepend (GTK_LIST_STORE (model), &iter);
1101
 
        gtk_list_store_set (GTK_LIST_STORE (model), &iter, THEME_NAME_COLUMN, current_value, -1);
1102
 
        iter_found = iter;
1103
 
    }
1104
 
 
1105
 
    path = gtk_tree_model_get_path (model, &iter_found);
1106
 
    {
1107
 
        gtk_tree_view_set_cursor (tree_view, path, NULL, FALSE);
1108
 
        gtk_tree_view_scroll_to_cell (tree_view, path, NULL, TRUE, 0.5, 0.0);
1109
 
        gtk_tree_path_free (path);
1110
 
    }
1111
 
    setting_model = FALSE;
1112
 
 
1113
 
    return new_list;
1114
 
}
1115
 
 
1116
 
static gint
1117
 
sort_func (GtkTreeModel * model, GtkTreeIter * a, GtkTreeIter * b, gpointer user_data)
1118
 
{
1119
 
    gchar *a_str = NULL;
1120
 
    gchar *b_str = NULL;
1121
 
 
1122
 
    gtk_tree_model_get (model, a, 0, &a_str, -1);
1123
 
    gtk_tree_model_get (model, b, 0, &b_str, -1);
1124
 
 
1125
 
    if (a_str == NULL)
1126
 
        a_str = g_strdup ("");
1127
 
    if (b_str == NULL)
1128
 
        b_str = g_strdup ("");
1129
 
 
1130
 
    if (!strcmp (a_str, DEFAULT_THEME))
1131
 
        return -1;
1132
 
    if (!strcmp (b_str, DEFAULT_THEME))
1133
 
        return 1;
1134
 
 
1135
 
    return g_utf8_collate (a_str, b_str);
1136
 
}
1137
 
 
1138
 
static void
1139
 
cb_click_to_focus_changed (GtkWidget * dialog, gpointer user_data)
1140
 
{
1141
 
    Itf *itf = (Itf *) user_data;
1142
 
    McsPlugin *mcs_plugin = itf->mcs_plugin;
1143
 
 
1144
 
    click_to_focus = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (itf->click_focus_radio));
1145
 
 
1146
 
    mcs_manager_set_int (mcs_plugin->manager, "Xfwm/ClickToFocus", CHANNEL1,
1147
 
        click_to_focus ? 1 : 0);
1148
 
    mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
1149
 
    xfwm4_plugin_write_options (mcs_plugin);
1150
 
}
1151
 
 
1152
 
static void
1153
 
cb_focus_new_changed (GtkWidget * dialog, gpointer user_data)
1154
 
{
1155
 
    Itf *itf = (Itf *) user_data;
1156
 
    McsPlugin *mcs_plugin = itf->mcs_plugin;
1157
 
 
1158
 
    focus_new = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (itf->focus_new_check));
1159
 
 
1160
 
    mcs_manager_set_int (mcs_plugin->manager, "Xfwm/FocusNewWindow", CHANNEL1, focus_new ? 1 : 0);
1161
 
    mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
1162
 
    xfwm4_plugin_write_options (mcs_plugin);
1163
 
}
1164
 
 
1165
 
static void
1166
 
cb_raise_on_focus_changed (GtkWidget * dialog, gpointer user_data)
1167
 
{
1168
 
    Itf *itf = (Itf *) user_data;
1169
 
    McsPlugin *mcs_plugin = itf->mcs_plugin;
1170
 
 
1171
 
    focus_raise = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (itf->raise_on_focus_check));
1172
 
    gtk_widget_set_sensitive (itf->raise_delay_scale, focus_raise);
1173
 
 
1174
 
    mcs_manager_set_int (mcs_plugin->manager, "Xfwm/FocusRaise", CHANNEL1, focus_raise ? 1 : 0);
1175
 
    mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
1176
 
    xfwm4_plugin_write_options (mcs_plugin);
1177
 
}
1178
 
 
1179
 
static void
1180
 
cb_raise_delay_changed (GtkWidget * dialog, gpointer user_data)
1181
 
{
1182
 
    Itf *itf = (Itf *) user_data;
1183
 
    McsPlugin *mcs_plugin = itf->mcs_plugin;
1184
 
 
1185
 
    raise_delay = (int) gtk_range_get_value (GTK_RANGE (itf->raise_delay_scale));
1186
 
    mcs_manager_set_int (mcs_plugin->manager, "Xfwm/RaiseDelay", CHANNEL1, raise_delay);
1187
 
    mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
1188
 
    xfwm4_plugin_write_options (mcs_plugin);
1189
 
}
1190
 
 
1191
 
static void
1192
 
cb_raise_on_click_changed (GtkWidget * dialog, gpointer user_data)
1193
 
{
1194
 
    Itf *itf = (Itf *) user_data;
1195
 
    McsPlugin *mcs_plugin = itf->mcs_plugin;
1196
 
 
1197
 
    raise_on_click = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (itf->click_raise_check));
1198
 
 
1199
 
    mcs_manager_set_int (mcs_plugin->manager, "Xfwm/RaiseOnClick", CHANNEL1,
1200
 
        raise_on_click ? 1 : 0);
1201
 
    mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
1202
 
    xfwm4_plugin_write_options (mcs_plugin);
1203
 
}
1204
 
 
1205
 
static void
1206
 
cb_snap_to_border_changed (GtkWidget * dialog, gpointer user_data)
1207
 
{
1208
 
    Itf *itf = (Itf *) user_data;
1209
 
    McsPlugin *mcs_plugin = itf->mcs_plugin;
1210
 
 
1211
 
    snap_to_border = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (itf->snap_to_border_check));
1212
 
    gtk_widget_set_sensitive (itf->snap_width_scale, snap_to_windows || snap_to_border);
1213
 
 
1214
 
    mcs_manager_set_int (mcs_plugin->manager, "Xfwm/SnapToBorder", CHANNEL1,
1215
 
        snap_to_border ? 1 : 0);
1216
 
    mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
1217
 
    xfwm4_plugin_write_options (mcs_plugin);
1218
 
}
1219
 
 
1220
 
static void
1221
 
cb_snap_to_windows_changed (GtkWidget * dialog, gpointer user_data)
1222
 
{
1223
 
    Itf *itf = (Itf *) user_data;
1224
 
    McsPlugin *mcs_plugin = itf->mcs_plugin;
1225
 
 
1226
 
    snap_to_windows = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (itf->snap_to_windows_check));
1227
 
    gtk_widget_set_sensitive (itf->snap_width_scale, snap_to_windows || snap_to_border);
1228
 
 
1229
 
    mcs_manager_set_int (mcs_plugin->manager, "Xfwm/SnapToWindows", CHANNEL1,
1230
 
        snap_to_windows ? 1 : 0);
1231
 
    mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
1232
 
    xfwm4_plugin_write_options (mcs_plugin);
1233
 
}
1234
 
 
1235
 
static void
1236
 
cb_snap_width_changed (GtkWidget * dialog, gpointer user_data)
1237
 
{
1238
 
    Itf *itf = (Itf *) user_data;
1239
 
    McsPlugin *mcs_plugin = itf->mcs_plugin;
1240
 
 
1241
 
    snap_width = (int) gtk_range_get_value (GTK_RANGE (itf->snap_width_scale));
1242
 
    mcs_manager_set_int (mcs_plugin->manager, "Xfwm/SnapWidth", CHANNEL1, snap_width);
1243
 
    mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
1244
 
    xfwm4_plugin_write_options (mcs_plugin);
1245
 
}
1246
 
 
1247
 
static void
1248
 
cb_wrap_resistance_changed (GtkWidget * dialog, gpointer user_data)
1249
 
{
1250
 
    Itf *itf = (Itf *) user_data;
1251
 
    McsPlugin *mcs_plugin = itf->mcs_plugin;
1252
 
 
1253
 
    wrap_resistance = (int) gtk_range_get_value (GTK_RANGE (itf->wrap_resistance_scale));
1254
 
    mcs_manager_set_int (mcs_plugin->manager, "Xfwm/WrapResistance", CHANNEL1, wrap_resistance);
1255
 
    mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
1256
 
    xfwm4_plugin_write_options (mcs_plugin);
1257
 
}
1258
 
 
1259
 
static void
1260
 
cb_wrap_workspaces_changed (GtkWidget * dialog, gpointer user_data)
1261
 
{
1262
 
    Itf *itf = (Itf *) user_data;
1263
 
    McsPlugin *mcs_plugin = itf->mcs_plugin;
1264
 
 
1265
 
    wrap_workspaces = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (itf->wrap_workspaces_check));
1266
 
    gtk_widget_set_sensitive (itf->wrap_resistance_scale, wrap_workspaces || wrap_windows);
1267
 
 
1268
 
    mcs_manager_set_int (mcs_plugin->manager, "Xfwm/WrapWorkspaces", CHANNEL1,
1269
 
        wrap_workspaces ? 1 : 0);
1270
 
    mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
1271
 
    xfwm4_plugin_write_options (mcs_plugin);
1272
 
}
1273
 
 
1274
 
static void
1275
 
cb_wrap_windows_changed (GtkWidget * dialog, gpointer user_data)
1276
 
{
1277
 
    Itf *itf = (Itf *) user_data;
1278
 
    McsPlugin *mcs_plugin = itf->mcs_plugin;
1279
 
 
1280
 
    wrap_windows = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (itf->wrap_windows_check));
1281
 
    gtk_widget_set_sensitive (itf->wrap_resistance_scale, wrap_workspaces || wrap_windows);
1282
 
 
1283
 
    mcs_manager_set_int (mcs_plugin->manager, "Xfwm/WrapWindows", CHANNEL1, wrap_windows ? 1 : 0);
1284
 
    mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
1285
 
    xfwm4_plugin_write_options (mcs_plugin);
1286
 
}
1287
 
 
1288
 
static void
1289
 
cb_box_move_changed (GtkWidget * dialog, gpointer user_data)
1290
 
{
1291
 
    Itf *itf = (Itf *) user_data;
1292
 
    McsPlugin *mcs_plugin = itf->mcs_plugin;
1293
 
 
1294
 
    box_move = !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (itf->box_move_check));
1295
 
 
1296
 
    mcs_manager_set_int (mcs_plugin->manager, "Xfwm/BoxMove", CHANNEL1, box_move ? 1 : 0);
1297
 
    mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
1298
 
    xfwm4_plugin_write_options (mcs_plugin);
1299
 
}
1300
 
 
1301
 
static void
1302
 
cb_box_resize_changed (GtkWidget * dialog, gpointer user_data)
1303
 
{
1304
 
    Itf *itf = (Itf *) user_data;
1305
 
    McsPlugin *mcs_plugin = itf->mcs_plugin;
1306
 
 
1307
 
    box_resize = !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (itf->box_resize_check));
1308
 
 
1309
 
    mcs_manager_set_int (mcs_plugin->manager, "Xfwm/BoxResize", CHANNEL1, box_resize ? 1 : 0);
1310
 
    mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
1311
 
    xfwm4_plugin_write_options (mcs_plugin);
1312
 
}
1313
 
 
1314
 
static void
1315
 
cb_dblclick_action_value_changed (GtkWidget * widget, gpointer user_data)
1316
 
{
1317
 
    McsPlugin *mcs_plugin = (McsPlugin *) user_data;
1318
 
    gint active;
1319
 
 
1320
 
    g_free (dbl_click_action);
1321
 
    active = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
1322
 
    dbl_click_action = g_strdup (dbl_click_values[active].action);
1323
 
 
1324
 
    mcs_manager_set_string (mcs_plugin->manager, "Xfwm/DblClickAction", CHANNEL1, dbl_click_action);
1325
 
    mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
1326
 
    xfwm4_plugin_write_options (mcs_plugin);
1327
 
}
1328
 
 
1329
 
static void
1330
 
cb_title_align_value_changed (GtkWidget * widget, gpointer user_data)
1331
 
{
1332
 
    McsPlugin *mcs_plugin = (McsPlugin *) user_data;
1333
 
    gint active;
1334
 
 
1335
 
    g_free (title_align);
1336
 
    active = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
1337
 
    title_align = g_strdup (title_align_values[active].action);
1338
 
 
1339
 
    mcs_manager_set_string (mcs_plugin->manager, "Xfwm/TitleAlign", CHANNEL1, title_align);
1340
 
    mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
1341
 
    xfwm4_plugin_write_options (mcs_plugin);
1342
 
}
1343
 
 
1344
 
static void
1345
 
font_selection_ok (GtkWidget * w, gpointer user_data)
1346
 
{
1347
 
    Itf *itf = (Itf *) user_data;
1348
 
    gchar *new_font =
1349
 
        gtk_font_selection_dialog_get_font_name (GTK_FONT_SELECTION_DIALOG (itf->font_selection));
1350
 
    McsPlugin *mcs_plugin = itf->mcs_plugin;
1351
 
 
1352
 
    if (new_font != NULL)
1353
 
    {
1354
 
        if (current_font && strcmp (current_font, new_font))
1355
 
        {
1356
 
            g_free (current_font);
1357
 
            current_font = new_font;
1358
 
            gtk_button_set_label (GTK_BUTTON (itf->font_button), current_font);
1359
 
            mcs_manager_set_string (mcs_plugin->manager, "Xfwm/TitleFont", CHANNEL1, current_font);
1360
 
            mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
1361
 
            xfwm4_plugin_write_options (mcs_plugin);
1362
 
        }
1363
 
    }
1364
 
 
1365
 
    gtk_widget_destroy (GTK_WIDGET (itf->font_selection));
1366
 
    itf->font_selection = NULL;
1367
 
}
1368
 
 
1369
 
static void
1370
 
show_font_selection (GtkWidget * widget, gpointer user_data)
1371
 
{
1372
 
    Itf *itf = (Itf *) user_data;
1373
 
 
1374
 
    if (!(itf->font_selection))
1375
 
    {
1376
 
        itf->font_selection = gtk_font_selection_dialog_new (_("Font Selection Dialog"));
1377
 
 
1378
 
        gtk_window_set_position (GTK_WINDOW (itf->font_selection), GTK_WIN_POS_MOUSE);
1379
 
        gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (itf->font_selection),
1380
 
            current_font);
1381
 
        g_signal_connect (itf->font_selection, "destroy", G_CALLBACK (gtk_widget_destroyed),
1382
 
            &itf->font_selection);
1383
 
 
1384
 
        g_signal_connect (GTK_FONT_SELECTION_DIALOG (itf->font_selection)->ok_button, "clicked",
1385
 
            G_CALLBACK (font_selection_ok), user_data);
1386
 
        g_signal_connect_swapped (GTK_FONT_SELECTION_DIALOG (itf->font_selection)->cancel_button,
1387
 
            "clicked", G_CALLBACK (gtk_widget_destroy), itf->font_selection);
1388
 
 
1389
 
        gtk_widget_show (itf->font_selection);
1390
 
    }
1391
 
    else
1392
 
    {
1393
 
        gtk_widget_destroy (itf->font_selection);
1394
 
        itf->font_selection = NULL;
1395
 
    }
1396
 
}
1397
 
 
1398
 
static void
1399
 
cb_dialog_response (GtkWidget * dialog, gint response_id)
1400
 
{
1401
 
    if (response_id == GTK_RESPONSE_HELP)
1402
 
    {
1403
 
        GError *error = NULL;
1404
 
        xfce_exec ("xfhelp4 xfwm4.html", FALSE, FALSE, &error);
1405
 
        if (error)
1406
 
        {
1407
 
            char *msg = g_strcompress (error->message);
1408
 
            xfce_warn ("%s", msg);
1409
 
            g_free (msg);
1410
 
            g_error_free (error);
1411
 
        }
1412
 
    }
1413
 
    else
1414
 
    {
1415
 
        is_running = FALSE;
1416
 
        gtk_widget_destroy (dialog);
1417
 
    }
1418
 
}
1419
 
 
1420
 
static Itf *
1421
 
create_dialog (McsPlugin * mcs_plugin)
1422
 
{
1423
 
    Itf *dialog;
1424
 
    GtkWidget *frame;
1425
 
    GtkWidget *hbox;
1426
 
    GtkWidget *label;
1427
 
    GtkWidget *notebook;
1428
 
    GtkWidget *table;
1429
 
    GtkWidget *vbox;
1430
 
    GtkWidget *vbox_page;
1431
 
    GtkTreeViewColumn *hidden_column;
1432
 
 
1433
 
    GtkCellRenderer *renderer;
1434
 
    GtkListStore *model;
1435
 
 
1436
 
    dialog = g_new (Itf, 1);
1437
 
 
1438
 
    dialog->mcs_plugin = mcs_plugin;
1439
 
 
1440
 
    dialog->xfwm4_dialog = xfce_titled_dialog_new ();
1441
 
    gtk_window_set_title (GTK_WINDOW (dialog->xfwm4_dialog), _("Window Manager"));
1442
 
    gtk_dialog_set_has_separator (GTK_DIALOG (dialog->xfwm4_dialog), FALSE);
1443
 
    gtk_window_set_icon_name(GTK_WINDOW(dialog->xfwm4_dialog), "xfwm4");
1444
 
 
1445
 
    dialog->font_selection = NULL;
1446
 
 
1447
 
    dialog->click_focus_radio_group = NULL;
1448
 
 
1449
 
    dialog->dialog_vbox = GTK_DIALOG (dialog->xfwm4_dialog)->vbox;
1450
 
    gtk_widget_show (dialog->dialog_vbox);
1451
 
 
1452
 
    notebook = gtk_notebook_new ();
1453
 
    gtk_container_set_border_width (GTK_CONTAINER (notebook), BORDER + 1);
1454
 
    gtk_widget_show (notebook);
1455
 
    gtk_box_pack_start (GTK_BOX (dialog->dialog_vbox), notebook, TRUE, TRUE, 0);
1456
 
 
1457
 
    hbox = gtk_hbox_new (FALSE, BORDER);
1458
 
    gtk_container_set_border_width (GTK_CONTAINER (hbox), BORDER);
1459
 
    gtk_widget_show (hbox);
1460
 
    gtk_container_add (GTK_CONTAINER (notebook), hbox);
1461
 
 
1462
 
    dialog->scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
1463
 
    gtk_widget_show (dialog->scrolledwindow1);
1464
 
    gtk_container_set_border_width (GTK_CONTAINER (dialog->scrolledwindow1), BORDER);
1465
 
    gtk_box_pack_start (GTK_BOX (hbox), dialog->scrolledwindow1, FALSE, TRUE, 0);
1466
 
    gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (dialog->scrolledwindow1),
1467
 
        GTK_SHADOW_IN);
1468
 
 
1469
 
    dialog->treeview1 = gtk_tree_view_new ();
1470
 
    gtk_widget_show (dialog->treeview1);
1471
 
    gtk_container_add (GTK_CONTAINER (dialog->scrolledwindow1), dialog->treeview1);
1472
 
    gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dialog->treeview1), FALSE);
1473
 
 
1474
 
    vbox = gtk_vbox_new (FALSE, BORDER);
1475
 
    gtk_widget_show (vbox);
1476
 
    gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
1477
 
 
1478
 
    hbox = gtk_hbox_new (FALSE, BORDER);
1479
 
    gtk_widget_show (hbox);
1480
 
 
1481
 
    frame = xfce_create_framebox_with_content (_("Title font"), hbox);
1482
 
    gtk_widget_show (frame);
1483
 
    gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, FALSE, 0);
1484
 
 
1485
 
    dialog->font_button = gtk_button_new ();
1486
 
    gtk_button_set_label (GTK_BUTTON (dialog->font_button), current_font);
1487
 
    gtk_widget_show (dialog->font_button);
1488
 
    gtk_box_pack_start (GTK_BOX (hbox), dialog->font_button, TRUE, TRUE, 0);
1489
 
 
1490
 
    dialog->frame_align = xfce_create_framebox_with_content (_("Title Alignment"),
1491
 
        create_option_menu_box (title_align_values, 3,
1492
 
            /*XXX*/ _("Text alignment inside title bar :"), title_align,
1493
 
            G_CALLBACK (cb_title_align_value_changed), mcs_plugin));
1494
 
    gtk_widget_show (dialog->frame_align);
1495
 
    gtk_box_pack_start (GTK_BOX (vbox), dialog->frame_align, TRUE, TRUE, 0);
1496
 
 
1497
 
    dialog->frame_layout =
1498
 
        xfce_create_framebox_with_content (_("Button layout"),
1499
 
        create_layout_buttons (current_layout, mcs_plugin));
1500
 
    gtk_widget_show (dialog->frame_layout);
1501
 
    gtk_box_pack_start (GTK_BOX (vbox), dialog->frame_layout, TRUE, FALSE, 0);
1502
 
 
1503
 
    label = gtk_label_new (_("Style"));
1504
 
    gtk_widget_show (label);
1505
 
    gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook),
1506
 
        gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), 0), label);
1507
 
    gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1508
 
 
1509
 
    hbox = gtk_hbox_new (FALSE, BORDER);
1510
 
    gtk_container_set_border_width (GTK_CONTAINER (hbox), BORDER);
1511
 
    gtk_widget_show (hbox);
1512
 
    gtk_container_add (GTK_CONTAINER (notebook), hbox);
1513
 
 
1514
 
    vbox = gtk_vbox_new (FALSE, BORDER);
1515
 
    gtk_container_set_border_width (GTK_CONTAINER (vbox), BORDER);
1516
 
    gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
1517
 
    gtk_widget_show (vbox);
1518
 
 
1519
 
    dialog->scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
1520
 
    gtk_container_set_border_width (GTK_CONTAINER (dialog->scrolledwindow2), BORDER);
1521
 
    gtk_widget_show (dialog->scrolledwindow2);
1522
 
    gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (dialog->scrolledwindow2),
1523
 
        GTK_SHADOW_IN);
1524
 
    gtk_box_pack_start (GTK_BOX (vbox), dialog->scrolledwindow2, TRUE, TRUE, 0);
1525
 
 
1526
 
    dialog->treeview2 = gtk_tree_view_new ();
1527
 
    gtk_widget_show (dialog->treeview2);
1528
 
    gtk_container_add (GTK_CONTAINER (dialog->scrolledwindow2), dialog->treeview2);
1529
 
    gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dialog->treeview2), FALSE);
1530
 
 
1531
 
    dialog->add_button = gtk_button_new_from_stock (GTK_STOCK_ADD);
1532
 
    gtk_widget_show (dialog->add_button);
1533
 
    gtk_box_pack_start (GTK_BOX (vbox), dialog->add_button, FALSE, FALSE, 0);
1534
 
    dialog->del_button = gtk_button_new_from_stock (GTK_STOCK_REMOVE);
1535
 
    gtk_widget_show (dialog->del_button);
1536
 
    gtk_box_pack_start (GTK_BOX (vbox), dialog->del_button, FALSE, FALSE, 0);
1537
 
 
1538
 
    vbox = gtk_vbox_new (FALSE, BORDER);
1539
 
    gtk_container_set_border_width (GTK_CONTAINER (vbox), BORDER);
1540
 
    gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
1541
 
    gtk_widget_show (vbox);
1542
 
 
1543
 
    dialog->scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL);
1544
 
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (dialog->scrolledwindow3),
1545
 
        GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1546
 
    gtk_container_set_border_width (GTK_CONTAINER (dialog->scrolledwindow3), BORDER);
1547
 
    gtk_widget_show (dialog->scrolledwindow3);
1548
 
    gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (dialog->scrolledwindow3),
1549
 
        GTK_SHADOW_IN);
1550
 
 
1551
 
    frame = xfce_create_framebox_with_content (_("Window shortcuts"), dialog->scrolledwindow3);
1552
 
    gtk_widget_show (frame);
1553
 
    gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
1554
 
 
1555
 
    model = gtk_list_store_new (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
1556
 
    dialog->treeview3 = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
1557
 
    gtk_widget_show (dialog->treeview3);
1558
 
    gtk_container_add (GTK_CONTAINER (dialog->scrolledwindow3), dialog->treeview3);
1559
 
 
1560
 
    /* command column */
1561
 
    renderer = gtk_cell_renderer_text_new ();
1562
 
    g_object_set_data (G_OBJECT (renderer), "column", (gint *) COLUMN_COMMAND);
1563
 
 
1564
 
    gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->treeview3), -1,
1565
 
        _("Command"), renderer, "text", COLUMN_COMMAND, NULL);
1566
 
    /* shortcut column */
1567
 
    renderer = gtk_cell_renderer_text_new ();
1568
 
    g_object_set_data (G_OBJECT (renderer), "column", (gint *) COLUMN_SHORTCUT);
1569
 
 
1570
 
    gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->treeview3), -1,
1571
 
        _("Shortcut"), renderer, "text", COLUMN_SHORTCUT, NULL);
1572
 
    /* command name hidden column */
1573
 
    hidden_column =
1574
 
        gtk_tree_view_column_new_with_attributes ("name", renderer, "text", COLUMN_NAME, NULL);
1575
 
    gtk_tree_view_column_set_visible (hidden_column, FALSE);
1576
 
    gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->treeview3), hidden_column);
1577
 
 
1578
 
    gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dialog->treeview3), TRUE);
1579
 
 
1580
 
    /* popup menu */
1581
 
    dialog->popup_menu = gtk_menu_new ();
1582
 
    dialog->popup_add_menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_ADD, NULL);
1583
 
    gtk_container_add (GTK_CONTAINER (dialog->popup_menu), dialog->popup_add_menuitem);
1584
 
    dialog->popup_del_menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_REMOVE, NULL);
1585
 
    gtk_container_add (GTK_CONTAINER (dialog->popup_menu), dialog->popup_del_menuitem);
1586
 
    gtk_widget_show_all (dialog->popup_menu);
1587
 
 
1588
 
    label = gtk_label_new (_("Keyboard"));
1589
 
    gtk_widget_show (label);
1590
 
    gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook),
1591
 
        gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), 1), label);
1592
 
    gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1593
 
 
1594
 
    vbox_page = gtk_vbox_new (FALSE, BORDER);
1595
 
    gtk_widget_show (vbox_page);
1596
 
    gtk_container_set_border_width (GTK_CONTAINER (vbox_page), BORDER);
1597
 
    gtk_widget_show (vbox_page);
1598
 
    gtk_container_add (GTK_CONTAINER (notebook), vbox_page);
1599
 
 
1600
 
    hbox = gtk_hbox_new (FALSE, BORDER);
1601
 
    gtk_widget_show (hbox);
1602
 
 
1603
 
    frame = xfce_create_framebox_with_content (_("Focus model"), hbox);
1604
 
    gtk_widget_show (frame);
1605
 
    gtk_box_pack_start (GTK_BOX (vbox_page), frame, TRUE, TRUE, 0);
1606
 
 
1607
 
    dialog->click_focus_radio = gtk_radio_button_new_with_mnemonic (NULL, _("Click to focus"));
1608
 
    gtk_widget_show (dialog->click_focus_radio);
1609
 
    gtk_box_pack_start (GTK_BOX (hbox), dialog->click_focus_radio, TRUE, FALSE, 0);
1610
 
    gtk_radio_button_set_group (GTK_RADIO_BUTTON (dialog->click_focus_radio),
1611
 
        dialog->click_focus_radio_group);
1612
 
    dialog->click_focus_radio_group =
1613
 
        gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->click_focus_radio));
1614
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->click_focus_radio), click_to_focus);
1615
 
 
1616
 
    dialog->focus_follow_mouse_radio =
1617
 
        gtk_radio_button_new_with_mnemonic (NULL, _("Focus follows mouse"));
1618
 
    gtk_widget_show (dialog->focus_follow_mouse_radio);
1619
 
    gtk_box_pack_start (GTK_BOX (hbox), dialog->focus_follow_mouse_radio, TRUE, FALSE, 0);
1620
 
    gtk_radio_button_set_group (GTK_RADIO_BUTTON (dialog->focus_follow_mouse_radio),
1621
 
        dialog->click_focus_radio_group);
1622
 
    dialog->click_focus_radio_group =
1623
 
        gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->focus_follow_mouse_radio));
1624
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->focus_follow_mouse_radio),
1625
 
        !click_to_focus);
1626
 
 
1627
 
    dialog->focus_new_check =
1628
 
        create_check_button_with_mnemonic (_("Automatically give focus to newly created windows"));
1629
 
    gtk_widget_show (dialog->focus_new_check);
1630
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->focus_new_check), focus_new);
1631
 
 
1632
 
    frame = xfce_create_framebox_with_content (_("New window focus"), dialog->focus_new_check);
1633
 
    gtk_widget_show (frame);
1634
 
    gtk_box_pack_start (GTK_BOX (vbox_page), frame, TRUE, TRUE, 0);
1635
 
 
1636
 
    vbox = gtk_vbox_new (FALSE, BORDER);
1637
 
    gtk_widget_show (vbox);
1638
 
 
1639
 
    frame = xfce_create_framebox_with_content (_("Raise on focus"), vbox);
1640
 
    gtk_widget_show (frame);
1641
 
    gtk_box_pack_start (GTK_BOX (vbox_page), frame, TRUE, TRUE, 0);
1642
 
 
1643
 
    dialog->raise_on_focus_check =
1644
 
        create_check_button_with_mnemonic (
1645
 
        _("Automatically raise windows when they receive focus"));
1646
 
    gtk_widget_show (dialog->raise_on_focus_check);
1647
 
    gtk_box_pack_start (GTK_BOX (vbox), dialog->raise_on_focus_check, FALSE, FALSE, 0);
1648
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->raise_on_focus_check), focus_raise);
1649
 
 
1650
 
    table = gtk_table_new (2, 3, FALSE);
1651
 
    gtk_widget_show (table);
1652
 
    gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
1653
 
    gtk_container_set_border_width (GTK_CONTAINER (table), BORDER);
1654
 
 
1655
 
    label = gtk_label_new (_("Delay before raising focused window :"));
1656
 
    gtk_widget_show (label);
1657
 
    gtk_table_attach (GTK_TABLE (table), label, 0, 3, 0, 1, (GtkAttachOptions) (GTK_FILL),
1658
 
        (GtkAttachOptions) (0), 0, 0);
1659
 
    gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1660
 
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1661
 
 
1662
 
    label = xfce_create_small_label (_("Slow"));
1663
 
    gtk_widget_show (label);
1664
 
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL),
1665
 
        (GtkAttachOptions) (0), 0, 0);
1666
 
    gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1667
 
    gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
1668
 
 
1669
 
    label = xfce_create_small_label (_("Fast"));
1670
 
    gtk_widget_show (label);
1671
 
    gtk_table_attach (GTK_TABLE (table), label, 2, 3, 1, 2, (GtkAttachOptions) (GTK_FILL),
1672
 
        (GtkAttachOptions) (0), 0, 0);
1673
 
    gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1674
 
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1675
 
 
1676
 
    dialog->raise_delay_scale =
1677
 
        gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (raise_delay, 100, 2000, 10, 100, 0)));
1678
 
    gtk_widget_show (dialog->raise_delay_scale);
1679
 
    gtk_table_attach (GTK_TABLE (table), dialog->raise_delay_scale, 1, 2, 1,
1680
 
        2, (GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK | GTK_FILL), (GtkAttachOptions) (GTK_FILL),
1681
 
        0, 0);
1682
 
    gtk_scale_set_draw_value (GTK_SCALE (dialog->raise_delay_scale), FALSE);
1683
 
    gtk_scale_set_digits (GTK_SCALE (dialog->raise_delay_scale), 0);
1684
 
    gtk_range_set_update_policy (GTK_RANGE (dialog->raise_delay_scale), GTK_UPDATE_DISCONTINUOUS);
1685
 
    gtk_range_set_inverted (GTK_RANGE (dialog->raise_delay_scale), TRUE);
1686
 
    gtk_widget_set_sensitive (dialog->raise_delay_scale, focus_raise);
1687
 
 
1688
 
    dialog->click_raise_check =
1689
 
        create_check_button_with_mnemonic (
1690
 
        _("Raise window when clicking inside application window"));
1691
 
    gtk_widget_show (dialog->click_raise_check);
1692
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->click_raise_check), raise_on_click);
1693
 
 
1694
 
    frame = xfce_create_framebox_with_content (_("Raise on click"), dialog->click_raise_check);
1695
 
    gtk_widget_show (frame);
1696
 
    gtk_box_pack_start (GTK_BOX (vbox_page), frame, TRUE, TRUE, 0);
1697
 
 
1698
 
    label = gtk_label_new (_("Focus"));
1699
 
    gtk_widget_show (label);
1700
 
    gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook),
1701
 
        gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), 2), label);
1702
 
    gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1703
 
 
1704
 
    vbox_page = gtk_vbox_new (FALSE, BORDER);
1705
 
    gtk_container_set_border_width (GTK_CONTAINER (vbox_page), BORDER);
1706
 
    gtk_widget_show (vbox_page);
1707
 
    gtk_container_add (GTK_CONTAINER (notebook), vbox_page);
1708
 
 
1709
 
    vbox = gtk_vbox_new (FALSE, BORDER);
1710
 
    gtk_widget_show (vbox);
1711
 
 
1712
 
    frame = xfce_create_framebox_with_content (_("Windows snapping"), vbox);
1713
 
    gtk_widget_show (frame);
1714
 
    gtk_box_pack_start (GTK_BOX (vbox_page), frame, TRUE, TRUE, 0);
1715
 
 
1716
 
    dialog->snap_to_border_check =
1717
 
        create_check_button_with_mnemonic (_("Snap windows to screen border"));
1718
 
    gtk_widget_show (dialog->snap_to_border_check);
1719
 
    gtk_box_pack_start (GTK_BOX (vbox), dialog->snap_to_border_check, FALSE, FALSE, 0);
1720
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->snap_to_border_check), snap_to_border);
1721
 
 
1722
 
    dialog->snap_to_windows_check =
1723
 
        create_check_button_with_mnemonic (_("Snap windows to other windows"));
1724
 
    gtk_widget_show (dialog->snap_to_windows_check);
1725
 
    gtk_box_pack_start (GTK_BOX (vbox), dialog->snap_to_windows_check, FALSE, FALSE, 0);
1726
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->snap_to_windows_check),
1727
 
        snap_to_windows);
1728
 
 
1729
 
    table = gtk_table_new (2, 3, FALSE);
1730
 
    gtk_widget_show (table);
1731
 
    gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
1732
 
    gtk_container_set_border_width (GTK_CONTAINER (table), BORDER);
1733
 
 
1734
 
    label = gtk_label_new (_("Distance :"));
1735
 
    gtk_widget_show (label);
1736
 
    gtk_table_attach (GTK_TABLE (table), label, 0, 3, 0, 1, (GtkAttachOptions) (GTK_FILL),
1737
 
        (GtkAttachOptions) (0), 0, 0);
1738
 
    gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1739
 
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1740
 
 
1741
 
    label = xfce_create_small_label (Q_("Distance|Small"));
1742
 
    gtk_widget_show (label);
1743
 
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL),
1744
 
        (GtkAttachOptions) (0), 0, 0);
1745
 
    gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1746
 
    gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
1747
 
 
1748
 
    label = xfce_create_small_label (Q_("Distance|Wide"));
1749
 
    gtk_widget_show (label);
1750
 
    gtk_table_attach (GTK_TABLE (table), label, 2, 3, 1, 2, (GtkAttachOptions) (GTK_FILL),
1751
 
        (GtkAttachOptions) (0), 0, 0);
1752
 
    gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1753
 
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1754
 
 
1755
 
    dialog->snap_width_scale =
1756
 
        gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (snap_width, 5, 50, 5, 10, 0)));
1757
 
    gtk_widget_show (dialog->snap_width_scale);
1758
 
    gtk_table_attach (GTK_TABLE (table), dialog->snap_width_scale, 1, 2, 1,
1759
 
        2, (GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK | GTK_FILL), (GtkAttachOptions) (GTK_FILL),
1760
 
        0, 0);
1761
 
    gtk_scale_set_draw_value (GTK_SCALE (dialog->snap_width_scale), FALSE);
1762
 
    gtk_scale_set_digits (GTK_SCALE (dialog->snap_width_scale), 0);
1763
 
    gtk_range_set_update_policy (GTK_RANGE (dialog->snap_width_scale), GTK_UPDATE_DISCONTINUOUS);
1764
 
    gtk_widget_set_sensitive (dialog->snap_width_scale, snap_to_border || snap_to_windows);
1765
 
 
1766
 
    vbox = gtk_vbox_new (FALSE, BORDER);
1767
 
    gtk_widget_show (vbox);
1768
 
 
1769
 
    frame = xfce_create_framebox_with_content (_("Wrap workspaces"), vbox);
1770
 
    gtk_widget_show (frame);
1771
 
    gtk_box_pack_start (GTK_BOX (vbox_page), frame, TRUE, TRUE, 0);
1772
 
 
1773
 
    dialog->wrap_workspaces_check =
1774
 
        create_check_button_with_mnemonic (
1775
 
        _("Wrap workspaces when the pointer reaches a screen edge"));
1776
 
    gtk_widget_show (dialog->wrap_workspaces_check);
1777
 
    gtk_box_pack_start (GTK_BOX (vbox), dialog->wrap_workspaces_check, FALSE, FALSE, 0);
1778
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->wrap_workspaces_check),
1779
 
        wrap_workspaces);
1780
 
 
1781
 
    dialog->wrap_windows_check =
1782
 
        create_check_button_with_mnemonic (
1783
 
        _("Wrap workspaces when dragging a window off the screen"));
1784
 
    gtk_widget_show (dialog->wrap_windows_check);
1785
 
    gtk_box_pack_start (GTK_BOX (vbox), dialog->wrap_windows_check, FALSE, FALSE, 0);
1786
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->wrap_windows_check), wrap_windows);
1787
 
 
1788
 
    table = gtk_table_new (2, 3, FALSE);
1789
 
    gtk_widget_show (table);
1790
 
    gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
1791
 
    gtk_container_set_border_width (GTK_CONTAINER (table), BORDER);
1792
 
 
1793
 
    label = gtk_label_new (_("Edge Resistance :"));
1794
 
    gtk_widget_show (label);
1795
 
    gtk_table_attach (GTK_TABLE (table), label, 0, 3, 0, 1, (GtkAttachOptions) (GTK_FILL),
1796
 
        (GtkAttachOptions) (0), 0, 0);
1797
 
    gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1798
 
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1799
 
 
1800
 
    label = xfce_create_small_label (Q_("Resistance|Small"));
1801
 
    gtk_widget_show (label);
1802
 
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL),
1803
 
        (GtkAttachOptions) (0), 0, 0);
1804
 
    gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1805
 
    gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
1806
 
 
1807
 
    label = xfce_create_small_label (Q_("Resistance|Wide"));
1808
 
    gtk_widget_show (label);
1809
 
    gtk_table_attach (GTK_TABLE (table), label, 2, 3, 1, 2, (GtkAttachOptions) (GTK_FILL),
1810
 
        (GtkAttachOptions) (0), 0, 0);
1811
 
    gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1812
 
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1813
 
 
1814
 
    dialog->wrap_resistance_scale =
1815
 
        gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (wrap_resistance, 1, 50, 5, 10, 0)));
1816
 
    gtk_widget_show (dialog->wrap_resistance_scale);
1817
 
    gtk_table_attach (GTK_TABLE (table), dialog->wrap_resistance_scale, 1, 2,
1818
 
        1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK | GTK_FILL),
1819
 
        (GtkAttachOptions) (GTK_FILL), 0, 0);
1820
 
    gtk_scale_set_draw_value (GTK_SCALE (dialog->wrap_resistance_scale), FALSE);
1821
 
    gtk_scale_set_digits (GTK_SCALE (dialog->wrap_resistance_scale), 0);
1822
 
    gtk_range_set_update_policy (GTK_RANGE (dialog->wrap_resistance_scale),
1823
 
        GTK_UPDATE_DISCONTINUOUS);
1824
 
    gtk_widget_set_sensitive (dialog->wrap_resistance_scale, wrap_workspaces || wrap_windows);
1825
 
 
1826
 
    vbox = gtk_vbox_new (FALSE, BORDER);
1827
 
    gtk_widget_show (vbox);
1828
 
 
1829
 
    frame = xfce_create_framebox_with_content (_("Opaque move and resize"), vbox);
1830
 
    gtk_widget_show (frame);
1831
 
    gtk_box_pack_start (GTK_BOX (vbox_page), frame, TRUE, TRUE, 0);
1832
 
 
1833
 
    dialog->box_resize_check =
1834
 
        create_check_button_with_mnemonic (_("Display content of windows when resizing"));
1835
 
    gtk_widget_show (dialog->box_resize_check);
1836
 
    gtk_box_pack_start (GTK_BOX (vbox), dialog->box_resize_check, FALSE, FALSE, 0);
1837
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->box_resize_check), !box_resize);
1838
 
 
1839
 
    dialog->box_move_check =
1840
 
        create_check_button_with_mnemonic (_("Display content of windows when moving"));
1841
 
    gtk_widget_show (dialog->box_move_check);
1842
 
    gtk_box_pack_start (GTK_BOX (vbox), dialog->box_move_check, FALSE, FALSE, 0);
1843
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->box_move_check), !box_move);
1844
 
 
1845
 
    frame = xfce_create_framebox_with_content (_("Double click action"),
1846
 
        create_option_menu_box (dbl_click_values, 4,
1847
 
            _("Action to perform when double clicking on title bar :"), dbl_click_action,
1848
 
            G_CALLBACK (cb_dblclick_action_value_changed), mcs_plugin));
1849
 
    gtk_widget_show (frame);
1850
 
    gtk_box_pack_start (GTK_BOX (vbox_page), frame, TRUE, TRUE, 0);
1851
 
 
1852
 
    label = gtk_label_new (_("Advanced"));
1853
 
    gtk_widget_show (label);
1854
 
    gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook),
1855
 
        gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), 3), label);
1856
 
    gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1857
 
 
1858
 
    dialog->dialog_action_area1 = GTK_DIALOG (dialog->xfwm4_dialog)->action_area;
1859
 
    gtk_widget_show (dialog->dialog_action_area1);
1860
 
    gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog->dialog_action_area1), GTK_BUTTONBOX_END);
1861
 
 
1862
 
    dialog->closebutton1 = gtk_button_new_from_stock ("gtk-close");
1863
 
    gtk_widget_show (dialog->closebutton1);
1864
 
    gtk_dialog_add_action_widget (GTK_DIALOG (dialog->xfwm4_dialog), dialog->closebutton1,
1865
 
        GTK_RESPONSE_CLOSE);
1866
 
    GTK_WIDGET_SET_FLAGS (dialog->closebutton1, GTK_CAN_DEFAULT);
1867
 
 
1868
 
    dialog->helpbutton1 = gtk_button_new_from_stock ("gtk-help");
1869
 
    gtk_widget_show (dialog->helpbutton1);
1870
 
    gtk_dialog_add_action_widget (GTK_DIALOG (dialog->xfwm4_dialog), dialog->helpbutton1,
1871
 
        GTK_RESPONSE_HELP);
1872
 
 
1873
 
    gtk_widget_grab_focus (dialog->closebutton1);
1874
 
    gtk_widget_grab_default (dialog->closebutton1);
1875
 
 
1876
 
    return dialog;
1877
 
}
1878
 
 
1879
 
static void
1880
 
setup_dialog (Itf * itf)
1881
 
{
1882
 
    GtkTreeModel *model1, *model2;
1883
 
    GtkTreeSelection *selection;
1884
 
    ThemeInfo *ti;
1885
 
 
1886
 
    gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (itf->treeview1), -1, NULL,
1887
 
        gtk_cell_renderer_text_new (), "text", THEME_NAME_COLUMN, NULL);
1888
 
    gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (itf->treeview2), -1, NULL,
1889
 
        gtk_cell_renderer_text_new (), "text", THEME_NAME_COLUMN, NULL);
1890
 
 
1891
 
    model1 = (GtkTreeModel *) gtk_list_store_new (N_COLUMNS, G_TYPE_STRING);
1892
 
    gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (model1), 0, sort_func, NULL, NULL);
1893
 
    gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model1), 0, GTK_SORT_ASCENDING);
1894
 
    gtk_tree_view_set_model (GTK_TREE_VIEW (itf->treeview1), model1);
1895
 
 
1896
 
    model2 = (GtkTreeModel *) gtk_list_store_new (N_COLUMNS, G_TYPE_STRING);
1897
 
    gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (model2), 0, sort_func, NULL, NULL);
1898
 
    gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model2), 0, GTK_SORT_ASCENDING);
1899
 
    gtk_tree_view_set_model (GTK_TREE_VIEW (itf->treeview2), model2);
1900
 
 
1901
 
    selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (itf->treeview1));
1902
 
    gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
1903
 
    g_signal_connect (G_OBJECT (selection), "changed", (GCallback) decoration_selection_changed,
1904
 
        itf);
1905
 
 
1906
 
    selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (itf->treeview2));
1907
 
    gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
1908
 
 
1909
 
    g_signal_connect (G_OBJECT (selection), "changed", (GCallback) keybinding_selection_changed,
1910
 
        itf);
1911
 
 
1912
 
    g_signal_connect (G_OBJECT (itf->treeview2), "button-press-event", G_CALLBACK (cb_popup_menu),
1913
 
        itf);
1914
 
    g_signal_connect (G_OBJECT (itf->popup_add_menuitem), "activate",
1915
 
        G_CALLBACK (cb_popup_add_menu), itf);
1916
 
    g_signal_connect (G_OBJECT (itf->popup_del_menuitem), "activate",
1917
 
        G_CALLBACK (cb_popup_del_menu), itf);
1918
 
    g_signal_connect (G_OBJECT (itf->add_button), "clicked", G_CALLBACK (cb_popup_add_menu), itf);
1919
 
    g_signal_connect (G_OBJECT (itf->del_button), "clicked", G_CALLBACK (cb_popup_del_menu), itf);
1920
 
 
1921
 
    g_signal_connect (G_OBJECT (itf->treeview3), "row-activated",
1922
 
        G_CALLBACK (cb_activate_treeview3), itf);
1923
 
 
1924
 
 
1925
 
    decoration_theme_list =
1926
 
        xfwm4_plugin_read_themes (decoration_theme_list, itf->treeview1, itf->scrolledwindow1,
1927
 
        DECORATION_THEMES, current_theme);
1928
 
    keybinding_theme_list =
1929
 
        xfwm4_plugin_read_themes (keybinding_theme_list, itf->treeview2, itf->scrolledwindow2,
1930
 
        KEYBINDING_THEMES, xfwm4_plugin_current_key_theme);
1931
 
    dialog_update_from_theme (itf, current_theme, decoration_theme_list);
1932
 
 
1933
 
    /* load the theme */
1934
 
    ti = xfwm4_plugin_find_theme_info_by_name (xfwm4_plugin_current_key_theme,
1935
 
        keybinding_theme_list);
1936
 
 
1937
 
    if (ti)
1938
 
    {
1939
 
        gtk_widget_set_sensitive (itf->treeview3, ti->user_writable);
1940
 
        loadtheme_in_treeview (ti, itf);
1941
 
    }
1942
 
    else
1943
 
    {
1944
 
        g_warning ("Cannot find the keytheme !");
1945
 
    }
1946
 
    g_signal_connect (G_OBJECT (itf->xfwm4_dialog), "response", G_CALLBACK (cb_dialog_response),
1947
 
        itf->mcs_plugin);
1948
 
    g_signal_connect (G_OBJECT (itf->font_button), "clicked", G_CALLBACK (show_font_selection),
1949
 
        itf);
1950
 
    g_signal_connect (G_OBJECT (itf->click_focus_radio), "toggled",
1951
 
        G_CALLBACK (cb_click_to_focus_changed), itf);
1952
 
    g_signal_connect (G_OBJECT (itf->focus_new_check), "toggled", G_CALLBACK (cb_focus_new_changed),
1953
 
        itf);
1954
 
    g_signal_connect (G_OBJECT (itf->raise_on_focus_check), "toggled",
1955
 
        G_CALLBACK (cb_raise_on_focus_changed), itf);
1956
 
    g_signal_connect (G_OBJECT (itf->raise_delay_scale), "value_changed",
1957
 
        (GCallback) cb_raise_delay_changed, itf);
1958
 
    g_signal_connect (G_OBJECT (itf->click_raise_check), "toggled",
1959
 
        G_CALLBACK (cb_raise_on_click_changed), itf);
1960
 
    g_signal_connect (G_OBJECT (itf->snap_to_border_check), "toggled",
1961
 
        G_CALLBACK (cb_snap_to_border_changed), itf);
1962
 
    g_signal_connect (G_OBJECT (itf->snap_to_windows_check), "toggled",
1963
 
        G_CALLBACK (cb_snap_to_windows_changed), itf);
1964
 
    g_signal_connect (G_OBJECT (itf->snap_width_scale), "value_changed",
1965
 
        (GCallback) cb_snap_width_changed, itf);
1966
 
    g_signal_connect (G_OBJECT (itf->wrap_workspaces_check), "toggled",
1967
 
        G_CALLBACK (cb_wrap_workspaces_changed), itf);
1968
 
    g_signal_connect (G_OBJECT (itf->wrap_windows_check), "toggled",
1969
 
        G_CALLBACK (cb_wrap_windows_changed), itf);
1970
 
    g_signal_connect (G_OBJECT (itf->wrap_resistance_scale), "value_changed",
1971
 
        (GCallback) cb_wrap_resistance_changed, itf);
1972
 
    g_signal_connect (G_OBJECT (itf->box_move_check), "toggled", (GCallback) cb_box_move_changed,
1973
 
        itf);
1974
 
    g_signal_connect (G_OBJECT (itf->box_resize_check), "toggled",
1975
 
        G_CALLBACK (cb_box_resize_changed), itf);
1976
 
 
1977
 
    xfce_gtk_window_center_on_monitor_with_pointer (GTK_WINDOW (itf->xfwm4_dialog));
1978
 
    gdk_x11_window_set_user_time (GTK_WIDGET (itf->xfwm4_dialog)->window,
1979
 
        gdk_x11_get_server_time (GTK_WIDGET (itf->xfwm4_dialog)->window));
1980
 
    gtk_widget_show (itf->xfwm4_dialog);
1981
 
}
1982
 
 
1983
 
McsPluginInitResult
1984
 
mcs_plugin_init (McsPlugin * mcs_plugin)
1985
 
{
1986
 
    xfce_textdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR, "UTF-8");
1987
 
 
1988
 
    xfwm4_create_channel (mcs_plugin);
1989
 
    mcs_plugin->plugin_name = g_strdup (PLUGIN_NAME);
1990
 
    /* the button label in the xfce-mcs-manager dialog */
1991
 
    mcs_plugin->caption = g_strdup (Q_ ("Button Label|Window Manager"));
1992
 
    mcs_plugin->run_dialog = run_dialog;
1993
 
    mcs_plugin->icon = xfce_themed_icon_load ("xfwm4", 48);
1994
 
    if (G_LIKELY (mcs_plugin->icon != NULL))
1995
 
      g_object_set_data_full (G_OBJECT (mcs_plugin->icon), "mcs-plugin-icon-name", g_strdup ("xfwm4"), g_free);
1996
 
    mcs_manager_notify (mcs_plugin->manager, CHANNEL1);
1997
 
 
1998
 
    return (MCS_PLUGIN_INIT_OK);
1999
 
}
2000
 
 
2001
 
static void
2002
 
xfwm4_create_channel (McsPlugin * mcs_plugin)
2003
 
{
2004
 
    McsSetting *setting;
2005
 
    gchar *rcfile, *path;
2006
 
 
2007
 
    path = g_build_filename ("xfce4", RCDIR, RCFILE1, NULL);
2008
 
    rcfile = xfce_resource_lookup (XFCE_RESOURCE_CONFIG, path);
2009
 
    g_free (path);
2010
 
 
2011
 
    if (!rcfile)
2012
 
        rcfile = xfce_get_userfile (OLDRCDIR, RCFILE1, NULL);
2013
 
 
2014
 
    if (g_file_test (rcfile, G_FILE_TEST_EXISTS))
2015
 
    {
2016
 
        mcs_manager_add_channel_from_file (mcs_plugin->manager, CHANNEL1, rcfile);
2017
 
    }
2018
 
    else
2019
 
    {
2020
 
        mcs_manager_add_channel (mcs_plugin->manager, CHANNEL1);
2021
 
    }
2022
 
    g_free (rcfile);
2023
 
 
2024
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/ThemeName", CHANNEL1);
2025
 
    if (setting)
2026
 
    {
2027
 
        if (current_theme)
2028
 
        {
2029
 
            g_free (current_theme);
2030
 
        }
2031
 
        current_theme = g_strdup (setting->data.v_string);
2032
 
    }
2033
 
    else
2034
 
    {
2035
 
        if (current_theme)
2036
 
        {
2037
 
            g_free (current_theme);
2038
 
        }
2039
 
 
2040
 
        current_theme = g_strdup (DEFAULT_THEME);
2041
 
        mcs_manager_set_string (mcs_plugin->manager, "Xfwm/ThemeName", CHANNEL1, current_theme);
2042
 
    }
2043
 
 
2044
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/TitleFont", CHANNEL1);
2045
 
    if (setting)
2046
 
    {
2047
 
        if (current_font)
2048
 
        {
2049
 
            g_free (current_font);
2050
 
        }
2051
 
        current_font = g_strdup (setting->data.v_string);
2052
 
    }
2053
 
    else
2054
 
    {
2055
 
        if (current_font)
2056
 
        {
2057
 
            g_free (current_font);
2058
 
        }
2059
 
 
2060
 
        current_font = g_strdup (DEFAULT_FONT);
2061
 
        mcs_manager_set_string (mcs_plugin->manager, "Xfwm/TitleFont", CHANNEL1, current_font);
2062
 
    }
2063
 
 
2064
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/TitleAlign", CHANNEL1);
2065
 
    if (setting)
2066
 
    {
2067
 
        if (title_align)
2068
 
        {
2069
 
            g_free (title_align);
2070
 
        }
2071
 
        title_align = g_strdup (setting->data.v_string);
2072
 
    }
2073
 
    else
2074
 
    {
2075
 
        if (title_align)
2076
 
        {
2077
 
            g_free (title_align);
2078
 
        }
2079
 
 
2080
 
        title_align = g_strdup (DEFAULT_ALIGN);
2081
 
        mcs_manager_set_string (mcs_plugin->manager, "Xfwm/TitleAlign", CHANNEL1, title_align);
2082
 
    }
2083
 
 
2084
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/ButtonLayout", CHANNEL1);
2085
 
    if (setting)
2086
 
    {
2087
 
        if (current_layout)
2088
 
        {
2089
 
            g_free (current_layout);
2090
 
        }
2091
 
        current_layout = g_strdup (setting->data.v_string);
2092
 
    }
2093
 
    else
2094
 
    {
2095
 
        if (current_layout)
2096
 
        {
2097
 
            g_free (current_layout);
2098
 
        }
2099
 
 
2100
 
        current_layout = g_strdup (DEFAULT_LAYOUT);
2101
 
        mcs_manager_set_string (mcs_plugin->manager, "Xfwm/ButtonLayout", CHANNEL1, current_layout);
2102
 
    }
2103
 
 
2104
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/ClickToFocus", CHANNEL1);
2105
 
    if (setting)
2106
 
    {
2107
 
        click_to_focus = (setting->data.v_int ? TRUE : FALSE);
2108
 
    }
2109
 
    else
2110
 
    {
2111
 
        click_to_focus = TRUE;
2112
 
        mcs_manager_set_int (mcs_plugin->manager, "Xfwm/ClickToFocus", CHANNEL1,
2113
 
            click_to_focus ? 1 : 0);
2114
 
    }
2115
 
 
2116
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/FocusNewWindow", CHANNEL1);
2117
 
    if (setting)
2118
 
    {
2119
 
        focus_new = (setting->data.v_int ? TRUE : FALSE);
2120
 
    }
2121
 
    else
2122
 
    {
2123
 
        focus_new = TRUE;
2124
 
        mcs_manager_set_int (mcs_plugin->manager, "Xfwm/FocusNewWindow", CHANNEL1,
2125
 
            focus_new ? 1 : 0);
2126
 
    }
2127
 
 
2128
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/FocusRaise", CHANNEL1);
2129
 
    if (setting)
2130
 
    {
2131
 
        focus_raise = (setting->data.v_int ? TRUE : FALSE);
2132
 
    }
2133
 
    else
2134
 
    {
2135
 
        focus_raise = FALSE;
2136
 
        mcs_manager_set_int (mcs_plugin->manager, "Xfwm/FocusRaise", CHANNEL1, focus_raise ? 1 : 0);
2137
 
    }
2138
 
 
2139
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/RaiseDelay", CHANNEL1);
2140
 
    if (setting)
2141
 
    {
2142
 
        raise_delay = setting->data.v_int;
2143
 
    }
2144
 
    else
2145
 
    {
2146
 
        raise_delay = 250;
2147
 
        mcs_manager_set_int (mcs_plugin->manager, "Xfwm/RaiseDelay", CHANNEL1, raise_delay);
2148
 
    }
2149
 
 
2150
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/RaiseOnClick", CHANNEL1);
2151
 
    if (setting)
2152
 
    {
2153
 
        raise_on_click = (setting->data.v_int ? TRUE : FALSE);
2154
 
    }
2155
 
    else
2156
 
    {
2157
 
        raise_on_click = TRUE;
2158
 
        mcs_manager_set_int (mcs_plugin->manager, "Xfwm/RaiseOnClick", CHANNEL1,
2159
 
            raise_on_click ? 1 : 0);
2160
 
    }
2161
 
 
2162
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/SnapToBorder", CHANNEL1);
2163
 
    if (setting)
2164
 
    {
2165
 
        snap_to_border = (setting->data.v_int ? TRUE : FALSE);
2166
 
    }
2167
 
    else
2168
 
    {
2169
 
        snap_to_border = TRUE;
2170
 
        mcs_manager_set_int (mcs_plugin->manager, "Xfwm/SnapToBorder", CHANNEL1,
2171
 
            snap_to_border ? 1 : 0);
2172
 
    }
2173
 
 
2174
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/SnapToWindows", CHANNEL1);
2175
 
    if (setting)
2176
 
    {
2177
 
        snap_to_windows = (setting->data.v_int ? TRUE : FALSE);
2178
 
    }
2179
 
    else
2180
 
    {
2181
 
        snap_to_windows = FALSE;
2182
 
        mcs_manager_set_int (mcs_plugin->manager, "Xfwm/SnapToWindows", CHANNEL1,
2183
 
            snap_to_windows ? 1 : 0);
2184
 
    }
2185
 
 
2186
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/SnapWidth", CHANNEL1);
2187
 
    if (setting)
2188
 
    {
2189
 
        snap_width = setting->data.v_int;
2190
 
    }
2191
 
    else
2192
 
    {
2193
 
        snap_width = 10;
2194
 
        mcs_manager_set_int (mcs_plugin->manager, "Xfwm/SnapWidth", CHANNEL1, snap_width);
2195
 
    }
2196
 
 
2197
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/WrapResistance", CHANNEL1);
2198
 
    if (setting)
2199
 
    {
2200
 
        wrap_resistance = setting->data.v_int;
2201
 
    }
2202
 
    else
2203
 
    {
2204
 
        wrap_resistance = 10;
2205
 
        mcs_manager_set_int (mcs_plugin->manager, "Xfwm/WrapResistance", CHANNEL1, wrap_resistance);
2206
 
    }
2207
 
 
2208
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/WrapWorkspaces", CHANNEL1);
2209
 
    if (setting)
2210
 
    {
2211
 
        wrap_workspaces = (setting->data.v_int ? TRUE : FALSE);
2212
 
    }
2213
 
    else
2214
 
    {
2215
 
        wrap_workspaces = FALSE;
2216
 
        mcs_manager_set_int (mcs_plugin->manager, "Xfwm/WrapWorkspaces", CHANNEL1,
2217
 
            wrap_workspaces ? 1 : 0);
2218
 
    }
2219
 
 
2220
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/WrapWindows", CHANNEL1);
2221
 
    if (setting)
2222
 
    {
2223
 
        wrap_windows = (setting->data.v_int ? TRUE : FALSE);
2224
 
    }
2225
 
    else
2226
 
    {
2227
 
        wrap_windows = TRUE;
2228
 
        mcs_manager_set_int (mcs_plugin->manager, "Xfwm/WrapWindows", CHANNEL1,
2229
 
            wrap_windows ? 1 : 0);
2230
 
    }
2231
 
 
2232
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/BoxMove", CHANNEL1);
2233
 
    if (setting)
2234
 
    {
2235
 
        box_move = (setting->data.v_int ? TRUE : FALSE);
2236
 
    }
2237
 
    else
2238
 
    {
2239
 
        box_move = FALSE;
2240
 
        mcs_manager_set_int (mcs_plugin->manager, "Xfwm/BoxMove", CHANNEL1, box_move ? 1 : 0);
2241
 
    }
2242
 
 
2243
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/BoxResize", CHANNEL1);
2244
 
    if (setting)
2245
 
    {
2246
 
        box_resize = (setting->data.v_int ? TRUE : FALSE);
2247
 
    }
2248
 
    else
2249
 
    {
2250
 
        box_resize = FALSE;
2251
 
        mcs_manager_set_int (mcs_plugin->manager, "Xfwm/BoxResize", CHANNEL1, box_resize ? 1 : 0);
2252
 
    }
2253
 
 
2254
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/DblClickAction", CHANNEL1);
2255
 
    if (setting)
2256
 
    {
2257
 
        if (dbl_click_action)
2258
 
        {
2259
 
            g_free (dbl_click_action);
2260
 
        }
2261
 
        dbl_click_action = g_strdup (setting->data.v_string);
2262
 
    }
2263
 
    else
2264
 
    {
2265
 
        if (dbl_click_action)
2266
 
        {
2267
 
            g_free (dbl_click_action);
2268
 
        }
2269
 
 
2270
 
        dbl_click_action = g_strdup (DEFAULT_ACTION);
2271
 
        mcs_manager_set_string (mcs_plugin->manager, "Xfwm/DblClickAction", CHANNEL1,
2272
 
            dbl_click_action);
2273
 
    }
2274
 
 
2275
 
    /* 
2276
 
     * Second separate channel for keytheme (used as a raw channel from the client) 
2277
 
     */
2278
 
 
2279
 
    path = g_build_filename ("xfce4", RCDIR, RCFILE2, NULL);
2280
 
    rcfile = xfce_resource_lookup (XFCE_RESOURCE_CONFIG, path);
2281
 
    g_free (path);
2282
 
 
2283
 
    if (!rcfile)
2284
 
        rcfile = xfce_get_userfile (OLDRCDIR, RCFILE2, NULL);
2285
 
 
2286
 
    if (g_file_test (rcfile, G_FILE_TEST_EXISTS))
2287
 
    {
2288
 
        mcs_manager_add_channel_from_file (mcs_plugin->manager, CHANNEL2, rcfile);
2289
 
    }
2290
 
    else
2291
 
    {
2292
 
        mcs_manager_add_channel (mcs_plugin->manager, CHANNEL2);
2293
 
    }
2294
 
    g_free (rcfile);
2295
 
 
2296
 
    setting = mcs_manager_setting_lookup (mcs_plugin->manager, "Xfwm/KeyThemeName", CHANNEL2);
2297
 
    if (setting)
2298
 
    {
2299
 
        if (xfwm4_plugin_current_key_theme)
2300
 
        {
2301
 
            g_free (xfwm4_plugin_current_key_theme);
2302
 
        }
2303
 
        xfwm4_plugin_current_key_theme = g_strdup (setting->data.v_string);
2304
 
    }
2305
 
    else
2306
 
    {
2307
 
        if (xfwm4_plugin_current_key_theme)
2308
 
        {
2309
 
            g_free (xfwm4_plugin_current_key_theme);
2310
 
        }
2311
 
 
2312
 
        xfwm4_plugin_current_key_theme = g_strdup (DEFAULT_KEY_THEME);
2313
 
        mcs_manager_set_string (mcs_plugin->manager, "Xfwm/KeyThemeName", CHANNEL2,
2314
 
            xfwm4_plugin_current_key_theme);
2315
 
    }
2316
 
 
2317
 
#if 0
2318
 
    /* I fail to see why we need to save the options here, during startup... */
2319
 
    xfwm4_plugin_write_options (mcs_plugin);
2320
 
#endif
2321
 
}
2322
 
 
2323
 
gboolean
2324
 
xfwm4_plugin_write_options (McsPlugin * mcs_plugin)
2325
 
{
2326
 
    gchar *rcfile, *path;
2327
 
    gboolean result = FALSE;
2328
 
 
2329
 
    path = g_build_filename ("xfce4", "mcs_settings", RCFILE1, NULL);
2330
 
    rcfile = xfce_resource_save_location (XFCE_RESOURCE_CONFIG, path, TRUE);
2331
 
    if (G_LIKELY (rcfile != NULL))
2332
 
    {
2333
 
        result = mcs_manager_save_channel_to_file (mcs_plugin->manager, CHANNEL1, rcfile);
2334
 
        g_free (rcfile);
2335
 
    }
2336
 
    g_free (path);
2337
 
 
2338
 
    path = g_build_filename ("xfce4", "mcs_settings", RCFILE2, NULL);
2339
 
    rcfile = xfce_resource_save_location (XFCE_RESOURCE_CONFIG, path, TRUE);
2340
 
    if (G_LIKELY (rcfile != NULL))
2341
 
    {
2342
 
        result = mcs_manager_save_channel_to_file (mcs_plugin->manager, CHANNEL2, rcfile);
2343
 
        g_free (rcfile);
2344
 
    }
2345
 
    g_free (path);
2346
 
 
2347
 
    return result;
2348
 
}
2349
 
 
2350
 
static void
2351
 
run_dialog (McsPlugin * mcs_plugin)
2352
 
{
2353
 
    const gchar *wm_name;
2354
 
    static Itf *dialog = NULL;
2355
 
 
2356
 
    wm_name = gdk_x11_screen_get_window_manager_name (gdk_screen_get_default ());
2357
 
    if (g_ascii_strcasecmp (wm_name, "Xfwm4"))
2358
 
    {
2359
 
        xfce_err (_("These settings cannot work with your current window manager (%s)"), wm_name);
2360
 
        return;
2361
 
    }
2362
 
 
2363
 
    if (is_running)
2364
 
    {
2365
 
        if ((dialog) && (dialog->xfwm4_dialog))
2366
 
        {
2367
 
            gtk_window_present (GTK_WINDOW (dialog->xfwm4_dialog));
2368
 
            gtk_window_set_focus (GTK_WINDOW (dialog->xfwm4_dialog), NULL);
2369
 
        }
2370
 
        return;
2371
 
    }
2372
 
 
2373
 
    is_running = TRUE;
2374
 
 
2375
 
    xfce_textdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR, "UTF-8");
2376
 
 
2377
 
    dialog = create_dialog (mcs_plugin);
2378
 
    setup_dialog (dialog);
2379
 
}
2380
 
 
2381
 
/* macro defined in manager-plugin.h */
2382
 
MCS_PLUGIN_CHECK_INIT