Copyright	Will Thompson, Iñaki García Etxebarria and Jonas Platte
License	LGPL-2.1
Maintainer	Iñaki García Etxebarria (garetxe@gmail.com)
Safe Haskell	None
Language	Haskell2010

GI.Gtk.Objects.MenuItem

Contents

Exported types
Methods
Properties
Signals

Description

The MenuItem widget and the derived widgets are the only valid children for menus. Their function is to correctly handle highlighting, alignment, events and submenus.

As a GtkMenuItem derives from Bin it can hold any valid child widget, although only a few are really useful.

By default, a GtkMenuItem sets a AccelLabel as its child. GtkMenuItem has direct functions to set the label and its mnemonic. For more advanced label settings, you can fetch the child widget from the GtkBin.

An example for setting markup and accelerator on a MenuItem:

C code

GtkWidget *child = gtk_bin_get_child (GTK_BIN (menu_item));
gtk_label_set_markup (GTK_LABEL (child), "<i>new label</i> with <b>markup</b>");
gtk_accel_label_set_accel (GTK_ACCEL_LABEL (child), GDK_KEY_1, 0);

GtkMenuItem as GtkBuildable

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

An example of UI definition fragment with submenus: > >class="GtkMenuItem" > type="submenu" > class="GtkMenu"/ > /child >/object

CSS nodes

plain code

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

GtkMenuItem 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.

Synopsis

Exported types

newtype MenuItem Source #

Constructors

MenuItem (ManagedPtr MenuItem)

Instances

GObject MenuItem Source #
Methods gobjectType :: MenuItem -> IO GType #
IsImplementorIface MenuItem Source #

IsObject MenuItem Source #

IsWidget MenuItem Source #

IsMenuItem MenuItem Source #

IsContainer MenuItem Source #

IsBin MenuItem Source #

IsBuildable MenuItem Source #

IsActivatable MenuItem Source #

IsActionable MenuItem Source #

((~) * info (ResolveMenuItemMethod t MenuItem), MethodInfo * info MenuItem p) => IsLabel t (MenuItem -> p) Source #
Methods fromLabel :: Proxy# Symbol t -> MenuItem -> p #
((~) * info (ResolveMenuItemMethod t MenuItem), MethodInfo * info MenuItem p) => IsLabelProxy t (MenuItem -> p) Source #
Methods fromLabelProxy :: Proxy Symbol t -> MenuItem -> p #
HasAttributeList * MenuItem Source #

type AttributeList MenuItem Source #
type AttributeList MenuItem
type SignalList MenuItem Source #
type SignalList MenuItem

class GObject o => IsMenuItem o Source #

toMenuItem :: IsMenuItem o => o -> IO MenuItem Source #

noMenuItem :: Maybe MenuItem Source #

Methods

activate

data MenuItemActivateMethodInfo Source #

Instances

((~) * signature (m ()), MonadIO m, IsMenuItem a) => MethodInfo * MenuItemActivateMethodInfo a signature Source #
Methods overloadedMethod :: MethodProxy MenuItemActivateMethodInfo a -> signature -> s #

menuItemActivate Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuItem a)
=> a	`menuItem`: the menu item
-> m ()

Emits the MenuItem::activate signal on the given item

deselect

data MenuItemDeselectMethodInfo Source #

Instances

((~) * signature (m ()), MonadIO m, IsMenuItem a) => MethodInfo * MenuItemDeselectMethodInfo a signature Source #
Methods overloadedMethod :: MethodProxy MenuItemDeselectMethodInfo a -> signature -> s #

menuItemDeselect Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuItem a)
=> a	`menuItem`: the menu item
-> m ()

Emits the MenuItem::deselect signal on the given item.

getAccelPath

data MenuItemGetAccelPathMethodInfo Source #

Instances

((~) * signature (m (Maybe Text)), MonadIO m, IsMenuItem a) => MethodInfo * MenuItemGetAccelPathMethodInfo a signature Source #
Methods overloadedMethod :: MethodProxy MenuItemGetAccelPathMethodInfo a -> signature -> s #

menuItemGetAccelPath Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuItem a)
=> a	`menuItem`: a valid `MenuItem`
-> m (Maybe Text)	Returns: the accelerator path corresponding to this menu item’s functionality, or `Nothing` if not set

Retrieve the accelerator path that was previously set on menuItem.

See menuItemSetAccelPath for details.

Since: 2.14

getLabel

data MenuItemGetLabelMethodInfo Source #

Instances

((~) * signature (m Text), MonadIO m, IsMenuItem a) => MethodInfo * MenuItemGetLabelMethodInfo a signature Source #
Methods overloadedMethod :: MethodProxy MenuItemGetLabelMethodInfo a -> signature -> s #

menuItemGetLabel Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuItem a)
=> a	`menuItem`: a `MenuItem`
-> m Text	Returns: The text in the `menuItem` label. This is the internal string used by the label, and must not be modified.

Sets text on the menuItem label

Since: 2.16

getReserveIndicator

data MenuItemGetReserveIndicatorMethodInfo Source #

Instances

((~) * signature (m Bool), MonadIO m, IsMenuItem a) => MethodInfo * MenuItemGetReserveIndicatorMethodInfo a signature Source #
Methods overloadedMethod :: MethodProxy MenuItemGetReserveIndicatorMethodInfo a -> signature -> s #

menuItemGetReserveIndicator Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuItem a)
=> a	`menuItem`: a `MenuItem`
-> m Bool	Returns: `True` if `menuItem` always reserves space for the submenu indicator

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

Since: 3.0

getRightJustified

data MenuItemGetRightJustifiedMethodInfo Source #

Instances

((~) * signature (m Bool), MonadIO m, IsMenuItem a) => MethodInfo * MenuItemGetRightJustifiedMethodInfo a signature Source #
Methods overloadedMethod :: MethodProxy MenuItemGetRightJustifiedMethodInfo a -> signature -> s #

menuItemGetRightJustified Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuItem a)
=> a	`menuItem`: a `MenuItem`
-> m Bool	Returns: `True` if the menu item will appear at the far right if added to a menu bar.

Deprecated: (Since version 3.2)See menuItemSetRightJustified

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

getSubmenu

data MenuItemGetSubmenuMethodInfo Source #

Instances

((~) * signature (m (Maybe Widget)), MonadIO m, IsMenuItem a) => MethodInfo * MenuItemGetSubmenuMethodInfo a signature Source #
Methods overloadedMethod :: MethodProxy MenuItemGetSubmenuMethodInfo a -> signature -> s #

menuItemGetSubmenu Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuItem a)
=> a	`menuItem`: a `MenuItem`
-> m (Maybe Widget)	Returns: submenu for this menu item, or `Nothing` if none

Gets the submenu underneath this menu item, if any. See menuItemSetSubmenu.

getUseUnderline

data MenuItemGetUseUnderlineMethodInfo Source #

Instances

((~) * signature (m Bool), MonadIO m, IsMenuItem a) => MethodInfo * MenuItemGetUseUnderlineMethodInfo a signature Source #
Methods overloadedMethod :: MethodProxy MenuItemGetUseUnderlineMethodInfo a -> signature -> s #

menuItemGetUseUnderline Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuItem a)
=> a	`menuItem`: a `MenuItem`
-> m Bool	Returns: `True` if an embedded underline in the label indicates the mnemonic accelerator key.

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

Since: 2.16

new

menuItemNew Source #

Arguments

:: (HasCallStack, MonadIO m)
=> m MenuItem	Returns: the newly created `MenuItem`

Creates a new MenuItem.

newWithLabel

menuItemNewWithLabel Source #

Arguments

:: (HasCallStack, MonadIO m)
=> Text	`label`: the text for the label
-> m MenuItem	Returns: the newly created `MenuItem`

Creates a new MenuItem whose child is a Label.

newWithMnemonic

menuItemNewWithMnemonic Source #

Arguments

:: (HasCallStack, MonadIO m)
=> Text	`label`: The text of the button, with an underscore in front of the mnemonic character
-> m MenuItem	Returns: a new `MenuItem`

Creates a new MenuItem containing a label.

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

select

data MenuItemSelectMethodInfo Source #

Instances

((~) * signature (m ()), MonadIO m, IsMenuItem a) => MethodInfo * MenuItemSelectMethodInfo a signature Source #
Methods overloadedMethod :: MethodProxy MenuItemSelectMethodInfo a -> signature -> s #

menuItemSelect Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuItem a)
=> a	`menuItem`: the menu item
-> m ()

Emits the MenuItem::select signal on the given item.

setAccelPath

data MenuItemSetAccelPathMethodInfo Source #

Instances

((~) * signature (Maybe Text -> m ()), MonadIO m, IsMenuItem a) => MethodInfo * MenuItemSetAccelPathMethodInfo a signature Source #
Methods overloadedMethod :: MethodProxy MenuItemSetAccelPathMethodInfo a -> signature -> s #

menuItemSetAccelPath Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuItem a)
=> a	`menuItem`: a valid `MenuItem`
-> Maybe Text	`accelPath`: accelerator path, corresponding to this menu item’s functionality, or `Nothing` to unset the current path.
-> m ()

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

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

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

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.

setLabel

data MenuItemSetLabelMethodInfo Source #

Instances

((~) * signature (Text -> m ()), MonadIO m, IsMenuItem a) => MethodInfo * MenuItemSetLabelMethodInfo a signature Source #
Methods overloadedMethod :: MethodProxy MenuItemSetLabelMethodInfo a -> signature -> s #

menuItemSetLabel Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuItem a)
=> a	`menuItem`: a `MenuItem`
-> Text	`label`: the text you want to set
-> m ()

Sets text on the menuItem label

Since: 2.16

setReserveIndicator

data MenuItemSetReserveIndicatorMethodInfo Source #

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsMenuItem a) => MethodInfo * MenuItemSetReserveIndicatorMethodInfo a signature Source #
Methods overloadedMethod :: MethodProxy MenuItemSetReserveIndicatorMethodInfo a -> signature -> s #

menuItemSetReserveIndicator Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuItem a)
=> a	`menuItem`: a `MenuItem`
-> Bool	`reserve`: the new value
-> m ()

Sets whether the menuItem 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

setRightJustified

data MenuItemSetRightJustifiedMethodInfo Source #

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsMenuItem a) => MethodInfo * MenuItemSetRightJustifiedMethodInfo a signature Source #
Methods overloadedMethod :: MethodProxy MenuItemSetRightJustifiedMethodInfo a -> signature -> s #

menuItemSetRightJustified Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuItem a)
=> a	`menuItem`: a `MenuItem`.
-> Bool	`rightJustified`: if `True` the menu item will appear at the far right if added to a menu bar
-> m ()

Deprecated: (Since version 3.2)If you insist on using it, use widgetSetHexpand and widgetSetHalign.

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.)

setSubmenu

data MenuItemSetSubmenuMethodInfo Source #

Instances

((~) * signature (Maybe b -> m ()), MonadIO m, IsMenuItem a, IsMenu b) => MethodInfo * MenuItemSetSubmenuMethodInfo a signature Source #
Methods overloadedMethod :: MethodProxy MenuItemSetSubmenuMethodInfo a -> signature -> s #

menuItemSetSubmenu Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuItem a, IsMenu b)
=> a	`menuItem`: a `MenuItem`
-> Maybe b	`submenu`: the submenu, or `Nothing`
-> m ()

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

setUseUnderline

data MenuItemSetUseUnderlineMethodInfo Source #

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsMenuItem a) => MethodInfo * MenuItemSetUseUnderlineMethodInfo a signature Source #
Methods overloadedMethod :: MethodProxy MenuItemSetUseUnderlineMethodInfo a -> signature -> s #

menuItemSetUseUnderline Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuItem a)
=> a	`menuItem`: a `MenuItem`
-> Bool	`setting`: `True` if underlines in the text indicate mnemonics
-> m ()

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

Since: 2.16

toggleSizeAllocate

data MenuItemToggleSizeAllocateMethodInfo Source #

Instances

((~) * signature (Int32 -> m ()), MonadIO m, IsMenuItem a) => MethodInfo * MenuItemToggleSizeAllocateMethodInfo a signature Source #
Methods overloadedMethod :: MethodProxy MenuItemToggleSizeAllocateMethodInfo a -> signature -> s #

menuItemToggleSizeAllocate Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuItem a)
=> a	`menuItem`: the menu item.
-> Int32	`allocation`: the allocation to use as signal data.
-> m ()

Emits the MenuItem::toggle-size-allocate signal on the given item.

toggleSizeRequest

data MenuItemToggleSizeRequestMethodInfo Source #

Instances

((~) * signature (Int32 -> m Int32), MonadIO m, IsMenuItem a) => MethodInfo * MenuItemToggleSizeRequestMethodInfo a signature Source #
Methods overloadedMethod :: MethodProxy MenuItemToggleSizeRequestMethodInfo a -> signature -> s #

menuItemToggleSizeRequest Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuItem a)
=> a	`menuItem`: the menu item
-> Int32	`requisition`: the requisition to use as signal data.
-> m Int32

Emits the MenuItem::toggle-size-request signal on the given item.

Properties

accelPath

data MenuItemAccelPathPropertyInfo Source #

Instances

AttrInfo MenuItemAccelPathPropertyInfo Source #
Associated Types type AttrAllowedOps MenuItemAccelPathPropertyInfo :: [AttrOpTag] # type AttrSetTypeConstraint MenuItemAccelPathPropertyInfo :: * -> Constraint # type AttrBaseTypeConstraint MenuItemAccelPathPropertyInfo :: * -> Constraint # type AttrGetType MenuItemAccelPathPropertyInfo :: * # type AttrLabel MenuItemAccelPathPropertyInfo :: Symbol # type AttrOrigin MenuItemAccelPathPropertyInfo :: * # Methods attrGet :: AttrBaseTypeConstraint MenuItemAccelPathPropertyInfo o => Proxy * MenuItemAccelPathPropertyInfo -> o -> IO (AttrGetType MenuItemAccelPathPropertyInfo) # attrSet :: (AttrBaseTypeConstraint MenuItemAccelPathPropertyInfo o, AttrSetTypeConstraint MenuItemAccelPathPropertyInfo b) => Proxy * MenuItemAccelPathPropertyInfo -> o -> b -> IO () # attrClear :: AttrBaseTypeConstraint MenuItemAccelPathPropertyInfo o => Proxy * MenuItemAccelPathPropertyInfo -> o -> IO () # attrConstruct :: (AttrBaseTypeConstraint MenuItemAccelPathPropertyInfo o, AttrSetTypeConstraint MenuItemAccelPathPropertyInfo b) => Proxy * MenuItemAccelPathPropertyInfo -> b -> IO (GValueConstruct o) #
type AttrOrigin MenuItemAccelPathPropertyInfo Source #
type AttrOrigin MenuItemAccelPathPropertyInfo = MenuItem
type AttrLabel MenuItemAccelPathPropertyInfo Source #
type AttrLabel MenuItemAccelPathPropertyInfo = "accel-path"
type AttrGetType MenuItemAccelPathPropertyInfo Source #
type AttrGetType MenuItemAccelPathPropertyInfo = Maybe Text
type AttrBaseTypeConstraint MenuItemAccelPathPropertyInfo Source #
type AttrBaseTypeConstraint MenuItemAccelPathPropertyInfo = IsMenuItem
type AttrSetTypeConstraint MenuItemAccelPathPropertyInfo Source #
type AttrSetTypeConstraint MenuItemAccelPathPropertyInfo = * ~ Text
type AttrAllowedOps MenuItemAccelPathPropertyInfo Source #
type AttrAllowedOps MenuItemAccelPathPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))))

clearMenuItemAccelPath :: (MonadIO m, IsMenuItem o) => o -> m () Source #

constructMenuItemAccelPath :: IsMenuItem o => Text -> IO (GValueConstruct o) Source #

getMenuItemAccelPath :: (MonadIO m, IsMenuItem o) => o -> m (Maybe Text) Source #

menuItemAccelPath :: AttrLabelProxy "accelPath" Source #

setMenuItemAccelPath :: (MonadIO m, IsMenuItem o) => o -> Text -> m () Source #

label

data MenuItemLabelPropertyInfo Source #

Instances

AttrInfo MenuItemLabelPropertyInfo Source #
Associated Types type AttrAllowedOps MenuItemLabelPropertyInfo :: [AttrOpTag] # type AttrSetTypeConstraint MenuItemLabelPropertyInfo :: * -> Constraint # type AttrBaseTypeConstraint MenuItemLabelPropertyInfo :: * -> Constraint # type AttrGetType MenuItemLabelPropertyInfo :: * # type AttrLabel MenuItemLabelPropertyInfo :: Symbol # type AttrOrigin MenuItemLabelPropertyInfo :: * # Methods attrGet :: AttrBaseTypeConstraint MenuItemLabelPropertyInfo o => Proxy * MenuItemLabelPropertyInfo -> o -> IO (AttrGetType MenuItemLabelPropertyInfo) # attrSet :: (AttrBaseTypeConstraint MenuItemLabelPropertyInfo o, AttrSetTypeConstraint MenuItemLabelPropertyInfo b) => Proxy * MenuItemLabelPropertyInfo -> o -> b -> IO () # attrClear :: AttrBaseTypeConstraint MenuItemLabelPropertyInfo o => Proxy * MenuItemLabelPropertyInfo -> o -> IO () # attrConstruct :: (AttrBaseTypeConstraint MenuItemLabelPropertyInfo o, AttrSetTypeConstraint MenuItemLabelPropertyInfo b) => Proxy * MenuItemLabelPropertyInfo -> b -> IO (GValueConstruct o) #
type AttrOrigin MenuItemLabelPropertyInfo Source #
type AttrOrigin MenuItemLabelPropertyInfo = MenuItem
type AttrLabel MenuItemLabelPropertyInfo Source #
type AttrLabel MenuItemLabelPropertyInfo = "label"
type AttrGetType MenuItemLabelPropertyInfo Source #
type AttrGetType MenuItemLabelPropertyInfo = Text
type AttrBaseTypeConstraint MenuItemLabelPropertyInfo Source #
type AttrBaseTypeConstraint MenuItemLabelPropertyInfo = IsMenuItem
type AttrSetTypeConstraint MenuItemLabelPropertyInfo Source #
type AttrSetTypeConstraint MenuItemLabelPropertyInfo = * ~ Text
type AttrAllowedOps MenuItemLabelPropertyInfo Source #
type AttrAllowedOps MenuItemLabelPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructMenuItemLabel :: IsMenuItem o => Text -> IO (GValueConstruct o) Source #

getMenuItemLabel :: (MonadIO m, IsMenuItem o) => o -> m Text Source #

menuItemLabel :: AttrLabelProxy "label" Source #

setMenuItemLabel :: (MonadIO m, IsMenuItem o) => o -> Text -> m () Source #

rightJustified

data MenuItemRightJustifiedPropertyInfo Source #

Instances

AttrInfo MenuItemRightJustifiedPropertyInfo Source #
Associated Types type AttrAllowedOps MenuItemRightJustifiedPropertyInfo :: [AttrOpTag] # type AttrSetTypeConstraint MenuItemRightJustifiedPropertyInfo :: * -> Constraint # type AttrBaseTypeConstraint MenuItemRightJustifiedPropertyInfo :: * -> Constraint # type AttrGetType MenuItemRightJustifiedPropertyInfo :: * # type AttrLabel MenuItemRightJustifiedPropertyInfo :: Symbol # type AttrOrigin MenuItemRightJustifiedPropertyInfo :: * # Methods attrGet :: AttrBaseTypeConstraint MenuItemRightJustifiedPropertyInfo o => Proxy * MenuItemRightJustifiedPropertyInfo -> o -> IO (AttrGetType MenuItemRightJustifiedPropertyInfo) # attrSet :: (AttrBaseTypeConstraint MenuItemRightJustifiedPropertyInfo o, AttrSetTypeConstraint MenuItemRightJustifiedPropertyInfo b) => Proxy * MenuItemRightJustifiedPropertyInfo -> o -> b -> IO () # attrClear :: AttrBaseTypeConstraint MenuItemRightJustifiedPropertyInfo o => Proxy * MenuItemRightJustifiedPropertyInfo -> o -> IO () # attrConstruct :: (AttrBaseTypeConstraint MenuItemRightJustifiedPropertyInfo o, AttrSetTypeConstraint MenuItemRightJustifiedPropertyInfo b) => Proxy * MenuItemRightJustifiedPropertyInfo -> b -> IO (GValueConstruct o) #
type AttrOrigin MenuItemRightJustifiedPropertyInfo Source #
type AttrOrigin MenuItemRightJustifiedPropertyInfo = MenuItem
type AttrLabel MenuItemRightJustifiedPropertyInfo Source #
type AttrLabel MenuItemRightJustifiedPropertyInfo = "right-justified"
type AttrGetType MenuItemRightJustifiedPropertyInfo Source #
type AttrGetType MenuItemRightJustifiedPropertyInfo = Bool
type AttrBaseTypeConstraint MenuItemRightJustifiedPropertyInfo Source #
type AttrBaseTypeConstraint MenuItemRightJustifiedPropertyInfo = IsMenuItem
type AttrSetTypeConstraint MenuItemRightJustifiedPropertyInfo Source #
type AttrSetTypeConstraint MenuItemRightJustifiedPropertyInfo = * ~ Bool
type AttrAllowedOps MenuItemRightJustifiedPropertyInfo Source #
type AttrAllowedOps MenuItemRightJustifiedPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructMenuItemRightJustified :: IsMenuItem o => Bool -> IO (GValueConstruct o) Source #

getMenuItemRightJustified :: (MonadIO m, IsMenuItem o) => o -> m Bool Source #

menuItemRightJustified :: AttrLabelProxy "rightJustified" Source #

setMenuItemRightJustified :: (MonadIO m, IsMenuItem o) => o -> Bool -> m () Source #

submenu

data MenuItemSubmenuPropertyInfo Source #

Instances

AttrInfo MenuItemSubmenuPropertyInfo Source #
Associated Types type AttrAllowedOps MenuItemSubmenuPropertyInfo :: [AttrOpTag] # type AttrSetTypeConstraint MenuItemSubmenuPropertyInfo :: * -> Constraint # type AttrBaseTypeConstraint MenuItemSubmenuPropertyInfo :: * -> Constraint # type AttrGetType MenuItemSubmenuPropertyInfo :: * # type AttrLabel MenuItemSubmenuPropertyInfo :: Symbol # type AttrOrigin MenuItemSubmenuPropertyInfo :: * # Methods attrGet :: AttrBaseTypeConstraint MenuItemSubmenuPropertyInfo o => Proxy * MenuItemSubmenuPropertyInfo -> o -> IO (AttrGetType MenuItemSubmenuPropertyInfo) # attrSet :: (AttrBaseTypeConstraint MenuItemSubmenuPropertyInfo o, AttrSetTypeConstraint MenuItemSubmenuPropertyInfo b) => Proxy * MenuItemSubmenuPropertyInfo -> o -> b -> IO () # attrClear :: AttrBaseTypeConstraint MenuItemSubmenuPropertyInfo o => Proxy * MenuItemSubmenuPropertyInfo -> o -> IO () # attrConstruct :: (AttrBaseTypeConstraint MenuItemSubmenuPropertyInfo o, AttrSetTypeConstraint MenuItemSubmenuPropertyInfo b) => Proxy * MenuItemSubmenuPropertyInfo -> b -> IO (GValueConstruct o) #
type AttrOrigin MenuItemSubmenuPropertyInfo Source #
type AttrOrigin MenuItemSubmenuPropertyInfo = MenuItem
type AttrLabel MenuItemSubmenuPropertyInfo Source #
type AttrLabel MenuItemSubmenuPropertyInfo = "submenu"
type AttrGetType MenuItemSubmenuPropertyInfo Source #
type AttrGetType MenuItemSubmenuPropertyInfo = Maybe Menu
type AttrBaseTypeConstraint MenuItemSubmenuPropertyInfo Source #
type AttrBaseTypeConstraint MenuItemSubmenuPropertyInfo = IsMenuItem
type AttrSetTypeConstraint MenuItemSubmenuPropertyInfo Source #
type AttrSetTypeConstraint MenuItemSubmenuPropertyInfo = IsMenu
type AttrAllowedOps MenuItemSubmenuPropertyInfo Source #
type AttrAllowedOps MenuItemSubmenuPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))))

clearMenuItemSubmenu :: (MonadIO m, IsMenuItem o) => o -> m () Source #

constructMenuItemSubmenu :: (IsMenuItem o, IsMenu a) => a -> IO (GValueConstruct o) Source #

getMenuItemSubmenu :: (MonadIO m, IsMenuItem o) => o -> m (Maybe Menu) Source #

menuItemSubmenu :: AttrLabelProxy "submenu" Source #

setMenuItemSubmenu :: (MonadIO m, IsMenuItem o, IsMenu a) => o -> a -> m () Source #

useUnderline

data MenuItemUseUnderlinePropertyInfo Source #

Instances

AttrInfo MenuItemUseUnderlinePropertyInfo Source #
Associated Types type AttrAllowedOps MenuItemUseUnderlinePropertyInfo :: [AttrOpTag] # type AttrSetTypeConstraint MenuItemUseUnderlinePropertyInfo :: * -> Constraint # type AttrBaseTypeConstraint MenuItemUseUnderlinePropertyInfo :: * -> Constraint # type AttrGetType MenuItemUseUnderlinePropertyInfo :: * # type AttrLabel MenuItemUseUnderlinePropertyInfo :: Symbol # type AttrOrigin MenuItemUseUnderlinePropertyInfo :: * # Methods attrGet :: AttrBaseTypeConstraint MenuItemUseUnderlinePropertyInfo o => Proxy * MenuItemUseUnderlinePropertyInfo -> o -> IO (AttrGetType MenuItemUseUnderlinePropertyInfo) # attrSet :: (AttrBaseTypeConstraint MenuItemUseUnderlinePropertyInfo o, AttrSetTypeConstraint MenuItemUseUnderlinePropertyInfo b) => Proxy * MenuItemUseUnderlinePropertyInfo -> o -> b -> IO () # attrClear :: AttrBaseTypeConstraint MenuItemUseUnderlinePropertyInfo o => Proxy * MenuItemUseUnderlinePropertyInfo -> o -> IO () # attrConstruct :: (AttrBaseTypeConstraint MenuItemUseUnderlinePropertyInfo o, AttrSetTypeConstraint MenuItemUseUnderlinePropertyInfo b) => Proxy * MenuItemUseUnderlinePropertyInfo -> b -> IO (GValueConstruct o) #
type AttrOrigin MenuItemUseUnderlinePropertyInfo Source #
type AttrOrigin MenuItemUseUnderlinePropertyInfo = MenuItem
type AttrLabel MenuItemUseUnderlinePropertyInfo Source #
type AttrLabel MenuItemUseUnderlinePropertyInfo = "use-underline"
type AttrGetType MenuItemUseUnderlinePropertyInfo Source #
type AttrGetType MenuItemUseUnderlinePropertyInfo = Bool
type AttrBaseTypeConstraint MenuItemUseUnderlinePropertyInfo Source #
type AttrBaseTypeConstraint MenuItemUseUnderlinePropertyInfo = IsMenuItem
type AttrSetTypeConstraint MenuItemUseUnderlinePropertyInfo Source #
type AttrSetTypeConstraint MenuItemUseUnderlinePropertyInfo = * ~ Bool
type AttrAllowedOps MenuItemUseUnderlinePropertyInfo Source #
type AttrAllowedOps MenuItemUseUnderlinePropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructMenuItemUseUnderline :: IsMenuItem o => Bool -> IO (GValueConstruct o) Source #

getMenuItemUseUnderline :: (MonadIO m, IsMenuItem o) => o -> m Bool Source #

menuItemUseUnderline :: AttrLabelProxy "useUnderline" Source #

setMenuItemUseUnderline :: (MonadIO m, IsMenuItem o) => o -> Bool -> m () Source #

Signals

activate

type C_MenuItemActivateCallback = Ptr () -> Ptr () -> IO () Source #

type MenuItemActivateCallback = IO () Source #

data MenuItemActivateSignalInfo Source #

Instances

SignalInfo MenuItemActivateSignalInfo Source #
Associated Types type HaskellCallbackType MenuItemActivateSignalInfo :: * # Methods connectSignal :: GObject o => SignalProxy o MenuItemActivateSignalInfo -> o -> HaskellCallbackType MenuItemActivateSignalInfo -> SignalConnectMode -> IO SignalHandlerId #
type HaskellCallbackType MenuItemActivateSignalInfo Source #
type HaskellCallbackType MenuItemActivateSignalInfo = MenuItemActivateCallback

afterMenuItemActivate :: (GObject a, MonadIO m) => a -> MenuItemActivateCallback -> m SignalHandlerId Source #

genClosure_MenuItemActivate :: MenuItemActivateCallback -> IO Closure Source #

mk_MenuItemActivateCallback :: C_MenuItemActivateCallback -> IO (FunPtr C_MenuItemActivateCallback) Source #

noMenuItemActivateCallback :: Maybe MenuItemActivateCallback Source #

onMenuItemActivate :: (GObject a, MonadIO m) => a -> MenuItemActivateCallback -> m SignalHandlerId Source #

wrap_MenuItemActivateCallback :: MenuItemActivateCallback -> Ptr () -> Ptr () -> IO () Source #

activateItem

type C_MenuItemActivateItemCallback = Ptr () -> Ptr () -> IO () Source #

type MenuItemActivateItemCallback = IO () Source #

data MenuItemActivateItemSignalInfo Source #

Instances

SignalInfo MenuItemActivateItemSignalInfo Source #
Associated Types type HaskellCallbackType MenuItemActivateItemSignalInfo :: * # Methods connectSignal :: GObject o => SignalProxy o MenuItemActivateItemSignalInfo -> o -> HaskellCallbackType MenuItemActivateItemSignalInfo -> SignalConnectMode -> IO SignalHandlerId #
type HaskellCallbackType MenuItemActivateItemSignalInfo Source #
type HaskellCallbackType MenuItemActivateItemSignalInfo = MenuItemActivateItemCallback

afterMenuItemActivateItem :: (GObject a, MonadIO m) => a -> MenuItemActivateItemCallback -> m SignalHandlerId Source #

genClosure_MenuItemActivateItem :: MenuItemActivateItemCallback -> IO Closure Source #

mk_MenuItemActivateItemCallback :: C_MenuItemActivateItemCallback -> IO (FunPtr C_MenuItemActivateItemCallback) Source #

noMenuItemActivateItemCallback :: Maybe MenuItemActivateItemCallback Source #

onMenuItemActivateItem :: (GObject a, MonadIO m) => a -> MenuItemActivateItemCallback -> m SignalHandlerId Source #

wrap_MenuItemActivateItemCallback :: MenuItemActivateItemCallback -> Ptr () -> Ptr () -> IO () Source #

deselect

type C_MenuItemDeselectCallback = Ptr () -> Ptr () -> IO () Source #

type MenuItemDeselectCallback = IO () Source #

data MenuItemDeselectSignalInfo Source #

Instances

SignalInfo MenuItemDeselectSignalInfo Source #
Associated Types type HaskellCallbackType MenuItemDeselectSignalInfo :: * # Methods connectSignal :: GObject o => SignalProxy o MenuItemDeselectSignalInfo -> o -> HaskellCallbackType MenuItemDeselectSignalInfo -> SignalConnectMode -> IO SignalHandlerId #
type HaskellCallbackType MenuItemDeselectSignalInfo Source #
type HaskellCallbackType MenuItemDeselectSignalInfo = MenuItemDeselectCallback

afterMenuItemDeselect :: (GObject a, MonadIO m) => a -> MenuItemDeselectCallback -> m SignalHandlerId Source #

genClosure_MenuItemDeselect :: MenuItemDeselectCallback -> IO Closure Source #

mk_MenuItemDeselectCallback :: C_MenuItemDeselectCallback -> IO (FunPtr C_MenuItemDeselectCallback) Source #

noMenuItemDeselectCallback :: Maybe MenuItemDeselectCallback Source #

onMenuItemDeselect :: (GObject a, MonadIO m) => a -> MenuItemDeselectCallback -> m SignalHandlerId Source #

wrap_MenuItemDeselectCallback :: MenuItemDeselectCallback -> Ptr () -> Ptr () -> IO () Source #

select

type C_MenuItemSelectCallback = Ptr () -> Ptr () -> IO () Source #

type MenuItemSelectCallback = IO () Source #

data MenuItemSelectSignalInfo Source #

Instances

SignalInfo MenuItemSelectSignalInfo Source #
Associated Types type HaskellCallbackType MenuItemSelectSignalInfo :: * # Methods connectSignal :: GObject o => SignalProxy o MenuItemSelectSignalInfo -> o -> HaskellCallbackType MenuItemSelectSignalInfo -> SignalConnectMode -> IO SignalHandlerId #
type HaskellCallbackType MenuItemSelectSignalInfo Source #
type HaskellCallbackType MenuItemSelectSignalInfo = MenuItemSelectCallback

afterMenuItemSelect :: (GObject a, MonadIO m) => a -> MenuItemSelectCallback -> m SignalHandlerId Source #

genClosure_MenuItemSelect :: MenuItemSelectCallback -> IO Closure Source #

mk_MenuItemSelectCallback :: C_MenuItemSelectCallback -> IO (FunPtr C_MenuItemSelectCallback) Source #

noMenuItemSelectCallback :: Maybe MenuItemSelectCallback Source #

onMenuItemSelect :: (GObject a, MonadIO m) => a -> MenuItemSelectCallback -> m SignalHandlerId Source #

wrap_MenuItemSelectCallback :: MenuItemSelectCallback -> Ptr () -> Ptr () -> IO () Source #

toggleSizeAllocate

type C_MenuItemToggleSizeAllocateCallback = Ptr () -> Int32 -> Ptr () -> IO () Source #

type MenuItemToggleSizeAllocateCallback = Int32 -> IO () Source #

afterMenuItemToggleSizeAllocate :: (GObject a, MonadIO m) => a -> MenuItemToggleSizeAllocateCallback -> m SignalHandlerId Source #

genClosure_MenuItemToggleSizeAllocate :: MenuItemToggleSizeAllocateCallback -> IO Closure Source #

mk_MenuItemToggleSizeAllocateCallback :: C_MenuItemToggleSizeAllocateCallback -> IO (FunPtr C_MenuItemToggleSizeAllocateCallback) Source #

noMenuItemToggleSizeAllocateCallback :: Maybe MenuItemToggleSizeAllocateCallback Source #

onMenuItemToggleSizeAllocate :: (GObject a, MonadIO m) => a -> MenuItemToggleSizeAllocateCallback -> m SignalHandlerId Source #

wrap_MenuItemToggleSizeAllocateCallback :: MenuItemToggleSizeAllocateCallback -> Ptr () -> Int32 -> Ptr () -> IO () Source #

toggleSizeRequest

type C_MenuItemToggleSizeRequestCallback = Ptr () -> Ptr () -> Ptr () -> IO () Source #

type MenuItemToggleSizeRequestCallback = Ptr () -> IO () Source #

afterMenuItemToggleSizeRequest :: (GObject a, MonadIO m) => a -> MenuItemToggleSizeRequestCallback -> m SignalHandlerId Source #

genClosure_MenuItemToggleSizeRequest :: MenuItemToggleSizeRequestCallback -> IO Closure Source #

mk_MenuItemToggleSizeRequestCallback :: C_MenuItemToggleSizeRequestCallback -> IO (FunPtr C_MenuItemToggleSizeRequestCallback) Source #

noMenuItemToggleSizeRequestCallback :: Maybe MenuItemToggleSizeRequestCallback Source #

onMenuItemToggleSizeRequest :: (GObject a, MonadIO m) => a -> MenuItemToggleSizeRequestCallback -> m SignalHandlerId Source #

wrap_MenuItemToggleSizeRequestCallback :: MenuItemToggleSizeRequestCallback -> Ptr () -> Ptr () -> Ptr () -> IO () Source #

(GObject a, UnknownAncestorError Constraint MenuItem a) => IsMenuItem a Source #

IsMenuItem MenuItem Source #

IsMenuItem CheckMenuItem Source #

IsMenuItem ImageMenuItem Source #

IsMenuItem RadioMenuItem Source #

IsMenuItem SeparatorMenuItem Source #

IsMenuItem TearoffMenuItem Source #

SignalInfo MenuItemToggleSizeAllocateSignalInfo Source #
Associated Types type HaskellCallbackType MenuItemToggleSizeAllocateSignalInfo :: * # Methods connectSignal :: GObject o => SignalProxy o MenuItemToggleSizeAllocateSignalInfo -> o -> HaskellCallbackType MenuItemToggleSizeAllocateSignalInfo -> SignalConnectMode -> IO SignalHandlerId #
type HaskellCallbackType MenuItemToggleSizeAllocateSignalInfo Source #
type HaskellCallbackType MenuItemToggleSizeAllocateSignalInfo = MenuItemToggleSizeAllocateCallback

SignalInfo MenuItemToggleSizeRequestSignalInfo Source #
Associated Types type HaskellCallbackType MenuItemToggleSizeRequestSignalInfo :: * # Methods connectSignal :: GObject o => SignalProxy o MenuItemToggleSizeRequestSignalInfo -> o -> HaskellCallbackType MenuItemToggleSizeRequestSignalInfo -> SignalConnectMode -> IO SignalHandlerId #
type HaskellCallbackType MenuItemToggleSizeRequestSignalInfo Source #
type HaskellCallbackType MenuItemToggleSizeRequestSignalInfo = MenuItemToggleSizeRequestCallback