source: trunk/third/gnome-core/panel/applet.c @ 16302

Revision 16302, 19.0 KB checked in by ghudson, 24 years ago (diff)
Merge with gnome-core 1.4.0.4.
Line 
1/* Gnome panel: general applet functionality
2 * (C) 1997 the Free Software Foundation
3 *
4 * Authors:  George Lebl
5 *           Federico Mena
6 *           Miguel de Icaza
7 */
8
9#include <config.h>
10#include <string.h>
11#include <signal.h>
12#include <gnome.h>
13#include <gdk/gdkx.h>
14
15#include "panel-include.h"
16#include "gnome-panel.h"
17#include "scroll-menu.h"
18
19#define SMALL_ICON_SIZE 20
20
21#define APPLET_EVENT_MASK (GDK_BUTTON_PRESS_MASK |              \
22                           GDK_BUTTON_RELEASE_MASK |            \
23                           GDK_POINTER_MOTION_MASK |            \
24                           GDK_POINTER_MOTION_HINT_MASK)
25
26extern GSList *panels;
27
28GSList *applets = NULL;
29GSList *applets_last = NULL;
30int applet_count = 0;
31
32/*config sync stuff*/
33extern int config_sync_timeout;
34extern int applets_to_sync;
35extern int panels_to_sync;
36extern int need_complete_save;
37
38extern GlobalConfig global_config;
39extern PanelWidget *current_panel;
40
41static void
42move_applet_callback (GtkWidget *widget, AppletInfo *info)
43{
44        PanelWidget *panel;
45
46        g_return_if_fail (info != NULL);
47        g_return_if_fail (info->widget != NULL);
48        g_return_if_fail (info->widget->parent != NULL);
49        g_return_if_fail (IS_PANEL_WIDGET (info->widget->parent));
50
51        panel = PANEL_WIDGET (info->widget->parent);
52
53        panel_widget_applet_drag_start (panel, info->widget,
54                                        PW_DRAG_OFF_CENTER);
55}
56
57/*destroy widgets and call the above cleanup function*/
58void
59panel_clean_applet (AppletInfo *info)
60{
61        g_return_if_fail (info != NULL);
62
63        if (info->widget != NULL) {
64                if(info->type == APPLET_STATUS) {
65                        status_applet_put_offscreen (info->data);
66                }
67                /* destroy will remove it from the panel */
68                gtk_widget_destroy (info->widget);
69                info->widget = NULL;
70        }
71
72        info->data = NULL;
73}
74
75static gboolean
76kill_applet_in_idle(gpointer data)
77{
78        AppletInfo *info = data;
79        if (info->type == APPLET_EXTERN) {
80                Extern *ext = info->data;
81                extern_save_last_position (ext, TRUE /* sync */);
82                ext->clean_remove = TRUE;
83        } else if (info->type == APPLET_SWALLOW) {
84                Swallow *swallow = info->data;
85                swallow->clean_remove = TRUE;
86        }
87        panel_clean_applet (info);
88        return FALSE;
89}
90
91static void
92remove_applet_callback(GtkWidget *widget, AppletInfo *info)
93{
94        gtk_idle_add (kill_applet_in_idle, info);
95}
96
97static void
98applet_callback_callback(GtkWidget *widget, gpointer data)
99{
100        AppletUserMenu *menu = data;
101
102        g_return_if_fail(menu->info != NULL);
103
104        switch(menu->info->type) {
105        case APPLET_EXTERN:
106                {
107                        CORBA_Environment ev;
108                        Extern *ext = menu->info->data;
109                        g_assert(ext);
110                        g_assert(ext->applet);
111
112                        CORBA_exception_init(&ev);
113                        GNOME_Applet_do_callback(ext->applet, menu->name, &ev);
114                        if(ev._major)
115                                panel_clean_applet(ext->info);
116                        CORBA_exception_free(&ev);
117                        break;
118                }
119        case APPLET_LAUNCHER:
120                if(strcmp(menu->name,"properties")==0)
121                        launcher_properties(menu->info->data);
122                else if (strcmp (menu->name, "help") == 0)
123                        panel_show_help ("launchers.html");
124                else if (strcmp (menu->name, "help_on_app") == 0) {
125                        Launcher * launcher = menu->info->data;
126                        if (launcher->dentry != NULL) {
127                                char *path = panel_gnome_kde_help_path
128                                        (launcher->dentry->docpath);
129                                if (path != NULL) {
130                                        gnome_url_show (path);
131                                        g_free (path);
132                                }
133                        }
134                }
135                break;
136        case APPLET_DRAWER:
137                if(strcmp(menu->name,"properties")==0) {
138                        Drawer *drawer = menu->info->data;
139                        g_assert(drawer);
140                        panel_config(drawer->drawer);
141                } else if (strcmp (menu->name, "help") == 0)
142                        panel_show_help ("drawers.html");
143                break;
144        case APPLET_SWALLOW:
145                if (strcmp (menu->name, "help") == 0)
146                        panel_show_help ("specialobjects.html#SWALLOWEDAPP");
147#if 0
148                if(strcmp(menu->name,"properties")==0) {
149                        Swallow *swallow = info->data;
150                        g_assert(swallow);
151                        swallow_properties(swallow); /* doesn't exist yet*/
152                }
153#endif
154                break;
155        case APPLET_MENU:
156                if(strcmp(menu->name,"properties")==0)
157                        menu_properties(menu->info->data);
158                else if(strcmp(menu->name,"edit_menus")==0) {
159                        char *tmp;
160                        if((tmp = panel_is_program_in_path("gmenu")))  {
161                                gnome_execute_async (g_get_home_dir (), 1, &tmp);
162                                g_free(tmp);
163                        }
164                } else if (strcmp (menu->name, "help") == 0) {
165                        Menu *menu2 = menu->info->data;
166                        char *page;
167                        page = (menu2->path && strcmp (menu2->path,"."))
168                                ? "menus.html" : "mainmenu.html";
169                        panel_show_help (page);
170                }
171                break;
172        case APPLET_LOCK: {
173                /*
174                  <jwz> Blank Screen Now
175                  <jwz> Lock Screen Now
176                  <jwz> Kill Daemon
177                  <jwz> Restart Daemon
178                  <jwz> Preferences
179                  <jwz> (or "configuration" instead?  whatever word you use)
180                  <jwz> those should do xscreensaver-command -activate, -lock, -exit...
181                  <jwz> and "xscreensaver-command -exit ; xscreensaver &"
182                  <jwz> and "xscreensaver-demo"
183                */
184                char *command = NULL;
185                gboolean freeit = FALSE;
186                if (strcmp (menu->name, "help") == 0)
187                        panel_show_help ("specialobjects.html#LOCKBUTTON");
188                else if (!strcmp (menu->name, "restart")) {
189                        command = "xss-command -exit ; xss &";
190                } else if (!strcmp (menu->name, "prefs")) {
191                        command = "xss-demo";
192                } else {
193                        command = g_strdup_printf ("xss-command -%s",
194                                                   menu->name);
195                        freeit = TRUE;
196                }
197                if (command)
198                        gnome_execute_shell (g_get_home_dir (), command);
199                if (freeit)
200                        g_free (command);
201                break;
202        }
203        case APPLET_LOGOUT:
204                if (strcmp (menu->name, "help") == 0)
205                        panel_show_help ("specialobjects.html#LOGOUTBUTTON");
206                break;
207        case APPLET_STATUS:
208                if (strcmp (menu->name, "help") == 0)
209                        panel_show_help ("specialobjects.html#STATUSDOC");
210                break;
211        case APPLET_RUN:
212                if (strcmp (menu->name, "help") == 0)
213                        panel_show_help ("specialobjects.html#RUNBUTTON");
214                break;
215        default: break;
216        }
217}
218
219static void
220applet_menu_deactivate(GtkWidget *w, AppletInfo *info)
221{
222        GtkWidget *panel = get_panel_parent(info->widget);
223        info->menu_age = 0;
224       
225        if(IS_BASEP_WIDGET(panel))
226                BASEP_WIDGET(panel)->autohide_inhibit = FALSE;
227}
228
229AppletUserMenu *
230applet_get_callback (GList *user_menu, const char *name)
231{
232        GList *li;
233
234        for (li = user_menu; li != NULL; li = li->next) {
235                AppletUserMenu *menu = li->data;
236                if (strcmp (menu->name, name) == 0)
237                        return menu;
238        }
239
240        return NULL;   
241}
242
243void
244applet_add_callback(AppletInfo *info,
245                    const char *callback_name,
246                    const char *stock_item,
247                    const char *menuitem_text)
248{
249        AppletUserMenu *menu;
250
251        g_return_if_fail (info != NULL);
252       
253        menu = applet_get_callback (info->user_menu, callback_name);
254        if (menu == NULL) {
255                menu = g_new0 (AppletUserMenu, 1);
256                menu->name = g_strdup (callback_name);
257                menu->stock_item = g_strdup (stock_item);
258                menu->text = g_strdup (menuitem_text);
259                menu->sensitive = TRUE;
260                menu->info = info;
261                menu->menuitem = NULL;
262                menu->submenu = NULL;
263                info->user_menu = g_list_append (info->user_menu, menu);
264        } else {
265                g_free (menu->stock_item);
266                menu->stock_item = NULL;
267                g_free (menu->text);
268                menu->text = NULL;
269                menu->text = g_strdup (menuitem_text);
270                menu->stock_item = g_strdup (stock_item);
271        }
272
273        /*make sure the menu is rebuilt*/
274        if(info->menu) {
275                GList *list;
276                for(list=info->user_menu;list!=NULL;list=g_list_next(list)) {
277                        AppletUserMenu *menu = list->data;
278                        menu->menuitem=NULL;
279                        menu->submenu=NULL;
280                }
281                gtk_widget_unref(info->menu);
282                info->menu = NULL;
283                info->menu_age = 0;
284        }
285}
286
287void
288applet_remove_callback(AppletInfo *info, const char *callback_name)
289{
290        AppletUserMenu *menu;
291
292        g_return_if_fail (info != NULL);
293       
294        menu = applet_get_callback (info->user_menu, callback_name);
295        if (menu != NULL) {
296                info->user_menu = g_list_remove (info->user_menu, menu);
297                g_free(menu->name);
298                menu->name = NULL;
299                g_free(menu->stock_item);
300                menu->stock_item = NULL;
301                g_free(menu->text);
302                menu->text = NULL;
303                g_free(menu);
304        } else
305                return; /*it just isn't there*/
306
307        /*make sure the menu is rebuilt*/
308        if (info->menu != NULL) {
309                GList *list;
310                for (list = info->user_menu; list != NULL; list = list->next) {
311                        AppletUserMenu *menu = list->data;
312                        menu->menuitem = NULL;
313                        menu->submenu = NULL;
314                }
315                gtk_widget_unref (info->menu);
316                info->menu = NULL;
317                info->menu_age = 0;
318        }
319}
320
321void
322applet_callback_set_sensitive(AppletInfo *info, const char *callback_name, int sensitive)
323{
324        AppletUserMenu *menu;
325
326        g_return_if_fail(info != NULL);
327       
328        menu = applet_get_callback(info->user_menu, callback_name);
329        if (menu != NULL)
330                menu->sensitive = sensitive;
331        else
332                return; /*it just isn't there*/
333
334        /*make sure the menu is rebuilt*/
335        if(info->menu) {
336                GList *list;
337                for(list=info->user_menu;list!=NULL;list=g_list_next(list)) {
338                        AppletUserMenu *menu = list->data;
339                        menu->menuitem=NULL;
340                        menu->submenu=NULL;
341                }
342                gtk_widget_unref(info->menu);
343                info->menu = NULL;
344                info->menu_age = 0;
345        }
346}
347
348static void
349setup_an_item(AppletUserMenu *menu,
350              GtkWidget *submenu,
351              int is_submenu)
352{
353        menu->menuitem = gtk_menu_item_new ();
354        gtk_signal_connect (GTK_OBJECT (menu->menuitem), "destroy",
355                            GTK_SIGNAL_FUNC (gtk_widget_destroyed),
356                            &menu->menuitem);
357        if(menu->stock_item && *(menu->stock_item))
358                setup_menuitem (menu->menuitem,
359                                gnome_stock_pixmap_widget(submenu,
360                                                          menu->stock_item),
361                                menu->text);
362        else
363                setup_menuitem (menu->menuitem,
364                                NULL,
365                                menu->text);
366
367        if(submenu)
368                gtk_menu_append (GTK_MENU (submenu), menu->menuitem);
369
370        /*if an item not a submenu*/
371        if(!is_submenu) {
372                gtk_signal_connect(GTK_OBJECT(menu->menuitem), "activate",
373                                   (GtkSignalFunc) applet_callback_callback,
374                                   menu);
375                gtk_signal_connect(GTK_OBJECT (submenu), "destroy",
376                                   GTK_SIGNAL_FUNC (gtk_widget_destroyed),
377                                   &menu->submenu);
378        /* if the item is a submenu and doesn't have it's menu
379           created yet*/
380        } else if(!menu->submenu) {
381                menu->submenu = scroll_menu_new();
382        }
383
384        if(menu->submenu) {
385                gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu->menuitem),
386                                          menu->submenu);
387                gtk_signal_connect (GTK_OBJECT (menu->submenu), "destroy",
388                                    GTK_SIGNAL_FUNC (gtk_widget_destroyed),
389                                    &menu->submenu);
390        }
391       
392        gtk_widget_set_sensitive(menu->menuitem,menu->sensitive);
393}
394
395static void
396add_to_submenus (AppletInfo *info,
397                 const char *path,
398                 const char *name,
399                 AppletUserMenu *menu,
400                 GtkWidget *submenu,
401                 GList *user_menu)
402{
403        char *n = g_strdup (name);
404        char *p = strchr (n, '/');
405        char *t;
406        AppletUserMenu *s_menu;
407
408        /*this is the last one*/
409        if (p == NULL) {
410                g_free (n);
411                setup_an_item (menu, submenu, FALSE);
412                return;
413        }
414       
415        /*this is the last one and we are a submenu, we have already been
416          set up*/
417        if(p==(n + strlen(n) - 1)) {
418                g_free(n);
419                return;
420        }
421       
422        *p = '\0';
423        p++;
424       
425        t = g_strconcat (path, n, "/", NULL);
426        s_menu = applet_get_callback (user_menu, t);
427        /*the user did not give us this sub menu, whoops, will create an empty
428          one then*/
429        if (s_menu == NULL) {
430                s_menu = g_new0 (AppletUserMenu,1);
431                s_menu->name = g_strdup (t);
432                s_menu->stock_item = NULL;
433                s_menu->text = g_strdup (_("???"));
434                s_menu->sensitive = TRUE;
435                s_menu->info = info;
436                s_menu->menuitem = NULL;
437                s_menu->submenu = NULL;
438                info->user_menu = g_list_append (info->user_menu,s_menu);
439                user_menu = info->user_menu;
440        }
441       
442        if (s_menu->submenu == NULL) {
443                s_menu->submenu = scroll_menu_new();
444                /*a more elegant way to do this should be done
445                  when I don't want to go to sleep */
446                if (s_menu->menuitem != NULL) {
447                        gtk_widget_destroy (s_menu->menuitem);
448                        s_menu->menuitem = NULL;
449                }
450        }
451        if (s_menu->menuitem == NULL)
452                setup_an_item (s_menu, submenu, TRUE);
453       
454        add_to_submenus (info, t, p, menu, s_menu->submenu, user_menu);
455       
456        g_free(t);
457        g_free(n);
458}
459
460void
461create_applet_menu (AppletInfo *info, gboolean is_basep)
462{
463        GtkWidget *menuitem, *panel_menu;
464        GList *user_menu = info->user_menu;
465        gchar *pixmap;
466
467        info->menu = scroll_menu_new ();
468
469        menuitem = gtk_menu_item_new();
470        setup_menuitem(menuitem,
471                       gnome_stock_new_with_icon (GNOME_STOCK_PIXMAP_REMOVE),
472                       _("Remove from panel"));
473        gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
474                           (GtkSignalFunc) remove_applet_callback,
475                           info);
476        gtk_menu_append(GTK_MENU(info->menu), menuitem);
477       
478        menuitem = gtk_menu_item_new();
479        setup_menuitem(menuitem,NULL,_("Move"));
480        gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
481                           (GtkSignalFunc) move_applet_callback,
482                           info);
483        gtk_menu_append(GTK_MENU(info->menu), menuitem);
484
485        panel_menu = scroll_menu_new();
486        make_panel_submenu (panel_menu, TRUE, is_basep);
487        menuitem = gtk_menu_item_new ();
488
489        pixmap = gnome_pixmap_file ("gnome-panel.png");
490        if (pixmap == NULL) {
491                g_message (_("Cannot find pixmap file %s"), "gnome-panel.png");
492                setup_menuitem (menuitem, NULL, _("Panel"));
493        } else {
494                setup_menuitem (menuitem,
495                                gnome_stock_pixmap_widget_at_size (NULL, pixmap,
496                                                                   SMALL_ICON_SIZE,
497                                                                   SMALL_ICON_SIZE),
498                                _("Panel"));
499                g_free (pixmap);
500        }
501        gtk_menu_append (GTK_MENU (info->menu), menuitem);
502        gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), panel_menu);
503
504        if(user_menu) {
505                menuitem = gtk_menu_item_new();
506                gtk_menu_append(GTK_MENU(info->menu), menuitem);
507                gtk_widget_set_sensitive (menuitem, FALSE);
508                gtk_widget_show(menuitem);
509        }
510
511        for(;user_menu!=NULL;user_menu = g_list_next(user_menu)) {
512                AppletUserMenu *menu=user_menu->data;
513                add_to_submenus (info, "", menu->name, menu, info->menu,
514                                 info->user_menu);
515        }
516
517        /*connect the deactivate signal, so that we can "re-allow" autohide
518          when the menu is deactivated*/
519        gtk_signal_connect (GTK_OBJECT (info->menu), "deactivate",
520                            GTK_SIGNAL_FUNC (applet_menu_deactivate),
521                            info);
522}
523
524static void
525set_data(GtkWidget *menu, gpointer panel)
526{
527        GList *children, *li;
528
529        gtk_object_set_data (GTK_OBJECT (menu), "menu_panel", panel);
530
531        children = gtk_container_children (GTK_CONTAINER (menu));
532
533        for(li = children; li; li = li->next) {
534                GtkMenuItem *item = li->data;
535                if (item->submenu != NULL)
536                        set_data (item->submenu, panel);
537        }
538        g_list_free (children);
539}
540
541void
542show_applet_menu(AppletInfo *info, GdkEventButton *event)
543{
544        GtkWidget *panel;
545
546        g_return_if_fail(info!=NULL);
547
548        panel = get_panel_parent(info->widget);
549
550        if (info->menu == NULL)
551                create_applet_menu (info, IS_BASEP_WIDGET (panel));
552        g_assert (info->menu != NULL);
553
554        if(IS_BASEP_WIDGET(panel)) {
555                BASEP_WIDGET(panel)->autohide_inhibit = TRUE;
556                basep_widget_queue_autohide(BASEP_WIDGET(panel));
557        }
558        info->menu_age = 0;
559
560        set_data (info->menu, info->widget->parent);
561
562        gtk_menu_popup (GTK_MENU (info->menu),
563                        NULL,
564                        NULL,
565                        global_config.off_panel_popups ?
566                          applet_menu_position :
567                          NULL,
568                        info,
569                        event->button,
570                        event->time);
571}
572
573
574
575static gboolean
576applet_button_press (GtkWidget *widget, GdkEventButton *event, AppletInfo *info)
577{
578        if (event->button == 3) {
579                if ( ! panel_applet_in_drag) {
580                        if(info->type == APPLET_SWALLOW) {
581                                Swallow *swallow = info->data;
582                                GtkWidget *handle_box = swallow->handle_box;
583                                if(!GTK_HANDLE_BOX(handle_box)->child_detached)
584                                        show_applet_menu(info, event);
585                        } else {
586                                show_applet_menu (info, event);
587                        }
588                }
589        }
590        /* don't let any button click events to the panel or moving the applets
591         * would move the panel */
592        return TRUE;
593}
594
595static GList *launchers_to_kill = NULL;
596
597void
598remove_unused_launchers (void)
599{
600        GList *li;
601
602        for (li = launchers_to_kill; li != NULL; li = li->next) {
603                char *file = li->data;
604                li->data = NULL;
605
606                unlink (file);
607
608                g_free (file);
609        }
610
611        g_list_free (launchers_to_kill);
612        launchers_to_kill = NULL;
613}
614
615static void
616applet_destroy (GtkWidget *w, AppletInfo *info)
617{
618        GList *li;
619       
620        g_return_if_fail (info != NULL);
621
622        info->widget = NULL;
623
624        if (info->type == APPLET_DRAWER) {
625                Drawer *drawer = info->data;
626                g_assert(drawer);
627                if(drawer->drawer) {
628                        GtkWidget *dw = drawer->drawer;
629                        drawer->drawer = NULL;
630                        PANEL_WIDGET(BASEP_WIDGET(dw)->panel)->master_widget = NULL;
631                        gtk_widget_destroy(dw);
632                }
633        } else if (info->type == APPLET_LAUNCHER) {
634                Launcher *launcher = info->data;
635
636                /* we CAN'T unlink the file here as we may just
637                 * be killing stuff before exit, basically we
638                 * just want to schedule removals until session
639                 * saving */
640
641                if (launcher->dentry->location != NULL) {
642                        char *file = g_strdup (launcher->dentry->location);
643                        launchers_to_kill =
644                                g_list_prepend (launchers_to_kill, file);
645                }
646        }
647
648
649        if (info->menu != NULL) {
650                gtk_widget_unref(info->menu);
651                info->menu = NULL;
652                info->menu_age = 0;
653        }
654
655        info->type = APPLET_EMPTY;
656
657        if (info->data_destroy)
658                info->data_destroy (info->data);
659        info->data_destroy = NULL;
660        info->data = NULL;
661
662        /*free the user menu*/
663        for(li = info->user_menu; li != NULL; li = g_list_next(li)) {
664                AppletUserMenu *umenu = li->data;
665
666                li->data = NULL;
667
668                g_free(umenu->name);
669                umenu->name = NULL;
670                g_free(umenu->stock_item);
671                umenu->stock_item = NULL;
672                g_free(umenu->text);
673                umenu->text = NULL;
674
675                g_free(umenu);
676        }
677        g_list_free (info->user_menu);
678        info->user_menu = NULL;
679}
680
681gboolean
682register_toy (GtkWidget *applet,
683              gpointer data,
684              GDestroyNotify data_destroy,
685              PanelWidget *panel,
686              int pos,
687              gboolean exactpos,
688              AppletType type)
689{
690        AppletInfo *info;
691        int newpos;
692        gboolean insert_at_pos;
693       
694        g_return_val_if_fail (applet != NULL, FALSE);
695        g_return_val_if_fail (panel != NULL, FALSE);
696
697        if ( ! GTK_WIDGET_NO_WINDOW (applet))
698                gtk_widget_set_events (applet, (gtk_widget_get_events (applet) |
699                                                APPLET_EVENT_MASK) &
700                                       ~( GDK_POINTER_MOTION_MASK |
701                                          GDK_POINTER_MOTION_HINT_MASK));
702
703        info = g_new0 (AppletInfo, 1);
704        info->applet_id = applet_count;
705        info->type = type;
706        info->widget = applet;
707        info->menu = NULL;
708        info->menu_age = 0;
709        info->data = data;
710        info->data_destroy = data_destroy;
711        info->user_menu = NULL;
712
713        gtk_object_set_data (GTK_OBJECT (applet), "applet_info", info);
714
715        if (type == APPLET_DRAWER) {
716                Drawer *drawer = data;
717                PanelWidget *assoc_panel =
718                        PANEL_WIDGET (BASEP_WIDGET (drawer->drawer)->panel);
719
720                gtk_object_set_data (GTK_OBJECT (applet),
721                                     PANEL_APPLET_ASSOC_PANEL_KEY, assoc_panel);
722                assoc_panel->master_widget = applet;
723        }
724
725        gtk_object_set_data (GTK_OBJECT (applet),
726                             PANEL_APPLET_FORBIDDEN_PANELS, NULL);
727               
728        if (applets == NULL) {
729                applets_last = applets = g_slist_append (NULL, info);
730        } else {
731                applets_last = g_slist_append (applets_last, info);
732                applets_last = applets_last->next;
733        }
734        applet_count++;
735
736        /*we will need to save this applet's config now*/
737        applets_to_sync = TRUE;
738
739        /*add at the beginning if pos == -1*/
740        if (pos >= 0) {
741                newpos = pos;
742                insert_at_pos = FALSE;
743        } else {
744                newpos = 0;
745                insert_at_pos = TRUE;
746        }
747        /* if exact pos is on then insert at that precise location */
748        if (exactpos)
749                insert_at_pos = TRUE;
750
751        if (panel_widget_add_full (panel, applet, newpos, TRUE,
752                                   insert_at_pos)==-1) {
753                GSList *list;
754                for(list = panels; list != NULL; list = g_slist_next(list))
755                        if (panel_widget_add_full (panel, applet, 0,
756                                                   TRUE, TRUE)!=-1)
757                                break;
758                if(!list) {
759                        /*can't put it anywhere, clean up*/
760                        gtk_widget_destroy(applet);
761                        info->widget = NULL;
762                        panel_clean_applet(info);
763                        g_warning(_("Can't find an empty spot"));
764                        return FALSE;
765                }
766                panel = PANEL_WIDGET(list->data);
767        }
768
769        if(IS_BUTTON_WIDGET (applet) || !GTK_WIDGET_NO_WINDOW(applet))
770                gtk_signal_connect(GTK_OBJECT(applet),
771                                   "button_press_event",
772                                   GTK_SIGNAL_FUNC(applet_button_press),
773                                   info);
774
775        gtk_signal_connect(GTK_OBJECT(applet), "destroy",
776                           GTK_SIGNAL_FUNC(applet_destroy),
777                           info);
778
779        gtk_widget_show_all(applet);
780
781        /*gtk_signal_connect (GTK_OBJECT (applet),
782                            "drag_request_event",
783                            GTK_SIGNAL_FUNC(panel_dnd_drag_request),
784                            info);
785
786        gtk_widget_dnd_drag_set (GTK_WIDGET(applet), TRUE,
787                                 applet_drag_types, 1);*/
788
789        orientation_change (info, panel);
790        size_change (info, panel);
791        back_change (info, panel);
792
793        return TRUE;
794}
Note: See TracBrowser for help on using the repository browser.