Menus

There are two constructors that create a new menu:

The 'accel_group' argument is the accelerator group which holds the global accelerators for this menu. The first constructor creates the accelerator group for you which can be retrieved by calling:

The next three constructors are used to create menu items that are packed into menubars and menus:


The 'label' argument is the menu item text, 'submenu' is a menu to associate with the menu item and 'use_underline', if true, specifies that label should be parsed for the mnemonic character. The first constructor creates an empty menu item, the second constructor creates a menu item with a label already packed into it and the last constructor creates a menu item that displays another menu when activated.

There are other more specialized menu items which can be used to construct menus. ImageMenuItem displays an image next to the text string. CheckMenuitem displays a checkbutton that can be in an active or inactive state. RadioMenuItem displays a radiobutton as part of a group which only allows one active menu item at a time. SeparatorMenuItem displays a separator line in the menu and TearoffMenuItem allows its menu to be torn off and displayed in a separate window.

Once you have created a menu item you have to put it into a menu. This is done using one of the Gtk::MenuShell methods: append, prepend or insert. There are several indentical overloaded methods for each. These are the append methods:


The 'item' argument is the menu item to add, 'callback' is the slot function to be called if the menu item is activated, 'accel_key' is the accelerator key for the menu item, 'accel_group' is the accelerator group to add the accelerator key to, and 'stock_id' is the identifier of the stock menu item to add. The last method, append_separator(), is a convenience method that creates and appends a separator for you.

In order to capture when a menu item is selected by the user, you need to connect a callback slot to the item's 'activate' signal. If you use the first append method you will have to make this connection yourself. If you pass a valid slot to one of the other append methods, append() will make this connection for you.

For example, if you wanted to create a standard File menu, with the options File, Save, and Quit, the code would look like this:






Here is a summary of the steps needed to create a menu bar with menus attached:

• Construct a new menu.
• Construct multiple menu items and use Gtk::MenuShell::append() to add each of these new items to the menu.
• Construct a menu item that will be the root of the menu, the text appearing here will be on the menubar itself.
• Pass a reference to the menu, to the root menu item constructor (the one created in the above step).
• Construct a new menubar. This step only needs to be done once when creating a series of menus on one menu bar.
• Use Gtk::MenuShell::append() to put the root menu onto the menubar.

Applications can display a Menu as a popup menu by calling the Gtk::Menu::popup() method:


The 'button' argument is the button which was pressed to initiate the event and 'activate_time' is the time at which the event occurred. This method positions the popup menu at the current pointer position. There are two other popup() methods with extended options that give you more control over where the popup menu will appear.

You can create a popup menu by explicitly calling popup() from a 'button_press_event' signal handler, which has the following prototype:




Use sigc::bind() to bind a pointer to the menu, to your slot:


where 'menu' is the bound menu pointer. Remember that bound data is always passed as the last argument to the bound method, unless otherwise specified. This would pass the bound data as the first argument:


in which case your slot would have this extended prototype:


Using the first prototype, if the event is a mouse button press, treat the event as a button event (which it is) and use it as shown in the following code to pass information to Gtk::Menu::popup():

Menu Example

Let's take a look at a menu example that implements all of the above features. The header file for this example is <menu.hh>:


and the source file is <menu.cc>:

Compiling Menu

If you compiled and installed XFC yourself, you will find the source code for Menu in the <examples/menu> source directory along with a Makefile. If XFC came pre-installed, or you installed it from an RPM package, you will find the source code in the </usr/share/doc/xfcui-X.X/examples/menu> subdirectory. In this case you will have to create the Makefile yourself (replace X.X with the version number of the libXFCui library you have installed).

To create a Makefile for Menu, add the following lines to a new text file and save it using the name "Makefile":


If you cut and paste these lines make sure the whitespace before $(CC) and rm is a tab character. When you compile and run this program you will see the following window appear:

Compiling Stock

To create a Makefile for Stock, add the following lines to a new text file and save it using the name "Makefile":


If you cut and paste these lines make sure the whitespace before $(CC) and rm is a tab character. When you compile and run the Stock program you will see the following window appear:


The XFC_MAIN macro is a convenience macro that writes a simple main function, its only argument is the name of the main window class. The macro is defined in <xfc/main.hh> as:


Most main functions in C++ are simple because all the creation work for the main window is done inside its constructor, not the main function.

---