gi-gtk-3.0.11: Gtk bindings

CopyrightWill Thompson, Iñaki García Etxebarria and Jonas Platte
LicenseLGPL-2.1
MaintainerIñaki García Etxebarria (garetxe@gmail.com)
Safe HaskellNone
LanguageHaskell2010

GI.Gtk.Objects.Menu

Contents

Description

A Menu is a MenuShell that implements a drop down menu consisting of a list of MenuItem objects which can be navigated and activated by the user to perform application functions.

A Menu is most commonly dropped down by activating a MenuItem in a MenuBar or popped up by activating a MenuItem in another Menu.

A Menu can also be popped up by activating a ComboBox. Other composite widgets such as the Notebook can pop up a Menu as well.

Applications can display a Menu as a popup menu by calling the menuPopup function. The example below shows how an application can pop up a menu when the 3rd mouse button is pressed.

Connecting the popup signal handler.

C code

  // connect our handler which will popup the menu
  g_signal_connect_swapped (window, "button_press_event",
G_CALLBACK (my_popup_handler), menu);

Signal handler which displays a popup menu.

C code

static gint
my_popup_handler (GtkWidget *widget, GdkEvent *event)
{
  GtkMenu *menu;
  GdkEventButton *event_button;

  g_return_val_if_fail (widget != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_MENU (widget), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);

  // The "widget" is the menu that was supplied when
  // g_signal_connect_swapped() was called.
  menu = GTK_MENU (widget);

  if (event->type == GDK_BUTTON_PRESS)
    {
      event_button = (GdkEventButton *) event;
      if (event_button->button == GDK_BUTTON_SECONDARY)
        {
          gtk_menu_popup (menu, NULL, NULL, NULL, NULL,
                          event_button->button, event_button->time);
          return TRUE;
        }
    }

  return FALSE;
}

CSS nodes

plain code

menu
├── arrow.top
├── <child>
┊
├── <child>
╰── arrow.bottom

The main CSS node of GtkMenu has name menu, and there are two subnodes with name arrow, for scrolling menu arrows. These subnodes get the .top and .bottom style classes.

Synopsis

Exported types

newtype Menu Source #

Constructors

Menu (ManagedPtr Menu) 

Instances

class GObject o => IsMenu o Source #

Instances

toMenu :: IsMenu o => o -> IO Menu Source #

noMenu :: Maybe Menu Source #

Methods

attach

data MenuAttachMethodInfo Source #

Instances

((~) * signature (b -> Word32 -> Word32 -> Word32 -> Word32 -> m ()), MonadIO m, IsMenu a, IsWidget b) => MethodInfo * MenuAttachMethodInfo a signature Source # 

Methods

overloadedMethod :: MethodProxy MenuAttachMethodInfo a -> signature -> s #

menuAttach Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsWidget b) 
=> a

menu: a Menu

-> b

child: a MenuItem

-> Word32

leftAttach: The column number to attach the left side of the item to

-> Word32

rightAttach: The column number to attach the right side of the item to

-> Word32

topAttach: The row number to attach the top of the item to

-> Word32

bottomAttach: The row number to attach the bottom of the item to

-> m () 

Adds a new MenuItem to a (table) menu. The number of “cells” that an item will occupy is specified by leftAttach, rightAttach, topAttach and bottomAttach. These each represent the leftmost, rightmost, uppermost and lower column and row numbers of the table. (Columns and rows are indexed from zero).

Note that this function is not related to menuDetach.

Since: 2.4

attachToWidget

data MenuAttachToWidgetMethodInfo Source #

Instances

((~) * signature (b -> Maybe MenuDetachFunc -> m ()), MonadIO m, IsMenu a, IsWidget b) => MethodInfo * MenuAttachToWidgetMethodInfo a signature Source # 

menuAttachToWidget Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsWidget b) 
=> a

menu: a Menu

-> b

attachWidget: the Widget that the menu will be attached to

-> Maybe MenuDetachFunc

detacher: the user supplied callback function that will be called when the menu calls menuDetach

-> m () 

Attaches the menu to the widget and provides a callback function that will be invoked when the menu calls menuDetach during its destruction.

If the menu is attached to the widget then it will be destroyed when the widget is destroyed, as if it was a child widget. An attached menu will also move between screens correctly if the widgets moves between screens.

detach

data MenuDetachMethodInfo Source #

Instances

((~) * signature (m ()), MonadIO m, IsMenu a) => MethodInfo * MenuDetachMethodInfo a signature Source # 

Methods

overloadedMethod :: MethodProxy MenuDetachMethodInfo a -> signature -> s #

menuDetach Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a) 
=> a

menu: a Menu

-> m () 

Detaches the menu from the widget to which it had been attached. This function will call the callback function, detacher, provided when the menuAttachToWidget function was called.

getAccelGroup

data MenuGetAccelGroupMethodInfo Source #

Instances

((~) * signature (m AccelGroup), MonadIO m, IsMenu a) => MethodInfo * MenuGetAccelGroupMethodInfo a signature Source # 

menuGetAccelGroup Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a) 
=> a

menu: a Menu

-> m AccelGroup

Returns: the AccelGroup associated with the menu

Gets the AccelGroup which holds global accelerators for the menu. See menuSetAccelGroup.

getAccelPath

data MenuGetAccelPathMethodInfo Source #

Instances

((~) * signature (m Text), MonadIO m, IsMenu a) => MethodInfo * MenuGetAccelPathMethodInfo a signature Source # 

menuGetAccelPath Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a) 
=> a

menu: a valid Menu

-> m Text

Returns: the accelerator path set on the menu.

Retrieves the accelerator path set on the menu.

Since: 2.14

getActive

data MenuGetActiveMethodInfo Source #

Instances

((~) * signature (m Widget), MonadIO m, IsMenu a) => MethodInfo * MenuGetActiveMethodInfo a signature Source # 

menuGetActive Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a) 
=> a

menu: a Menu

-> m Widget

Returns: the MenuItem that was last selected in the menu. If a selection has not yet been made, the first menu item is selected.

Returns the selected menu item from the menu. This is used by the ComboBox.

getAttachWidget

data MenuGetAttachWidgetMethodInfo Source #

Instances

((~) * signature (m Widget), MonadIO m, IsMenu a) => MethodInfo * MenuGetAttachWidgetMethodInfo a signature Source # 

menuGetAttachWidget Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a) 
=> a

menu: a Menu

-> m Widget

Returns: the Widget that the menu is attached to

Returns the Widget that the menu is attached to.

getForAttachWidget

menuGetForAttachWidget Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a) 
=> a

widget: a Widget

-> m [Widget]

Returns: the list of menus attached to his widget.

Returns a list of the menus which are attached to this widget. This list is owned by GTK+ and must not be modified.

Since: 2.6

getMonitor

data MenuGetMonitorMethodInfo Source #

Instances

((~) * signature (m Int32), MonadIO m, IsMenu a) => MethodInfo * MenuGetMonitorMethodInfo a signature Source # 

menuGetMonitor Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a) 
=> a

menu: a Menu

-> m Int32

Returns: the number of the monitor on which the menu should be popped up or -1, if no monitor has been set

Retrieves the number of the monitor on which to show the menu.

Since: 2.14

getReserveToggleSize

data MenuGetReserveToggleSizeMethodInfo Source #

Instances

menuGetReserveToggleSize Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a) 
=> a

menu: a Menu

-> m Bool

Returns: Whether the menu reserves toggle space

Returns whether the menu reserves space for toggles and icons, regardless of their actual presence.

Since: 2.18

getTearoffState

data MenuGetTearoffStateMethodInfo Source #

Instances

((~) * signature (m Bool), MonadIO m, IsMenu a) => MethodInfo * MenuGetTearoffStateMethodInfo a signature Source # 

menuGetTearoffState Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a) 
=> a

menu: a Menu

-> m Bool

Returns: True if the menu is currently torn off.

Deprecated: (Since version 3.10)

Returns whether the menu is torn off. See menuSetTearoffState.

getTitle

data MenuGetTitleMethodInfo Source #

Instances

((~) * signature (m Text), MonadIO m, IsMenu a) => MethodInfo * MenuGetTitleMethodInfo a signature Source # 

menuGetTitle Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a) 
=> a

menu: a Menu

-> m Text

Returns: the title of the menu, or Nothing if the menu has no title set on it. This string is owned by GTK+ and should not be modified or freed.

Deprecated: (Since version 3.10)

Returns the title of the menu. See menuSetTitle.

new

menuNew Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> m Menu

Returns: a new Menu

Creates a new Menu

newFromModel

menuNewFromModel Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuModel a) 
=> a

model: a MenuModel

-> m Menu

Returns: a new Menu

Creates a Menu and populates it with menu items and submenus according to model.

The created menu items are connected to actions found in the ApplicationWindow to which the menu belongs - typically by means of being attached to a widget (see menuAttachToWidget) that is contained within the GtkApplicationWindows widget hierarchy.

Actions can also be added using widgetInsertActionGroup on the menu's attach widget or on any of its parent widgets.

Since: 3.4

placeOnMonitor

data MenuPlaceOnMonitorMethodInfo Source #

Instances

((~) * signature (b -> m ()), MonadIO m, IsMenu a, IsMonitor b) => MethodInfo * MenuPlaceOnMonitorMethodInfo a signature Source # 

menuPlaceOnMonitor Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsMonitor b) 
=> a

menu: a Menu

-> b

monitor: the monitor to place the menu on

-> m () 

Places menu on the given monitor.

Since: 3.22

popdown

data MenuPopdownMethodInfo Source #

Instances

((~) * signature (m ()), MonadIO m, IsMenu a) => MethodInfo * MenuPopdownMethodInfo a signature Source # 

Methods

overloadedMethod :: MethodProxy MenuPopdownMethodInfo a -> signature -> s #

menuPopdown Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a) 
=> a

menu: a Menu

-> m () 

Removes the menu from the screen.

popup

data MenuPopupMethodInfo Source #

Instances

((~) * signature (Maybe b -> Maybe c -> Maybe MenuPositionFunc -> Word32 -> Word32 -> m ()), MonadIO m, IsMenu a, IsWidget b, IsWidget c) => MethodInfo * MenuPopupMethodInfo a signature Source # 

Methods

overloadedMethod :: MethodProxy MenuPopupMethodInfo a -> signature -> s #

menuPopup Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsWidget b, IsWidget c) 
=> a

menu: a Menu

-> Maybe b

parentMenuShell: the menu shell containing the triggering menu item, or Nothing

-> Maybe c

parentMenuItem: the menu item whose activation triggered the popup, or Nothing

-> Maybe MenuPositionFunc

func: a user supplied function used to position the menu, or Nothing

-> Word32

button: the mouse button which was pressed to initiate the event.

-> Word32

activateTime: the time at which the activation event occurred.

-> m () 

Deprecated: (Since version 3.22)Please use menuPopupAtWidget, menuPopupAtPointer. or menuPopupAtRect instead

Displays a menu and makes it available for selection.

Applications can use this function to display context-sensitive menus, and will typically supply Nothing for the parentMenuShell, parentMenuItem, func and data parameters. The default menu positioning function will position the menu at the current mouse cursor position.

The button parameter should be the mouse button pressed to initiate the menu popup. If the menu popup was initiated by something other than a mouse button press, such as a mouse button release or a keypress, button should be 0.

The activateTime parameter is used to conflict-resolve initiation of concurrent requests for mouse/keyboard grab requests. To function properly, this needs to be the timestamp of the user event (such as a mouse click or key press) that caused the initiation of the popup. Only if no such event is available, getCurrentEventTime can be used instead.

Note that this function does not work very well on GDK backends that do not have global coordinates, such as Wayland or Mir. You should probably use one of the gtk_menu_popup_at_ variants, which do not have this problem.

popupAtPointer

data MenuPopupAtPointerMethodInfo Source #

Instances

((~) * signature (Maybe Event -> m ()), MonadIO m, IsMenu a) => MethodInfo * MenuPopupAtPointerMethodInfo a signature Source # 

menuPopupAtPointer Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a) 
=> a

menu: the Menu to pop up

-> Maybe Event

triggerEvent: the Event that initiated this request or Nothing if it's the current event

-> m () 

Displays menu and makes it available for selection.

See gtk_menu_popup_at_widget () to pop up a menu at a widget. gtk_menu_popup_at_rect () also allows you to position a menu at an arbitrary rectangle.

menu will be positioned at the pointer associated with triggerEvent.

Properties that influence the behaviour of this function are Menu:anchor-hints, Menu:rect-anchor-dx, Menu:rect-anchor-dy, and Menu:menu-type-hint. Connect to the Menu::popped-up signal to find out how it was actually positioned.

Since: 3.22

popupAtRect

data MenuPopupAtRectMethodInfo Source #

Instances

((~) * signature (b -> Rectangle -> Gravity -> Gravity -> Maybe Event -> m ()), MonadIO m, IsMenu a, IsWindow b) => MethodInfo * MenuPopupAtRectMethodInfo a signature Source # 

menuPopupAtRect Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsWindow b) 
=> a

menu: the Menu to pop up

-> b

rectWindow: the Window rect is relative to

-> Rectangle

rect: the Rectangle to align menu with

-> Gravity

rectAnchor: the point on rect to align with menu's anchor point

-> Gravity

menuAnchor: the point on menu to align with rect's anchor point

-> Maybe Event

triggerEvent: the Event that initiated this request or Nothing if it's the current event

-> m () 

Displays menu and makes it available for selection.

See gtk_menu_popup_at_widget () and gtk_menu_popup_at_pointer (), which handle more common cases for popping up menus.

menu will be positioned at rect, aligning their anchor points. rect is relative to the top-left corner of rectWindow. rectAnchor and menuAnchor determine anchor points on rect and menu to pin together. menu can optionally be offset by Menu:rect-anchor-dx and Menu:rect-anchor-dy.

Anchors should be specified under the assumption that the text direction is left-to-right; they will be flipped horizontally automatically if the text direction is right-to-left.

Other properties that influence the behaviour of this function are Menu:anchor-hints and Menu:menu-type-hint. Connect to the Menu::popped-up signal to find out how it was actually positioned.

Since: 3.22

popupAtWidget

data MenuPopupAtWidgetMethodInfo Source #

Instances

((~) * signature (b -> Gravity -> Gravity -> Maybe Event -> m ()), MonadIO m, IsMenu a, IsWidget b) => MethodInfo * MenuPopupAtWidgetMethodInfo a signature Source # 

menuPopupAtWidget Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsWidget b) 
=> a

menu: the Menu to pop up

-> b

widget: the Widget to align menu with

-> Gravity

widgetAnchor: the point on widget to align with menu's anchor point

-> Gravity

menuAnchor: the point on menu to align with widget's anchor point

-> Maybe Event

triggerEvent: the Event that initiated this request or Nothing if it's the current event

-> m () 

Displays menu and makes it available for selection.

See gtk_menu_popup_at_pointer () to pop up a menu at the master pointer. gtk_menu_popup_at_rect () also allows you to position a menu at an arbitrary rectangle.

menu will be positioned at widget, aligning their anchor points. widgetAnchor and menuAnchor determine anchor points on widget and menu to pin together. menu can optionally be offset by Menu:rect-anchor-dx and Menu:rect-anchor-dy.

Anchors should be specified under the assumption that the text direction is left-to-right; they will be flipped horizontally automatically if the text direction is right-to-left.

Other properties that influence the behaviour of this function are Menu:anchor-hints and Menu:menu-type-hint. Connect to the Menu::popped-up signal to find out how it was actually positioned.

Since: 3.22

popupForDevice

data MenuPopupForDeviceMethodInfo Source #

Instances

((~) * signature (Maybe b -> Maybe c -> Maybe d -> Maybe MenuPositionFunc -> Word32 -> Word32 -> m ()), MonadIO m, IsMenu a, IsDevice b, IsWidget c, IsWidget d) => MethodInfo * MenuPopupForDeviceMethodInfo a signature Source # 

menuPopupForDevice Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsDevice b, IsWidget c, IsWidget d) 
=> a

menu: a Menu

-> Maybe b

device: a Device

-> Maybe c

parentMenuShell: the menu shell containing the triggering menu item, or Nothing

-> Maybe d

parentMenuItem: the menu item whose activation triggered the popup, or Nothing

-> Maybe MenuPositionFunc

func: a user supplied function used to position the menu, or Nothing

-> Word32

button: the mouse button which was pressed to initiate the event

-> Word32

activateTime: the time at which the activation event occurred

-> m () 

Deprecated: (Since version 3.22)Please use menuPopupAtWidget, menuPopupAtPointer. or menuPopupAtRect instead

Displays a menu and makes it available for selection.

Applications can use this function to display context-sensitive menus, and will typically supply Nothing for the parentMenuShell, parentMenuItem, func, data and destroy parameters. The default menu positioning function will position the menu at the current position of device (or its corresponding pointer).

The button parameter should be the mouse button pressed to initiate the menu popup. If the menu popup was initiated by something other than a mouse button press, such as a mouse button release or a keypress, button should be 0.

The activateTime parameter is used to conflict-resolve initiation of concurrent requests for mouse/keyboard grab requests. To function properly, this needs to be the time stamp of the user event (such as a mouse click or key press) that caused the initiation of the popup. Only if no such event is available, getCurrentEventTime can be used instead.

Note that this function does not work very well on GDK backends that do not have global coordinates, such as Wayland or Mir. You should probably use one of the gtk_menu_popup_at_ variants, which do not have this problem.

Since: 3.0

reorderChild

data MenuReorderChildMethodInfo Source #

Instances

((~) * signature (b -> Int32 -> m ()), MonadIO m, IsMenu a, IsWidget b) => MethodInfo * MenuReorderChildMethodInfo a signature Source # 

menuReorderChild Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsWidget b) 
=> a

menu: a Menu

-> b

child: the MenuItem to move

-> Int32

position: the new position to place child. Positions are numbered from 0 to n - 1

-> m () 

Moves child to a new position in the list of menu children.

reposition

data MenuRepositionMethodInfo Source #

Instances

((~) * signature (m ()), MonadIO m, IsMenu a) => MethodInfo * MenuRepositionMethodInfo a signature Source # 

menuReposition Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a) 
=> a

menu: a Menu

-> m () 

Repositions the menu according to its position function.

setAccelGroup

data MenuSetAccelGroupMethodInfo Source #

Instances

((~) * signature (Maybe b -> m ()), MonadIO m, IsMenu a, IsAccelGroup b) => MethodInfo * MenuSetAccelGroupMethodInfo a signature Source # 

menuSetAccelGroup Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsAccelGroup b) 
=> a

menu: a Menu

-> Maybe b

accelGroup: the AccelGroup to be associated with the menu.

-> m () 

Set the AccelGroup which holds global accelerators for the menu. This accelerator group needs to also be added to all windows that this menu is being used in with windowAddAccelGroup, in order for those windows to support all the accelerators contained in this group.

setAccelPath

data MenuSetAccelPathMethodInfo Source #

Instances

((~) * signature (Maybe Text -> m ()), MonadIO m, IsMenu a) => MethodInfo * MenuSetAccelPathMethodInfo a signature Source # 

menuSetAccelPath Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a) 
=> a

menu: a valid Menu

-> Maybe Text

accelPath: a valid accelerator path

-> m () 

Sets an accelerator path for this menu from which accelerator paths for its immediate children, its menu items, can be constructed. The main purpose of this function is to spare the programmer the inconvenience of having to call menuItemSetAccelPath on each menu item that should support runtime user changable accelerators. Instead, by just calling menuSetAccelPath on their parent, each menu item of this menu, that contains a label describing its purpose, automatically gets an accel path assigned.

For example, a menu containing menu items “New” and “Exit”, will, after gtk_menu_set_accel_path (menu, "<Gnumeric-Sheet>/File"); has been called, assign its items the accel paths: "<Gnumeric-Sheet>/File/New" and "<Gnumeric-Sheet>/File/Exit".

Assigning accel paths to menu items then enables the user to change their accelerators at runtime. More details about accelerator paths and their default setups can be found at accelMapAddEntry.

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

setActive

data MenuSetActiveMethodInfo Source #

Instances

((~) * signature (Word32 -> m ()), MonadIO m, IsMenu a) => MethodInfo * MenuSetActiveMethodInfo a signature Source # 

menuSetActive Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a) 
=> a

menu: a Menu

-> Word32

index: the index of the menu item to select. Index values are from 0 to n-1

-> m () 

Selects the specified menu item within the menu. This is used by the ComboBox and should not be used by anyone else.

setMonitor

data MenuSetMonitorMethodInfo Source #

Instances

((~) * signature (Int32 -> m ()), MonadIO m, IsMenu a) => MethodInfo * MenuSetMonitorMethodInfo a signature Source # 

menuSetMonitor Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a) 
=> a

menu: a Menu

-> Int32

monitorNum: the number of the monitor on which the menu should be popped up

-> m () 

Informs GTK+ on which monitor a menu should be popped up. See monitorGetGeometry.

This function should be called from a MenuPositionFunc if the menu should not appear on the same monitor as the pointer. This information can’t be reliably inferred from the coordinates returned by a MenuPositionFunc, since, for very long menus, these coordinates may extend beyond the monitor boundaries or even the screen boundaries.

Since: 2.4

setReserveToggleSize

data MenuSetReserveToggleSizeMethodInfo Source #

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsMenu a) => MethodInfo * MenuSetReserveToggleSizeMethodInfo a signature Source # 

menuSetReserveToggleSize Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a) 
=> a

menu: a Menu

-> Bool

reserveToggleSize: whether to reserve size for toggles

-> m () 

Sets whether the menu should reserve space for drawing toggles or icons, regardless of their actual presence.

Since: 2.18

setScreen

data MenuSetScreenMethodInfo Source #

Instances

((~) * signature (Maybe b -> m ()), MonadIO m, IsMenu a, IsScreen b) => MethodInfo * MenuSetScreenMethodInfo a signature Source # 

menuSetScreen Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsScreen b) 
=> a

menu: a Menu

-> Maybe b

screen: a Screen, or Nothing if the screen should be determined by the widget the menu is attached to

-> m () 

Sets the Screen on which the menu will be displayed.

Since: 2.2

setTearoffState

data MenuSetTearoffStateMethodInfo Source #

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsMenu a) => MethodInfo * MenuSetTearoffStateMethodInfo a signature Source # 

menuSetTearoffState Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a) 
=> a

menu: a Menu

-> Bool

tornOff: If True, menu is displayed as a tearoff menu.

-> m () 

Deprecated: (Since version 3.10)

Changes the tearoff state of the menu. A menu is normally displayed as drop down menu which persists as long as the menu is active. It can also be displayed as a tearoff menu which persists until it is closed or reattached.

setTitle

data MenuSetTitleMethodInfo Source #

Instances

((~) * signature (Text -> m ()), MonadIO m, IsMenu a) => MethodInfo * MenuSetTitleMethodInfo a signature Source # 

menuSetTitle Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a) 
=> a

menu: a Menu

-> Text

title: a string containing the title for the menu

-> m () 

Deprecated: (Since version 3.10)

Sets the title string for the menu.

The title is displayed when the menu is shown as a tearoff menu. If title is Nothing, the menu will see if it is attached to a parent menu item, and if so it will try to use the same text as that menu item’s label.

Properties

accelGroup

data MenuAccelGroupPropertyInfo Source #

Instances

AttrInfo MenuAccelGroupPropertyInfo Source # 
type AttrOrigin MenuAccelGroupPropertyInfo Source # 
type AttrLabel MenuAccelGroupPropertyInfo Source # 
type AttrGetType MenuAccelGroupPropertyInfo Source # 
type AttrBaseTypeConstraint MenuAccelGroupPropertyInfo Source # 
type AttrSetTypeConstraint MenuAccelGroupPropertyInfo Source # 
type AttrAllowedOps MenuAccelGroupPropertyInfo Source # 

clearMenuAccelGroup :: (MonadIO m, IsMenu o) => o -> m () Source #

constructMenuAccelGroup :: (IsMenu o, IsAccelGroup a) => a -> IO (GValueConstruct o) Source #

getMenuAccelGroup :: (MonadIO m, IsMenu o) => o -> m AccelGroup Source #

menuAccelGroup :: AttrLabelProxy "accelGroup" Source #

setMenuAccelGroup :: (MonadIO m, IsMenu o, IsAccelGroup a) => o -> a -> m () Source #

accelPath

data MenuAccelPathPropertyInfo Source #

Instances

AttrInfo MenuAccelPathPropertyInfo Source # 
type AttrOrigin MenuAccelPathPropertyInfo Source # 
type AttrLabel MenuAccelPathPropertyInfo Source # 
type AttrGetType MenuAccelPathPropertyInfo Source # 
type AttrBaseTypeConstraint MenuAccelPathPropertyInfo Source # 
type AttrSetTypeConstraint MenuAccelPathPropertyInfo Source # 
type AttrAllowedOps MenuAccelPathPropertyInfo Source # 

clearMenuAccelPath :: (MonadIO m, IsMenu o) => o -> m () Source #

constructMenuAccelPath :: IsMenu o => Text -> IO (GValueConstruct o) Source #

getMenuAccelPath :: (MonadIO m, IsMenu o) => o -> m Text Source #

menuAccelPath :: AttrLabelProxy "accelPath" Source #

setMenuAccelPath :: (MonadIO m, IsMenu o) => o -> Text -> m () Source #

active

data MenuActivePropertyInfo Source #

Instances

AttrInfo MenuActivePropertyInfo Source # 
type AttrOrigin MenuActivePropertyInfo Source # 
type AttrLabel MenuActivePropertyInfo Source # 
type AttrGetType MenuActivePropertyInfo Source # 
type AttrBaseTypeConstraint MenuActivePropertyInfo Source # 
type AttrSetTypeConstraint MenuActivePropertyInfo Source # 
type AttrAllowedOps MenuActivePropertyInfo Source # 

constructMenuActive :: IsMenu o => Int32 -> IO (GValueConstruct o) Source #

getMenuActive :: (MonadIO m, IsMenu o) => o -> m Int32 Source #

menuActive :: AttrLabelProxy "active" Source #

setMenuActive :: (MonadIO m, IsMenu o) => o -> Int32 -> m () Source #

anchorHints

data MenuAnchorHintsPropertyInfo Source #

Instances

AttrInfo MenuAnchorHintsPropertyInfo Source # 
type AttrOrigin MenuAnchorHintsPropertyInfo Source # 
type AttrLabel MenuAnchorHintsPropertyInfo Source # 
type AttrGetType MenuAnchorHintsPropertyInfo Source # 
type AttrBaseTypeConstraint MenuAnchorHintsPropertyInfo Source # 
type AttrSetTypeConstraint MenuAnchorHintsPropertyInfo Source # 
type AttrAllowedOps MenuAnchorHintsPropertyInfo Source # 

constructMenuAnchorHints :: IsMenu o => [AnchorHints] -> IO (GValueConstruct o) Source #

getMenuAnchorHints :: (MonadIO m, IsMenu o) => o -> m [AnchorHints] Source #

menuAnchorHints :: AttrLabelProxy "anchorHints" Source #

setMenuAnchorHints :: (MonadIO m, IsMenu o) => o -> [AnchorHints] -> m () Source #

attachWidget

data MenuAttachWidgetPropertyInfo Source #

Instances

AttrInfo MenuAttachWidgetPropertyInfo Source # 
type AttrOrigin MenuAttachWidgetPropertyInfo Source # 
type AttrLabel MenuAttachWidgetPropertyInfo Source # 
type AttrGetType MenuAttachWidgetPropertyInfo Source # 
type AttrBaseTypeConstraint MenuAttachWidgetPropertyInfo Source # 
type AttrSetTypeConstraint MenuAttachWidgetPropertyInfo Source # 
type AttrAllowedOps MenuAttachWidgetPropertyInfo Source # 

clearMenuAttachWidget :: (MonadIO m, IsMenu o) => o -> m () Source #

constructMenuAttachWidget :: (IsMenu o, IsWidget a) => a -> IO (GValueConstruct o) Source #

getMenuAttachWidget :: (MonadIO m, IsMenu o) => o -> m Widget Source #

menuAttachWidget :: AttrLabelProxy "attachWidget" Source #

setMenuAttachWidget :: (MonadIO m, IsMenu o, IsWidget a) => o -> a -> m () Source #

menuTypeHint

data MenuMenuTypeHintPropertyInfo Source #

Instances

AttrInfo MenuMenuTypeHintPropertyInfo Source # 
type AttrOrigin MenuMenuTypeHintPropertyInfo Source # 
type AttrLabel MenuMenuTypeHintPropertyInfo Source # 
type AttrLabel MenuMenuTypeHintPropertyInfo = "menu-type-hint"
type AttrGetType MenuMenuTypeHintPropertyInfo Source # 
type AttrBaseTypeConstraint MenuMenuTypeHintPropertyInfo Source # 
type AttrSetTypeConstraint MenuMenuTypeHintPropertyInfo Source # 
type AttrAllowedOps MenuMenuTypeHintPropertyInfo Source # 

constructMenuMenuTypeHint :: IsMenu o => WindowTypeHint -> IO (GValueConstruct o) Source #

getMenuMenuTypeHint :: (MonadIO m, IsMenu o) => o -> m WindowTypeHint Source #

menuMenuTypeHint :: AttrLabelProxy "menuTypeHint" Source #

setMenuMenuTypeHint :: (MonadIO m, IsMenu o) => o -> WindowTypeHint -> m () Source #

monitor

data MenuMonitorPropertyInfo Source #

Instances

AttrInfo MenuMonitorPropertyInfo Source # 
type AttrOrigin MenuMonitorPropertyInfo Source # 
type AttrLabel MenuMonitorPropertyInfo Source # 
type AttrGetType MenuMonitorPropertyInfo Source # 
type AttrBaseTypeConstraint MenuMonitorPropertyInfo Source # 
type AttrSetTypeConstraint MenuMonitorPropertyInfo Source # 
type AttrAllowedOps MenuMonitorPropertyInfo Source # 

constructMenuMonitor :: IsMenu o => Int32 -> IO (GValueConstruct o) Source #

getMenuMonitor :: (MonadIO m, IsMenu o) => o -> m Int32 Source #

menuMonitor :: AttrLabelProxy "monitor" Source #

setMenuMonitor :: (MonadIO m, IsMenu o) => o -> Int32 -> m () Source #

rectAnchorDx

data MenuRectAnchorDxPropertyInfo Source #

Instances

AttrInfo MenuRectAnchorDxPropertyInfo Source # 
type AttrOrigin MenuRectAnchorDxPropertyInfo Source # 
type AttrLabel MenuRectAnchorDxPropertyInfo Source # 
type AttrLabel MenuRectAnchorDxPropertyInfo = "rect-anchor-dx"
type AttrGetType MenuRectAnchorDxPropertyInfo Source # 
type AttrBaseTypeConstraint MenuRectAnchorDxPropertyInfo Source # 
type AttrSetTypeConstraint MenuRectAnchorDxPropertyInfo Source # 
type AttrAllowedOps MenuRectAnchorDxPropertyInfo Source # 

constructMenuRectAnchorDx :: IsMenu o => Int32 -> IO (GValueConstruct o) Source #

getMenuRectAnchorDx :: (MonadIO m, IsMenu o) => o -> m Int32 Source #

menuRectAnchorDx :: AttrLabelProxy "rectAnchorDx" Source #

setMenuRectAnchorDx :: (MonadIO m, IsMenu o) => o -> Int32 -> m () Source #

rectAnchorDy

data MenuRectAnchorDyPropertyInfo Source #

Instances

AttrInfo MenuRectAnchorDyPropertyInfo Source # 
type AttrOrigin MenuRectAnchorDyPropertyInfo Source # 
type AttrLabel MenuRectAnchorDyPropertyInfo Source # 
type AttrLabel MenuRectAnchorDyPropertyInfo = "rect-anchor-dy"
type AttrGetType MenuRectAnchorDyPropertyInfo Source # 
type AttrBaseTypeConstraint MenuRectAnchorDyPropertyInfo Source # 
type AttrSetTypeConstraint MenuRectAnchorDyPropertyInfo Source # 
type AttrAllowedOps MenuRectAnchorDyPropertyInfo Source # 

constructMenuRectAnchorDy :: IsMenu o => Int32 -> IO (GValueConstruct o) Source #

getMenuRectAnchorDy :: (MonadIO m, IsMenu o) => o -> m Int32 Source #

menuRectAnchorDy :: AttrLabelProxy "rectAnchorDy" Source #

setMenuRectAnchorDy :: (MonadIO m, IsMenu o) => o -> Int32 -> m () Source #

reserveToggleSize

data MenuReserveToggleSizePropertyInfo Source #

Instances

AttrInfo MenuReserveToggleSizePropertyInfo Source # 
type AttrOrigin MenuReserveToggleSizePropertyInfo Source # 
type AttrLabel MenuReserveToggleSizePropertyInfo Source # 
type AttrLabel MenuReserveToggleSizePropertyInfo = "reserve-toggle-size"
type AttrGetType MenuReserveToggleSizePropertyInfo Source # 
type AttrBaseTypeConstraint MenuReserveToggleSizePropertyInfo Source # 
type AttrSetTypeConstraint MenuReserveToggleSizePropertyInfo Source # 
type AttrAllowedOps MenuReserveToggleSizePropertyInfo Source # 

constructMenuReserveToggleSize :: IsMenu o => Bool -> IO (GValueConstruct o) Source #

getMenuReserveToggleSize :: (MonadIO m, IsMenu o) => o -> m Bool Source #

menuReserveToggleSize :: AttrLabelProxy "reserveToggleSize" Source #

setMenuReserveToggleSize :: (MonadIO m, IsMenu o) => o -> Bool -> m () Source #

tearoffState

data MenuTearoffStatePropertyInfo Source #

Instances

AttrInfo MenuTearoffStatePropertyInfo Source # 
type AttrOrigin MenuTearoffStatePropertyInfo Source # 
type AttrLabel MenuTearoffStatePropertyInfo Source # 
type AttrGetType MenuTearoffStatePropertyInfo Source # 
type AttrBaseTypeConstraint MenuTearoffStatePropertyInfo Source # 
type AttrSetTypeConstraint MenuTearoffStatePropertyInfo Source # 
type AttrAllowedOps MenuTearoffStatePropertyInfo Source # 

constructMenuTearoffState :: IsMenu o => Bool -> IO (GValueConstruct o) Source #

getMenuTearoffState :: (MonadIO m, IsMenu o) => o -> m Bool Source #

menuTearoffState :: AttrLabelProxy "tearoffState" Source #

setMenuTearoffState :: (MonadIO m, IsMenu o) => o -> Bool -> m () Source #

tearoffTitle

data MenuTearoffTitlePropertyInfo Source #

Instances

AttrInfo MenuTearoffTitlePropertyInfo Source # 
type AttrOrigin MenuTearoffTitlePropertyInfo Source # 
type AttrLabel MenuTearoffTitlePropertyInfo Source # 
type AttrGetType MenuTearoffTitlePropertyInfo Source # 
type AttrBaseTypeConstraint MenuTearoffTitlePropertyInfo Source # 
type AttrSetTypeConstraint MenuTearoffTitlePropertyInfo Source # 
type AttrAllowedOps MenuTearoffTitlePropertyInfo Source # 

clearMenuTearoffTitle :: (MonadIO m, IsMenu o) => o -> m () Source #

constructMenuTearoffTitle :: IsMenu o => Text -> IO (GValueConstruct o) Source #

getMenuTearoffTitle :: (MonadIO m, IsMenu o) => o -> m (Maybe Text) Source #

menuTearoffTitle :: AttrLabelProxy "tearoffTitle" Source #

setMenuTearoffTitle :: (MonadIO m, IsMenu o) => o -> Text -> m () Source #

Signals

moveScroll

type C_MenuMoveScrollCallback = Ptr () -> CUInt -> Ptr () -> IO () Source #

type MenuMoveScrollCallback = ScrollType -> IO () Source #

data MenuMoveScrollSignalInfo Source #

Instances

afterMenuMoveScroll :: (GObject a, MonadIO m) => a -> MenuMoveScrollCallback -> m SignalHandlerId Source #

genClosure_MenuMoveScroll :: MenuMoveScrollCallback -> IO Closure Source #

mk_MenuMoveScrollCallback :: C_MenuMoveScrollCallback -> IO (FunPtr C_MenuMoveScrollCallback) Source #

noMenuMoveScrollCallback :: Maybe MenuMoveScrollCallback Source #

onMenuMoveScroll :: (GObject a, MonadIO m) => a -> MenuMoveScrollCallback -> m SignalHandlerId Source #

wrap_MenuMoveScrollCallback :: MenuMoveScrollCallback -> Ptr () -> CUInt -> Ptr () -> IO () Source #

poppedUp

type C_MenuPoppedUpCallback = Ptr () -> Ptr () -> Ptr () -> CInt -> CInt -> Ptr () -> IO () Source #

type MenuPoppedUpCallback = Ptr () -> Ptr () -> Bool -> Bool -> IO () Source #

data MenuPoppedUpSignalInfo Source #

Instances

afterMenuPoppedUp :: (GObject a, MonadIO m) => a -> MenuPoppedUpCallback -> m SignalHandlerId Source #

genClosure_MenuPoppedUp :: MenuPoppedUpCallback -> IO Closure Source #

mk_MenuPoppedUpCallback :: C_MenuPoppedUpCallback -> IO (FunPtr C_MenuPoppedUpCallback) Source #

noMenuPoppedUpCallback :: Maybe MenuPoppedUpCallback Source #

onMenuPoppedUp :: (GObject a, MonadIO m) => a -> MenuPoppedUpCallback -> m SignalHandlerId Source #

wrap_MenuPoppedUpCallback :: MenuPoppedUpCallback -> Ptr () -> Ptr () -> Ptr () -> CInt -> CInt -> Ptr () -> IO () Source #