← Back to branch summary

~ubuntu-branches/ubuntu/trusty/xfce4-panel/trusty-proposed

« back to all changes in this revision

Viewing changes to plugins/switcher/switcher.c

  • Committer: Bazaar Package Importer
  • Author(s): Simon Huggins
  • Date: 2004-06-08 10:44:21 UTC
  • Revision ID: james.westby@ubuntu.com-20040608104421-b0b77kis8o0uoi6q
Tags: upstream-4.0.5
Import upstream version 4.0.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/switcher/switcher.c
 
1
/*  xfce4
 
2
 *
 
3
 *  Copyright (C) 2002 Jasper Huijsmans(huysmans@users.sourceforge.net)
 
4
 *
 
5
 *  This program is free software; you can redistribute it and/or modify
 
6
 *  it under the terms of the GNU General Public License as published by
 
7
 *  the Free Software Foundation; either version 2 of the License, or
 
8
 *  (at your option) any later version.
 
9
 *
 
10
 *  This program is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *  GNU General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public License
 
16
 *  along with this program; if not, write to the Free Software
 
17
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
18
*/
 
19
 
 
20
#ifdef HAVE_CONFIG_H
 
21
#include <config.h>
 
22
#endif
 
23
 
 
24
#include <X11/Xlib.h>
 
25
#include <X11/Xatom.h>
 
26
 
 
27
#include <libxfce4util/i18n.h>
 
28
#include <libxfcegui4/libxfcegui4.h>
 
29
 
 
30
#include <panel/xfce.h>
 
31
#include <panel/popup.h>
 
32
#include <panel/settings.h>
 
33
#include <panel/plugins.h>
 
34
 
 
35
#if 0
 
36
#include <panel/mcs_client.h>
 
37
#endif
 
38
 
 
39
static int screen_button_width[] = { 35, 45, 80, 80 };
 
40
 
 
41
typedef struct
 
42
{
 
43
    int index;
 
44
    NetkWorkspace *workspace;
 
45
 
 
46
    int cb_id;
 
47
 
 
48
    GtkWidget *frame;
 
49
    GtkWidget *button;
 
50
    GtkWidget *label;
 
51
}
 
52
ScreenButton;
 
53
 
 
54
typedef struct
 
55
{
 
56
    const char *signal;
 
57
    GCallback callback;
 
58
    gpointer data;
 
59
}
 
60
SignalCallback;
 
61
 
 
62
typedef struct
 
63
{
 
64
    NetkScreen *screen;
 
65
 
 
66
    GtkWidget *box;
 
67
    GtkWidget *buttonboxes[2];
 
68
    GList *buttons;
 
69
}
 
70
CdePager;
 
71
 
 
72
typedef struct
 
73
{
 
74
    NetkScreen *screen;
 
75
    GPtrArray *screen_names;
 
76
 
 
77
    /* callback id's */
 
78
    int ws_changed_id;
 
79
    int ws_created_id;
 
80
    int ws_destroyed_id;
 
81
 
 
82
    GtkWidget *frame;
 
83
    GtkWidget *box;
 
84
 
 
85
/*    GtkWidget *separators[2];*/
 
86
 
 
87
    /* traditional switcher */
 
88
    CdePager *cde_pager;
 
89
 
 
90
    /* callback(s) we have to save for new buttons and for reorientation */
 
91
    GList *callbacks;
 
92
}
 
93
t_switcher;
 
94
 
 
95
/*  callback structure
 
96
 *  ------------------
 
97
 *  we want to keep track of callbacks to be able to 
 
98
 *  add them to new desktop buttons
 
99
*/
 
100
SignalCallback *
 
101
signal_callback_new (const char *signal, GCallback callback, gpointer data)
 
102
{
 
103
    SignalCallback *sc = g_new0 (SignalCallback, 1);
 
104
 
 
105
    sc->signal = signal;
 
106
    sc->callback = callback;
 
107
    sc->data = data;
 
108
 
 
109
    return sc;
 
110
}
 
111
 
 
112
/*  screenbuttons
 
113
 *  -------------
 
114
 *  traditional xfce desktop buttons
 
115
*/
 
116
 
 
117
/*  color names used for screen buttons
 
118
 *  may be used in gtk themes */
 
119
static char *screen_class[] = {
 
120
    "xfce_button1",
 
121
    "xfce_button2",
 
122
    "xfce_button3",
 
123
    "xfce_button4",
 
124
};
 
125
 
 
126
/*  callbacks */
 
127
static void
 
128
screen_button_update_label (ScreenButton * sb, const char *name)
 
129
{
 
130
    char *markup;
 
131
 
 
132
    switch (settings.size)
 
133
    {
 
134
        case TINY:
 
135
            markup = g_strconcat ("<span size=\"smaller\">",
 
136
                                  name, "</span>", NULL);
 
137
            break;
 
138
        case LARGE:
 
139
            markup = g_strconcat ("<span size=\"larger\">",
 
140
                                  name, "</span>", NULL);
 
141
            break;
 
142
        default:
 
143
            markup = g_strdup (name);
 
144
    }
 
145
 
 
146
    gtk_label_set_markup (GTK_LABEL (sb->label), markup);
 
147
    g_free (markup);
 
148
}
 
149
 
 
150
static gboolean
 
151
screen_button_pressed_cb (GtkButton * b, GdkEventButton * ev,
 
152
                          ScreenButton * sb)
 
153
{
 
154
    hide_current_popup_menu ();
 
155
 
 
156
    if (ev->button == 1)
 
157
    {
 
158
        netk_workspace_activate (sb->workspace);
 
159
        return TRUE;
 
160
    }
 
161
 
 
162
    if (ev->button == 3 && disable_user_config)
 
163
    {
 
164
        return TRUE;
 
165
    }
 
166
 
 
167
    return FALSE;
 
168
}
 
169
 
 
170
/* settings */
 
171
static void
 
172
screen_button_update_size (ScreenButton * sb)
 
173
{
 
174
    int w, h;
 
175
 
 
176
    /* TODO:
 
177
     * calculation of height is very arbitrary. I just put here what looks
 
178
     * good on my screen. Should probably be something a little more
 
179
     * intelligent. */
 
180
 
 
181
    /* don't let screen buttons get too large in vertical mode */
 
182
    if (settings.orientation == VERTICAL && settings.size > SMALL)
 
183
        w = screen_button_width[MEDIUM] * 3 / 4;
 
184
    else
 
185
        w = screen_button_width[settings.size];
 
186
 
 
187
    switch (settings.size)
 
188
    {
 
189
        case TINY:
 
190
            h = icon_size[TINY];
 
191
            break;
 
192
        case SMALL:
 
193
            h = -1;
 
194
            break;
 
195
        case LARGE:
 
196
            h = (top_height[LARGE] + icon_size[LARGE]) / 2 - 6;
 
197
            break;
 
198
        default:
 
199
            h = (top_height[MEDIUM] + icon_size[MEDIUM]) / 2 - 5;
 
200
            break;
 
201
    }
 
202
 
 
203
    h = -1;
 
204
    gtk_widget_set_size_request (sb->button, w, h);
 
205
 
 
206
    screen_button_update_label (sb,
 
207
                                gtk_label_get_text (GTK_LABEL (sb->label)));
 
208
}
 
209
 
 
210
/* creation and destruction */
 
211
static void
 
212
ws_name_changed (NetkWorkspace * ws, ScreenButton * sb)
 
213
{
 
214
    const char *name = netk_workspace_get_name (ws);
 
215
 
 
216
    gtk_label_set_text (GTK_LABEL (sb->label), name);
 
217
}
 
218
 
 
219
ScreenButton *
 
220
create_screen_button (int index, const char *name, NetkScreen * screen)
 
221
{
 
222
    const char *realname;
 
223
    ScreenButton *sb = g_new0 (ScreenButton, 1);
 
224
 
 
225
    sb->index = index;
 
226
 
 
227
    sb->workspace = netk_screen_get_workspace (screen, index);
 
228
    realname = netk_workspace_get_name (sb->workspace);
 
229
 
 
230
    if (!realname || !strlen (realname))
 
231
        realname = name;
 
232
 
 
233
    sb->cb_id = g_signal_connect (sb->workspace, "name-changed",
 
234
                                  G_CALLBACK (ws_name_changed), sb);
 
235
 
 
236
    sb->frame = gtk_alignment_new (0, 0, 1, 1); /* gtk_frame_new(NULL); */
 
237
    gtk_widget_show (sb->frame);
 
238
 
 
239
    sb->button = gtk_toggle_button_new ();
 
240
    gtk_button_set_relief (GTK_BUTTON (sb->button), GTK_RELIEF_HALF);
 
241
    gtk_widget_set_name (sb->button, screen_class[sb->index % 4]);
 
242
    gtk_widget_show (sb->button);
 
243
    gtk_container_add (GTK_CONTAINER (sb->frame), sb->button);
 
244
 
 
245
    sb->label = gtk_label_new (realname);
 
246
/*    gtk_misc_set_alignment(GTK_MISC(sb->label), 0.1, 0.5);*/
 
247
    gtk_widget_show (sb->label);
 
248
    gtk_container_add (GTK_CONTAINER (sb->button), sb->label);
 
249
 
 
250
    screen_button_update_size (sb);
 
251
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sb->button),
 
252
                                  sb->index == 0);
 
253
 
 
254
    g_signal_connect (sb->button, "button-press-event",
 
255
                      G_CALLBACK (screen_button_pressed_cb), sb);
 
256
 
 
257
    return sb;
 
258
}
 
259
 
 
260
void
 
261
screen_button_pack (ScreenButton * sb, GtkBox * box)
 
262
{
 
263
    gtk_box_pack_start (box, sb->frame, TRUE, TRUE, 0);
 
264
}
 
265
 
 
266
void
 
267
screen_button_free (ScreenButton * sb)
 
268
{
 
269
    g_signal_handler_disconnect (sb->workspace, sb->cb_id);
 
270
    g_free (sb);
 
271
}
 
272
 
 
273
/*  Traditional pager
 
274
 *  -----------------
 
275
 *  it's not completely stand-alone now, but perhaps we should make it a
 
276
 *  separate widget (?)
 
277
*/
 
278
static void
 
279
cde_pager_update_size (CdePager * pager)
 
280
{
 
281
    GList *li;
 
282
 
 
283
    for (li = pager->buttons; li; li = li->next)
 
284
    {
 
285
        ScreenButton *sb = li->data;
 
286
 
 
287
        screen_button_update_size (sb);
 
288
    }
 
289
 
 
290
    /* check if we can rearrange the buttons (== horizontal mode) */
 
291
    if (!pager->buttonboxes[1])
 
292
        return;
 
293
 
 
294
    if (settings.size > SMALL)
 
295
        gtk_widget_show (pager->buttonboxes[1]);
 
296
    else
 
297
        gtk_widget_hide (pager->buttonboxes[1]);
 
298
 
 
299
    /* remove the buttons ... */
 
300
    for (li = pager->buttons; li; li = li->next)
 
301
    {
 
302
        ScreenButton *sb = li->data;
 
303
 
 
304
        g_object_ref (sb->frame);
 
305
        gtk_container_remove (GTK_CONTAINER (sb->frame->parent), sb->frame);
 
306
    }
 
307
 
 
308
    /* ... and put them back again */
 
309
    for (li = pager->buttons; li; li = li->next)
 
310
    {
 
311
        ScreenButton *sb = li->data;
 
312
 
 
313
        if (settings.size <= SMALL || sb->index % 2 == 0)
 
314
        {
 
315
            gtk_box_pack_start (GTK_BOX (pager->buttonboxes[0]), sb->frame,
 
316
                                TRUE, TRUE, 0);
 
317
        }
 
318
        else
 
319
        {
 
320
            gtk_box_pack_start (GTK_BOX (pager->buttonboxes[1]), sb->frame,
 
321
                                TRUE, TRUE, 0);
 
322
        }
 
323
 
 
324
        g_object_unref (sb->frame);
 
325
    }
 
326
}
 
327
 
 
328
static void
 
329
cde_pager_attach_callback (CdePager * pager, SignalCallback * sc)
 
330
{
 
331
    GList *li;
 
332
 
 
333
    for (li = pager->buttons; li; li = li->next)
 
334
    {
 
335
        ScreenButton *sb = li->data;
 
336
 
 
337
        g_signal_connect (sb->button, sc->signal, sc->callback, sc->data);
 
338
    }
 
339
}
 
340
 
 
341
static void
 
342
cde_pager_add_button (CdePager * pager, GList * callbacks, GPtrArray * names)
 
343
{
 
344
    ScreenButton *sb;
 
345
    int i, index, active;
 
346
    GList *li;
 
347
    char *name;
 
348
 
 
349
    index = g_list_length (pager->buttons);
 
350
    active =
 
351
        netk_workspace_get_number (netk_screen_get_active_workspace
 
352
                                   (pager->screen));
 
353
 
 
354
    for (i = names->len; i < index + 1; i++)
 
355
    {
 
356
        char tmp[3];
 
357
 
 
358
        sprintf (tmp, "%d", i + 1);
 
359
 
 
360
        g_ptr_array_add (names, g_strdup (tmp));
 
361
    }
 
362
 
 
363
    name = g_ptr_array_index (names, index);
 
364
    sb = create_screen_button (index, name, pager->screen);
 
365
 
 
366
    pager->buttons = g_list_append (pager->buttons, sb);
 
367
 
 
368
    if (settings.orientation == VERTICAL || settings.size <= SMALL ||
 
369
        index % 2 == 0)
 
370
    {
 
371
        screen_button_pack (sb, GTK_BOX (pager->buttonboxes[0]));
 
372
    }
 
373
    else
 
374
    {
 
375
        screen_button_pack (sb, GTK_BOX (pager->buttonboxes[1]));
 
376
    }
 
377
 
 
378
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sb->button),
 
379
                                  index == active);
 
380
 
 
381
    for (li = callbacks; li; li = li->next)
 
382
    {
 
383
        SignalCallback *sc = li->data;
 
384
 
 
385
        g_signal_connect (sb->button, sc->signal, sc->callback, sc->data);
 
386
    }
 
387
}
 
388
 
 
389
static void
 
390
cde_pager_remove_button (CdePager * pager)
 
391
{
 
392
    GList *li;
 
393
    ScreenButton *sb;
 
394
 
 
395
    li = g_list_last (pager->buttons);
 
396
    sb = li->data;
 
397
 
 
398
    pager->buttons = g_list_delete_link (pager->buttons, li);
 
399
 
 
400
    gtk_widget_destroy (sb->frame);
 
401
 
 
402
    screen_button_free (sb);
 
403
}
 
404
 
 
405
static void
 
406
cde_pager_set_active (CdePager * pager, NetkWorkspace * ws)
 
407
{
 
408
    GList *li;
 
409
 
 
410
    for (li = pager->buttons; li; li = li->next)
 
411
    {
 
412
        ScreenButton *sb = li->data;
 
413
 
 
414
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sb->button),
 
415
                                      sb->workspace == ws);
 
416
    }
 
417
}
 
418
 
 
419
CdePager *
 
420
create_cde_pager (NetkScreen * screen, GPtrArray * names)
 
421
{
 
422
    int i, n;
 
423
 
 
424
    CdePager *pager = g_new0 (CdePager, 1);
 
425
 
 
426
    pager->screen = screen;
 
427
 
 
428
    n = netk_screen_get_workspace_count (screen);
 
429
 
 
430
    if (settings.orientation == HORIZONTAL)
 
431
    {
 
432
        GtkWidget *spacer;
 
433
 
 
434
        pager->box = gtk_vbox_new (FALSE, 0);
 
435
        gtk_widget_show (pager->box);
 
436
 
 
437
        spacer = gtk_alignment_new (0, 0, 0, 0);
 
438
        gtk_widget_show (spacer);
 
439
        gtk_box_pack_start (GTK_BOX (pager->box), spacer, TRUE, TRUE, 0);
 
440
 
 
441
        pager->buttonboxes[0] = gtk_hbox_new (TRUE, 2);
 
442
        gtk_widget_show (pager->buttonboxes[0]);
 
443
        gtk_box_pack_start (GTK_BOX (pager->box), pager->buttonboxes[0],
 
444
                            FALSE, FALSE, 2);
 
445
 
 
446
        pager->buttonboxes[1] = gtk_hbox_new (TRUE, 2);
 
447
        gtk_widget_show (pager->buttonboxes[1]);
 
448
        gtk_box_pack_start (GTK_BOX (pager->box), pager->buttonboxes[1],
 
449
                            FALSE, FALSE, 0);
 
450
 
 
451
        spacer = gtk_alignment_new (0, 0, 0, 0);
 
452
        gtk_widget_show (spacer);
 
453
        gtk_box_pack_start (GTK_BOX (pager->box), spacer, TRUE, TRUE, 0);
 
454
    }
 
455
    else
 
456
    {
 
457
        pager->box = pager->buttonboxes[0] = gtk_vbox_new (TRUE, 2);
 
458
        gtk_widget_show (pager->box);
 
459
    }
 
460
 
 
461
    for (i = 0; i < n; i++)
 
462
    {
 
463
        /* no callbacks yet */
 
464
        cde_pager_add_button (pager, NULL, names);
 
465
    }
 
466
 
 
467
    return pager;
 
468
}
 
469
 
 
470
static void
 
471
cde_pager_free (CdePager * pager)
 
472
{
 
473
    GList *li;
 
474
 
 
475
    for (li = pager->buttons; li; li = li->next)
 
476
    {
 
477
        ScreenButton *sb = li->data;
 
478
 
 
479
        screen_button_free (sb);
 
480
    }
 
481
 
 
482
    g_list_free (pager->buttons);
 
483
    g_free (pager);
 
484
}
 
485
 
 
486
/*  Desktop switcher
 
487
 *  ----------------
 
488
*/
 
489
 
 
490
/* static prototypes */
 
491
static void arrange_switcher (t_switcher * sw);
 
492
 
 
493
/* settings */
 
494
static void
 
495
switcher_set_size (Control * control, int size)
 
496
{
 
497
    t_switcher *sw;
 
498
 
 
499
    gtk_widget_set_size_request (control->base, -1, -1);
 
500
 
 
501
    sw = control->data;
 
502
 
 
503
    cde_pager_update_size (sw->cde_pager);
 
504
}
 
505
 
 
506
static void
 
507
switcher_set_orientation (Control * control, int orientation)
 
508
{
 
509
    t_switcher *sw;
 
510
 
 
511
    sw = control->data;
 
512
 
 
513
    arrange_switcher (sw);
 
514
    switcher_set_size (control, settings.size);
 
515
}
 
516
 
 
517
/*  creation, destruction and configuration 
 
518
 *  ---------------------------------------
 
519
*/
 
520
static void
 
521
switcher_attach_callback (Control * control, const char *signal,
 
522
                          GCallback callback, gpointer data)
 
523
{
 
524
    SignalCallback *sc;
 
525
    t_switcher *sw;
 
526
 
 
527
    sw = control->data;
 
528
 
 
529
    sc = signal_callback_new (signal, callback, data);
 
530
    sw->callbacks = g_list_append (sw->callbacks, sc);
 
531
 
 
532
    cde_pager_attach_callback (sw->cde_pager, sc);
 
533
}
 
534
 
 
535
static void
 
536
arrange_switcher (t_switcher * sw)
 
537
{
 
538
    GList *li;
 
539
    gboolean vertical = settings.orientation == VERTICAL;
 
540
 
 
541
    /* destroy existing widgets */
 
542
    if (sw->box)
 
543
    {
 
544
        cde_pager_free (sw->cde_pager);
 
545
 
 
546
        gtk_widget_destroy (sw->box);
 
547
    }
 
548
 
 
549
    /* then create new ones */
 
550
    if (vertical)
 
551
    {
 
552
        sw->box = gtk_vbox_new (FALSE, 1);
 
553
/*      sw->separators[0] = gtk_hseparator_new ();
 
554
        sw->separators[1] = gtk_hseparator_new ();*/
 
555
    }
 
556
    else
 
557
    {
 
558
        sw->box = gtk_hbox_new (FALSE, 0);
 
559
/*      sw->separators[0] = gtk_vseparator_new ();
 
560
        sw->separators[1] = gtk_vseparator_new ();*/
 
561
    }
 
562
 
 
563
    sw->cde_pager = create_cde_pager (sw->screen, sw->screen_names);
 
564
 
 
565
    /* show the widgets */
 
566
    gtk_widget_show (sw->box);
 
567
 
 
568
/*    gtk_widget_show (sw->separators[0]);
 
569
    gtk_widget_show (sw->separators[1]);
 
570
*/
 
571
    /* packing the widgets */
 
572
    gtk_container_add (GTK_CONTAINER (sw->frame), sw->box);
 
573
 
 
574
/*    gtk_box_pack_start (GTK_BOX (sw->box), sw->separators[0], TRUE, TRUE, 2);
 
575
*/
 
576
    gtk_box_pack_start (GTK_BOX (sw->box), sw->cde_pager->box, TRUE, TRUE, 2);
 
577
 
 
578
/*    gtk_box_pack_start (GTK_BOX (sw->box), sw->separators[1], TRUE, TRUE, 2);
 
579
*/
 
580
    /* attach callbacks */
 
581
    for (li = sw->callbacks; li; li = li->next)
 
582
    {
 
583
        SignalCallback *cb = li->data;
 
584
 
 
585
        cde_pager_attach_callback (sw->cde_pager, cb);
 
586
    }
 
587
}
 
588
 
 
589
/* callbacks */
 
590
static void
 
591
switcher_set_current_screen (NetkScreen * screen, t_switcher * sw)
 
592
{
 
593
    NetkWorkspace *ws;
 
594
 
 
595
    ws = netk_screen_get_active_workspace (sw->screen);
 
596
 
 
597
    cde_pager_set_active (sw->cde_pager, ws);
 
598
}
 
599
 
 
600
static void
 
601
switcher_screen_created (NetkScreen * screen, NetkWorkspace * ws,
 
602
                         t_switcher * sw)
 
603
{
 
604
    cde_pager_add_button (sw->cde_pager, sw->callbacks, sw->screen_names);
 
605
}
 
606
 
 
607
static void
 
608
switcher_screen_destroyed (NetkScreen * screen, NetkWorkspace * ws,
 
609
                           t_switcher * sw)
 
610
{
 
611
    cde_pager_remove_button (sw->cde_pager);
 
612
}
 
613
 
 
614
t_switcher *
 
615
switcher_new (NetkScreen * screen)
 
616
{
 
617
    t_switcher *sw = g_new0 (t_switcher, 1);
 
618
 
 
619
    sw->screen = screen;
 
620
 
 
621
    sw->screen_names =
 
622
        g_ptr_array_sized_new (netk_screen_get_workspace_count (screen));
 
623
 
 
624
    sw->frame = gtk_alignment_new (0.5, 0.5, 0.8, 0.8);
 
625
    gtk_widget_show (sw->frame);
 
626
 
 
627
    /* this creates all widgets */
 
628
    arrange_switcher (sw);
 
629
 
 
630
    sw->ws_changed_id =
 
631
        g_signal_connect (sw->screen, "active-workspace-changed",
 
632
                          G_CALLBACK (switcher_set_current_screen), sw);
 
633
 
 
634
    sw->ws_created_id =
 
635
        g_signal_connect (sw->screen, "workspace-created",
 
636
                          G_CALLBACK (switcher_screen_created), sw);
 
637
 
 
638
    sw->ws_destroyed_id =
 
639
        g_signal_connect (sw->screen, "workspace-destroyed",
 
640
                          G_CALLBACK (switcher_screen_destroyed), sw);
 
641
 
 
642
    return sw;
 
643
}
 
644
 
 
645
static void
 
646
switcher_free (Control * control)
 
647
{
 
648
    GList *li;
 
649
    t_switcher *sw;
 
650
 
 
651
    sw = control->data;
 
652
 
 
653
    g_signal_handler_disconnect (sw->screen, sw->ws_changed_id);
 
654
    g_signal_handler_disconnect (sw->screen, sw->ws_created_id);
 
655
    g_signal_handler_disconnect (sw->screen, sw->ws_destroyed_id);
 
656
 
 
657
    cde_pager_free (sw->cde_pager);
 
658
 
 
659
    for (li = sw->callbacks; li; li = li->next)
 
660
        g_free (li->data);
 
661
 
 
662
    g_list_free (sw->callbacks);
 
663
 
 
664
    g_free (sw);
 
665
}
 
666
 
 
667
/*  Switcher panel control
 
668
 *  ----------------------
 
669
*/
 
670
gboolean
 
671
create_switcher_control (Control * control)
 
672
{
 
673
    t_switcher *sw;
 
674
    NetkScreen *screen;
 
675
 
 
676
    screen = netk_screen_get_default ();
 
677
 
 
678
    netk_screen_force_update (screen);
 
679
    sw = switcher_new (screen);
 
680
    netk_screen_force_update (screen);
 
681
 
 
682
    gtk_container_add (GTK_CONTAINER (control->base), sw->frame);
 
683
 
 
684
    control->data = sw;
 
685
    control->with_popup = FALSE;
 
686
 
 
687
    switcher_set_size (control, settings.size);
 
688
 
 
689
    return TRUE;
 
690
}
 
691
 
 
692
G_MODULE_EXPORT void
 
693
xfce_control_class_init (ControlClass * cc)
 
694
{
 
695
    cc->name = "switcher";
 
696
    cc->caption = _("Desktop switcher");
 
697
 
 
698
    cc->create_control = (CreateControlFunc) create_switcher_control;
 
699
 
 
700
    cc->free = switcher_free;
 
701
    cc->attach_callback = switcher_attach_callback;
 
702
 
 
703
    cc->set_orientation = switcher_set_orientation;
 
704
    cc->set_size = switcher_set_size;
 
705
}
 
706
 
 
707
 
 
708
XFCE_PLUGIN_CHECK_INIT