GI.Gio.Objects.Menu

Menu is a simple implementation of MenuModel. You populate a Menu by adding MenuItem instances to it.

There are some convenience functions to allow you to directly add items (avoiding MenuItem) for the common cases. To add a regular item, use menuInsert. To add a section, use menuInsertSection. To add a submenu, use menuInsertSubmenu.

Exported types

newtype Menu

Constructors

Menu (ManagedPtr Menu)

Instances

GObject Menu

Methods

gobjectType :: Menu -> IO GType

IsObject Menu

IsMenuModel Menu

IsMenu Menu

((~) * info (ResolveMenuMethod t Menu), MethodInfo * info Menu p) => IsLabel t (Menu -> p)

Methods

fromLabel :: Proxy# Symbol t -> Menu -> p

((~) * info (ResolveMenuMethod t Menu), MethodInfo * info Menu p) => IsLabelProxy t (Menu -> p)

Methods

fromLabelProxy :: Proxy Symbol t -> Menu -> p

HasAttributeList * Menu

type AttributeList Menu

type AttributeList Menu

type SignalList Menu

type SignalList Menu

class GObject o => IsMenu o

Instances

(GObject a, UnknownAncestorError Constraint Menu a) => IsMenu a

IsMenu Menu

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

noMenu :: Maybe Menu

Methods

append

data MenuAppendMethodInfo

Instances

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

Methods

overloadedMethod :: MethodProxy MenuAppendMethodInfo a -> signature -> s

menuAppend

Arguments

:: (HasCallStack, MonadIO m, IsMenu a)

=> a

menu: a Menu

-> Maybe Text

label: the section label, or Nothing

-> Maybe Text

detailedAction: the detailed action string, or Nothing

-> m ()

Convenience function for appending a normal menu item to the end of menu. Combine menuItemNew and menuInsertItem for a more flexible alternative.

Since: 2.32

appendItem

data MenuAppendItemMethodInfo

Instances

((~) * signature (b -> m ()), MonadIO m, IsMenu a, IsMenuItem b) => MethodInfo * MenuAppendItemMethodInfo a signature

Methods

overloadedMethod :: MethodProxy MenuAppendItemMethodInfo a -> signature -> s

menuAppendItem

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsMenuItem b)

=> a

menu: a Menu

-> b

item: a MenuItem to append

-> m ()

Appends item to the end of menu.

See menuInsertItem for more information.

Since: 2.32

appendSection

data MenuAppendSectionMethodInfo

Instances

((~) * signature (Maybe Text -> b -> m ()), MonadIO m, IsMenu a, IsMenuModel b) => MethodInfo * MenuAppendSectionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy MenuAppendSectionMethodInfo a -> signature -> s

menuAppendSection

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsMenuModel b)

=> a

menu: a Menu

-> Maybe Text

label: the section label, or Nothing

-> b

section: a MenuModel with the items of the section

-> m ()

Convenience function for appending a section menu item to the end of menu. Combine menuItemNewSection and menuInsertItem for a more flexible alternative.

Since: 2.32

appendSubmenu

data MenuAppendSubmenuMethodInfo

Instances

((~) * signature (Maybe Text -> b -> m ()), MonadIO m, IsMenu a, IsMenuModel b) => MethodInfo * MenuAppendSubmenuMethodInfo a signature

Methods

overloadedMethod :: MethodProxy MenuAppendSubmenuMethodInfo a -> signature -> s

menuAppendSubmenu

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsMenuModel b)

=> a

menu: a Menu

-> Maybe Text

label: the section label, or Nothing

-> b

submenu: a MenuModel with the items of the submenu

-> m ()

Convenience function for appending a submenu menu item to the end of menu. Combine menuItemNewSubmenu and menuInsertItem for a more flexible alternative.

Since: 2.32

freeze

data MenuFreezeMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsMenu a) => MethodInfo * MenuFreezeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy MenuFreezeMethodInfo a -> signature -> s

menuFreeze

Arguments

:: (HasCallStack, MonadIO m, IsMenu a)

=> a

menu: a Menu

-> m ()

Marks menu as frozen.

After the menu is frozen, it is an error to attempt to make any changes to it. In effect this means that the Menu API must no longer be used.

This function causes menuModelIsMutable to begin returning False, which has some positive performance implications.

Since: 2.32

insert

data MenuInsertMethodInfo

Instances

((~) * signature (Int32 -> Maybe Text -> Maybe Text -> m ()), MonadIO m, IsMenu a) => MethodInfo * MenuInsertMethodInfo a signature

Methods

overloadedMethod :: MethodProxy MenuInsertMethodInfo a -> signature -> s

menuInsert

Arguments

:: (HasCallStack, MonadIO m, IsMenu a)

=> a

menu: a Menu

-> Int32

position: the position at which to insert the item

-> Maybe Text

label: the section label, or Nothing

-> Maybe Text

detailedAction: the detailed action string, or Nothing

-> m ()

Convenience function for inserting a normal menu item into menu. Combine menuItemNew and menuInsertItem for a more flexible alternative.

Since: 2.32

insertItem

data MenuInsertItemMethodInfo

Instances

((~) * signature (Int32 -> b -> m ()), MonadIO m, IsMenu a, IsMenuItem b) => MethodInfo * MenuInsertItemMethodInfo a signature

Methods

overloadedMethod :: MethodProxy MenuInsertItemMethodInfo a -> signature -> s

menuInsertItem

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsMenuItem b)

=> a

menu: a Menu

-> Int32

position: the position at which to insert the item

-> b

item: the MenuItem to insert

-> m ()

Inserts item into menu.

The "insertion" is actually done by copying all of the attribute and link values of item and using them to form a new item within menu. As such, item itself is not really inserted, but rather, a menu item that is exactly the same as the one presently described by item.

This means that item is essentially useless after the insertion occurs. Any changes you make to it are ignored unless it is inserted again (at which point its updated values will be copied).

You should probably just free item once you're done.

There are many convenience functions to take care of common cases. See menuInsert, menuInsertSection and menuInsertSubmenu as well as "prepend" and "append" variants of each of these functions.

Since: 2.32

insertSection

data MenuInsertSectionMethodInfo

Instances

((~) * signature (Int32 -> Maybe Text -> b -> m ()), MonadIO m, IsMenu a, IsMenuModel b) => MethodInfo * MenuInsertSectionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy MenuInsertSectionMethodInfo a -> signature -> s

menuInsertSection

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsMenuModel b)

=> a

menu: a Menu

-> Int32

position: the position at which to insert the item

-> Maybe Text

label: the section label, or Nothing

-> b

section: a MenuModel with the items of the section

-> m ()

Convenience function for inserting a section menu item into menu. Combine menuItemNewSection and menuInsertItem for a more flexible alternative.

Since: 2.32

insertSubmenu

data MenuInsertSubmenuMethodInfo

Instances

((~) * signature (Int32 -> Maybe Text -> b -> m ()), MonadIO m, IsMenu a, IsMenuModel b) => MethodInfo * MenuInsertSubmenuMethodInfo a signature

Methods

overloadedMethod :: MethodProxy MenuInsertSubmenuMethodInfo a -> signature -> s

menuInsertSubmenu

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsMenuModel b)

=> a

menu: a Menu

-> Int32

position: the position at which to insert the item

-> Maybe Text

label: the section label, or Nothing

-> b

submenu: a MenuModel with the items of the submenu

-> m ()

Convenience function for inserting a submenu menu item into menu. Combine menuItemNewSubmenu and menuInsertItem for a more flexible alternative.

Since: 2.32

new

menuNew

Arguments

:: (HasCallStack, MonadIO m)

=> m Menu

Returns: a new Menu

Creates a new Menu.

The new menu has no items.

Since: 2.32

prepend

data MenuPrependMethodInfo

Instances

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

Methods

overloadedMethod :: MethodProxy MenuPrependMethodInfo a -> signature -> s

menuPrepend

Arguments

:: (HasCallStack, MonadIO m, IsMenu a)

=> a

menu: a Menu

-> Maybe Text

label: the section label, or Nothing

-> Maybe Text

detailedAction: the detailed action string, or Nothing

-> m ()

Convenience function for prepending a normal menu item to the start of menu. Combine menuItemNew and menuInsertItem for a more flexible alternative.

Since: 2.32

prependItem

data MenuPrependItemMethodInfo

Instances

((~) * signature (b -> m ()), MonadIO m, IsMenu a, IsMenuItem b) => MethodInfo * MenuPrependItemMethodInfo a signature

Methods

overloadedMethod :: MethodProxy MenuPrependItemMethodInfo a -> signature -> s

menuPrependItem

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsMenuItem b)

=> a

menu: a Menu

-> b

item: a MenuItem to prepend

-> m ()

Prepends item to the start of menu.

See menuInsertItem for more information.

Since: 2.32

prependSection

data MenuPrependSectionMethodInfo

Instances

((~) * signature (Maybe Text -> b -> m ()), MonadIO m, IsMenu a, IsMenuModel b) => MethodInfo * MenuPrependSectionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy MenuPrependSectionMethodInfo a -> signature -> s

menuPrependSection

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsMenuModel b)

=> a

menu: a Menu

-> Maybe Text

label: the section label, or Nothing

-> b

section: a MenuModel with the items of the section

-> m ()

Convenience function for prepending a section menu item to the start of menu. Combine menuItemNewSection and menuInsertItem for a more flexible alternative.

Since: 2.32

prependSubmenu

data MenuPrependSubmenuMethodInfo

Instances

((~) * signature (Maybe Text -> b -> m ()), MonadIO m, IsMenu a, IsMenuModel b) => MethodInfo * MenuPrependSubmenuMethodInfo a signature

Methods

overloadedMethod :: MethodProxy MenuPrependSubmenuMethodInfo a -> signature -> s

menuPrependSubmenu

Arguments

:: (HasCallStack, MonadIO m, IsMenu a, IsMenuModel b)

=> a

menu: a Menu

-> Maybe Text

label: the section label, or Nothing

-> b

submenu: a MenuModel with the items of the submenu

-> m ()

Convenience function for prepending a submenu menu item to the start of menu. Combine menuItemNewSubmenu and menuInsertItem for a more flexible alternative.

Since: 2.32

remove

data MenuRemoveMethodInfo

Instances

((~) * signature (Int32 -> m ()), MonadIO m, IsMenu a) => MethodInfo * MenuRemoveMethodInfo a signature

Methods

overloadedMethod :: MethodProxy MenuRemoveMethodInfo a -> signature -> s

menuRemove

Arguments

:: (HasCallStack, MonadIO m, IsMenu a)

=> a

menu: a Menu

-> Int32

position: the position of the item to remove

-> m ()

Removes an item from the menu.

position gives the index of the item to remove.

It is an error if position is not in range the range from 0 to one less than the number of items in the menu.

It is not possible to remove items by identity since items are added to the menu simply by copying their links and attributes (ie: identity of the item itself is not preserved).

Since: 2.32

removeAll

data MenuRemoveAllMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsMenu a) => MethodInfo * MenuRemoveAllMethodInfo a signature

Methods

overloadedMethod :: MethodProxy MenuRemoveAllMethodInfo a -> signature -> s

menuRemoveAll

Arguments

:: (HasCallStack, MonadIO m, IsMenu a)

=> a

menu: a Menu

-> m ()

Removes all items in the menu.

Since: 2.38