~ubuntu-branches/debian/experimental/xfdesktop4/experimental

« back to all changes in this revision

Viewing changes to panel-plugin/desktop-menu-plugin.c

  • Committer: Bazaar Package Importer
  • Author(s): Yves-Alexis Perez, Yves-Alexis Perez, Lionel Le Folgoc
  • Date: 2011-02-07 00:17:47 UTC
  • mfrom: (1.4.9 upstream) (5.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20110207001747-htl6rhaglfhhik8g
Tags: 4.8.1-1
[ Yves-Alexis Perez ]
* New upstream development release.
* debian/control:
  - update standards version to 3.9.1.
  - refresh build-deps for Xfce 4.7.
  - add build dep on libxfce4ui-1-dev.
  - drop xfce4-panel build-dep since we don't build any plugin anymore.
  - add build-dep on hardening-includes.
* Switch to 3.0 (quilt) source format.
* debian/rules:
  - pick {C,LD}FLAGS from dpkg-buildflags.
  - drop --libexecdir, --disable-rpath and --enable-final from configure args.
  - drop usr/lib from chrpath call, it doesn't exist anymore.
  - don't rename generic terminal .desktop file, it's gone too.
  - pass docdir to configure.
  - add hardening flags to {C,LD}FLAGS
* debian/xfdesktop4-data.install:
  - drop usr/share/desktop-directories from install file.
* debian/xfdesktop4.install:
  - drop etc/ no menu is installed anymore.
  - drop usr/ too, no more desktop menu module nor panel plugin. 
* debian/copyright updated for new upstream release.

[ Lionel Le Folgoc ]
* New upstream bugfix release.
* debian/control: clean up build-deps since xfdesktop has been ported to gio,
  exo-1 and garcon.
* Refresh build-deps for Xfce 4.8.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/*
2
 
 *  desktop-menu-plugin.c - xfce4-panel plugin that displays the desktop menu
3
 
 *
4
 
 *  Copyright (C) 2004 Brian Tarricone, <bjt23@cornell.edu>
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; either version 2 of the License, or
9
 
 *  (at your option) any later version.
10
 
 *
11
 
 *  This program is distributed in the hope that it will be useful,
12
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 *  GNU Library General Public License for more details.
15
 
 *
16
 
 *  You should have received a copy of the GNU General Public License
17
 
 *  along with this program; if not, write to the Free Software
18
 
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19
 
 *
20
 
 *  Contributors:
21
 
 *    Jean-Francois Wauthy (option panel for choice between icon/text)
22
 
 *    Jasper Huijsmans (menu placement function, toggle button, scaled image
23
 
 *                      fixes)
24
 
 *    Olivier Fourdan  (remote popup)
25
 
 */
26
 
 
27
 
#include <gtk/gtk.h>
28
 
#include <glib.h>
29
 
#include <gdk/gdkx.h>
30
 
#include <X11/Xlib.h>
31
 
 
32
 
#ifdef HAVE_CONFIG_H
33
 
#include <config.h>
34
 
#endif
35
 
 
36
 
#ifdef HAVE_UNISTD_H
37
 
#include <unistd.h>
38
 
#endif
39
 
 
40
 
#ifdef HAVE_STRING_H
41
 
#include <string.h>
42
 
#endif
43
 
 
44
 
#ifdef HAVE_STDLIB_H
45
 
#include <stdlib.h>
46
 
#endif
47
 
 
48
 
#ifndef PATH_MAX
49
 
#define PATH_MAX 4096
50
 
#endif
51
 
 
52
 
#include <libxfcegui4/libxfcegui4.h>
53
 
#include <libxfce4panel/xfce-panel-plugin.h>
54
 
#include <libxfce4panel/xfce-panel-convenience.h>
55
 
 
56
 
#ifdef HAVE_THUNAR_VFS
57
 
#include <thunar-vfs/thunar-vfs.h>
58
 
#endif
59
 
 
60
 
#include "desktop-menu-stub.h"
61
 
#include "xfdesktop-common.h"
62
 
#include "xfce4-popup-menu.h"
63
 
 
64
 
#define BORDER 8
65
 
#define DEFAULT_BUTTON_ICON  DATADIR "/pixmaps/xfce4_xicon1.png"
66
 
#define DEFAULT_BUTTON_TITLE "Xfce Menu"
67
 
 
68
 
/* this'll only allow one copy of the plugin; useful for forcing the
69
 
 * xfce4-popup-menu keybind to work with only one plugin */
70
 
/* #define CHECK_RUNNING_PLUGIN */
71
 
 
72
 
typedef struct _DMPlugin {
73
 
    XfcePanelPlugin *plugin;
74
 
    
75
 
    GtkWidget *button;
76
 
    GtkWidget *box;
77
 
    GtkWidget *image;
78
 
    GtkWidget *label;
79
 
    XfceDesktopMenu *desktop_menu;
80
 
    gboolean use_default_menu;
81
 
    gchar *menu_file;
82
 
    gchar *icon_file;
83
 
    gboolean show_menu_icons;
84
 
    gchar *button_title;
85
 
    gboolean show_button_title;
86
 
    
87
 
    GtkWidget *file_entry;
88
 
    GtkWidget *icon_entry;
89
 
    GtkWidget *icons_chk;
90
 
    GtkTooltips *tooltip;  /* needed? */
91
 
} DMPlugin;
92
 
 
93
 
 
94
 
static gchar *
95
 
dmp_get_real_path(const gchar *raw_path)
96
 
{
97
 
    if(!raw_path)
98
 
        return NULL;
99
 
    
100
 
    if(strstr(raw_path, "$XDG_CONFIG_DIRS/") == raw_path)
101
 
        return xfce_resource_lookup(XFCE_RESOURCE_CONFIG, raw_path+17);
102
 
    else if(strstr(raw_path, "$XDG_CONFIG_HOME/") == raw_path)
103
 
        return xfce_resource_save_location(XFCE_RESOURCE_CONFIG, raw_path+17, FALSE);
104
 
    else if(strstr(raw_path, "$XDG_DATA_DIRS/") == raw_path)
105
 
        return xfce_resource_lookup(XFCE_RESOURCE_DATA, raw_path+15);
106
 
    else if(strstr(raw_path, "$XDG_DATA_HOME/") == raw_path)
107
 
        return xfce_resource_save_location(XFCE_RESOURCE_DATA, raw_path+15, FALSE);
108
 
    else if(strstr(raw_path, "$XDG_CACHE_HOME/") == raw_path)
109
 
        return xfce_resource_save_location(XFCE_RESOURCE_CACHE, raw_path+16, FALSE);
110
 
    
111
 
    return xfce_expand_variables(raw_path, NULL);
112
 
}
113
 
 
114
 
static GdkPixbuf *
115
 
dmp_get_icon(const gchar *icon_name, gint size, GtkOrientation orientation)
116
 
{
117
 
    GdkPixbuf *pix = NULL;
118
 
    gchar *filename;
119
 
    gint w, h;
120
 
    
121
 
    filename = xfce_themed_icon_lookup(icon_name, size);
122
 
    if(!filename)
123
 
        return NULL;
124
 
    
125
 
#if GTK_CHECK_VERSION(2, 8, 0)
126
 
    w = orientation == GTK_ORIENTATION_HORIZONTAL ? -1 : size;
127
 
    h = orientation == GTK_ORIENTATION_VERTICAL ? -1 : size;
128
 
    pix = gdk_pixbuf_new_from_file_at_scale(filename, w, h, TRUE, NULL);
129
 
#else
130
 
    pix = gdk_pixbuf_new_from_file(filename, NULL);
131
 
    if(pix) {
132
 
        GdkPixbuf *tmp;
133
 
        gdouble aspect;
134
 
        
135
 
        w = gdk_pixbuf_get_width(pix);
136
 
        h = gdk_pixbuf_get_height(pix);
137
 
        aspect = (gdouble)w / h;
138
 
        
139
 
        w = orientation == GTK_ORIENTATION_HORIZONTAL ? size*aspect : size;
140
 
        h = orientation == GTK_ORIENTATION_VERTICAL ? size*aspect : size;
141
 
        
142
 
        tmp = gdk_pixbuf_scale_simple(pix, w, h, GDK_INTERP_BILINEAR);
143
 
        g_object_unref(G_OBJECT(pix));
144
 
        pix = tmp;
145
 
    }
146
 
#endif
147
 
    
148
 
    g_free(filename);
149
 
    
150
 
    return pix;
151
 
}
152
 
 
153
 
static void
154
 
dmp_set_size(XfcePanelPlugin *plugin, gint wsize, DMPlugin *dmp)
155
 
{
156
 
    gint width, height, size, pix_w = 0, pix_h = 0;
157
 
    GtkOrientation orientation = xfce_panel_plugin_get_orientation(plugin);
158
 
    
159
 
    size = wsize - MAX(GTK_WIDGET(dmp->button)->style->xthickness,
160
 
                       GTK_WIDGET(dmp->button)->style->ythickness) - 1;
161
 
    
162
 
    DBG("wsize: %d, size: %d", wsize, size);
163
 
    
164
 
    if(dmp->icon_file) {
165
 
        GdkPixbuf *pix = dmp_get_icon(dmp->icon_file, size, orientation);
166
 
        if(pix) {
167
 
            pix_w = gdk_pixbuf_get_width(pix);
168
 
            pix_h = gdk_pixbuf_get_height(pix);
169
 
            gtk_image_set_from_pixbuf(GTK_IMAGE(dmp->image), pix);
170
 
            g_object_unref(G_OBJECT(pix));
171
 
        }
172
 
    }
173
 
    
174
 
    width = pix_w + (wsize - size);
175
 
    height = pix_h + (wsize - size);
176
 
    
177
 
    if(dmp->show_button_title) {
178
 
        GtkRequisition req;
179
 
        
180
 
        gtk_widget_size_request(dmp->label, &req);
181
 
        if(orientation == GTK_ORIENTATION_HORIZONTAL)
182
 
            width += req.width + BORDER / 2;
183
 
        else {
184
 
            width = (width > req.width ? width : req.width
185
 
                     + GTK_WIDGET(dmp->label)->style->xthickness);
186
 
            height += req.height + BORDER / 2;
187
 
        }
188
 
    }
189
 
    
190
 
    if(dmp->icon_file && dmp->show_button_title) {
191
 
        gint delta = gtk_box_get_spacing(GTK_BOX(dmp->box));
192
 
        
193
 
        if(orientation == GTK_ORIENTATION_HORIZONTAL)
194
 
            width += delta;
195
 
        else
196
 
            height += delta;
197
 
    }
198
 
    
199
 
    DBG("width: %d, height: %d", width, height);
200
 
    
201
 
    gtk_widget_set_size_request(dmp->button, width, height);
202
 
}
203
 
 
204
 
static void
205
 
dmp_set_orientation(XfcePanelPlugin *plugin,
206
 
                    GtkOrientation orientation,
207
 
                    DMPlugin *dmp)
208
 
{
209
 
    if(!dmp->show_button_title)
210
 
        return;
211
 
    
212
 
    gtk_widget_set_size_request(dmp->button, -1, -1);
213
 
    
214
 
    gtk_container_remove(GTK_CONTAINER(dmp->button),
215
 
            gtk_bin_get_child(GTK_BIN(dmp->button)));
216
 
    
217
 
    if(xfce_panel_plugin_get_orientation(plugin) == GTK_ORIENTATION_HORIZONTAL)
218
 
        dmp->box = gtk_hbox_new(FALSE, BORDER / 2);
219
 
    else
220
 
        dmp->box = gtk_vbox_new(FALSE, BORDER / 2);
221
 
    gtk_container_set_border_width(GTK_CONTAINER(dmp->box), 0);
222
 
    gtk_widget_show(dmp->box);
223
 
    gtk_container_add(GTK_CONTAINER(dmp->button), dmp->box);
224
 
    
225
 
    gtk_widget_show(dmp->image);
226
 
    gtk_box_pack_start(GTK_BOX(dmp->box), dmp->image, TRUE, TRUE, 0);
227
 
    gtk_widget_show(dmp->label);
228
 
    gtk_box_pack_start(GTK_BOX(dmp->box), dmp->label, TRUE, TRUE, 0);
229
 
    
230
 
    dmp_set_size(plugin, xfce_panel_plugin_get_size(plugin), dmp);
231
 
}
232
 
 
233
 
static void
234
 
show_title_toggled_cb(GtkToggleButton *tb, gpointer user_data)
235
 
{
236
 
    DMPlugin *dmp = user_data;
237
 
    
238
 
    dmp->show_button_title = gtk_toggle_button_get_active(tb);
239
 
    
240
 
    if(dmp->show_button_title)
241
 
        dmp_set_orientation(dmp->plugin, xfce_panel_plugin_get_orientation(dmp->plugin), dmp);
242
 
    else {
243
 
        gtk_widget_hide(dmp->label);
244
 
        dmp_set_size(dmp->plugin, xfce_panel_plugin_get_size(dmp->plugin), dmp);
245
 
    }
246
 
}
247
 
 
248
 
static void
249
 
dmp_free(XfcePanelPlugin *plugin, DMPlugin *dmp)
250
 
{
251
 
    if(dmp->desktop_menu)
252
 
        xfce_desktop_menu_destroy(dmp->desktop_menu);
253
 
    if(dmp->tooltip)
254
 
        gtk_object_sink(GTK_OBJECT(dmp->tooltip));
255
 
    
256
 
    if(dmp->menu_file)
257
 
        g_free(dmp->menu_file);
258
 
    if(dmp->icon_file)
259
 
        g_free(dmp->icon_file);
260
 
    if(dmp->button_title)
261
 
        g_free(dmp->button_title);
262
 
    
263
 
    g_free(dmp);
264
 
}
265
 
 
266
 
static void
267
 
dmp_position_menu (GtkMenu *menu, int *x, int *y, gboolean *push_in, 
268
 
                   DMPlugin *dmp)
269
 
{
270
 
    XfceScreenPosition pos;
271
 
    GtkRequisition req;
272
 
 
273
 
    gtk_widget_size_request(GTK_WIDGET(menu), &req);
274
 
 
275
 
    gdk_window_get_origin (GTK_WIDGET (dmp->plugin)->window, x, y);
276
 
 
277
 
    pos = xfce_panel_plugin_get_screen_position(dmp->plugin);
278
 
 
279
 
    switch(pos) {
280
 
        case XFCE_SCREEN_POSITION_NW_V:
281
 
        case XFCE_SCREEN_POSITION_W:
282
 
        case XFCE_SCREEN_POSITION_SW_V:
283
 
            *x += dmp->button->allocation.width;
284
 
            *y += dmp->button->allocation.height - req.height;
285
 
            break;
286
 
        
287
 
        case XFCE_SCREEN_POSITION_NE_V:
288
 
        case XFCE_SCREEN_POSITION_E:
289
 
        case XFCE_SCREEN_POSITION_SE_V:
290
 
            *x -= req.width;
291
 
            *y += dmp->button->allocation.height - req.height;
292
 
            break;
293
 
        
294
 
        case XFCE_SCREEN_POSITION_NW_H:
295
 
        case XFCE_SCREEN_POSITION_N:
296
 
        case XFCE_SCREEN_POSITION_NE_H:
297
 
            *y += dmp->button->allocation.height;
298
 
            break;
299
 
        
300
 
        case XFCE_SCREEN_POSITION_SW_H:
301
 
        case XFCE_SCREEN_POSITION_S:
302
 
        case XFCE_SCREEN_POSITION_SE_H:
303
 
            *y -= req.height;
304
 
            break;
305
 
        
306
 
        default:  /* floating */
307
 
        {
308
 
            GdkScreen *screen = NULL;
309
 
            gint screen_width, screen_height;
310
 
 
311
 
            gdk_display_get_pointer(gtk_widget_get_display(GTK_WIDGET(dmp->plugin)),
312
 
                                                           &screen, x, y, NULL);
313
 
            screen_width = gdk_screen_get_width(screen);
314
 
            screen_height = gdk_screen_get_height(screen);
315
 
            if ((*x + req.width) > screen_width)
316
 
                *x -= req.width;
317
 
            if ((*y + req.height) > screen_height)
318
 
                *y -= req.height;
319
 
        }
320
 
    }
321
 
 
322
 
    if (*x < 0)
323
 
        *x = 0;
324
 
 
325
 
    if (*y < 0)
326
 
        *y = 0;
327
 
 
328
 
    /* TODO: wtf is this ? */
329
 
    *push_in = FALSE;
330
 
}
331
 
 
332
 
static gboolean
333
 
menu_destroy_idled(gpointer data)
334
 
{
335
 
    gtk_widget_destroy(GTK_WIDGET(data));
336
 
    return FALSE;
337
 
}
338
 
 
339
 
static void
340
 
menu_deactivated(GtkWidget *menu, gpointer user_data)
341
 
{
342
 
    DMPlugin *dmp = user_data;
343
 
 
344
 
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dmp->button), FALSE);
345
 
    g_idle_add(menu_destroy_idled, menu);
346
 
}
347
 
 
348
 
static void
349
 
menu_activate(DMPlugin *dmp, gboolean at_pointer)
350
 
{
351
 
    GtkWidget *menu;
352
 
    GtkWidget *button;
353
 
    
354
 
    button = dmp->button;
355
 
    if(!dmp->desktop_menu) {
356
 
        g_critical("dmp->desktop_menu is NULL - module load failed?");
357
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), FALSE);
358
 
    }
359
 
    
360
 
    if(xfce_desktop_menu_need_update(dmp->desktop_menu))
361
 
        xfce_desktop_menu_force_regen(dmp->desktop_menu);
362
 
 
363
 
    menu = xfce_desktop_menu_get_widget(dmp->desktop_menu);
364
 
    if(menu) {
365
 
        g_signal_connect(menu, "deactivate", 
366
 
                         G_CALLBACK(menu_deactivated), dmp);
367
 
        if (!at_pointer)
368
 
          gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
369
 
        xfce_panel_plugin_register_menu (dmp->plugin, GTK_MENU(menu));
370
 
        gtk_menu_popup(GTK_MENU(menu), NULL, NULL,
371
 
                       (GtkMenuPositionFunc)(at_pointer ? NULL : dmp_position_menu),
372
 
                       dmp, 1, gtk_get_current_event_time());
373
 
    } else
374
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), FALSE);
375
 
}
376
 
 
377
 
static gboolean
378
 
dmp_message_received(GtkWidget *w, 
379
 
                        GdkEventClient *evt, 
380
 
                        gpointer user_data)
381
 
{
382
 
    DMPlugin *dmp = user_data;
383
 
    GdkScreen *gscreen;
384
 
    GdkWindow *root;
385
 
    GtkWidget *button;
386
 
 
387
 
    button = dmp->button;
388
 
    gscreen = gtk_widget_get_screen (button);
389
 
    root = gdk_screen_get_root_window(gscreen);
390
 
    if(!xfdesktop_popup_grab_available(root, GDK_CURRENT_TIME))
391
 
    {
392
 
        g_critical("Unable to get keyboard/mouse grab.");
393
 
        return FALSE;
394
 
    }
395
 
 
396
 
    if(evt->data_format == 8) {
397
 
        if(strcmp(XFCE_MENU_MESSAGE, evt->data.b) == 0) {
398
 
            menu_activate(dmp, FALSE);
399
 
            return TRUE;
400
 
        }
401
 
        if(strcmp(XFCE_MENU_AT_POINTER_MESSAGE, evt->data.b) == 0) {
402
 
            menu_activate(dmp, TRUE);
403
 
            return TRUE;
404
 
        }
405
 
    }
406
 
 
407
 
    return FALSE;
408
 
}
409
 
 
410
 
static gboolean
411
 
dmp_popup(GtkWidget *w,
412
 
          GdkEventButton *evt,
413
 
          gpointer user_data)
414
 
{
415
 
    DMPlugin *dmp = user_data;
416
 
    
417
 
    if(evt->button != 1 || ((evt->state & GDK_CONTROL_MASK)
418
 
                            && !(evt->state & (GDK_MOD1_MASK|GDK_SHIFT_MASK
419
 
                                               |GDK_MOD4_MASK))))
420
 
    {
421
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), FALSE);
422
 
        return FALSE;
423
 
    }
424
 
 
425
 
    menu_activate(dmp, FALSE);
426
 
 
427
 
    return TRUE;
428
 
}
429
 
 
430
 
static void
431
 
dmp_set_defaults(DMPlugin *dmp)
432
 
{
433
 
    dmp->use_default_menu = TRUE;
434
 
    dmp->menu_file = NULL;
435
 
    dmp->icon_file = g_strdup(DEFAULT_BUTTON_ICON);
436
 
    dmp->show_menu_icons = TRUE;
437
 
    dmp->button_title = g_strdup(_(DEFAULT_BUTTON_TITLE));
438
 
    dmp->show_button_title = TRUE;
439
 
}
440
 
 
441
 
static void
442
 
dmp_read_config(XfcePanelPlugin *plugin, DMPlugin *dmp)
443
 
{
444
 
    gchar *cfgfile;
445
 
    XfceRc *rcfile;
446
 
    const gchar *value;
447
 
    
448
 
    if(!(cfgfile = xfce_panel_plugin_lookup_rc_file(plugin))) {
449
 
        dmp_set_defaults(dmp);
450
 
        return;
451
 
    }
452
 
    
453
 
    rcfile = xfce_rc_simple_open(cfgfile, TRUE);
454
 
    g_free(cfgfile);
455
 
    
456
 
    if(!rcfile) {
457
 
        dmp_set_defaults(dmp);
458
 
        return;
459
 
    }
460
 
    
461
 
    dmp->use_default_menu = xfce_rc_read_bool_entry(rcfile, "use_default_menu",
462
 
                                                    TRUE);
463
 
    
464
 
    value = xfce_rc_read_entry(rcfile, "menu_file", NULL);
465
 
    if(value) {
466
 
        g_free(dmp->menu_file);
467
 
        dmp->menu_file = g_strdup(value);
468
 
    } else
469
 
        dmp->use_default_menu = TRUE;
470
 
    
471
 
    value = xfce_rc_read_entry(rcfile, "icon_file", NULL);
472
 
    if(value) {
473
 
        g_free(dmp->icon_file);
474
 
        dmp->icon_file = g_strdup(value);
475
 
    } else
476
 
        dmp->icon_file = g_strdup(DEFAULT_BUTTON_ICON);
477
 
    
478
 
    dmp->show_menu_icons = xfce_rc_read_bool_entry(rcfile, "show_menu_icons",
479
 
                                                   TRUE);
480
 
    
481
 
    value = xfce_rc_read_entry(rcfile, "button_title", NULL);
482
 
    if(value) {
483
 
        g_free(dmp->button_title);
484
 
        dmp->button_title = g_strdup(value);
485
 
    } else
486
 
        dmp->button_title = g_strdup(_(DEFAULT_BUTTON_TITLE));
487
 
    
488
 
    dmp->show_button_title = xfce_rc_read_bool_entry(rcfile,
489
 
                                                     "show_button_title",
490
 
                                                     TRUE);
491
 
    
492
 
    xfce_rc_close(rcfile);
493
 
}
494
 
 
495
 
static void
496
 
dmp_write_config(XfcePanelPlugin *plugin, DMPlugin *dmp)
497
 
{
498
 
    gchar *cfgfile;
499
 
    XfceRc *rcfile;
500
 
    
501
 
    if(!(cfgfile = xfce_panel_plugin_save_location(plugin, TRUE)))
502
 
        return;
503
 
    
504
 
    rcfile = xfce_rc_simple_open(cfgfile, FALSE);
505
 
    g_free(cfgfile);
506
 
    
507
 
    xfce_rc_write_bool_entry(rcfile, "use_default_menu", dmp->use_default_menu);
508
 
    xfce_rc_write_entry(rcfile, "menu_file", dmp->menu_file ? dmp->menu_file : "");
509
 
    xfce_rc_write_entry(rcfile, "icon_file", dmp->icon_file ? dmp->icon_file : "");
510
 
    xfce_rc_write_bool_entry(rcfile, "show_menu_icons", dmp->show_menu_icons);
511
 
    xfce_rc_write_entry(rcfile, "button_title", dmp->button_title ? dmp->button_title : "");
512
 
    xfce_rc_write_bool_entry(rcfile, "show_button_title", dmp->show_button_title);
513
 
    
514
 
    xfce_rc_close(rcfile);
515
 
}
516
 
 
517
 
static void
518
 
dmp_menu_file_set(GtkFileChooser *fc,
519
 
                  gpointer user_data)
520
 
{
521
 
    DMPlugin *dmp = user_data;
522
 
 
523
 
    g_free(dmp->menu_file);
524
 
    dmp->menu_file = gtk_file_chooser_get_filename(fc);
525
 
    if(!dmp->menu_file|| !g_file_test(dmp->menu_file, G_FILE_TEST_EXISTS)) {
526
 
        g_free(dmp->menu_file);
527
 
        dmp->menu_file = NULL;
528
 
        return;
529
 
    }
530
 
 
531
 
    if(dmp->desktop_menu) {
532
 
        const gchar *cur_file = xfce_desktop_menu_get_menu_file(dmp->desktop_menu);
533
 
        if(strcmp(dmp->menu_file, cur_file)) {
534
 
            gchar *path;
535
 
            xfce_desktop_menu_destroy(dmp->desktop_menu);
536
 
            path = dmp_get_real_path(dmp->menu_file);
537
 
            dmp->desktop_menu = xfce_desktop_menu_new(path, TRUE);
538
 
            g_free(path);
539
 
            if(!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dmp->icons_chk)))
540
 
                xfce_desktop_menu_set_show_icons(dmp->desktop_menu, FALSE);
541
 
        }
542
 
    }
543
 
}
544
 
 
545
 
static void
546
 
dmp_icon_file_set(GtkFileChooser *fc,
547
 
                  gpointer user_data)
548
 
{
549
 
    DMPlugin *dmp = user_data;
550
 
 
551
 
    g_free(dmp->icon_file);
552
 
    dmp->icon_file = gtk_file_chooser_get_filename(fc);
553
 
 
554
 
    if(dmp->icon_file && *dmp->icon_file)
555
 
        dmp_set_size(dmp->plugin, xfce_panel_plugin_get_size(dmp->plugin), dmp);
556
 
    else
557
 
        gtk_image_set_from_pixbuf(GTK_IMAGE(dmp->image), NULL);            
558
 
}
559
 
 
560
 
static void
561
 
icon_chk_cb(GtkToggleButton *w, gpointer user_data)
562
 
{
563
 
    DMPlugin *dmp = user_data;
564
 
    
565
 
    dmp->show_menu_icons = gtk_toggle_button_get_active(w);
566
 
    if(dmp->desktop_menu)
567
 
        xfce_desktop_menu_set_show_icons(dmp->desktop_menu, dmp->show_menu_icons);
568
 
}
569
 
 
570
 
static void
571
 
dmp_use_desktop_menu_toggled_cb(GtkToggleButton *tb, gpointer user_data)
572
 
{
573
 
    DMPlugin *dmp = user_data;
574
 
    
575
 
    if(gtk_toggle_button_get_active(tb)) {
576
 
        GtkWidget *hbox;
577
 
        
578
 
        dmp->use_default_menu = TRUE;
579
 
        
580
 
        hbox = g_object_get_data(G_OBJECT(tb), "dmp-child-hbox");
581
 
        gtk_widget_set_sensitive(hbox, FALSE);
582
 
        
583
 
        if(dmp->desktop_menu)
584
 
            xfce_desktop_menu_destroy(dmp->desktop_menu);
585
 
        dmp->desktop_menu = xfce_desktop_menu_new(NULL, TRUE);
586
 
    }
587
 
}
588
 
 
589
 
static void
590
 
dmp_use_custom_menu_toggled_cb(GtkToggleButton *tb, gpointer user_data)
591
 
{
592
 
    DMPlugin *dmp = user_data;
593
 
    
594
 
    if(gtk_toggle_button_get_active(tb)) {
595
 
        GtkWidget *hbox;
596
 
        
597
 
        dmp->use_default_menu = FALSE;
598
 
        
599
 
        hbox = g_object_get_data(G_OBJECT(tb), "dmp-child-hbox");
600
 
        gtk_widget_set_sensitive(hbox, TRUE);
601
 
        
602
 
        if(dmp->menu_file && g_file_test(dmp->menu_file, G_FILE_TEST_EXISTS)) {
603
 
            if(dmp->desktop_menu)
604
 
                xfce_desktop_menu_destroy(dmp->desktop_menu);
605
 
            dmp->desktop_menu = xfce_desktop_menu_new(dmp->menu_file, TRUE);
606
 
        }
607
 
    }
608
 
}
609
 
 
610
 
static gboolean
611
 
dmp_button_title_focus_out_cb(GtkWidget *w, GdkEventFocus *evt,
612
 
        gpointer user_data)
613
 
{
614
 
    DMPlugin *dmp = user_data;
615
 
    
616
 
    if(dmp->button_title)
617
 
        g_free(dmp->button_title);
618
 
    dmp->button_title = gtk_editable_get_chars(GTK_EDITABLE(w), 0, -1);
619
 
    
620
 
    gtk_tooltips_set_tip(dmp->tooltip, dmp->button, dmp->button_title, NULL);
621
 
    gtk_label_set_text(GTK_LABEL(dmp->label), dmp->button_title);
622
 
    dmp_set_size(dmp->plugin, xfce_panel_plugin_get_size(dmp->plugin), dmp);
623
 
    
624
 
    return FALSE;
625
 
}
626
 
 
627
 
#if 0
628
 
static void
629
 
dmp_edit_menu_clicked_cb(GtkWidget *w, gpointer user_data)
630
 
{
631
 
    DMPlugin *dmp = user_data;
632
 
    GError *err = NULL;
633
 
    const gchar *menu_file = NULL;
634
 
    gchar cmd[PATH_MAX];
635
 
    
636
 
    g_return_if_fail(dmp && dmp->desktop_menu);
637
 
    
638
 
    
639
 
    if(dmp->use_default_menu)
640
 
        g_snprintf(cmd, PATH_MAX, "%s/xfce4-menueditor", BINDIR);
641
 
    else {
642
 
        menu_file = xfce_desktop_menu_get_menu_file(dmp->desktop_menu);
643
 
        if(!menu_file)
644
 
            return;
645
 
        g_snprintf(cmd, PATH_MAX, "%s/xfce4-menueditor \"%s\"", BINDIR,
646
 
                   menu_file);
647
 
    }
648
 
    
649
 
    if(xfce_exec(cmd, FALSE, FALSE, NULL))
650
 
        return;
651
 
    
652
 
    if(dmp->use_default_menu)
653
 
        g_strlcpy(cmd, "xfce4-menueditor", PATH_MAX);
654
 
    else
655
 
        g_snprintf(cmd, PATH_MAX, "xfce4-menueditor \"%s\"", menu_file);
656
 
    
657
 
    if(!xfce_exec(cmd, FALSE, FALSE, &err)) {
658
 
        xfce_warn(_("Unable to launch xfce4-menueditor: %s"), err->message);
659
 
        g_error_free(err);
660
 
    }
661
 
}
662
 
#endif
663
 
 
664
 
static void
665
 
dmp_options_dlg_response_cb(GtkDialog *dialog, gint response, DMPlugin *dmp)
666
 
{
667
 
    gtk_widget_destroy(GTK_WIDGET(dialog));
668
 
    xfce_panel_plugin_unblock_menu(dmp->plugin);
669
 
    dmp_write_config(dmp->plugin, dmp);
670
 
}
671
 
 
672
 
static GtkWidget *
673
 
dmp_create_file_chooser_button(DMPlugin *dmp,
674
 
                               gboolean is_icon)
675
 
{
676
 
    GtkWidget *chooser;
677
 
    GtkFileFilter *filter;
678
 
    const gchar *title;
679
 
    
680
 
    if(is_icon)
681
 
        title = _("Select Icon");
682
 
    else
683
 
        title = _("Select Menu File");
684
 
    
685
 
    chooser = gtk_file_chooser_button_new(title, GTK_FILE_CHOOSER_ACTION_OPEN);
686
 
 
687
 
    if(is_icon) {
688
 
        gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(chooser),
689
 
                DATADIR "/pixmaps", NULL);
690
 
    } else {
691
 
        gchar *dir;
692
 
 
693
 
        dir = xfce_resource_save_location(XFCE_RESOURCE_CONFIG, "menus/",
694
 
                                          FALSE);
695
 
        if(dir) {
696
 
            gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(chooser),
697
 
                                                 dir, NULL);
698
 
            g_free(dir);
699
 
        }
700
 
 
701
 
        dir = xfce_resource_lookup(XFCE_RESOURCE_CONFIG, "menus/");
702
 
        if(dir) {
703
 
            gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(chooser),
704
 
                                                 dir, NULL);
705
 
            g_free(dir);
706
 
        }
707
 
    }
708
 
 
709
 
    filter = gtk_file_filter_new();
710
 
    gtk_file_filter_set_name(filter, _("All Files"));
711
 
    gtk_file_filter_add_pattern(filter, "*");
712
 
    gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(chooser), filter);
713
 
    gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(chooser), filter);
714
 
 
715
 
    filter = gtk_file_filter_new();
716
 
    if(is_icon) {
717
 
        gtk_file_filter_set_name(filter, _("Image Files"));
718
 
        gtk_file_filter_add_pixbuf_formats(filter);
719
 
    } else {
720
 
        gtk_file_filter_set_name(filter, _("Menu Files"));
721
 
        gtk_file_filter_add_pattern(filter, "*.menu");
722
 
    }
723
 
    gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(chooser), filter);
724
 
    
725
 
#ifdef HAVE_LIBEXO
726
 
    if(is_icon)
727
 
        exo_gtk_file_chooser_add_thumbnail_preview(GTK_FILE_CHOOSER(chooser));
728
 
#endif
729
 
 
730
 
    gtk_widget_show(chooser);
731
 
 
732
 
    return chooser;
733
 
}
734
 
 
735
 
static void
736
 
dmp_create_options(XfcePanelPlugin *plugin, DMPlugin *dmp)
737
 
{
738
 
    GtkWidget *dlg, *topvbox, *vbox, *hbox, *frame, *frame_bin, *spacer;
739
 
    GtkWidget *label, *chk, *radio, *entry;
740
 
 
741
 
    xfce_textdomain (GETTEXT_PACKAGE, LOCALEDIR, "UTF-8");
742
 
    
743
 
    xfce_panel_plugin_block_menu(plugin);
744
 
    
745
 
    dlg = xfce_titled_dialog_new_with_buttons(_("Xfce Menu"),
746
 
                        GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(plugin))),
747
 
                        GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR,
748
 
                        GTK_STOCK_CLOSE, GTK_RESPONSE_ACCEPT, NULL);
749
 
    gtk_container_set_border_width(GTK_CONTAINER(dlg), 0);
750
 
    g_signal_connect(G_OBJECT(dlg), "response",
751
 
                     G_CALLBACK(dmp_options_dlg_response_cb), dmp);
752
 
    
753
 
    topvbox = gtk_vbox_new(FALSE, BORDER / 2);
754
 
    gtk_widget_show(topvbox);
755
 
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dlg)->vbox), topvbox, TRUE, TRUE, 0);
756
 
    
757
 
    frame = xfce_create_framebox(_("Button"), &frame_bin);
758
 
    gtk_widget_show(frame);
759
 
    gtk_box_pack_start(GTK_BOX(topvbox), frame, FALSE, FALSE, 0);
760
 
    
761
 
    vbox = gtk_vbox_new(FALSE, BORDER / 2);
762
 
    gtk_widget_show(vbox);
763
 
    gtk_container_add(GTK_CONTAINER(frame_bin), vbox);
764
 
    
765
 
    hbox = gtk_hbox_new(FALSE, BORDER / 2);
766
 
    gtk_container_set_border_width(GTK_CONTAINER(hbox), BORDER / 2);
767
 
    gtk_widget_show(hbox);
768
 
    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
769
 
    
770
 
    label = gtk_label_new_with_mnemonic(_("Button _title:"));
771
 
    gtk_widget_show(label);
772
 
    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
773
 
    
774
 
    entry = gtk_entry_new();
775
 
    if(dmp->button_title)
776
 
        gtk_entry_set_text(GTK_ENTRY(entry), dmp->button_title);
777
 
    gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry);
778
 
    gtk_widget_show(entry);
779
 
    gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
780
 
    g_signal_connect(G_OBJECT(entry), "focus-out-event",
781
 
            G_CALLBACK(dmp_button_title_focus_out_cb), dmp);
782
 
    
783
 
    chk = gtk_check_button_new_with_mnemonic(_("_Show title in button"));
784
 
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chk), dmp->show_button_title);
785
 
    gtk_widget_show(chk);
786
 
    gtk_box_pack_start(GTK_BOX(vbox), chk, FALSE, FALSE, 0);
787
 
    g_signal_connect(G_OBJECT(chk), "toggled",
788
 
            G_CALLBACK(show_title_toggled_cb), dmp);
789
 
    
790
 
    frame = xfce_create_framebox(_("Menu File"), &frame_bin);
791
 
    gtk_widget_show(frame);
792
 
    gtk_box_pack_start(GTK_BOX(topvbox), frame, FALSE, FALSE, 0);
793
 
    
794
 
    vbox = gtk_vbox_new(FALSE, BORDER / 2);
795
 
    gtk_widget_show(vbox);
796
 
    gtk_container_add(GTK_CONTAINER(frame_bin), vbox);
797
 
    
798
 
    /* 2nd radio button's child hbox */
799
 
    hbox = gtk_hbox_new(FALSE, BORDER / 2);
800
 
    gtk_widget_show(hbox);
801
 
    
802
 
    radio = gtk_radio_button_new_with_mnemonic(NULL, _("Use default _desktop menu file"));
803
 
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio), dmp->use_default_menu);
804
 
    gtk_widget_show(radio);
805
 
    gtk_box_pack_start(GTK_BOX(vbox), radio, FALSE, FALSE, 0);
806
 
    g_signal_connect(G_OBJECT(radio), "toggled",
807
 
            G_CALLBACK(dmp_use_desktop_menu_toggled_cb), dmp);
808
 
    g_object_set_data(G_OBJECT(radio), "dmp-child-hbox", hbox);
809
 
    
810
 
    radio = gtk_radio_button_new_with_mnemonic_from_widget(GTK_RADIO_BUTTON(radio),
811
 
            _("Use _custom menu file:"));
812
 
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio), !dmp->use_default_menu);
813
 
    gtk_widget_show(radio);
814
 
    gtk_box_pack_start(GTK_BOX(vbox), radio, FALSE, FALSE, 0);
815
 
    g_signal_connect(G_OBJECT(radio), "toggled",
816
 
            G_CALLBACK(dmp_use_custom_menu_toggled_cb), dmp);
817
 
    g_object_set_data(G_OBJECT(radio), "dmp-child-hbox", hbox);
818
 
    
819
 
    /* now pack in the child hbox */
820
 
    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
821
 
    
822
 
    spacer = gtk_alignment_new(0.5, 0.5, 1, 1);
823
 
    gtk_widget_show(spacer);
824
 
    gtk_box_pack_start(GTK_BOX(hbox), spacer, FALSE, FALSE, 0);
825
 
    gtk_widget_set_size_request(spacer, 16, -1);
826
 
    
827
 
    dmp->file_entry = dmp_create_file_chooser_button(dmp, FALSE);
828
 
    if(dmp->menu_file)
829
 
        gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dmp->file_entry), dmp->menu_file);
830
 
    else if(dmp->desktop_menu) {
831
 
        dmp->menu_file = g_strdup(xfce_desktop_menu_get_menu_file(dmp->desktop_menu));
832
 
        gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dmp->file_entry), dmp->menu_file);
833
 
    }
834
 
    gtk_label_set_mnemonic_widget(GTK_LABEL(label), dmp->file_entry);
835
 
    gtk_widget_show(dmp->file_entry);
836
 
    gtk_box_pack_start(GTK_BOX(hbox), dmp->file_entry, TRUE, TRUE, 3);
837
 
    g_signal_connect(G_OBJECT(dmp->file_entry), "file-set",
838
 
                     G_CALLBACK(dmp_menu_file_set), dmp);
839
 
    
840
 
    gtk_widget_set_sensitive(hbox, !dmp->use_default_menu);
841
 
    
842
 
#if 0  /* we don't have a menu editor anymore... */
843
 
    spacer = gtk_alignment_new(0.5, 0.5, 1, 1);
844
 
    gtk_widget_show(spacer);
845
 
    gtk_box_pack_start(GTK_BOX(vbox), spacer, FALSE, FALSE, 0);
846
 
    gtk_widget_set_size_request(spacer, -1, 4);
847
 
    
848
 
    hbox = gtk_hbox_new(FALSE, BORDER / 2);
849
 
    gtk_widget_show(hbox);
850
 
    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
851
 
    
852
 
    btn = xfce_create_mixed_button(GTK_STOCK_EDIT, _("_Edit Menu"));
853
 
    gtk_widget_show(btn);
854
 
    gtk_box_pack_end(GTK_BOX(hbox), btn, FALSE, FALSE, 0);
855
 
    g_signal_connect(G_OBJECT(btn), "clicked",
856
 
            G_CALLBACK(dmp_edit_menu_clicked_cb), dmp);
857
 
#endif
858
 
    
859
 
    frame = xfce_create_framebox(_("Icons"), &frame_bin);
860
 
    gtk_widget_show(frame);
861
 
    gtk_box_pack_start(GTK_BOX(topvbox), frame, FALSE, FALSE, 0);
862
 
    
863
 
    vbox = gtk_vbox_new(FALSE, BORDER / 2);
864
 
    gtk_widget_show(vbox);
865
 
    gtk_container_add(GTK_CONTAINER(frame_bin), vbox);
866
 
    
867
 
    hbox = gtk_hbox_new(FALSE, BORDER / 2);
868
 
    gtk_widget_show(hbox);
869
 
    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
870
 
    
871
 
    label = gtk_label_new_with_mnemonic(_("_Button icon:"));
872
 
    gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
873
 
    gtk_widget_show(label);
874
 
    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
875
 
    
876
 
    dmp->icon_entry = dmp_create_file_chooser_button(dmp, TRUE);
877
 
    if(dmp->icon_file)
878
 
        gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dmp->icon_entry), dmp->icon_file);
879
 
    gtk_label_set_mnemonic_widget(GTK_LABEL(label), dmp->icon_entry);
880
 
    gtk_widget_show(dmp->icon_entry);
881
 
    gtk_box_pack_start(GTK_BOX(hbox), dmp->icon_entry, TRUE, TRUE, 3);
882
 
    g_signal_connect(G_OBJECT(dmp->icon_entry), "file-set",
883
 
                     G_CALLBACK(dmp_icon_file_set), dmp);
884
 
    
885
 
    dmp->icons_chk = chk = gtk_check_button_new_with_mnemonic(_("Show _icons in menu"));
886
 
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chk), dmp->show_menu_icons);
887
 
    gtk_widget_show(chk);
888
 
    gtk_box_pack_start(GTK_BOX(vbox), chk, FALSE, FALSE, BORDER / 2);
889
 
    g_signal_connect(G_OBJECT(chk), "toggled", G_CALLBACK(icon_chk_cb), dmp);
890
 
    
891
 
    gtk_widget_show(dlg);
892
 
}
893
 
 
894
 
#ifdef XFCE_PANEL_PLUGIN_REGISTER_EXTERNAL_FULL
895
 
static gboolean
896
 
desktop_menu_plugin_preinit(int argc,
897
 
                            char **argv)
898
 
{
899
 
#ifdef HAVE_THUNAR_VFS
900
 
    g_thread_init(NULL);
901
 
#endif
902
 
    return TRUE;
903
 
}
904
 
#endif
905
 
 
906
 
static gboolean 
907
 
desktop_menu_plugin_check(GdkScreen *gscreen)
908
 
{
909
 
#ifdef CHECK_RUNNING_PLUGIN
910
 
    gchar selection_name[32];
911
 
    Atom selection_atom;
912
 
    
913
 
    g_snprintf(selection_name, 
914
 
               sizeof(selection_name), 
915
 
               XFCE_MENU_SELECTION"%d", 
916
 
               gdk_screen_get_number (gscreen));
917
 
    selection_atom = XInternAtom(GDK_DISPLAY(), selection_name, False);
918
 
 
919
 
    if(XGetSelectionOwner(GDK_DISPLAY(), selection_atom)) {
920
 
        xfce_info(_("There is already a panel menu registered for this screen"));
921
 
        return FALSE;
922
 
    }
923
 
#endif
924
 
 
925
 
    return TRUE;
926
 
}
927
 
 
928
 
static gboolean
929
 
dmp_set_selection(DMPlugin *dmp)
930
 
{
931
 
    GdkScreen *gscreen;
932
 
    gchar selection_name[32];
933
 
    Atom selection_atom;
934
 
    GtkWidget *win;
935
 
    Window xwin;
936
 
 
937
 
    win = gtk_invisible_new();
938
 
    gtk_widget_realize(win);
939
 
    xwin = GDK_WINDOW_XID(GTK_WIDGET(win)->window);
940
 
 
941
 
    gscreen = gtk_widget_get_screen (win);
942
 
    g_snprintf(selection_name, 
943
 
               sizeof(selection_name), 
944
 
               XFCE_MENU_SELECTION"%d", 
945
 
               gdk_screen_get_number (gscreen));
946
 
    selection_atom = XInternAtom(GDK_DISPLAY(), selection_name, False);
947
 
 
948
 
    if(XGetSelectionOwner(GDK_DISPLAY(), selection_atom)) {
949
 
        gtk_widget_destroy (win);
950
 
        return FALSE;
951
 
    }
952
 
 
953
 
    XSelectInput(GDK_DISPLAY(), xwin, PropertyChangeMask);
954
 
    XSetSelectionOwner(GDK_DISPLAY(), selection_atom, xwin, GDK_CURRENT_TIME);
955
 
 
956
 
    g_signal_connect(G_OBJECT(win), "client-event",
957
 
                     G_CALLBACK(dmp_message_received), dmp);
958
 
    
959
 
    return TRUE;
960
 
}
961
 
 
962
 
static DMPlugin *
963
 
dmp_new(XfcePanelPlugin *plugin)
964
 
{
965
 
    DMPlugin *dmp = g_new0(DMPlugin, 1);
966
 
 
967
 
    dmp->plugin = plugin;
968
 
    dmp_read_config(plugin, dmp);
969
 
    
970
 
    dmp->tooltip = gtk_tooltips_new();
971
 
    
972
 
    dmp->button = xfce_create_panel_toggle_button();
973
 
    gtk_widget_set_name(dmp->button, "xfce-menu-button");
974
 
    gtk_widget_show(dmp->button);
975
 
    gtk_tooltips_set_tip(dmp->tooltip, dmp->button, dmp->button_title, NULL);
976
 
    
977
 
    if(xfce_panel_plugin_get_orientation(plugin) == GTK_ORIENTATION_HORIZONTAL)
978
 
        dmp->box = gtk_hbox_new(FALSE, BORDER / 2);
979
 
    else
980
 
        dmp->box = gtk_vbox_new(FALSE, BORDER / 2);
981
 
    gtk_container_set_border_width(GTK_CONTAINER(dmp->box), 0);
982
 
    gtk_widget_show(dmp->box);
983
 
    gtk_container_add(GTK_CONTAINER(dmp->button), dmp->box);
984
 
    
985
 
    dmp->image = gtk_image_new();
986
 
    g_object_ref(G_OBJECT(dmp->image));
987
 
    gtk_widget_show(dmp->image);
988
 
    gtk_box_pack_start(GTK_BOX(dmp->box), dmp->image, TRUE, TRUE, 0);
989
 
    
990
 
    dmp->label = gtk_label_new(dmp->button_title);
991
 
    g_object_ref(G_OBJECT(dmp->label));
992
 
    if(dmp->show_button_title)
993
 
        gtk_widget_show(dmp->label);
994
 
    gtk_box_pack_start(GTK_BOX(dmp->box), dmp->label, TRUE, TRUE, 0);
995
 
    
996
 
    dmp->desktop_menu = xfce_desktop_menu_new(!dmp->use_default_menu
997
 
                                                ? dmp->menu_file : NULL,
998
 
                                              TRUE);
999
 
    if(dmp->desktop_menu) {
1000
 
        xfce_desktop_menu_set_show_icons(dmp->desktop_menu,
1001
 
                                         dmp->show_menu_icons);
1002
 
        xfce_desktop_menu_start_autoregen(dmp->desktop_menu, 10);
1003
 
    }
1004
 
    g_signal_connect(G_OBJECT(dmp->button), "button-press-event",
1005
 
            G_CALLBACK(dmp_popup), dmp);
1006
 
    dmp_set_selection(dmp);
1007
 
 
1008
 
    return dmp;
1009
 
}
1010
 
 
1011
 
static void
1012
 
desktop_menu_plugin_construct(XfcePanelPlugin *plugin)
1013
 
{
1014
 
    DMPlugin *dmp;
1015
 
#if 0
1016
 
    GtkWidget *mi, *img;
1017
 
#endif
1018
 
    
1019
 
    xfce_textdomain(GETTEXT_PACKAGE, LOCALEDIR, "UTF-8");
1020
 
    
1021
 
#ifdef HAVE_THUNAR_VFS
1022
 
    thunar_vfs_init();
1023
 
#endif
1024
 
    
1025
 
    if(!(dmp = dmp_new(plugin)))
1026
 
        exit(1);
1027
 
    
1028
 
    xfce_panel_plugin_add_action_widget(plugin, dmp->button);
1029
 
    gtk_container_add(GTK_CONTAINER(plugin), dmp->button);
1030
 
    
1031
 
#if 0
1032
 
    /* Add edit menu option to right click menu */
1033
 
    img = gtk_image_new_from_stock(GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
1034
 
    gtk_widget_show(img);
1035
 
    mi = gtk_image_menu_item_new_with_label(_("Edit Menu"));
1036
 
    gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mi), img);
1037
 
    gtk_widget_show(mi);
1038
 
    xfce_panel_plugin_menu_insert_item(plugin, GTK_MENU_ITEM(mi));
1039
 
    g_signal_connect(G_OBJECT(mi), "activate", 
1040
 
                     G_CALLBACK(dmp_edit_menu_clicked_cb), dmp);
1041
 
#endif
1042
 
    
1043
 
    g_signal_connect(plugin, "free-data",
1044
 
                     G_CALLBACK(dmp_free), dmp);
1045
 
    g_signal_connect(plugin, "save",
1046
 
                     G_CALLBACK(dmp_write_config), dmp);
1047
 
    g_signal_connect(plugin, "configure-plugin",
1048
 
                     G_CALLBACK(dmp_create_options), dmp);
1049
 
    g_signal_connect(plugin, "size-changed",
1050
 
                     G_CALLBACK(dmp_set_size), dmp);
1051
 
    g_signal_connect(plugin, "orientation-changed",
1052
 
                     G_CALLBACK(dmp_set_orientation), dmp);
1053
 
    
1054
 
    xfce_panel_plugin_menu_show_configure(plugin);
1055
 
    
1056
 
    dmp_set_size(plugin, xfce_panel_plugin_get_size(plugin), dmp);
1057
 
}
1058
 
 
1059
 
#ifdef XFCE_PANEL_PLUGIN_REGISTER_EXTERNAL_FULL
1060
 
XFCE_PANEL_PLUGIN_REGISTER_EXTERNAL_FULL(desktop_menu_plugin_construct,
1061
 
                                         desktop_menu_plugin_preinit,
1062
 
                                         desktop_menu_plugin_check)
1063
 
#else
1064
 
XFCE_PANEL_PLUGIN_REGISTER_EXTERNAL_WITH_CHECK(desktop_menu_plugin_construct,
1065
 
                                               desktop_menu_plugin_check)
1066
 
#endif