Copyright	Will Thompson Iñaki García Etxebarria and Jonas Platte
License	LGPL-2.1
Maintainer	Iñaki García Etxebarria
Safe Haskell	None
Language	Haskell2010

GI.Gio.Objects.Menu

Contents

Exported types
Methods

Description

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.

Since: 2.32

Synopsis

newtype Menu = Menu (ManagedPtr Menu)
class (GObject o, IsDescendantOf Menu o) => IsMenu o
toMenu :: (MonadIO m, IsMenu o) => o -> m Menu
noMenu :: Maybe Menu
menuAppend :: (HasCallStack, MonadIO m, IsMenu a) => a -> Maybe Text -> Maybe Text -> m ()
menuAppendItem :: (HasCallStack, MonadIO m, IsMenu a, IsMenuItem b) => a -> b -> m ()
menuAppendSection :: (HasCallStack, MonadIO m, IsMenu a, IsMenuModel b) => a -> Maybe Text -> b -> m ()
menuAppendSubmenu :: (HasCallStack, MonadIO m, IsMenu a, IsMenuModel b) => a -> Maybe Text -> b -> m ()
menuFreeze :: (HasCallStack, MonadIO m, IsMenu a) => a -> m ()
menuInsert :: (HasCallStack, MonadIO m, IsMenu a) => a -> Int32 -> Maybe Text -> Maybe Text -> m ()
menuInsertItem :: (HasCallStack, MonadIO m, IsMenu a, IsMenuItem b) => a -> Int32 -> b -> m ()
menuInsertSection :: (HasCallStack, MonadIO m, IsMenu a, IsMenuModel b) => a -> Int32 -> Maybe Text -> b -> m ()
menuInsertSubmenu :: (HasCallStack, MonadIO m, IsMenu a, IsMenuModel b) => a -> Int32 -> Maybe Text -> b -> m ()
menuNew :: (HasCallStack, MonadIO m) => m Menu
menuPrepend :: (HasCallStack, MonadIO m, IsMenu a) => a -> Maybe Text -> Maybe Text -> m ()
menuPrependItem :: (HasCallStack, MonadIO m, IsMenu a, IsMenuItem b) => a -> b -> m ()
menuPrependSection :: (HasCallStack, MonadIO m, IsMenu a, IsMenuModel b) => a -> Maybe Text -> b -> m ()
menuPrependSubmenu :: (HasCallStack, MonadIO m, IsMenu a, IsMenuModel b) => a -> Maybe Text -> b -> m ()
menuRemove :: (HasCallStack, MonadIO m, IsMenu a) => a -> Int32 -> m ()
menuRemoveAll :: (HasCallStack, MonadIO m, IsMenu a) => a -> m ()

Exported types

newtype Menu Source #

Memory-managed wrapper type.

Constructors

(ManagedPtr Menu)

Instances

Instances details

Eq Menu Source #
Instance details Defined in GI.Gio.Objects.Menu Methods (==) :: Menu -> Menu -> Bool # (/=) :: Menu -> Menu -> Bool #
GObject Menu Source #
Instance details Defined in GI.Gio.Objects.Menu Methods gobjectType :: IO GType #
IsGValue Menu Source #	Convert `Menu` to and from `GValue` with `toGValue` and `fromGValue`.
Instance details Defined in GI.Gio.Objects.Menu Methods toGValue :: Menu -> IO GValue # fromGValue :: GValue -> IO Menu #
HasParentTypes Menu Source #
Instance details Defined in GI.Gio.Objects.Menu
type ParentTypes Menu Source #
Instance details Defined in GI.Gio.Objects.Menu type ParentTypes Menu = '[MenuModel, Object]

class (GObject o, IsDescendantOf Menu o) => IsMenu o Source #

Type class for types which can be safely cast to Menu, for instance with toMenu.

Instances

Instances details

(GObject o, IsDescendantOf Menu o) => IsMenu o Source #
Instance details Defined in GI.Gio.Objects.Menu

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

Cast to Menu, for types for which this is known to be safe. For general casts, use castTo.

noMenu :: Maybe Menu Source #

A convenience alias for Nothing :: Maybe Menu.

Methods

Overloaded methods

append

menuAppend Source #

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

menuAppendItem Source #

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

menuAppendSection Source #

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

menuAppendSubmenu Source #

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

menuFreeze Source #

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

menuInsert Source #

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

menuInsertItem Source #

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

menuInsertSection Source #

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

menuInsertSubmenu Source #

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 Source #

Arguments

:: (HasCallStack, MonadIO m)
=> m Menu	Returns: a new `Menu`

Creates a new Menu.

The new menu has no items.

Since: 2.32

prepend

menuPrepend Source #

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

menuPrependItem Source #

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

menuPrependSection Source #

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

menuPrependSubmenu Source #

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

menuRemove Source #

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

menuRemoveAll Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a)
=> a	`menu`: a `Menu`
-> m ()

Removes all items in the menu.

Since: 2.38