← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/gnome-panel/oneiric

« back to all changes in this revision

Viewing changes to gnome-panel/menu.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher, Sebastien Bacher, Jeremy Bicha
  • Date: 2011-05-30 11:04:49 UTC
  • mfrom: (1.13.10 upstream) (2.2.5 experimental)
  • Revision ID: james.westby@ubuntu.com-20110530110449-hinl17kxkcefjw6x
Tags: 1:3.0.2-0ubuntu1
[ Sebastien Bacher ]
* New upstream version
* debian/control.in:
  - the new libgweather version is in oneiric, use it
  - drop the python and python-gconf depends, 
    they were added for gnome-panel-add which is still using gconf and buggy
* debian/gnome-panel-data.install:
  - don't install the apport hook, it's only getting gconf datas which 
    doesn't work since gnome-panel uses gsettings
* debian/patches/90_build_fixes.patch:
  - restore build fix from git not applied in the new serie
* debian/patches/01_panel_submenus.patch:
  - don't take that Debian diff, the .menus use the upstream naming in Ubuntu
* debian/patches/06_no_resize_grip.patch:
  - dropped, the issue is fixed in the new version
* debian/patches/50_fix-potfiles.patch:
  - dropped, the issue is fixed in the new version
* debian/watch:
  - track unstable series as well

Drop those delta, since gnome-panel is not the default Ubuntu session now we
can go back to an experience closer to the upstream one: 
* debian/control.in:
  - drop the indicators recommends, unity-2d is the ubuntu fallback session
    so we can get back to use an upstream config for gnome-panel and reduce
    the delta we carry
* debian/patches/04_default_panel_config.patch:
  - don't modify the upstream layout
* debian/patches/05_no_session_delay.patch:
  - no need to tweak the upstream session to optimize it
* debian/patches/16_compiz_workspace_switcher.patch:
  - go back to the upstream switcher behaviour    
* debian/patches/25_dynamic_fusa_detection.patch:
  - not needed since we use the upstream layout, could be ported if someone
    is wanting to do the work though
* debian/patches/30_disable-initial-animation.patch, debian/rules:
  - drop the --disable-initial-animation, that was some login optimization
    but since it's not the default desktop you should go back to the 
    upstream behaviour

[ Jeremy Bicha ]   
* New upstream version
* Merge from Debian experimental, remaining Ubuntu changes:
* debian/control:
  - Recommends gnome-settings-daemon which has the timezone polkit service
* debian/rules:
  - Update translations template.
* debian/gnome-panel-data.install:
  - Install apport hook
  - Install the "About Ubuntu" menu item.
* debian/patches/01_layout.patch:
  - Disabled, Help & About Ubuntu don't fit as well in Gnome Panel 3
* debian/patches/01_panel_submenus.patch.
  - Dropped
* debian/patches/03_dnd_places_link.patch:
  - Disabled, when using Drag'n'Drop from Places menu, install a link launcher
    (.desktop file) instead of copying the entire directory.
* debian/patches/17_about-ubuntu-translation.patch:
  - List ubuntu-about.desktop for translation.
* debian/patches/40_unset_menuproxy.patch:
  - Make sure gnome-panel and the applets don't pick up menu proxies.
* debian/patches/50_fix-potfiles.patch
  - Fix i18n
* debian/patches/85_disable_shutdown_on_ltsp.patch:
  - Suppress the shutdown option in the panel if LTSP_CLIENT is set.
* debian/patches/71_change_bookmark_submenu_limit_value.patch
  - Dropped, picked up by Debian
* debian/patches/18_lockdown_lock_editor.patch:
* debian/patches/90_git_wnck_show_realize.patch:
* debian/patches/90_fix_linking_DSO_link.patch:
* debian/patches/91_gir_annotations.patch
* debian/patches/92_git_calendar_day.patch
* debian/patches/92_git_fix_applets_in_multiscreen.patch:
  - Dropped, applied upstream
* debian/watch:
  - watch unstable versions

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnome-panel/menu.c
29
29
#include <glib/gi18n.h>
30
30
#include <gio/gio.h>
31
31
#include <gdk/gdkkeysyms.h>
32
 
#include <gconf/gconf-client.h>
33
32
 
34
33
#include <libpanel-util/panel-keyfile.h>
35
34
#include <libpanel-util/panel-xdg.h>
37
36
#include "launcher.h"
38
37
#include "panel-util.h"
39
38
#include "panel.h"
40
 
#include "drawer.h"
41
 
#include "panel-config-global.h"
42
39
#include "panel-stock-icons.h"
43
40
#include "panel-action-button.h"
44
 
#include "panel-profile.h"
45
41
#include "panel-menu-button.h"
46
42
#include "panel-menu-items.h"
47
43
#include "panel-globals.h"
84
80
                                            const char  *image_filename,
85
81
                                            const char  *fallback_image_filename);
86
82
 
87
 
static gboolean panel_menu_key_press_handler (GtkWidget   *widget,
88
 
                                              GdkEventKey *event);
89
 
 
90
 
static inline gboolean
91
 
desktop_is_home_dir (void)
92
 
{       
93
 
        return gconf_client_get_bool (
94
 
                        panel_gconf_get_client (),
95
 
                        "/apps/nautilus/preferences/desktop_is_home_dir",
96
 
                        NULL);
97
 
}
98
 
 
99
 
 
100
83
GtkWidget *
101
84
add_menu_separator (GtkWidget *menu)
102
85
{
215
198
panel_create_menu (void)
216
199
{
217
200
        GtkWidget       *retval;
 
201
        GtkStyleContext *context;
218
202
        static gboolean  registered_icon_theme_changer = FALSE;
219
203
 
220
204
        if (!registered_icon_theme_changer) {
227
211
        retval = gtk_menu_new ();
228
212
        gtk_widget_set_name (retval, "gnome-panel-main-menu");
229
213
 
230
 
        g_signal_connect (retval, "key_press_event",
231
 
                          G_CALLBACK (panel_menu_key_press_handler),
232
 
                          NULL);
 
214
        context = gtk_widget_get_style_context (retval);
 
215
        gtk_style_context_add_class (context, "gnome-panel-main-menu");
233
216
 
234
217
        return retval;
235
218
}
424
407
}
425
408
 
426
409
static void
427
 
menu_item_style_set (GtkImage *image,
428
 
                     gpointer  data)
 
410
menu_item_style_updated (GtkImage *image,
 
411
                         gpointer  data)
429
412
{
430
413
        GtkWidget   *widget;
431
414
        GdkPixbuf   *pixbuf;
480
463
                                GTK_IMAGE (icon_to_add->image),
481
464
                                icon_to_add->pixbuf);
482
465
 
483
 
                        g_signal_connect (icon_to_add->image, "style-set",
484
 
                                          G_CALLBACK (menu_item_style_set),
 
466
                        g_signal_connect (icon_to_add->image, "style-updated",
 
467
                                          G_CALLBACK (menu_item_style_updated),
485
468
                                          GINT_TO_POINTER (icon_to_add->icon_size));
486
469
 
487
470
                        g_object_unref (icon_to_add->pixbuf);
581
564
        return TRUE;
582
565
}
583
566
 
584
 
static void
585
 
add_app_to_panel (GtkWidget      *item,
586
 
                  GMenuTreeEntry *entry)
587
 
{
588
 
        PanelWidget   *panel_widget;
589
 
        PanelToplevel *toplevel;
590
 
        PanelData     *pd;
591
 
        int            position;
592
 
 
593
 
        panel_widget = menu_get_panel (item);
594
 
        toplevel = panel_widget->toplevel;
595
 
 
596
 
        pd = g_object_get_data (G_OBJECT (toplevel), "PanelData");
597
 
        position = pd ?  pd->insertion_pos : -1;
598
 
 
599
 
        panel_launcher_create (toplevel,
600
 
                               position,
601
 
                               gmenu_tree_entry_get_desktop_file_path (entry));
602
 
}
603
 
 
604
 
 
605
 
static void
606
 
add_app_to_desktop (GtkWidget      *item,
607
 
                    GMenuTreeEntry *entry)
608
 
{
609
 
        char       *source_uri;
610
 
        const char *source;
611
 
        char       *target_dir;
612
 
        char       *target_uri;
613
 
        char       *target;
614
 
        GError     *error;
615
 
 
616
 
        g_return_if_fail (entry != NULL);
617
 
 
618
 
        if (desktop_is_home_dir ()) {
619
 
                target_dir = g_build_filename (g_get_home_dir (), NULL);
620
 
        } else {
621
 
                target_dir = g_strdup (g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP));
622
 
        }
623
 
 
624
 
        source = gmenu_tree_entry_get_desktop_file_path (entry);
625
 
        source_uri = g_filename_to_uri (source, NULL, NULL);
626
 
 
627
 
        target_uri = panel_make_unique_desktop_uri (target_dir, source_uri);
628
 
        g_free (target_dir);
629
 
        g_free (source_uri);
630
 
 
631
 
        g_return_if_fail (target_uri != NULL);
632
 
 
633
 
        target = g_filename_from_uri (target_uri, NULL, NULL);
634
 
        g_free (target_uri);
635
 
 
636
 
        error = NULL;
637
 
        panel_key_file_copy_and_mark_trusted (source, target, &error);
638
 
 
639
 
        g_free (target);
640
 
 
641
 
        if (error != NULL) {
642
 
                g_warning ("Problem while copying launcher to desktop: %s",
643
 
                           error->message);
644
 
                g_error_free (error);
645
 
        }
646
 
}
647
 
 
648
 
 
649
 
static void add_drawers_from_dir (GMenuTreeDirectory *directory,
650
 
                                  int                 pos,
651
 
                                  const char         *toplevel_id);
652
 
 
653
 
static void
654
 
add_drawers_from_alias (GMenuTreeAlias *alias,
655
 
                        const char     *toplevel_id)
656
 
{
657
 
        GMenuTreeItem *aliased_item;
658
 
 
659
 
        aliased_item = gmenu_tree_alias_get_item (alias);
660
 
 
661
 
        switch (gmenu_tree_item_get_type (aliased_item)) {
662
 
        case GMENU_TREE_ITEM_DIRECTORY:
663
 
                add_drawers_from_dir (GMENU_TREE_DIRECTORY (aliased_item),
664
 
                                      G_MAXINT/2,
665
 
                                      toplevel_id);
666
 
                break;
667
 
 
668
 
        case GMENU_TREE_ITEM_ENTRY:
669
 
                panel_launcher_create_with_id (toplevel_id,
670
 
                                               G_MAXINT/2,
671
 
                                               gmenu_tree_entry_get_desktop_file_path (GMENU_TREE_ENTRY (aliased_item)));
672
 
                break;
673
 
 
674
 
        default:
675
 
                break;
676
 
        }
677
 
 
678
 
        gmenu_tree_item_unref (aliased_item);
679
 
}
680
 
 
681
 
static void
682
 
add_drawers_from_dir (GMenuTreeDirectory *directory,
683
 
                      int                 pos,
684
 
                      const char         *toplevel_id)
685
 
{
686
 
        const char *name;
687
 
        const char *icon;
688
 
        GSList     *items;
689
 
        GSList     *l;
690
 
        char       *attached_toplevel_id;
691
 
 
692
 
        name = gmenu_tree_directory_get_name (directory);
693
 
        icon = gmenu_tree_directory_get_icon (directory);
694
 
 
695
 
        attached_toplevel_id = panel_drawer_create_with_id (toplevel_id,
696
 
                                                            pos,
697
 
                                                            icon,
698
 
                                                            icon != NULL,
699
 
                                                            name);
700
 
        if (!attached_toplevel_id)
701
 
                return;
702
 
 
703
 
        items = gmenu_tree_directory_get_contents (directory);
704
 
        for (l = items; l; l = l->next) {
705
 
                GMenuTreeItem *item = l->data;
706
 
 
707
 
                switch (gmenu_tree_item_get_type (item)) {
708
 
                case GMENU_TREE_ITEM_ENTRY:
709
 
                        panel_launcher_create_with_id (attached_toplevel_id,
710
 
                                                       G_MAXINT/2,
711
 
                                                       gmenu_tree_entry_get_desktop_file_path (GMENU_TREE_ENTRY (item)));
712
 
                        break;
713
 
 
714
 
                case GMENU_TREE_ITEM_DIRECTORY:
715
 
                        add_drawers_from_dir (GMENU_TREE_DIRECTORY (item),
716
 
                                              G_MAXINT/2,
717
 
                                              attached_toplevel_id);
718
 
                        break;
719
 
 
720
 
                case GMENU_TREE_ITEM_ALIAS:
721
 
                        add_drawers_from_alias (GMENU_TREE_ALIAS (item), attached_toplevel_id);
722
 
                        break;
723
 
 
724
 
                default:
725
 
                        break;
726
 
                }
727
 
 
728
 
                gmenu_tree_item_unref (item);
729
 
        }
730
 
 
731
 
        g_slist_free (items);
732
 
 
733
 
        g_free (attached_toplevel_id);
734
 
}
735
 
 
736
 
static void
737
 
add_menudrawer_to_panel (GtkWidget      *menuitem,
738
 
                         GMenuTreeEntry *entry)
739
 
 
740
 
{
741
 
        GMenuTreeDirectory *directory;
742
 
        PanelWidget       *panel;
743
 
        PanelData         *pd;
744
 
        int                insertion_pos;
745
 
 
746
 
        directory = gmenu_tree_item_get_parent (GMENU_TREE_ITEM (entry));
747
 
 
748
 
        panel = menu_get_panel (menuitem);
749
 
 
750
 
        pd = g_object_get_data (G_OBJECT (panel->toplevel), "PanelData");
751
 
        insertion_pos = pd ? pd->insertion_pos : -1;
752
 
 
753
 
        add_drawers_from_dir (directory,
754
 
                              insertion_pos,
755
 
                              panel_profile_get_toplevel_id (panel->toplevel));
756
 
 
757
 
        gmenu_tree_item_unref (directory);
758
 
}
759
 
 
760
 
static void
761
 
add_menu_to_panel (GtkWidget      *menuitem,
762
 
                   GMenuTreeEntry *entry)
763
 
{
764
 
        GMenuTreeDirectory *directory;
765
 
        GMenuTree          *tree;
766
 
        PanelWidget        *panel;
767
 
        PanelData          *pd;
768
 
        int                 insertion_pos;
769
 
        char               *menu_path;
770
 
        const char         *menu_filename;
771
 
 
772
 
        directory = gmenu_tree_item_get_parent (GMENU_TREE_ITEM (entry));
773
 
        if (!directory) {
774
 
                g_warning ("Cannot find the filename for the menu: no directory");
775
 
                return;
776
 
        }
777
 
 
778
 
        tree = gmenu_tree_directory_get_tree (directory);
779
 
        if (!tree) {
780
 
                gmenu_tree_item_unref (directory);
781
 
                g_warning ("Cannot find the filename for the menu: no tree");
782
 
                return;
783
 
        }
784
 
 
785
 
        menu_filename = gmenu_tree_get_menu_file (tree);
786
 
        gmenu_tree_unref (tree);
787
 
        if (!menu_filename) {
788
 
                gmenu_tree_item_unref (directory);
789
 
                g_warning ("Cannot find the filename for the menu: no filename");
790
 
                return;
791
 
        }
792
 
 
793
 
        panel = menu_get_panel (menuitem);
794
 
 
795
 
        pd = g_object_get_data (G_OBJECT (panel->toplevel), "PanelData");
796
 
        insertion_pos = pd ? pd->insertion_pos : -1;
797
 
 
798
 
        menu_path = gmenu_tree_directory_make_path (directory, NULL);
799
 
 
800
 
        panel_menu_button_create (panel->toplevel,
801
 
                                  insertion_pos,
802
 
                                  menu_filename,
803
 
                                  menu_path,
804
 
                                  TRUE,
805
 
                                  gmenu_tree_directory_get_name (directory));
806
 
 
807
 
        g_free (menu_path);
808
 
 
809
 
        gmenu_tree_item_unref (directory);
810
 
}
811
 
 
812
 
/*most of this function stolen from the real gtk_menu_popup*/
813
 
static void
814
 
restore_grabs(GtkWidget *w, gpointer data)
815
 
{
816
 
        GtkWidget *menu_item = data;
817
 
        GtkMenu *menu = GTK_MENU (gtk_widget_get_parent (menu_item));
818
 
        GtkWidget *xgrab_shell;
819
 
        GtkWidget *parent;
820
 
 
821
 
        /* Find the last viewable ancestor, and make an X grab on it
822
 
         */
823
 
        parent = GTK_WIDGET (menu);
824
 
        xgrab_shell = NULL;
825
 
        while (parent) {
826
 
                gboolean viewable = TRUE;
827
 
                GtkWidget *tmp = parent;
828
 
 
829
 
                while (tmp) {
830
 
                        if (!gtk_widget_get_mapped (tmp)) {
831
 
                                viewable = FALSE;
832
 
                                break;
833
 
                        }
834
 
                        tmp = gtk_widget_get_parent (tmp);
835
 
                }
836
 
 
837
 
                if (viewable)
838
 
                        xgrab_shell = parent;
839
 
 
840
 
                parent = GTK_MENU_SHELL (parent)->parent_menu_shell;
841
 
        }
842
 
 
843
 
        /*only grab if this HAD a grab before*/
844
 
        if (xgrab_shell && (GTK_MENU_SHELL (xgrab_shell)->have_xgrab))
845
 
          {
846
 
            GdkWindow *window = gtk_widget_get_window (xgrab_shell);
847
 
 
848
 
            if (gdk_pointer_grab (window, TRUE,
849
 
                                  GDK_BUTTON_PRESS_MASK |
850
 
                                  GDK_BUTTON_RELEASE_MASK |
851
 
                                  GDK_ENTER_NOTIFY_MASK |
852
 
                                  GDK_LEAVE_NOTIFY_MASK,
853
 
                                  NULL, NULL, 0) == 0)
854
 
              {
855
 
                if (gdk_keyboard_grab (window, TRUE,
856
 
                                       GDK_CURRENT_TIME) == 0)
857
 
                  GTK_MENU_SHELL (xgrab_shell)->have_xgrab = TRUE;
858
 
                else
859
 
                  gdk_pointer_ungrab (GDK_CURRENT_TIME);
860
 
              }
861
 
         }
862
 
        
863
 
        gtk_grab_add (GTK_WIDGET (menu));
864
 
}
865
 
 
866
 
static void
867
 
menu_destroy_context_menu (GtkWidget *item,
868
 
                           GtkWidget *menu)
869
 
{
870
 
        g_signal_handlers_disconnect_by_func (menu, restore_grabs, item);
871
 
        gtk_widget_destroy (menu);
872
 
}
873
 
 
874
 
static GtkWidget *
875
 
create_item_context_menu (GtkWidget   *item,
876
 
                          PanelWidget *panel_widget)
877
 
{
878
 
        GMenuTreeEntry     *entry;
879
 
        GMenuTreeDirectory *directory;
880
 
        GMenuTree          *tree;
881
 
        GtkWidget          *menu;
882
 
        GtkWidget          *submenu;
883
 
        GtkWidget          *menuitem;
884
 
        const char         *menu_filename;
885
 
        gboolean            id_lists_writable;
886
 
 
887
 
        id_lists_writable = panel_profile_id_lists_are_writable ();
888
 
 
889
 
        entry = g_object_get_data (G_OBJECT (item), "panel-menu-tree-entry");
890
 
        if (!entry)
891
 
                return NULL;
892
 
 
893
 
        directory = gmenu_tree_item_get_parent (GMENU_TREE_ITEM (entry));
894
 
        if (!directory)
895
 
                return NULL;
896
 
 
897
 
        tree = gmenu_tree_directory_get_tree (directory);
898
 
        gmenu_tree_item_unref (directory);
899
 
        if (!tree)
900
 
                return NULL;
901
 
 
902
 
        menu_filename = gmenu_tree_get_menu_file (tree);
903
 
        gmenu_tree_unref (tree);
904
 
        if (!menu_filename)
905
 
                return NULL;
906
 
 
907
 
        menu = create_empty_menu ();
908
 
        g_object_set_data (G_OBJECT (item), "panel-item-context-menu", menu);
909
 
        g_object_set_data (G_OBJECT (menu), "menu_panel", panel_widget);
910
 
 
911
 
        g_signal_connect (item, "destroy",
912
 
                          G_CALLBACK (menu_destroy_context_menu), menu);
913
 
        g_signal_connect (menu, "deactivate",
914
 
                          G_CALLBACK (restore_grabs), item);
915
 
 
916
 
        menuitem = gtk_menu_item_new_with_mnemonic (_("Add this launcher to _panel"));
917
 
        g_signal_connect (menuitem, "activate",
918
 
                          G_CALLBACK (add_app_to_panel), entry);
919
 
        gtk_widget_set_sensitive (menuitem, id_lists_writable);
920
 
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
921
 
        gtk_widget_show (menuitem);
922
 
 
923
 
        menuitem = gtk_menu_item_new_with_mnemonic (_("Add this launcher to _desktop"));
924
 
        g_signal_connect (menuitem, "activate",
925
 
                          G_CALLBACK (add_app_to_desktop), entry);
926
 
        gtk_widget_set_sensitive (menuitem, id_lists_writable);
927
 
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
928
 
        gtk_widget_show (menuitem);
929
 
 
930
 
 
931
 
        submenu = create_empty_menu ();
932
 
 
933
 
        g_object_set_data (G_OBJECT (submenu), "menu_panel", panel_widget);
934
 
 
935
 
        menuitem = gtk_menu_item_new_with_mnemonic (_("_Entire menu"));
936
 
        gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
937
 
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
938
 
        gtk_widget_show (menuitem);
939
 
 
940
 
        menuitem = gtk_menu_item_new_with_mnemonic (_("Add this as _drawer to panel"));
941
 
        g_signal_connect (menuitem, "activate",
942
 
                          G_CALLBACK (add_menudrawer_to_panel), entry);
943
 
        gtk_widget_set_sensitive (menuitem, id_lists_writable);
944
 
        gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem);
945
 
        gtk_widget_show (menuitem);
946
 
 
947
 
        menuitem = gtk_menu_item_new_with_mnemonic (_("Add this as _menu to panel"));
948
 
        g_signal_connect (menuitem, "activate",
949
 
                          G_CALLBACK (add_menu_to_panel), entry);
950
 
        gtk_widget_set_sensitive (menuitem, id_lists_writable);
951
 
        gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem);
952
 
        gtk_widget_show (menuitem);
953
 
 
954
 
        return menu;
955
 
}
956
 
 
957
 
static gboolean
958
 
show_item_menu (GtkWidget      *item,
959
 
                GdkEventButton *bevent)
960
 
{
961
 
        PanelWidget *panel_widget;
962
 
        GtkWidget   *menu;
963
 
 
964
 
        if (panel_lockdown_get_locked_down ())
965
 
                return FALSE;
966
 
 
967
 
        panel_widget = menu_get_panel (item);
968
 
 
969
 
        menu = g_object_get_data (G_OBJECT (item), "panel-item-context-menu");
970
 
 
971
 
        if (!menu)
972
 
                menu = create_item_context_menu (item, panel_widget);
973
 
 
974
 
        if (!menu)
975
 
                return FALSE;
976
 
 
977
 
        gtk_menu_set_screen (GTK_MENU (menu),
978
 
                             gtk_window_get_screen (GTK_WINDOW (panel_widget->toplevel)));
979
 
 
980
 
        gtk_menu_popup (GTK_MENU (menu),
981
 
                        NULL, NULL, NULL, NULL,
982
 
                        bevent->button,
983
 
                        bevent->time);
984
 
 
985
 
        return TRUE;
986
 
}
987
 
 
988
567
gboolean
989
568
menu_dummy_button_press_event (GtkWidget      *menuitem,
990
569
                               GdkEventButton *event)
995
574
        return FALSE;
996
575
}
997
576
 
998
 
static gboolean
999
 
menuitem_button_press_event (GtkWidget      *menuitem,
1000
 
                             GdkEventButton *event)
1001
 
{
1002
 
        if (event->button == 3)
1003
 
                return show_item_menu (menuitem, event);
1004
 
        
1005
 
        return FALSE;
1006
 
}
1007
 
 
1008
577
static void  
1009
578
drag_begin_menu_cb (GtkWidget *widget, GdkDragContext     *context)
1010
579
{
1052
621
      if (viewable)
1053
622
        xgrab_shell = parent;
1054
623
      
1055
 
      parent = GTK_MENU_SHELL (parent)->parent_menu_shell;
 
624
      parent = gtk_menu_shell_get_parent_shell (GTK_MENU_SHELL (parent));
1056
625
    }
1057
626
  
1058
627
  if (xgrab_shell && !gtk_menu_get_tearoff_state (GTK_MENU(xgrab_shell)))
1059
628
    {
 
629
      gboolean      status;
 
630
      GdkDisplay    *display;
 
631
      GdkDevice     *pointer;
 
632
      GdkDevice     *keyboard;
 
633
      GdkDeviceManager *device_manager;
1060
634
      GdkWindow *window = gtk_widget_get_window (xgrab_shell);
1061
635
      GdkCursor *cursor = gdk_cursor_new (GDK_ARROW);
1062
636
 
1063
 
      if ((gdk_pointer_grab (window, TRUE,
1064
 
                             GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
1065
 
                             GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK |
1066
 
                             GDK_POINTER_MOTION_MASK,
1067
 
                             NULL, cursor, GDK_CURRENT_TIME) == 0))
 
637
      display = gdk_window_get_display (window);
 
638
      device_manager = gdk_display_get_device_manager (display);
 
639
      pointer = gdk_device_manager_get_client_pointer (device_manager);
 
640
      keyboard = gdk_device_get_associated_device (pointer);
 
641
 
 
642
      /* FIXMEgpoo: Not sure if report to GDK_OWNERSHIP_WINDOW
 
643
                    or GDK_OWNERSHIP_APPLICATION. Idem for the
 
644
                    keyboard below */
 
645
      status = gdk_device_grab (pointer, window,
 
646
                                GDK_OWNERSHIP_WINDOW, TRUE,
 
647
                                GDK_BUTTON_PRESS_MASK
 
648
                                | GDK_BUTTON_RELEASE_MASK
 
649
                                | GDK_ENTER_NOTIFY_MASK
 
650
                                | GDK_LEAVE_NOTIFY_MASK
 
651
                                | GDK_POINTER_MOTION_MASK,
 
652
                                cursor, GDK_CURRENT_TIME);
 
653
 
 
654
      if (!status)
1068
655
        {
1069
 
          if (gdk_keyboard_grab (window, TRUE,
1070
 
                                 GDK_CURRENT_TIME) == 0)
1071
 
            GTK_MENU_SHELL (xgrab_shell)->have_xgrab = TRUE;
 
656
          if (gdk_device_grab (keyboard, window,
 
657
                               GDK_OWNERSHIP_WINDOW, TRUE,
 
658
                               GDK_KEY_PRESS | GDK_KEY_RELEASE,
 
659
                               NULL, GDK_CURRENT_TIME) == GDK_GRAB_SUCCESS)
 
660
            {
 
661
            /* FIXMEgpoo: We need either accessors or a workaround to grab
 
662
               the focus */
 
663
#if 0
 
664
             GTK_MENU_SHELL (xgrab_shell)->GSEAL(have_xgrab) = TRUE;
 
665
#endif
 
666
            }
1072
667
          else
1073
668
            {
1074
 
              gdk_pointer_ungrab (GDK_CURRENT_TIME);
 
669
              gdk_device_ungrab (pointer, GDK_CURRENT_TIME);
1075
670
            }
1076
671
        }
1077
672
 
1078
 
      gdk_cursor_unref (cursor);
 
673
      g_object_unref (cursor);
1079
674
    }
1080
675
}
1081
676
 
1103
698
}
1104
699
 
1105
700
static void
1106
 
image_menuitem_size_request (GtkWidget      *menuitem,
1107
 
                             GtkRequisition *requisition,
1108
 
                             gpointer        data)
 
701
image_menuitem_set_size_request (GtkWidget  *menuitem,
 
702
                                 GtkIconSize icon_size)
1109
703
{
1110
 
        GtkIconSize icon_size = (GtkIconSize) GPOINTER_TO_INT (data);
1111
 
        int         icon_height;
1112
 
        int         req_height;
 
704
        GtkStyleContext *context;
 
705
        GtkStateFlags state;
 
706
        GtkBorder padding, border;
 
707
        int border_width;
 
708
        int icon_height;
 
709
        int req_height;
1113
710
 
1114
711
        if (!gtk_icon_size_lookup (icon_size, NULL, &icon_height))
1115
712
                return;
1120
717
         * This is a bit ugly, since we should keep this in sync with what's in
1121
718
         * gtk_menu_item_size_request()
1122
719
         */
 
720
        context = gtk_widget_get_style_context (menuitem);
 
721
        state = gtk_widget_get_state_flags (menuitem);
 
722
        gtk_style_context_get_padding (context, state, &padding);
 
723
        gtk_style_context_get_border (context, state, &border);
 
724
 
 
725
        border_width = gtk_container_get_border_width (GTK_CONTAINER (menuitem));
1123
726
        req_height = icon_height;
1124
 
        req_height += (gtk_container_get_border_width (GTK_CONTAINER (menuitem)) +
1125
 
                       (gtk_widget_get_style (menuitem))->ythickness) * 2;
1126
 
        requisition->height = MAX (requisition->height, req_height);
 
727
        req_height += (border_width * 2) + padding.top + padding.bottom + border.top + border.bottom;
 
728
        gtk_widget_set_size_request (menuitem, -1, req_height);
1127
729
}
1128
730
 
1129
731
static char *
1196
798
                gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem),
1197
799
                                               image);
1198
800
        } else if (icon_size != GTK_ICON_SIZE_INVALID)
1199
 
                g_signal_connect (menuitem, "size_request",
1200
 
                                  G_CALLBACK (image_menuitem_size_request),
1201
 
                                  GINT_TO_POINTER (icon_size));
 
801
                image_menuitem_set_size_request (menuitem, icon_size);
1202
802
 
1203
803
        gtk_widget_show (menuitem);
1204
804
}
1216
816
void
1217
817
setup_uri_drag (GtkWidget  *menuitem,
1218
818
                const char *uri,
1219
 
                const char *icon,
1220
 
                GdkDragAction action)
 
819
                const char *icon)
1221
820
{
1222
821
        static GtkTargetEntry menu_item_targets[] = {
1223
822
                { "text/uri-list", 0, 0 }
1224
823
        };
1225
824
 
1226
 
        if (panel_lockdown_get_locked_down ())
 
825
        if (panel_lockdown_get_panels_locked_down_s ())
1227
826
                return;
1228
827
 
1229
828
        gtk_drag_source_set (menuitem,
1230
829
                             GDK_BUTTON1_MASK|GDK_BUTTON2_MASK,
1231
830
                             menu_item_targets, 1,
1232
 
                             action);
 
831
                             GDK_ACTION_COPY);
1233
832
 
1234
833
        if (icon != NULL)
1235
834
                gtk_drag_source_set_icon_name (menuitem, icon);
1253
852
                { "application/x-panel-applet-internal", 0, 0 }
1254
853
        };
1255
854
 
1256
 
        if (panel_lockdown_get_locked_down ())
 
855
        if (panel_lockdown_get_panels_locked_down_s ())
1257
856
                return;
1258
857
 
1259
858
        gtk_drag_source_set (menuitem,
1381
980
panel_image_menu_item_new (void)
1382
981
{
1383
982
        GtkWidget *menuitem;
 
983
        GtkStyleContext *context;
1384
984
 
1385
985
        menuitem = gtk_image_menu_item_new ();
1386
986
        gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (menuitem),
1387
987
                                                   TRUE);
 
988
        context = gtk_widget_get_style_context (menuitem);
 
989
        gtk_style_context_add_class (context, "gnome-panel-menu-item");
 
990
 
1388
991
        return menuitem;
1389
992
}
1390
993
 
1458
1061
        menuitem = create_submenu_entry (menu, directory);
1459
1062
        gmenu_tree_item_unref (directory);
1460
1063
 
1461
 
        g_object_set_data_full (G_OBJECT (menuitem),
1462
 
                                "panel-gmenu-tree.header",
1463
 
                                gmenu_tree_item_ref (header),
1464
 
                                (GDestroyNotify) gmenu_tree_item_unref);
1465
 
 
1466
1064
        g_signal_connect (menuitem, "activate",
1467
1065
                          G_CALLBACK (gtk_false), NULL);
1468
1066
}
1476
1074
        
1477
1075
        menuitem = panel_image_menu_item_new ();
1478
1076
 
1479
 
        g_object_set_data_full (G_OBJECT (menuitem),
1480
 
                                "panel-menu-tree-entry",
1481
 
                                gmenu_tree_item_ref (entry),
1482
 
                                (GDestroyNotify) gmenu_tree_item_unref);
1483
 
 
1484
 
        if (alias_directory)
1485
 
                //FIXME: we should probably use this data when we do dnd or
1486
 
                //context menu for this menu item
1487
 
                g_object_set_data_full (G_OBJECT (menuitem),
1488
 
                                        "panel-menu-tree-alias-directory",
1489
 
                                        gmenu_tree_item_ref (alias_directory),
1490
 
                                        (GDestroyNotify) gmenu_tree_item_unref);
1491
 
 
1492
1077
        panel_load_menu_image_deferred (menuitem,
1493
1078
                                        panel_menu_icon_get_size (),
1494
1079
                                        NULL, NULL,
1516
1101
                                             gmenu_tree_entry_get_generic_name (entry));
1517
1102
 
1518
1103
        g_signal_connect_after (menuitem, "button_press_event",
1519
 
                                G_CALLBACK (menuitem_button_press_event), NULL);
 
1104
                                G_CALLBACK (menu_dummy_button_press_event), NULL);
1520
1105
 
1521
 
        if (!panel_lockdown_get_locked_down ()) {
 
1106
        if (!panel_lockdown_get_panels_locked_down_s ()) {
1522
1107
                static GtkTargetEntry menu_item_targets[] = {
1523
1108
                        { "text/uri-list", 0, 0 }
1524
1109
                };
1590
1175
                           GtkWidget *menu)
1591
1176
{
1592
1177
        guint idle_id;
 
1178
        GList *list, *l;
1593
1179
 
1594
 
        while (GTK_MENU_SHELL (menu)->children)
1595
 
                gtk_widget_destroy (GTK_MENU_SHELL (menu)->children->data);
 
1180
        /* Remove existing items */
 
1181
        list = gtk_container_get_children (GTK_CONTAINER (menu));
 
1182
        for (l = list; l; l = l->next)
 
1183
                gtk_widget_destroy (l->data);
 
1184
        g_list_free (list);
1596
1185
 
1597
1186
        g_object_set_data_full (G_OBJECT (menu),
1598
1187
                                "panel-menu-tree-directory",
1898
1487
 
1899
1488
        image_menu_items = g_slist_prepend (image_menu_items, image);
1900
1489
}
1901
 
 
1902
 
static gboolean
1903
 
panel_menu_key_press_handler (GtkWidget   *widget,
1904
 
                              GdkEventKey *event)
1905
 
{
1906
 
        gboolean retval = FALSE;
1907
 
 
1908
 
        if ((event->keyval == GDK_Menu) ||
1909
 
            (event->keyval == GDK_F10 &&
1910
 
            (event->state & gtk_accelerator_get_default_mod_mask ()) == GDK_SHIFT_MASK)) {
1911
 
                GtkMenuShell *menu_shell = GTK_MENU_SHELL (widget);
1912
 
 
1913
 
                if (menu_shell->active_menu_item &&
1914
 
                    GTK_MENU_ITEM (menu_shell->active_menu_item)->submenu == NULL) {
1915
 
                        GdkEventButton bevent;
1916
 
 
1917
 
                        bevent.button = 3;
1918
 
                        bevent.time = GDK_CURRENT_TIME;
1919
 
                        retval = show_item_menu (menu_shell->active_menu_item,
1920
 
                                                 &bevent);
1921
 
                }
1922
 
                
1923
 
        }
1924
 
        return retval;
1925
 
}