gi-gio-2.0.27: Gio bindings

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
  - Overloaded methods
  - append
  - appendItem
  - appendSection
  - appendSubmenu
  - freeze
  - insert
  - insertItem
  - insertSection
  - insertSubmenu
  - new
  - prepend
  - prependItem
  - prependSection
  - prependSubmenu
  - remove
  - removeAll

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

Menu (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
TypedObject Menu Source # |
Instance details Defined in GI.Gio.Objects.Menu Methods glibType :: IO GType Source #
ManagedPtrNewtype Menu Source # |
Instance details Defined in GI.Gio.Objects.Menu Methods toManagedPtr :: Menu -> ManagedPtr Menu Source #
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 Source # fromGValue :: GValue -> IO Menu Source #
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`.

# 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