source: mate-xfce4-panel-plugin-loader-applet/trunk/fuentes/.pc/llx_last_pid.patch/src/mate-xfce4-panel-plugin-loader-applet.c @ 4960

Last change on this file since 4960 was 4960, checked in by hectorgh, 2 years ago

adding patches

File size: 19.0 KB
Line 
1/* mate-xfce4-panel-plugin-loader-applet.c:
2 *
3 * Copyright (C) 2015 Błażej Szczygieł <spaz16@wp.pl>
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation; either version 2 of the
8 * License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13 * 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., 51 Franklin St, Fifth Floor, Boston, MA
18 * 02110-1301, USA.
19 */
20
21/* Commom includes */
22#include <config.h>
23#include <glib/gi18n.h>
24#include <sys/stat.h>
25#include <dlfcn.h>
26
27/* Xfce4 include */
28#include <libxfce4panel/libxfce4panel.h>
29
30/* Mate include */
31#include <mate-panel-applet-gsettings.h>
32#include <mate-panel-applet.h>
33
34#define PANEL_SETTINGS_SCHEMA "org.mate.panel.applet.Xfce4PanelPluginLoader"
35#define PANEL_SETTINGS_KEY_FILENAME_SCHEMA "filename"
36#define XFCE4_ICON "xfce4-logo"
37
38/* Xfce4 plugin private struct from "xfce4-panel" source code */
39struct _XfcePanelPluginPrivate
40{
41        /* plugin information */
42        gchar               *name;
43        gchar               *display_name;
44        gchar               *comment;
45        gint                 unique_id;
46        gchar               *property_base;
47        gchar              **arguments;
48        gint                 size; /* single row size */
49        guint                expand : 1;
50        guint                shrink : 1;
51        guint                nrows;
52        XfcePanelPluginMode  mode;
53        guint                small : 1;
54        XfceScreenPosition   screen_position;
55        guint                locked : 1;
56        GSList              *menu_items;
57
58        /* flags for rembering states */
59        gint          flags; /* PluginFlags */
60
61        /* plugin right-click menu */
62        GtkMenu             *menu;
63
64        /* menu block counter (configure insensitive) */
65        gint                 menu_blocked;
66
67        /* autohide block counter */
68        gint                 panel_lock;
69};
70
71/* Mate panel private struct from "mate-panel" source code */
72struct _MatePanelAppletPrivate
73{
74        GtkWidget         *plug;
75        GtkWidget         *applet;
76        GDBusConnection   *connection;
77
78        char              *id;
79        GClosure          *closure;
80        char              *object_path;
81        guint              object_id;
82        char              *prefs_path;
83
84        GtkUIManager      *ui_manager;
85        GtkActionGroup    *applet_action_group;
86        GtkActionGroup    *panel_action_group;
87
88        MatePanelAppletFlags   flags;
89        MatePanelAppletOrient  orient;
90        guint              size;
91        char              *background;
92        GtkWidget         *background_widget;
93
94        int                previous_width;
95        int                previous_height;
96
97        int               *size_hints;
98        int                size_hints_len;
99
100        gboolean           moving_focus_out;
101
102        gboolean           locked;
103        gboolean           locked_down;
104};
105
106/* Global array */
107static int num_applets = 0;
108static gchar **xfce4_panel_plugin_filenames = NULL;
109
110/* Structure */
111typedef struct
112{
113        GSettings *settings;
114        GtkWidget *button;
115        int lib_name_pos;
116        MatePanelApplet *mate_applet;
117        XfcePanelPlugin *xfce_panel_plugin;
118} Xfce4PanelPluginLoader;
119
120/* Signal handlers from Mate panel */
121static void xfce4_panel_plugin_loader_handle_orient_change(gpointer mate_applet, MatePanelAppletOrient orient, XfcePanelPluginProvider *xfce_panel_plugin)
122{
123        (void)mate_applet;
124        static XfcePanelPluginMode mate_orient_to_xfce_position[] =
125        {
126                XFCE_PANEL_PLUGIN_MODE_HORIZONTAL,
127                XFCE_PANEL_PLUGIN_MODE_HORIZONTAL,
128                XFCE_PANEL_PLUGIN_MODE_VERTICAL,
129                XFCE_PANEL_PLUGIN_MODE_VERTICAL
130        };
131        xfce_panel_plugin_provider_set_mode(xfce_panel_plugin, mate_orient_to_xfce_position[orient]);
132
133}
134static void xfce4_panel_plugin_loader_handle_size_change(gpointer mate_applet, gint size, Xfce4PanelPluginLoader *xfce4_panel_plugin_loader)
135{
136        (void)mate_applet;
137        if (xfce4_panel_plugin_loader->xfce_panel_plugin)
138                xfce_panel_plugin_provider_set_size((XfcePanelPluginProvider *)xfce4_panel_plugin_loader->xfce_panel_plugin, size);
139        else if (xfce4_panel_plugin_loader->button)
140        {
141                GtkWidget *image = gtk_image_new();
142                GdkPixbuf *icon = xfce_panel_pixbuf_from_source_at_size(XFCE4_ICON, gtk_icon_theme_get_default(), size, size);
143                gtk_image_set_from_pixbuf(GTK_IMAGE(image), icon);
144                g_object_unref(G_OBJECT(icon));
145                gtk_button_set_image(GTK_BUTTON(xfce4_panel_plugin_loader->button), image);
146        }
147}
148static void xfce4_panel_plugin_loader_handle_dispose(MatePanelApplet *mate_applet, Xfce4PanelPluginLoader *xfce4_panel_plugin_loader)
149{
150        (void)mate_applet;
151        if (xfce4_panel_plugin_loader->xfce_panel_plugin)
152        {
153                /* Free information about the loaded library */
154                g_free(xfce4_panel_plugin_filenames[xfce4_panel_plugin_loader->lib_name_pos]);
155                xfce4_panel_plugin_filenames[xfce4_panel_plugin_loader->lib_name_pos] = NULL;
156
157                /* "xfce4_panel_plugin_loader->xfce_panel_plugin" - automatically destroys itself with "mate_applet" */
158                xfce4_panel_plugin_loader->xfce_panel_plugin = NULL;
159        }
160        /* "lib_handle" - unloading libraries is dangerous and causes crashes */
161        if (xfce4_panel_plugin_loader->button)
162                gtk_widget_destroy(GTK_WIDGET(xfce4_panel_plugin_loader->button));
163        if (xfce4_panel_plugin_loader->settings)
164                g_object_unref(xfce4_panel_plugin_loader->settings);
165        g_free(xfce4_panel_plugin_loader);
166
167        /* Free global array if can */
168        gboolean can_free = TRUE;
169        int i;
170        for (i = 0; i < num_applets; ++i)
171        {
172                if (xfce4_panel_plugin_filenames[i] != NULL)
173                {
174                        can_free = FALSE;
175                        break;
176                }
177        }
178        if (can_free)
179        {
180                g_free(xfce4_panel_plugin_filenames);
181                xfce4_panel_plugin_filenames = NULL;
182        }
183}
184
185/* Helper function for creating menu separator */
186static GtkWidget *create_separator()
187{
188        GtkWidget *separator = gtk_separator_menu_item_new();
189        gtk_widget_show(separator);
190        return separator;
191}
192
193/* Helper function to obtain library file name */
194static gchar *get_lib_file_name()
195{
196        const gchar *base_dir = NULL;
197        gchar *file_name = NULL;
198
199        /* Find Xfce4 panel plugins directory */
200        static const gchar base_dirs[][37] =
201        {
202#if defined(__x86_64__) || defined(_M_X64) //What about AArch64 and PPC64?
203                "/usr/lib64/xfce4/panel/plugins",
204                "/usr/local/lib64/xfce4/panel/plugins",
205#endif
206                "/usr/lib/xfce4/panel/plugins",
207                "/usr/local/lib/xfce4/panel/plugins",
208        };
209        struct stat sb;
210        if (!stat(base_dirs[0], &sb) && S_ISDIR(sb.st_mode))
211                base_dir = base_dirs[0];
212        else if (!stat(base_dirs[1], &sb) && S_ISDIR(sb.st_mode))
213                base_dir = base_dirs[1];
214#if defined(__x86_64__) || defined(_M_X64) //Some distros (like Arch Linux) have 64-bit libs in "lib" instead of "lib64" and sometimes symlink to "lib->lib64" may not exists.
215        else if (!stat(base_dirs[2], &sb) && S_ISDIR(sb.st_mode))
216                base_dir = base_dirs[2];
217        else if (!stat(base_dirs[3], &sb) && S_ISDIR(sb.st_mode))
218                base_dir = base_dirs[3];
219#endif
220
221        if (!base_dir)
222                base_dir = "/usr";
223
224        /* Show file dialog to choose the library */
225        GtkWidget *file_dialog = gtk_file_chooser_dialog_new(_("Open Xfce4 panel plugin library"), NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
226        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_dialog), base_dir);
227
228        GtkFileFilter *filter = gtk_file_filter_new();
229        gtk_file_filter_add_pattern(filter, "lib*.so");
230        gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(file_dialog), filter);
231
232        gint res = gtk_dialog_run(GTK_DIALOG(file_dialog));
233        if (res == GTK_RESPONSE_ACCEPT)
234                file_name = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_dialog));
235        gtk_widget_destroy(file_dialog);
236
237        return file_name;
238}
239
240/* Helper function to show message dialogs */
241static void show_message(const gchar *lib_name, const gchar *info_msg)
242{
243        gchar *msg = (gchar *)g_malloc(strlen(lib_name) + 2 + strlen(info_msg) + 1);
244        strcpy(msg, lib_name);
245        strcat(msg, ": ");
246        strcat(msg, info_msg);
247
248        GtkWidget *dlg = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, msg);
249        gtk_dialog_run(GTK_DIALOG(dlg));
250        gtk_widget_destroy(dlg);
251
252        g_free(msg);
253}
254
255/* Load Xfce4 applet */
256static XfcePanelPlugin *get_xfce_panel_plugin(const gchar *file_name)
257{
258        void *handle = dlopen(file_name, RTLD_LOCAL | RTLD_LAZY);
259        if (!handle)
260                show_message(file_name, _("cannot load the library!"));
261        else
262        {
263                PluginConstructFunc construct_func = dlsym(handle, "xfce_panel_module_construct");
264                if (!construct_func)
265                {
266                        if (dlsym(handle, "xfce_panel_module_init"))
267                                show_message(file_name, _("this plugin is not supported yet!"));
268                        else
269                                show_message(file_name, _("is not Xfce4 panel plugin library!"));
270                }
271                else
272                {
273                        const gchar *lib_name = strrchr(file_name, '/');
274                        size_t lib_name_len = strlen(lib_name);
275                        if (lib_name_len > 7)
276                        {
277                                lib_name += 4; //"/lib"
278                                lib_name_len -= 4;
279                                gchar *name = g_malloc(lib_name_len-3+1); //Discard ".so"
280                                memcpy(name, lib_name, lib_name_len-3);
281                                name[lib_name_len-3] = '\0';
282                                XfcePanelPlugin *xfce_panel_plugin = (XfcePanelPlugin *)construct_func(name, 0, NULL, NULL, NULL, gdk_screen_get_default());
283                                g_free(name);
284                                return xfce_panel_plugin;
285                        }
286                }
287                dlclose(handle);
288        }
289        return NULL;
290}
291static gboolean load_xfce4_panel_plugin(Xfce4PanelPluginLoader *xfce4_panel_plugin_loader, gchar *lib_file_name)
292{
293        /* Extract library file name from path */
294        const gchar *lib_name = strrchr(lib_file_name, '/');
295        if (lib_name)
296                ++lib_name;
297        else
298                lib_name = lib_file_name;
299
300        /* Check whether Xfce4 panel plugin is already loaded */
301        int i;
302        for (i = 0; i < num_applets; ++i)
303        {
304                if (xfce4_panel_plugin_filenames[i] == NULL)
305                        continue;
306                if (!strcmp(xfce4_panel_plugin_filenames[i], lib_name))
307                {
308                        show_message(lib_name, _("the library is already loaded!"));
309                        return FALSE;
310                }
311        }
312
313        /* Load Xfce4 panel plugin library */
314        XfcePanelPlugin *xfce_panel_plugin = get_xfce_panel_plugin(lib_file_name);
315        if (!xfce_panel_plugin)
316        {
317                g_settings_set_string(xfce4_panel_plugin_loader->settings, PANEL_SETTINGS_KEY_FILENAME_SCHEMA, "");
318                return FALSE;
319        }
320
321        /* Save data */
322        xfce4_panel_plugin_loader->xfce_panel_plugin = xfce_panel_plugin;
323        g_settings_set_string(xfce4_panel_plugin_loader->settings, PANEL_SETTINGS_KEY_FILENAME_SCHEMA, lib_file_name);
324
325        /* Delete button */
326        if (xfce4_panel_plugin_loader->button)
327        {
328                gtk_widget_destroy(GTK_WIDGET(xfce4_panel_plugin_loader->button));
329                xfce4_panel_plugin_loader->button = NULL;
330        }
331
332        /* Show */
333        gtk_widget_set_can_focus(GTK_WIDGET(xfce_panel_plugin), TRUE); //If this property is "FALSE", there is 1px border
334        gtk_container_add(GTK_CONTAINER(xfce4_panel_plugin_loader->mate_applet), GTK_WIDGET(xfce_panel_plugin));
335        gtk_widget_show(GTK_WIDGET(xfce_panel_plugin));
336        gtk_widget_show(GTK_WIDGET(xfce4_panel_plugin_loader->mate_applet));
337
338        /*
339         * Manually create menu object, because I must manage all items by my-self.
340         * I must merge Xfce4 and Mate menus here.
341        */
342
343        /* Simulate an unlocked panel (for "show_configure") */
344        xfce_panel_plugin_provider_set_locked((XfcePanelPluginProvider *)xfce_panel_plugin, FALSE);
345
346        /* Create a new menu */
347        xfce_panel_plugin->priv->menu = GTK_MENU(gtk_menu_new());
348        gtk_menu_attach_to_widget(xfce_panel_plugin->priv->menu, GTK_WIDGET(xfce_panel_plugin), NULL);
349
350        /* Add "configure" item to the menu */
351        if (xfce_panel_plugin_provider_get_show_configure((XfcePanelPluginProvider *)xfce_panel_plugin))
352        {
353                GtkWidget *item = gtk_image_menu_item_new_from_stock(GTK_STOCK_PROPERTIES, NULL);
354                g_signal_connect_swapped(G_OBJECT(item), "activate", G_CALLBACK(xfce_panel_plugin_provider_show_configure), xfce_panel_plugin);
355                gtk_menu_shell_append(GTK_MENU_SHELL(xfce_panel_plugin->priv->menu), item);
356                gtk_widget_show(item);
357        }
358
359        /*
360         * Don't add "about" item to the menu, because it is not wotking properly when more then one Xfce4 panel plugin is loaded
361        */
362
363        /* Add other plugin items to the menu */
364        GSList *menu_items = xfce_panel_plugin->priv->menu_items;
365        while (menu_items)
366        {
367                gtk_menu_shell_append(GTK_MENU_SHELL(xfce_panel_plugin->priv->menu), menu_items->data);
368                menu_items = menu_items->next;
369        }
370
371        /* Add menu items from Mate panel */
372        gtk_menu_shell_append(GTK_MENU_SHELL(xfce_panel_plugin->priv->menu), create_separator());
373        gtk_menu_shell_append(GTK_MENU_SHELL(xfce_panel_plugin->priv->menu), gtk_action_create_menu_item(gtk_action_group_get_action(xfce4_panel_plugin_loader->mate_applet->priv->panel_action_group, "Remove")));
374        gtk_menu_shell_append(GTK_MENU_SHELL(xfce_panel_plugin->priv->menu), gtk_action_create_menu_item(gtk_action_group_get_action(xfce4_panel_plugin_loader->mate_applet->priv->panel_action_group, "Move")));
375        gtk_menu_shell_append(GTK_MENU_SHELL(xfce_panel_plugin->priv->menu), create_separator());
376        gtk_menu_shell_append(GTK_MENU_SHELL(xfce_panel_plugin->priv->menu), gtk_action_create_menu_item(gtk_action_group_get_action(xfce4_panel_plugin_loader->mate_applet->priv->panel_action_group, "Lock")));
377
378
379        /* Handle change orientation */
380        xfce4_panel_plugin_loader_handle_orient_change(NULL, mate_panel_applet_get_orient(xfce4_panel_plugin_loader->mate_applet), (XfcePanelPluginProvider *)xfce_panel_plugin);
381        g_signal_connect(G_OBJECT(xfce4_panel_plugin_loader->mate_applet), "change_orient", G_CALLBACK(xfce4_panel_plugin_loader_handle_orient_change), xfce_panel_plugin);
382
383        /* Set size */
384        xfce4_panel_plugin_loader_handle_size_change(NULL, mate_panel_applet_get_size(xfce4_panel_plugin_loader->mate_applet), xfce4_panel_plugin_loader);
385
386        /* Reset translations (Xfce4 panel plugin probably set it to its own package) */
387        textdomain(GETTEXT_PACKAGE);
388
389        /* Add to global array that the library is loaded */
390        xfce4_panel_plugin_filenames = (gchar **)g_realloc(xfce4_panel_plugin_filenames, ++num_applets * sizeof(void *) );
391        xfce4_panel_plugin_filenames[num_applets-1] = (gchar *)g_malloc(strlen(lib_name)+1);
392        strcpy(xfce4_panel_plugin_filenames[num_applets-1], lib_name);
393        xfce4_panel_plugin_loader->lib_name_pos = num_applets-1;
394
395        return TRUE;
396}
397
398/* Helper function to create file dialog button */
399static void file_dialog_button_clicked(GtkWidget *button, Xfce4PanelPluginLoader *xfce4_panel_plugin_loader)
400{
401        (void)button;
402        gtk_widget_set_sensitive(GTK_WIDGET(xfce4_panel_plugin_loader->button), FALSE);
403        gchar *lib_file_name = get_lib_file_name();
404        if (lib_file_name && *lib_file_name)
405                load_xfce4_panel_plugin(xfce4_panel_plugin_loader, lib_file_name);
406        gtk_widget_set_sensitive(GTK_WIDGET(xfce4_panel_plugin_loader->button), TRUE);
407}
408static gboolean do_not_eat_button_press(GtkWidget *widget, GdkEventButton *event)
409{
410        if (event->button != 1)
411                g_signal_stop_emission_by_name(widget, "button_press_event");
412        return FALSE;
413}
414static void create_file_dialog_button(Xfce4PanelPluginLoader *xfce4_panel_plugin_loader)
415{
416        xfce4_panel_plugin_loader->button = gtk_button_new();
417        gtk_button_set_relief(GTK_BUTTON(xfce4_panel_plugin_loader->button), GTK_RELIEF_NONE);
418        xfce4_panel_plugin_loader_handle_size_change(NULL, mate_panel_applet_get_size(xfce4_panel_plugin_loader->mate_applet), xfce4_panel_plugin_loader);
419        gtk_widget_set_tooltip_text(GTK_WIDGET(xfce4_panel_plugin_loader->button), _("Click here to choose Xfce4 panel plugin"));
420        g_signal_connect(xfce4_panel_plugin_loader->button, "button_press_event", G_CALLBACK(do_not_eat_button_press), NULL);
421        g_signal_connect(G_OBJECT(xfce4_panel_plugin_loader->button), "clicked", G_CALLBACK(file_dialog_button_clicked), xfce4_panel_plugin_loader);
422        gtk_container_add(GTK_CONTAINER(xfce4_panel_plugin_loader->mate_applet), GTK_WIDGET(xfce4_panel_plugin_loader->button));
423        gtk_widget_show_all(GTK_WIDGET(xfce4_panel_plugin_loader->mate_applet));
424}
425
426/* Helper function to set environmental variables */
427static FILE *open_proc_environ(const char *pname_to_find)
428{
429        /* Open "/proc" directory */
430        DIR *dirp = opendir("/proc");
431        if (!dirp)
432                return NULL;
433
434        /* Scan "/proc" dir */
435        struct dirent *dp;
436        while ((dp = readdir(dirp)) != NULL)
437        {
438                /* Convert dir name to number */
439                char *end_ptr;
440                pid_t pid = strtol(dp->d_name, &end_ptr, 10);
441                /* Directory name is not entirely numeric */
442                if (*end_ptr != '\0')
443                        continue;
444
445                /* Open the "stat" file */
446                char pth[32];
447                snprintf(pth, sizeof(pth), "/proc/%d/comm", pid);
448                FILE *f = fopen(pth, "r");
449                if (f)
450                {
451                        /* Get process name from file and check whether is the same as in function argument */
452                        char pname[256];
453                        if ((fscanf(f, "%255s", pname)) == 1 && !strcmp(pname, pname_to_find))
454                        {
455                                fclose(f);
456                                closedir(dirp);
457                                /* Open "environ" file */
458                                snprintf(pth, sizeof pth, "/proc/%d/environ", pid);
459                                return fopen(pth, "rb");
460                        }
461                        fclose(f);
462                }
463        }
464
465        closedir(dirp);
466        return NULL;
467}
468static void set_environmental_variables_from_mate_panel()
469{
470        FILE *f = open_proc_environ("mate-panel");
471        if (f)
472        {
473                int env_buff_size = 0, env_buff_pos = 0;
474                char *env_buff = NULL;
475                for (;;)
476                {
477                        /* Read one byte */
478                        int c = fgetc(f);
479                        /* EOF or error */
480                        if (c < 0)
481                                break;
482                        /* Expand buffer */
483                        if (env_buff_pos == env_buff_size)
484                                env_buff = (char *)realloc(env_buff, ++env_buff_size);
485                        /* Append byte to buffer */
486                        env_buff[env_buff_pos++] = c;
487                        /* End of single entry */
488                        if (c == '\0')
489                        {
490                                /* Allocate more memroy than necessary */
491                                char *var = (char *)malloc(env_buff_pos);
492                                char *val = (char *)malloc(env_buff_pos);
493                                /* Get variable name and its value */
494                                sscanf(env_buff, "%[^=]=%s", var, val);
495                                /* Set env */
496                                setenv(var, val, 1);
497                                /* Free allocated memory */
498                                free(var);
499                                free(val);
500                                /* Reset buffer position */
501                                env_buff_pos = 0;
502                        }
503                }
504                free(env_buff);
505                fclose(f);
506        }
507}
508
509/* Load applet */
510static gboolean xfce4_panel_plugin_loader_factory(MatePanelApplet *mate_applet, const gchar *iid, gpointer data)
511{
512        (void)data;
513        if (!g_strcmp0(iid, "Xfce4PanelPluginLoader"))
514        {
515                Xfce4PanelPluginLoader *xfce4_panel_plugin_loader = (Xfce4PanelPluginLoader *)g_malloc0(sizeof(Xfce4PanelPluginLoader));
516                xfce4_panel_plugin_loader->settings = mate_panel_applet_settings_new(mate_applet, PANEL_SETTINGS_SCHEMA);
517                xfce4_panel_plugin_loader->mate_applet = mate_applet;
518
519                /* Handle destroy signal */
520                g_signal_connect(G_OBJECT(mate_applet), "destroy", G_CALLBACK(xfce4_panel_plugin_loader_handle_dispose), xfce4_panel_plugin_loader);
521
522                /* Handle change size */
523                g_signal_connect(G_OBJECT(xfce4_panel_plugin_loader->mate_applet), "change_size", G_CALLBACK(xfce4_panel_plugin_loader_handle_size_change), xfce4_panel_plugin_loader);
524
525                /* Set Mate applet options */
526                mate_panel_applet_set_flags(mate_applet, MATE_PANEL_APPLET_EXPAND_MINOR);
527                mate_panel_applet_set_background_widget(mate_applet, GTK_WIDGET(mate_applet));
528
529                /* Set environmental variables from "mate-panel" (Linux only), call only once */
530                if (num_applets == 0)
531                        set_environmental_variables_from_mate_panel();
532
533                /* Get library file name from settings */
534                gchar *lib_file_name = g_settings_get_string(xfce4_panel_plugin_loader->settings, PANEL_SETTINGS_KEY_FILENAME_SCHEMA);
535
536                /* Create xfce4 applet or button to load it later */
537                if (!lib_file_name || !*lib_file_name || !load_xfce4_panel_plugin(xfce4_panel_plugin_loader, lib_file_name))
538                        create_file_dialog_button(xfce4_panel_plugin_loader);
539
540                if (lib_file_name)
541                        g_free(lib_file_name);
542
543                gtk_window_set_default_icon_name(XFCE4_ICON);
544
545                return TRUE;
546        }
547        return FALSE;
548}
549
550MATE_PANEL_APPLET_OUT_PROCESS_FACTORY("Xfce4PanelPluginLoaderFactory", PANEL_TYPE_APPLET, "Xfce4 panel plugin loader", xfce4_panel_plugin_loader_factory, NULL)
Note: See TracBrowser for help on using the repository browser.