NAME

       Gtk2::SimpleMenu - A simple interface to Gtk2's ItemFactory for creating application menus

SYNOPSIS

         use Gtk2 '-init';
         use Gtk2::SimpleMenu;

         my $menu_tree = [
               _File => {
                       item_type => '<Branch>',
                       children => [
                               _New => {
                                       callback => \&new_cb,
                                       callback_action => 0,
                                       accelerator => '<ctrl>N',
                               },
                               _Save => {
                                       callback_action => 1,
                                       callback_data => 'per entry cbdata',
                                       accelerator => '<ctrl>S',
                               },
                               _Exec => {
                                       item_type => '<StockItem>',
                                       callback_action => 2,
                                       extra_data => 'gtk-execute',
                               },
                               _Quit => {
                                       callback => sub { Gtk2->main_quit; },
                                       callback_action => 3,
                                       accelerator => '<ctrl>Q',
                               },
                       ],
               },
               _Mode => {
                       _First => {
                               item_type => '<RadioItem>',
                               callback => \&mode_callback,
                               callback_action => 4,
                               groupid => 1,
                       },
                       _Second => {
                               item_type => '<RadioItem>',
                               callback => \&mode_callback,
                               callback_action => 5,
                               groupid => 1,
                       },
                       _Third => {
                               item_type => '<RadioItem>',
                               callback => \&mode_callback,
                               callback_action => 6,
                               groupid => 1,
                       },
               }
               _Help => {
                       children => [
                               _Tearoff => {
                                       item_type => '<Tearoff>',
                               },
                               _CheckItem => {
                                       item_type => '<CheckItem>',
                                       callback_action => 7,
                               },
                               Separator => {
                                       item_type => '<Separator>',
                               },
                               _Contents => {
                                       callback_action => 8,
                               },
                               _About => {
                                       callback_action => 9,
                               },
                       ]
               }
         ];

         my $menu = Gtk2::SimpleMenu->new (
                       menu_tree => $menu_tree,
                       default_callback => \&default_callback,
                       user_data => 'user_data',
               );

         # an example of how to get to the menuitems.
         $menu->get_widget('/File/Save')->activate;

         $container->add ($menu->{widget});

ABSTRACT

       SimpleMenu is an interface for creating application menubars in as simple a manner as
       possible. Its main benefit is that the menu is specified as a tree, which is the natural
       representation of such a menu.

DESCRIPTION

       SimpleMenu aims to simplify the design and management of a complex application menu bar by
       allowing the structure to be specified as a multi-rooted tree. Much the same functionality
       is provided by Gtk2::ItemFactory, but the data provided as input is a 1-D array and the
       hierarchy of the menu is controlled entirely by the path components. This is not ideal
       when languages such as Perl provide for simple nested data structures.

       Another advantage of the SimpleMenu widget is that it simplifies the creation and use of
       accelerators.

       SimpleMenu is a child of Gtk2::ItemFactory, so that it may be treated as such.  Any method
       that can be called on a ItemFactory can be called on a SimpleMenu.

OBJECT HIERARCHY

        Glib::Object
        +--- Gtk2::Object
             +--- Gtk2::ItemFactory
                  +--- Gtk2::SimpleMenu

FUNCTIONS

       $menu = Gtk2::SimpleMenu->new (menu_tree => $menu_tree, ...)
           Creates a new Gtk2::SimpleMenu object with the specified tree. Optionally key value
           paris providing a default_callback and user_data can be provided as well.  After
           creating the menu object all of the subsequent widgets will have been created and are
           ready for use.

MEMBER VARIABLES

       $menu->{widget}
           The Gtk2::MenuBar root of the SimpleMenu. This is what should be added to the widget
           which will contain the SimpleMenu.

             $container->add ($menu->{widget});

       $menu->{accel_group}
           The Gtk2::AccellGroup created by the menu tree. Normally accell_group would be added
           to the main window of an application, but this is only necessary if accelerators are
           being used in the menu tree's items.

             $win->add_accel_group ($menu->{accel_group});

SEE ALSO

       Perl(1), Glib(3pm), Gtk2(3pm), examples/simple_menu.pl.

       Note: Gtk2::SimpleMenu is deprecated in favor of Gtk2::Ex::Simple::Menu, part of the
       Gtk2-Perl-Ex project at <http://gtk2-perl-ex.sf.net/> .

AUTHORS

        Ross McFarland <rwmcfa1 at neces dot com>

COPYRIGHT AND LICENSE

       Copyright 2003 by the Gtk2-Perl team.

       This library is free software; you can redistribute it and/or modify it under the terms of
       the GNU Library General Public License as published by the Free Software Foundation;
       either version 2.1 of the License, or (at your option) any later version.

       This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
       without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
       See the GNU Library General Public License for more details.

       You should have received a copy of the GNU Library General Public License along with this
       library; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
       Boston, MA  02111-1307  USA.