CtkMenuItem as CtkBuildable

The CtkMenuItem implementation of the CtkBuildable interface supports adding a submenu by specifying “submenu” as the “type” attribute of a <child> element.

An example of UI definition fragment with submenus:

1
2
3
4
5

<object class="CtkMenuItem">
  <child type="submenu">
    <object class="CtkMenu"/>
  </child>
</object>

CSS nodes

1
2
3

menuitem
├── <child>
╰── [arrow.right]

CtkMenuItem has a single CSS node with name menuitem. If the menuitem has a submenu, it gets another CSS node with name arrow, which has the .left or .right style class.

ctk_menu_item_new ()

CtkWidget *
ctk_menu_item_new (void);

Creates a new CtkMenuItem.

ctk_menu_item_new_with_label ()

CtkWidget *
ctk_menu_item_new_with_label (const gchar *label);

Creates a new CtkMenuItem whose child is a CtkLabel.

ctk_menu_item_new_with_mnemonic ()

CtkWidget *
ctk_menu_item_new_with_mnemonic (const gchar *label);

Creates a new CtkMenuItem containing a label.

The label will be created using ctk_label_new_with_mnemonic(), so underscores in label indicate the mnemonic for the menu item.

ctk_menu_item_set_right_justified ()

void
ctk_menu_item_set_right_justified (CtkMenuItem *menu_item,
                                   gboolean right_justified);

Sets whether the menu item appears justified at the right side of a menu bar. This was traditionally done for “Help” menu items, but is now considered a bad idea. (If the widget layout is reversed for a right-to-left language like Hebrew or Arabic, right-justified-menu-items appear at the left.)

ctk_menu_item_get_right_justified ()

gboolean
ctk_menu_item_get_right_justified (CtkMenuItem *menu_item);

Gets whether the menu item appears justified at the right side of the menu bar.

ctk_menu_item_get_label ()

const gchar *
ctk_menu_item_get_label (CtkMenuItem *menu_item);

Sets text on the menu_item label

Since: 2.16

ctk_menu_item_set_label ()

void
ctk_menu_item_set_label (CtkMenuItem *menu_item,
                         const gchar *label);

Sets text on the menu_item label

Since: 2.16

ctk_menu_item_get_use_underline ()

gboolean
ctk_menu_item_get_use_underline (CtkMenuItem *menu_item);

Checks if an underline in the text indicates the next character should be used for the mnemonic accelerator key.

Since: 2.16

ctk_menu_item_set_use_underline ()

void
ctk_menu_item_set_use_underline (CtkMenuItem *menu_item,
                                 gboolean setting);

If true, an underline in the text indicates the next character should be used for the mnemonic accelerator key.

Since: 2.16

ctk_menu_item_set_submenu ()

void
ctk_menu_item_set_submenu (CtkMenuItem *menu_item,
                           CtkWidget *submenu);

Sets or replaces the menu item’s submenu, or removes it when a NULL submenu is passed.

ctk_menu_item_get_submenu ()

CtkWidget *
ctk_menu_item_get_submenu (CtkMenuItem *menu_item);

Gets the submenu underneath this menu item, if any. See ctk_menu_item_set_submenu().

ctk_menu_item_set_accel_path ()

void
ctk_menu_item_set_accel_path (CtkMenuItem *menu_item,
                              const gchar *accel_path);

Set the accelerator path on menu_item , through which runtime changes of the menu item’s accelerator caused by the user can be identified and saved to persistent storage (see ctk_accel_map_save() on this). To set up a default accelerator for this menu item, call ctk_accel_map_add_entry() with the same accel_path . See also ctk_accel_map_add_entry() on the specifics of accelerator paths, and ctk_menu_set_accel_path() for a more convenient variant of this function.

This function is basically a convenience wrapper that handles calling ctk_widget_set_accel_path() with the appropriate accelerator group for the menu item.

Note that you do need to set an accelerator on the parent menu with ctk_menu_set_accel_group() for this to work.

Note that accel_path string will be stored in a GQuark. Therefore, if you pass a static string, you can save some memory by interning it first with g_intern_static_string().

ctk_menu_item_get_accel_path ()

const gchar *
ctk_menu_item_get_accel_path (CtkMenuItem *menu_item);

Retrieve the accelerator path that was previously set on menu_item .

See ctk_menu_item_set_accel_path() for details.

Since: 2.14

ctk_menu_item_select ()

void
ctk_menu_item_select (CtkMenuItem *menu_item);

Emits the “select” signal on the given item.

ctk_menu_item_deselect ()

void
ctk_menu_item_deselect (CtkMenuItem *menu_item);

Emits the “deselect” signal on the given item.

ctk_menu_item_activate ()

void
ctk_menu_item_activate (CtkMenuItem *menu_item);

Emits the “activate” signal on the given item

ctk_menu_item_toggle_size_request ()

void
ctk_menu_item_toggle_size_request (CtkMenuItem *menu_item,
                                   gint *requisition);

Emits the “toggle-size-request” signal on the given item.

ctk_menu_item_toggle_size_allocate ()

void
ctk_menu_item_toggle_size_allocate (CtkMenuItem *menu_item,
                                    gint allocation);

Emits the “toggle-size-allocate” signal on the given item.

ctk_menu_item_get_reserve_indicator ()

gboolean
ctk_menu_item_get_reserve_indicator (CtkMenuItem *menu_item);

Returns whether the menu_item reserves space for the submenu indicator, regardless if it has a submenu or not.

Since: 3.0

ctk_menu_item_set_reserve_indicator ()

void
ctk_menu_item_set_reserve_indicator (CtkMenuItem *menu_item,
                                     gboolean reserve);

Sets whether the menu_item should reserve space for the submenu indicator, regardless if it actually has a submenu or not.

There should be little need for applications to call this functions.

Since: 3.0

struct CtkMenuItem

struct CtkMenuItem;

struct CtkMenuItemClass

struct CtkMenuItemClass {
  CtkBinClass parent_class;

  /* If the following flag is true, then we should always
   * hide the menu when the MenuItem is activated. Otherwise,
   * it is up to the caller. For instance, when navigating
   * a menu with the keyboard, <Space> doesn't hide, but
   * <Return> does.
   */
  guint hide_on_activate : 1;

  void (* activate)             (CtkMenuItem *menu_item);
  void (* activate_item)        (CtkMenuItem *menu_item);
  void (* toggle_size_request)  (CtkMenuItem *menu_item,
                                 gint        *requisition);
  void (* toggle_size_allocate) (CtkMenuItem *menu_item,
                                 gint         allocation);
  void (* set_label)            (CtkMenuItem *menu_item,
                                 const gchar *label);
  const gchar * (* get_label)   (CtkMenuItem *menu_item);

  void (* select)               (CtkMenuItem *menu_item);
  void (* deselect)             (CtkMenuItem *menu_item);
};

The “accel-path” property

  “accel-path”               char *

Sets the accelerator path of the menu item, through which runtime changes of the menu item's accelerator caused by the user can be identified and saved to persistant storage.

Owner: CtkMenuItem

Flags: Read / Write

Default value: NULL

Since: 2.14

The “label” property

  “label”                    char *

The text for the child label.

Owner: CtkMenuItem

Flags: Read / Write

Default value: ""

Since: 2.16

The “right-justified” property

  “right-justified”          gboolean

Sets whether the menu item appears justified at the right side of a menu bar.

Owner: CtkMenuItem

Flags: Read / Write

Default value: FALSE

Since: 2.14

The “submenu” property

  “submenu”                  CtkMenu *

The submenu attached to the menu item, or NULL if it has none.

Owner: CtkMenuItem

Flags: Read / Write

Since: 2.12

The “use-underline” property

  “use-underline”            gboolean

TRUE if underlines in the text indicate mnemonics.

Owner: CtkMenuItem

Flags: Read / Write

Default value: FALSE

Since: 2.16

The “activate” signal

void
user_function (CtkMenuItem *menuitem,
               gpointer     user_data)

Emitted when the item is activated.

Flags: Action

The “activate-item” signal

void
user_function (CtkMenuItem *menuitem,
               gpointer     user_data)

Emitted when the item is activated, but also if the menu item has a submenu. For normal applications, the relevant signal is “activate”.

Flags: Run First

The “deselect” signal

void
user_function (CtkMenuItem *ctkmenuitem,
               gpointer     user_data)

Flags: Run First

The “select” signal

void
user_function (CtkMenuItem *ctkmenuitem,
               gpointer     user_data)

Flags: Run First

The “toggle-size-allocate” signal

void
user_function (CtkMenuItem *ctkmenuitem,
               int          arg1,
               gpointer     user_data)

Flags: Run First

The “toggle-size-request” signal

void
user_function (CtkMenuItem *ctkmenuitem,
               gpointer     arg1,
               gpointer     user_data)

Flags: Run First