← Back to branch summary

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

« back to all changes in this revision

Viewing changes to gnome-panel/panel-menu-button.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2011-05-30 11:04:49 UTC
  • mfrom: (1.3.4 upstream)
  • mto: This revision was merged to the branch mainline in revision 204.
  • Revision ID: james.westby@ubuntu.com-20110530110449-ut1tc5t61rpvf9e3
Tags: upstream-3.0.2
Import upstream version 3.0.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnome-panel/panel-menu-button.c
32
32
#include <gmenu-tree.h>
33
33
 
34
34
#include <libpanel-util/panel-error.h>
 
35
#include <libpanel-util/panel-glib.h>
35
36
#include <libpanel-util/panel-launch.h>
36
37
#include <libpanel-util/panel-show.h>
37
38
 
38
39
#include "applet.h"
39
40
#include "panel-widget.h"
40
41
#include "panel-util.h"
41
 
#include "panel-profile.h"
42
42
#include "panel-globals.h"
43
43
#include "menu.h"
44
44
#include "panel-lockdown.h"
45
45
#include "panel-a11y.h"
 
46
#include "panel-layout.h"
46
47
#include "panel-icon-names.h"
 
48
#include "panel-schemas.h"
47
49
 
48
50
G_DEFINE_TYPE (PanelMenuButton, panel_menu_button, BUTTON_TYPE_WIDGET)
49
51
 
54
56
        PROP_MENU_PATH,
55
57
        PROP_CUSTOM_ICON,
56
58
        PROP_TOOLTIP,
57
 
        PROP_USE_MENU_PATH,
58
 
        PROP_USE_CUSTOM_ICON,
59
59
        PROP_DND_ENABLED
60
60
};
61
61
 
63
63
        FIRST_MENU,
64
64
        APPLICATIONS_MENU,
65
65
#define DEFAULT_MENU      APPLICATIONS_MENU
66
 
        SETTINGS_MENU,
 
66
        GNOMECC_MENU,
67
67
        LAST_MENU
68
68
} MenuPathRoot;
69
69
 
75
75
 
76
76
static MenuPathRootItem root_items [] = {
77
77
        { APPLICATIONS_MENU, "applications", "applications.menu" },
78
 
        { SETTINGS_MENU,     "settings",     "settings.menu"     }
 
78
        { GNOMECC_MENU,      "gnomecc",      "gnomecc.menu"      }
79
79
};
80
80
 
81
81
struct _PanelMenuButtonPrivate {
82
82
        PanelToplevel         *toplevel;
83
 
        guint                  gconf_notify;
84
 
        char                  *applet_id;
 
83
        GSettings             *settings_instance;
85
84
 
86
85
        GtkWidget             *menu;
87
86
 
90
89
        char                  *tooltip;
91
90
 
92
91
        MenuPathRoot           path_root;
93
 
        guint                  use_menu_path : 1;
94
 
        guint                  use_custom_icon : 1;
95
92
        guint                  dnd_enabled : 1;
96
93
};
97
94
 
98
 
static void panel_menu_button_disconnect_from_gconf (PanelMenuButton *button);
99
 
static void panel_menu_button_recreate_menu         (PanelMenuButton *button);
100
95
static void panel_menu_button_set_icon              (PanelMenuButton *button);
101
96
 
102
97
static AtkObject *panel_menu_button_get_accessible  (GtkWidget       *widget);
170
165
{
171
166
        button->priv = PANEL_MENU_BUTTON_GET_PRIVATE (button);
172
167
 
173
 
        button->priv->applet_id    = NULL;
174
 
        button->priv->toplevel     = NULL;
175
 
        button->priv->gconf_notify = 0;
 
168
        button->priv->toplevel          = NULL;
 
169
        button->priv->settings_instance = NULL;
176
170
 
177
171
        button->priv->menu_path   = NULL;
178
172
        button->priv->custom_icon = NULL;
179
173
        button->priv->tooltip = NULL;
180
174
 
181
175
        button->priv->path_root       = LAST_MENU;
182
 
        button->priv->use_menu_path   = FALSE;
183
 
        button->priv->use_custom_icon = FALSE;
184
176
}
185
177
 
186
178
static void
188
180
{
189
181
        PanelMenuButton *button = PANEL_MENU_BUTTON (object);
190
182
 
191
 
        panel_lockdown_notify_remove (G_CALLBACK (panel_menu_button_recreate_menu),
192
 
                                      button);
193
 
 
194
 
        panel_menu_button_disconnect_from_gconf (button);
195
 
 
196
183
        if (button->priv->menu) {
197
184
                /* detaching the menu will kill our reference */
198
185
                gtk_menu_detach (GTK_MENU (button->priv->menu));
199
186
                button->priv->menu = NULL;
200
187
        }
201
188
 
202
 
        g_free (button->priv->applet_id);
203
 
        button->priv->applet_id = NULL;
 
189
        if (button->priv->settings_instance)
 
190
                g_object_unref (button->priv->settings_instance);
 
191
        button->priv->settings_instance = NULL;
204
192
 
205
193
        g_free (button->priv->menu_path);
206
194
        button->priv->menu_path = NULL;
236
224
        case PROP_TOOLTIP:
237
225
                g_value_set_string (value, button->priv->tooltip);
238
226
                break;
239
 
        case PROP_USE_MENU_PATH:
240
 
                g_value_set_boolean (value, button->priv->use_menu_path);
241
 
                break;
242
 
        case PROP_USE_CUSTOM_ICON:
243
 
                g_value_set_boolean (value, button->priv->use_custom_icon);
244
 
                break;
245
227
        case PROP_DND_ENABLED:
246
228
                g_value_set_boolean (value, button->priv->dnd_enabled);
247
229
                break;
273
255
        case PROP_TOOLTIP:
274
256
                panel_menu_button_set_tooltip (button, g_value_get_string (value));
275
257
                break;
276
 
        case PROP_USE_MENU_PATH:
277
 
                panel_menu_button_set_use_menu_path (button, g_value_get_boolean (value));
278
 
                break;
279
 
        case PROP_USE_CUSTOM_ICON:
280
 
                panel_menu_button_set_use_custom_icon (button, g_value_get_boolean (value));
281
 
                break;
282
258
        case PROP_DND_ENABLED:
283
259
                panel_menu_button_set_dnd_enabled (button, g_value_get_boolean (value));
284
260
                break;
349
325
{
350
326
        panel_toplevel_pop_autohide_disabler (button->priv->toplevel);
351
327
 
352
 
        GTK_BUTTON (button)->in_button = FALSE;
 
328
        gtk_widget_unset_state_flags (GTK_WIDGET (button),
 
329
                                      GTK_STATE_FLAG_PRELIGHT);
 
330
 
353
331
        button_widget_set_ignore_leave (BUTTON_WIDGET (button), FALSE);
354
332
}
355
333
 
380
358
 
381
359
        panel_widget = panel_toplevel_get_panel_widget (button->priv->toplevel);
382
360
 
383
 
        if (button->priv->use_menu_path          &&
384
 
            button->priv->path_root > FIRST_MENU &&
 
361
        if (!PANEL_GLIB_STR_EMPTY (button->priv->menu_path) &&
 
362
            button->priv->path_root > FIRST_MENU            &&
385
363
            button->priv->path_root < LAST_MENU) {
386
364
                const char *filename;
387
365
 
405
383
        return button->priv->menu;
406
384
}
407
385
 
408
 
static void
409
 
panel_menu_button_recreate_menu (PanelMenuButton *button)
410
 
{
411
 
        if (button->priv->menu)
412
 
                gtk_widget_destroy (button->priv->menu);
413
 
        button->priv->menu = NULL;
414
 
}
415
 
 
416
386
void
417
387
panel_menu_button_popup_menu (PanelMenuButton *button,
418
388
                              guint            n_button,
527
497
 
528
498
        g_object_class_install_property (
529
499
                        gobject_class,
530
 
                        PROP_USE_MENU_PATH,
531
 
                        g_param_spec_boolean ("use-menu-path",
532
 
                                              "Use Menu Path",
533
 
                                              "Use the path specified by the menu-path property",
534
 
                                              FALSE,
535
 
                                              G_PARAM_READWRITE));
536
 
 
537
 
        g_object_class_install_property (
538
 
                        gobject_class,
539
 
                        PROP_USE_CUSTOM_ICON,
540
 
                        g_param_spec_boolean ("use-custom-icon",
541
 
                                              "Use Custom Icon",
542
 
                                              "Use the icon specified by the custom-icon property",
543
 
                                              FALSE,
544
 
                                              G_PARAM_READWRITE));
545
 
 
546
 
        g_object_class_install_property (
547
 
                        gobject_class,
548
500
                        PROP_DND_ENABLED,
549
501
                        g_param_spec_boolean ("dnd-enabled",
550
502
                                              "Drag and drop enabled",
554
506
}
555
507
 
556
508
static void
557
 
panel_menu_button_gconf_notify (GConfClient     *client,
558
 
                                guint            cnxn_id,
559
 
                                GConfEntry      *entry,
560
 
                                PanelMenuButton *button)
 
509
panel_menu_button_settings_changed (GSettings       *settings,
 
510
                                    char            *key,
 
511
                                    PanelMenuButton *button)
561
512
{
562
 
        GConfValue *value;
563
 
        const char *key;
564
 
 
565
 
        key = panel_gconf_basename (gconf_entry_get_key (entry));
566
 
 
567
 
        value = entry->value;
568
 
 
569
 
        if (!strcmp (key, "menu_path")) {
570
 
                if (value && value->type == GCONF_VALUE_STRING)
571
 
                        panel_menu_button_set_menu_path (button,
572
 
                                                         gconf_value_get_string (value));
573
 
        } else if (!strcmp (key, "custom_icon")) {
574
 
                if (value && value->type == GCONF_VALUE_STRING)
575
 
                        panel_menu_button_set_custom_icon (button,
576
 
                                                           gconf_value_get_string (value));
577
 
        } else if (!strcmp (key, "tooltip")) {
578
 
                if (value && value->type == GCONF_VALUE_STRING)
579
 
                        panel_menu_button_set_tooltip (button,
580
 
                                                       gconf_value_get_string (value));
581
 
        } else if (!strcmp (key, "use_menu_path")) {
582
 
                if (value && value->type == GCONF_VALUE_BOOL)
583
 
                        panel_menu_button_set_use_menu_path (button,
584
 
                                                             gconf_value_get_bool (value));
585
 
        } else if (!strcmp (key, "use_custom_icon")) {
586
 
                if (value && value->type == GCONF_VALUE_BOOL)
587
 
                        panel_menu_button_set_use_custom_icon (button,
588
 
                                                               gconf_value_get_bool (value));
 
513
        char *value = NULL;
 
514
 
 
515
        if (g_strcmp0 (key, PANEL_MENU_BUTTON_MENU_PATH_KEY) == 0) {
 
516
                value = g_settings_get_string (settings, key);
 
517
                panel_menu_button_set_menu_path (button, value);
 
518
        } else if (g_strcmp0 (key, PANEL_MENU_BUTTON_CUSTOM_ICON_KEY) == 0) {
 
519
                value = g_settings_get_string (settings, key);
 
520
                panel_menu_button_set_custom_icon (button, value);
 
521
        } else if (g_strcmp0 (key, PANEL_MENU_BUTTON_TOOLTIP_KEY) == 0) {
 
522
                value = g_settings_get_string (settings, key);
 
523
                panel_menu_button_set_tooltip (button, value);
589
524
        }
590
 
}
591
 
 
592
 
static void
593
 
panel_menu_button_connect_to_gconf (PanelMenuButton *button)
594
 
{
595
 
        GConfClient *client;
596
 
        const char  *key;
597
 
 
598
 
        client  = panel_gconf_get_client ();
599
 
 
600
 
        key = panel_gconf_sprintf (PANEL_CONFIG_DIR "/objects/%s",
601
 
                                   button->priv->applet_id);
602
 
        gconf_client_add_dir (client, key, GCONF_CLIENT_PRELOAD_ONELEVEL, NULL);
603
 
        button->priv->gconf_notify =
604
 
                gconf_client_notify_add (client, key,
605
 
                                         (GConfClientNotifyFunc) panel_menu_button_gconf_notify,
606
 
                                         button, NULL, NULL);
607
 
}
608
 
 
609
 
static void
610
 
panel_menu_button_disconnect_from_gconf (PanelMenuButton *button)
611
 
{
612
 
        GConfClient *client;
613
 
        const char  *key;
614
 
 
615
 
        if (!button->priv->gconf_notify)
616
 
                return;
617
 
 
618
 
        client  = panel_gconf_get_client ();
619
 
 
620
 
        key = panel_gconf_sprintf (PANEL_CONFIG_DIR "/objects/%s",
621
 
                                   button->priv->applet_id);
622
 
 
623
 
        gconf_client_notify_remove (client, button->priv->gconf_notify);
624
 
        button->priv->gconf_notify = 0;
625
 
 
626
 
        gconf_client_remove_dir (client, key, NULL);
627
 
}
628
 
 
629
 
static void
630
 
panel_menu_button_load (const char  *menu_path,
631
 
                        gboolean     use_menu_path,
632
 
                        const char  *custom_icon,
633
 
                        gboolean     use_custom_icon,
634
 
                        const char  *tooltip,
635
 
                        PanelWidget *panel,
636
 
                        gboolean     locked,
637
 
                        int          position,
638
 
                        gboolean     exactpos,
639
 
                        const char  *id)
 
525
 
 
526
        g_free (value);
 
527
}
 
528
 
 
529
static void
 
530
panel_menu_button_load_helper (const char  *menu_path,
 
531
                               const char  *custom_icon,
 
532
                               const char  *tooltip,
 
533
                               PanelWidget *panel,
 
534
                               const char  *id,
 
535
                               GSettings   *settings)
640
536
{
641
537
        PanelMenuButton *button;
642
538
        AppletInfo      *info;
647
543
                               "menu-path", menu_path,
648
544
                               "custom-icon", custom_icon,
649
545
                               "tooltip", tooltip,
650
 
                               "use-menu-path", use_menu_path,
651
 
                               "use-custom-icon", use_custom_icon,
652
546
                               "has-arrow", TRUE,
653
547
                               NULL);
654
548
 
655
 
        info = panel_applet_register (GTK_WIDGET (button), NULL, NULL,
656
 
                                      panel, locked, position, exactpos,
657
 
                                      PANEL_OBJECT_MENU, id);
 
549
        info = panel_applet_register (GTK_WIDGET (button),
 
550
                                      panel,
 
551
                                      PANEL_OBJECT_MENU, id,
 
552
                                      settings,
 
553
                                      NULL, NULL);
658
554
        if (!info) {
659
555
                gtk_widget_destroy (GTK_WIDGET (button));
660
556
                return;
661
557
        }
662
558
 
663
 
        button->priv->applet_id = g_strdup (info->id);
664
 
 
665
 
        panel_applet_add_callback (info, "help", GTK_STOCK_HELP, _("_Help"), NULL);
666
 
 
667
559
        if (panel_is_program_in_path ("alacarte") ||
668
560
            panel_is_program_in_path ("gmenu-simple-editor"))
669
561
                panel_applet_add_callback (info, "edit", NULL,
670
 
                                           _("_Edit Menus"), NULL);
 
562
                                           _("_Edit Menus"),
 
563
                                           panel_lockdown_get_not_panels_locked_down_s);
671
564
 
672
565
        panel_widget_set_applet_expandable (panel, GTK_WIDGET (button), FALSE, TRUE);
673
566
        panel_widget_set_applet_size_constrained (panel, GTK_WIDGET (button), TRUE);
674
567
 
675
 
        panel_menu_button_connect_to_gconf (button);
 
568
        button->priv->settings_instance = panel_layout_get_instance_settings (
 
569
                                                        settings,
 
570
                                                        PANEL_MENU_BUTTON_SCHEMA);
676
571
 
677
 
        panel_lockdown_notify_add (G_CALLBACK (panel_menu_button_recreate_menu),
678
 
                                   button);
 
572
        g_signal_connect (button->priv->settings_instance, "changed",
 
573
                          G_CALLBACK (panel_menu_button_settings_changed),
 
574
                          button);
679
575
}
680
576
 
681
577
static char *
686
582
 
687
583
        retval = NULL;
688
584
 
689
 
        if (button->priv->use_custom_icon &&
690
 
            button->priv->custom_icon)
 
585
        if (!PANEL_GLIB_STR_EMPTY (button->priv->custom_icon))
691
586
                retval = g_strdup (button->priv->custom_icon);
692
587
 
693
 
        if (!retval                     &&
694
 
            button->priv->use_menu_path &&
695
 
            button->priv->menu_path     &&
 
588
        if (!retval                                         &&
 
589
            !PANEL_GLIB_STR_EMPTY (button->priv->menu_path) &&
696
590
            panel_menu_button_create_menu (button)) {
697
591
                directory = g_object_get_data (G_OBJECT (button->priv->menu),
698
592
                                               "panel-menu-tree-directory");
756
650
 
757
651
        return p;
758
652
}
759
 
                                                                                                             
 
653
 
 
654
gboolean
 
655
panel_menu_button_is_main_menu (PanelMenuButton *button)
 
656
{
 
657
        g_return_val_if_fail (PANEL_IS_MENU_BUTTON (button), FALSE);
 
658
 
 
659
        return PANEL_GLIB_STR_EMPTY (button->priv->menu_path);
 
660
}
 
661
 
760
662
void
761
663
panel_menu_button_set_menu_path (PanelMenuButton *button,
762
664
                                 const char      *menu_uri)
816
718
        g_return_if_fail (PANEL_IS_MENU_BUTTON (button));
817
719
 
818
720
        g_free (button->priv->tooltip);
819
 
        button->priv->tooltip = NULL;
820
 
 
821
 
        if (tooltip && tooltip [0]) {
822
 
                button->priv->tooltip = g_strdup (tooltip);
823
 
                panel_util_set_tooltip_text (GTK_WIDGET (button), tooltip);
824
 
        }
825
 
}
826
 
 
827
 
void
828
 
panel_menu_button_set_use_menu_path (PanelMenuButton *button,
829
 
                                     gboolean         use_menu_path)
830
 
{
831
 
        g_return_if_fail (PANEL_IS_MENU_BUTTON (button));
832
 
 
833
 
        use_menu_path = use_menu_path != FALSE;
834
 
 
835
 
        if (button->priv->use_menu_path == use_menu_path)
836
 
                return;
837
 
 
838
 
        button->priv->use_menu_path = use_menu_path;
839
 
 
840
 
        if (button->priv->menu)
841
 
                gtk_menu_detach (GTK_MENU (button->priv->menu));
842
 
        button->priv->menu = NULL;
843
 
 
844
 
        panel_menu_button_set_icon (button);
845
 
}
846
 
 
847
 
gboolean
848
 
panel_menu_button_get_use_menu_path (PanelMenuButton *button)
849
 
{
850
 
        g_return_val_if_fail (PANEL_IS_MENU_BUTTON (button), FALSE);
851
 
 
852
 
        return button->priv->use_menu_path;
853
 
}
854
 
 
855
 
void
856
 
panel_menu_button_set_use_custom_icon (PanelMenuButton *button,
857
 
                                       gboolean         use_custom_icon)
858
 
{
859
 
        g_return_if_fail (PANEL_IS_MENU_BUTTON (button));
860
 
 
861
 
        button->priv->use_custom_icon = use_custom_icon != FALSE;
862
 
 
863
 
        panel_menu_button_set_icon (button);
864
 
}
865
 
 
866
 
void
867
 
panel_menu_button_load_from_gconf (PanelWidget *panel,
868
 
                                   gboolean     locked,
869
 
                                   int          position,
870
 
                                   gboolean     exactpos,
871
 
                                   const char  *id)
872
 
{
873
 
        GConfClient *client;
874
 
        const char  *key;
875
 
        char        *menu_path;
876
 
        char        *custom_icon;
877
 
        char        *tooltip;
878
 
        gboolean     use_menu_path;
879
 
        gboolean     use_custom_icon;
880
 
 
881
 
        client  = panel_gconf_get_client ();
882
 
 
883
 
        key = panel_gconf_full_key (PANEL_GCONF_OBJECTS, id, "menu_path");
884
 
        menu_path = gconf_client_get_string (client, key, NULL);
885
 
 
886
 
        key = panel_gconf_full_key (PANEL_GCONF_OBJECTS, id, "custom_icon");
887
 
        custom_icon = gconf_client_get_string (client, key, NULL);
888
 
 
889
 
        key = panel_gconf_full_key (PANEL_GCONF_OBJECTS, id, "tooltip");
890
 
        tooltip = gconf_client_get_string (client, key, NULL);
891
 
 
892
 
        key = panel_gconf_full_key (PANEL_GCONF_OBJECTS, id, "use_menu_path");
893
 
        use_menu_path = gconf_client_get_bool (client, key, NULL);
894
 
 
895
 
        key = panel_gconf_full_key (PANEL_GCONF_OBJECTS, id, "use_custom_icon");
896
 
        use_custom_icon = gconf_client_get_bool (client, key, NULL);
897
 
 
898
 
        panel_menu_button_load (menu_path,
899
 
                                use_menu_path,
900
 
                                custom_icon,
901
 
                                use_custom_icon,
902
 
                                tooltip,
903
 
                                panel,
904
 
                                locked,
905
 
                                position,
906
 
                                exactpos,
907
 
                                id);
 
721
        button->priv->tooltip = g_strdup (tooltip);
 
722
 
 
723
        panel_util_set_tooltip_text (GTK_WIDGET (button), tooltip);
 
724
}
 
725
 
 
726
void
 
727
panel_menu_button_load (PanelWidget *panel,
 
728
                        const char  *id,
 
729
                        GSettings   *settings)
 
730
{
 
731
        GSettings    *settings_instance;
 
732
        char         *scheme;
 
733
        MenuPathRoot  root;
 
734
        char         *menu_path;
 
735
        char         *custom_icon;
 
736
        char         *tooltip;
 
737
 
 
738
        settings_instance = panel_layout_get_instance_settings (settings,
 
739
                                                                PANEL_MENU_BUTTON_SCHEMA);
 
740
 
 
741
        menu_path = g_settings_get_string (settings_instance,
 
742
                                           PANEL_MENU_BUTTON_MENU_PATH_KEY);
 
743
        custom_icon = g_settings_get_string (settings_instance,
 
744
                                             PANEL_MENU_BUTTON_CUSTOM_ICON_KEY);
 
745
        tooltip = g_settings_get_string (settings_instance,
 
746
                                         PANEL_MENU_BUTTON_TOOLTIP_KEY);
 
747
 
 
748
        scheme = g_strndup (menu_path, strcspn (menu_path, ":"));
 
749
        root = panel_menu_scheme_to_path_root (scheme);
 
750
        g_free (scheme);
 
751
 
 
752
        panel_menu_button_load_helper (menu_path,
 
753
                                       custom_icon,
 
754
                                       tooltip,
 
755
                                       panel,
 
756
                                       id,
 
757
                                       settings);
908
758
 
909
759
        g_free (menu_path);
910
760
        g_free (custom_icon);
911
761
        g_free (tooltip);
 
762
 
 
763
        g_object_unref (settings_instance);
912
764
}
913
765
 
914
766
gboolean
915
 
panel_menu_button_create (PanelToplevel *toplevel,
916
 
                          int            position,
917
 
                          const char    *filename,
918
 
                          const char    *menu_path,
919
 
                          gboolean       use_menu_path,
920
 
                          const char    *tooltip)
 
767
panel_menu_button_create (PanelToplevel       *toplevel,
 
768
                          PanelObjectPackType  pack_type,
 
769
                          int                  pack_index,
 
770
                          const char          *filename,
 
771
                          const char          *menu_path,
 
772
                          const char          *tooltip)
921
773
{
922
 
        GConfClient *client;
923
 
        const char  *scheme;
924
 
        const char  *key;
925
 
        char        *id;
926
 
 
927
 
        client  = panel_gconf_get_client ();
928
 
 
929
 
        id = panel_profile_prepare_object (PANEL_OBJECT_MENU, toplevel, position, FALSE);
930
 
 
931
 
        key = panel_gconf_full_key (PANEL_GCONF_OBJECTS, id, "use_menu_path");
932
 
        gconf_client_set_bool (client, key, use_menu_path, NULL);
 
774
        char       *id;
 
775
        GSettings  *settings;
 
776
        GSettings  *settings_instance;
 
777
        const char *scheme;
933
778
 
934
779
        scheme = panel_menu_filename_to_scheme (filename);
935
780
 
936
781
        if (filename && !scheme) {
937
782
                g_warning ("Failed to find menu scheme for %s\n", filename);
938
 
                g_free (id);
939
783
                return FALSE;
940
784
        }
941
785
 
942
 
        if (use_menu_path && menu_path && menu_path [0] && scheme) {
943
 
                char       *menu_uri;
 
786
        id = panel_layout_object_create_start (PANEL_OBJECT_MENU, NULL,
 
787
                                               panel_toplevel_get_id (toplevel),
 
788
                                               pack_type, pack_index,
 
789
                                               &settings);
 
790
 
 
791
        settings_instance = panel_layout_get_instance_settings (settings,
 
792
                                                                PANEL_MENU_BUTTON_SCHEMA);
 
793
 
 
794
        if (!PANEL_GLIB_STR_EMPTY (menu_path) && scheme) {
 
795
                char *menu_uri;
944
796
 
945
797
                menu_uri = g_strconcat (scheme, ":", menu_path, NULL);
946
798
 
947
 
                key = panel_gconf_full_key (PANEL_GCONF_OBJECTS, id, "menu_path");
948
 
                gconf_client_set_string (client, key, menu_uri, NULL);
 
799
                g_settings_set_string (settings_instance,
 
800
                                       PANEL_MENU_BUTTON_MENU_PATH_KEY,
 
801
                                       menu_uri);
949
802
 
950
803
                g_free (menu_uri);
951
804
        }
952
805
 
953
 
        if (tooltip && tooltip [0]) {
954
 
                key = panel_gconf_full_key (PANEL_GCONF_OBJECTS, id, "tooltip");
955
 
                gconf_client_set_string (client, key, tooltip, NULL);
 
806
        if (!PANEL_GLIB_STR_EMPTY (tooltip)) {
 
807
                g_settings_set_string (settings_instance,
 
808
                                       PANEL_MENU_BUTTON_TOOLTIP_KEY,
 
809
                                       tooltip);
956
810
        }
957
811
 
958
 
        panel_profile_add_to_list (PANEL_GCONF_OBJECTS, id);
 
812
        panel_layout_object_create_finish (id);
 
813
 
 
814
        g_object_unref (settings_instance);
 
815
        g_object_unref (settings);
959
816
        g_free (id);
960
817
 
961
818
        return TRUE;