-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Dbusmenu bindings
--
-- Bindings for libdbusmenu, autogenerated by haskell-gi.
@package gi-dbusmenu
@version 0.4.13
-- | Build time configuration used during code generation.
module GI.Dbusmenu.Config
-- | Overrides used when generating these bindings.
overrides :: Text
module GI.Dbusmenu.Constants
-- | String to attach to signal Server::layoutUpdated
pattern SERVER_SIGNAL_LAYOUT_UPDATED :: Text
-- | String to attach to signal Server::itemActivationRequested
pattern SERVER_SIGNAL_ITEM_ACTIVATION :: Text
-- | String to attach to signal Server::itemUpdated
pattern SERVER_SIGNAL_ID_UPDATE :: Text
-- | String to attach to signal Server::itemPropertyUpdated
pattern SERVER_SIGNAL_ID_PROP_UPDATE :: Text
-- | String to access property Server:version
pattern SERVER_PROP_VERSION :: Text
-- | String to access property Server:text-direction
pattern SERVER_PROP_TEXT_DIRECTION :: Text
-- | String to access property Server:status
pattern SERVER_PROP_STATUS :: Text
-- | String to access property Server:rootNode
pattern SERVER_PROP_ROOT_NODE :: Text
-- | String to access property Server:dbusObject
pattern SERVER_PROP_DBUS_OBJECT :: Text
-- | Used to set MENUITEM_PROP_TOGGLE_STATE so that the menu's
-- toggle item is undecided.
pattern MENUITEM_TOGGLE_STATE_UNKNOWN :: Int32
-- | Used to set MENUITEM_PROP_TOGGLE_STATE so that the menu's
-- toggle item is empty.
pattern MENUITEM_TOGGLE_STATE_UNCHECKED :: Int32
-- | Used to set MENUITEM_PROP_TOGGLE_STATE so that the menu's
-- toggle item is filled.
pattern MENUITEM_TOGGLE_STATE_CHECKED :: Int32
-- | Used to set MENUITEM_PROP_TOGGLE_TYPE to be a standard radio
-- item.
pattern MENUITEM_TOGGLE_RADIO :: Text
-- | Used to set MENUITEM_PROP_TOGGLE_TYPE to be a standard check
-- mark item.
pattern MENUITEM_TOGGLE_CHECK :: Text
-- | String to attach to signal Server::show-to-user
pattern MENUITEM_SIGNAL_SHOW_TO_USER :: Text
-- | String to attach to signal Server::realized
pattern MENUITEM_SIGNAL_REALIZED :: Text
-- | String to attach to signal
-- Server::property-changed
pattern MENUITEM_SIGNAL_PROPERTY_CHANGED :: Text
-- | String to attach to signal
-- Server::item-activated
pattern MENUITEM_SIGNAL_ITEM_ACTIVATED :: Text
-- | String to attach to signal Server::event
pattern MENUITEM_SIGNAL_EVENT :: Text
-- | String to attach to signal
-- Server::child-removed
pattern MENUITEM_SIGNAL_CHILD_REMOVED :: Text
-- | String to attach to signal Server::child-moved
pattern MENUITEM_SIGNAL_CHILD_MOVED :: Text
-- | String to attach to signal Server::child-added
pattern MENUITEM_SIGNAL_CHILD_ADDED :: Text
-- | String to attach to signal
-- Server::about-to-show
pattern MENUITEM_SIGNAL_ABOUT_TO_SHOW :: Text
-- | Used in MENUITEM_PROP_SHORTCUT to represent the super key.
pattern MENUITEM_SHORTCUT_SUPER :: Text
-- | Used in MENUITEM_PROP_SHORTCUT to represent the shift key.
pattern MENUITEM_SHORTCUT_SHIFT :: Text
-- | Used in MENUITEM_PROP_SHORTCUT to represent the control key.
pattern MENUITEM_SHORTCUT_CONTROL :: Text
-- | Used in MENUITEM_PROP_SHORTCUT to represent the alternate key.
pattern MENUITEM_SHORTCUT_ALT :: Text
-- | Menuitem property used to represent whether the menuitem should
-- be shown or not. Type: G_VARIANT_TYPE_BOOLEAN.
pattern MENUITEM_PROP_VISIBLE :: Text
-- | Menuitem property used to represent what type of menuitem this
-- object represents. Type: G_VARIANT_TYPE_STRING.
pattern MENUITEM_PROP_TYPE :: Text
-- | Menuitem property that says what type of toggle entry should be
-- shown in the menu. Should be either MENUITEM_TOGGLE_CHECK or
-- MENUITEM_TOGGLE_RADIO. Type:
-- G_VARIANT_TYPE_STRING
pattern MENUITEM_PROP_TOGGLE_TYPE :: Text
-- | Menuitem property that says what state a toggle entry should be
-- shown as the menu. Should be either
-- MENUITEM_TOGGLE_STATE_UNCHECKED
-- MENUITEM_TOGGLE_STATE_CHECKED or
-- DBUSMENU_MENUITEM_TOGGLE_STATUE_UNKNOWN.
pattern MENUITEM_PROP_TOGGLE_STATE :: Text
-- | Menuitem property that is the entries that represent a shortcut
-- to activate the menuitem. It is an array of arrays of strings.
--
-- It is recommended that this is not set directly but instead the
-- libdbusmenu-gtk library is used with the function
-- dbusmenu_menuitem_property_set_shortcut()
pattern MENUITEM_PROP_SHORTCUT :: Text
-- | Menuitem property used for the text on the menu item.
pattern MENUITEM_PROP_LABEL :: Text
-- | Menuitem property that is the name of the icon under the
-- Freedesktop.org icon naming spec. Type:
-- G_VARIANT_TYPE_STRING
pattern MENUITEM_PROP_ICON_NAME :: Text
-- | Menuitem property that is the raw data of a custom icon used in
-- the application. Type: G_VARIANT_TYPE_VARIANT
--
-- It is recommended that this is not set directly but instead the
-- libdbusmenu-gtk library is used with the function
-- dbusmenu_menuitem_property_set_image()
pattern MENUITEM_PROP_ICON_DATA :: Text
-- | Menuitem property used to represent whether the menuitem is
-- clickable or not. Type: G_VARIANT_TYPE_BOOLEAN.
pattern MENUITEM_PROP_ENABLED :: Text
-- | Menuitem property to tell what type of information that the
-- menu item is displaying to the user. Type:
-- G_VARIANT_TYPE_STRING
pattern MENUITEM_PROP_DISPOSITION :: Text
-- | Menuitem property that tells how the children of this menuitem
-- should be displayed. Most likely this will be unset or of the value
-- MENUITEM_CHILD_DISPLAY_SUBMENU. Type:
-- G_VARIANT_TYPE_STRING
pattern MENUITEM_PROP_CHILD_DISPLAY :: Text
-- | Menuitem property used to provide a textual description of any
-- information that the icon may convey. The contents of this property
-- are passed through to assistive technologies such as the Orca screen
-- reader. The contents of this property will not be visible in the menu
-- item. If this property is set, Orca will use this property instead of
-- the label property.
pattern MENUITEM_PROP_ACCESSIBLE_DESC :: Text
-- | Used to set MENUITEM_PROP_TOGGLE_STATE so that the menu's
-- toggle item is undecided.
pattern MENUITEM_ICON_NAME_BLANK :: Text
-- | String for the event identifier when a menu is opened and displayed to
-- the user. Only valid for items that contain submenus.
pattern MENUITEM_EVENT_OPENED :: Text
-- | String for the event identifier when a menu is closed and displayed to
-- the user. Only valid for items that contain submenus.
pattern MENUITEM_EVENT_CLOSED :: Text
-- | String for the event identifier when a menu item is clicked on by the
-- user.
pattern MENUITEM_EVENT_ACTIVATED :: Text
-- | Used in MENUITEM_PROP_DISPOSITION to have a menu item displayed
-- in a way that conveys it's giving a warning to the user.
pattern MENUITEM_DISPOSITION_WARNING :: Text
-- | Used in MENUITEM_PROP_DISPOSITION to have a menu item displayed
-- in the normal manner. Default value.
pattern MENUITEM_DISPOSITION_NORMAL :: Text
-- | Used in MENUITEM_PROP_DISPOSITION to have a menu item displayed
-- in a way that conveys it's giving additional information to the user.
pattern MENUITEM_DISPOSITION_INFORMATIVE :: Text
-- | Used in MENUITEM_PROP_DISPOSITION to have a menu item displayed
-- in a way that conveys it's giving an alert to the user.
pattern MENUITEM_DISPOSITION_ALERT :: Text
-- | Used in MENUITEM_PROP_CHILD_DISPLAY to have the subitems
-- displayed as a submenu.
pattern MENUITEM_CHILD_DISPLAY_SUBMENU :: Text
-- | Used to set the 'type' property on a menu item to create a separator
-- menu item.
pattern CLIENT_TYPES_SEPARATOR :: Text
-- | Used to set the 'type' property on a menu item to create an image menu
-- item. Deprecated as standard menu items now support images as well.
pattern CLIENT_TYPES_IMAGE :: Text
-- | Used to set the 'type' property on a menu item to create a standard
-- menu item.
pattern CLIENT_TYPES_DEFAULT :: Text
-- | String to attach to signal Client::rootChanged
pattern CLIENT_SIGNAL_ROOT_CHANGED :: Text
-- | String to attach to signal Client::newMenuitem
pattern CLIENT_SIGNAL_NEW_MENUITEM :: Text
-- | String to attach to signal Client::layoutUpdated
pattern CLIENT_SIGNAL_LAYOUT_UPDATED :: Text
-- | String to attach to signal Client::itemActivate
pattern CLIENT_SIGNAL_ITEM_ACTIVATE :: Text
-- | String to attach to signal Client::iconThemeDirsChanged
pattern CLIENT_SIGNAL_ICON_THEME_DIRS_CHANGED :: Text
-- | String to attach to signal Client::eventResult
pattern CLIENT_SIGNAL_EVENT_RESULT :: Text
-- | String to access property Client:text-direction
pattern CLIENT_PROP_TEXT_DIRECTION :: Text
-- | String to access property Client:status
pattern CLIENT_PROP_STATUS :: Text
-- | String to access property Client:groupEvents
pattern CLIENT_PROP_GROUP_EVENTS :: Text
-- | String to access property Client:dbusObject
pattern CLIENT_PROP_DBUS_OBJECT :: Text
-- | String to access property Client:dbusName
pattern CLIENT_PROP_DBUS_NAME :: Text
module GI.Dbusmenu.Enums
-- | Tracks how the menus should be presented to the user.
data Status
-- | Everything is normal
StatusNormal :: Status
-- | The menus should be shown at a higher priority
StatusNotice :: Status
-- | Catch-all for unknown values
AnotherStatus :: Int -> Status
-- | The direction of text that the strings that this server will be
-- sending strings as.
data TextDirection
-- | Unspecified text direction
TextDirectionNone :: TextDirection
-- | Left-to-right text direction
TextDirectionLtr :: TextDirection
-- | Right-to-left text direction
TextDirectionRtl :: TextDirection
-- | Catch-all for unknown values
AnotherTextDirection :: Int -> TextDirection
instance GHC.Classes.Eq GI.Dbusmenu.Enums.TextDirection
instance GHC.Show.Show GI.Dbusmenu.Enums.TextDirection
instance GHC.Classes.Eq GI.Dbusmenu.Enums.Status
instance GHC.Show.Show GI.Dbusmenu.Enums.Status
instance GHC.Enum.Enum GI.Dbusmenu.Enums.Status
instance GHC.Classes.Ord GI.Dbusmenu.Enums.Status
instance GHC.Enum.Enum GI.Dbusmenu.Enums.TextDirection
instance GHC.Classes.Ord GI.Dbusmenu.Enums.TextDirection
-- | This is the Object based object that represents a menu item. It
-- gets created the same on both the client and the server side and
-- libdbusmenu-glib does the work of making this object model appear on
-- both sides of DBus. Simple really, though through updates and people
-- coming on and off the bus it can lead to lots of fun complex
-- scenarios.
module GI.Dbusmenu.Objects.Menuitem
-- | Memory-managed wrapper type.
newtype Menuitem
Menuitem :: ManagedPtr Menuitem -> Menuitem
-- | Type class for types which can be safely cast to Menuitem, for
-- instance with toMenuitem.
class (GObject o, IsDescendantOf Menuitem o) => IsMenuitem o
-- | Cast to Menuitem, for types for which this is known to be safe.
-- For general casts, use castTo.
toMenuitem :: (MonadIO m, IsMenuitem o) => o -> m Menuitem
-- | Puts child in the list of children for
-- mi at the location specified in
-- position. If there is not enough entires available
-- then child will be placed at the end of the list.
menuitemChildAddPosition :: (HasCallStack, MonadIO m, IsMenuitem a, IsMenuitem b) => a -> b -> Word32 -> m Bool
-- | This function adds child to the list of children on
-- mi at the end of that list.
menuitemChildAppend :: (HasCallStack, MonadIO m, IsMenuitem a, IsMenuitem b) => a -> b -> m Bool
-- | This function removes child from the children list of
-- mi. It does not call g_object_unref on
-- child.
menuitemChildDelete :: (HasCallStack, MonadIO m, IsMenuitem a, IsMenuitem b) => a -> b -> m Bool
-- | Search the children of mi to find one with the ID of
-- id. If it doesn't exist then we return
-- NULL.
menuitemChildFind :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Int32 -> m (Maybe Menuitem)
-- | This function adds child to the list of children on
-- mi at the beginning of that list.
menuitemChildPrepend :: (HasCallStack, MonadIO m, IsMenuitem a, IsMenuitem b) => a -> b -> m Bool
-- | This function moves a child on the list of children. It is for a child
-- that is already in the list, but simply needs a new location.
menuitemChildReorder :: (HasCallStack, MonadIO m, IsMenuitem a, IsMenuitem b) => a -> b -> Word32 -> m Bool
-- | This function searchs the whole tree of children that are attached to
-- mi. This could be quite a few nodes, all the way down
-- the tree. It is a depth first search.
menuitemFindId :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Int32 -> m (Maybe Menuitem)
-- | This calls the function func on this menu item and all
-- of the children of this item. And their children. And their children.
-- And... you get the point. It will get called on the whole tree.
menuitemForeach :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Ptr () -> Ptr () -> m ()
-- | Returns simply the list of children that this menu item has. The list
-- is valid until another child related function is called, where it
-- might be changed.
menuitemGetChildren :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> m [Menuitem]
-- | Gets the unique ID for mi.
menuitemGetId :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> m Int32
-- | This function looks up the parent of mi
menuitemGetParent :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> m Menuitem
-- | This function returns the position of the menu item mi
-- in the children of parent. It will return zero if the
-- menu item can't be found.
menuitemGetPosition :: (HasCallStack, MonadIO m, IsMenuitem a, IsMenuitem b) => a -> b -> m Word32
-- | This function is very similar to
-- dbusmenu_menuitem_get_position except that it only
-- counts in the children that have been realized.
menuitemGetPositionRealized :: (HasCallStack, MonadIO m, IsMenuitem a, IsMenuitem b) => a -> b -> m Word32
-- | This function returns the internal value of whether this is a root
-- node or not.
menuitemGetRoot :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> m Bool
-- | This function is called to create an event. It is likely to be
-- overrided by subclasses. The default menu item will respond to the
-- activate signal and do:
--
-- Emits the Menuitem::item-activate signal on
-- this menu item. Called by server objects when they get the appropriate
-- DBus signals from the client.
--
-- If you subclass this function you should really think about calling
-- the parent function unless you have a good reason not to.
menuitemHandleEvent :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Text -> GVariant -> Word32 -> m ()
-- | Create a new Menuitem with all default values.
menuitemNew :: (HasCallStack, MonadIO m) => m Menuitem
-- | This creates a blank Menuitem with a specific ID.
menuitemNewWithId :: (HasCallStack, MonadIO m) => Int32 -> m Menuitem
-- | This function takes the properties of a Menuitem and puts them
-- into a HashTable that is referenced by the key of a string and
-- has the value of a string. The hash table may not have any entries if
-- there aren't any or there is an error in processing. It is the
-- caller's responsibility to destroy the created HashTable.
menuitemPropertiesCopy :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> m (Map (Ptr ()) (Ptr ()))
-- | This functiong gets a list of the names of all the properties that are
-- set on this menu item. This data on the list is owned by the menuitem
-- but the list is not and should be freed using
-- g_list_free() when the calling function is done with
-- it.
menuitemPropertiesList :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> m [Text]
-- | Checkes to see if a particular property exists on mi
-- and returns TRUE if so.
menuitemPropertyExist :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Text -> m Bool
-- | Look up a property on mi and return the value of it if
-- it exits. NULL will be returned if the property
-- doesn't exist.
menuitemPropertyGet :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Text -> m (Maybe Text)
-- | Look up a property on mi and return the value of it if
-- it exits. Returns FALSE if the property doesn't exist.
menuitemPropertyGetBool :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Text -> m Bool
-- | Look up a property on mi and return the value of it if
-- it exits. NULL will be returned if the property
-- doesn't exist.
menuitemPropertyGetByteArray :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Text -> m (Maybe ByteString)
-- | Look up a property on mi and return the value of it if
-- it exits. Returns zero if the property doesn't exist.
menuitemPropertyGetInt :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Text -> m Int32
-- | Look up a property on mi and return the value of it if
-- it exits. NULL will be returned if the property
-- doesn't exist.
menuitemPropertyGetVariant :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Text -> m (Maybe GVariant)
-- | Removes a property from the menuitem.
menuitemPropertyRemove :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Text -> m ()
-- | Takes the pair of property and value
-- and places them as a property on mi. If a property
-- already exists by that name, then the value is set to the new value.
-- If not, the property is added. If the value is changed or the property
-- was previously unset then the signal
-- Menuitem::prop-changed will be emitted by this
-- function.
menuitemPropertySet :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Text -> Text -> m Bool
-- | Takes a boolean value and sets it on
-- property as a property on mi. If a
-- property already exists by that name, then the value is set to the new
-- value. If not, the property is added. If the value is changed or the
-- property was previously unset then the signal
-- Menuitem::prop-changed will be emitted by this
-- function.
menuitemPropertySetBool :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Text -> Bool -> m Bool
-- | Takes a byte array value and sets it on
-- property as a property on mi. If a
-- property already exists by that name, then the value is set to the new
-- value. If not, the property is added. If the value is changed or the
-- property was previously unset then the signal
-- Menuitem::prop-changed will be emitted by this
-- function.
menuitemPropertySetByteArray :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Text -> Word8 -> Word64 -> m Bool
-- | Takes a boolean value and sets it on
-- property as a property on mi. If a
-- property already exists by that name, then the value is set to the new
-- value. If not, the property is added. If the value is changed or the
-- property was previously unset then the signal
-- Menuitem::prop-changed will be emitted by this
-- function.
menuitemPropertySetInt :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Text -> Int32 -> m Bool
-- | Takes the pair of property and value
-- and places them as a property on mi. If a property
-- already exists by that name, then the value is set to the new value.
-- If not, the property is added. If the value is changed or the property
-- was previously unset then the signal
-- Menuitem::prop-changed will be emitted by this
-- function.
menuitemPropertySetVariant :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Text -> GVariant -> m Bool
-- | This function is used to send the even that the submenu of this item
-- is about to be shown. Callers to this event should delay showing the
-- menu until their callback is called if possible.
menuitemSendAboutToShow :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Ptr () -> Ptr () -> m ()
-- | Sets the parent of mi to parent. If
-- mi already has a parent, then this call will fail. The
-- parent will be set automatically when using the usual methods to add a
-- child menuitem, so this function should not normally be called
-- directly
menuitemSetParent :: (HasCallStack, MonadIO m, IsMenuitem a, IsMenuitem b) => a -> b -> m Bool
-- | This function sets the internal value of whether this is a root node
-- or not.
menuitemSetRoot :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Bool -> m ()
-- | Signals that this menu item should be shown to the user. If this is
-- server side the server will then take it and send it over the bus.
menuitemShowToUser :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> Word32 -> m ()
-- | While the name sounds devious that's exactly what this function does.
-- It takes the list of children from the mi and clears
-- the internal list. The calling function is now in charge of the ref's
-- on the children it has taken. A lot of responsibility involved in
-- taking children.
menuitemTakeChildren :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> m [Menuitem]
-- | Unparents the menu item mi. If mi
-- doesn't have a parent, then this call will fail. The menuitem will be
-- unparented automatically when using the usual methods to delete a
-- child menuitem, so this function should not normally be called
-- directly
menuitemUnparent :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> m Bool
-- | Construct a GValueConstruct with valid value for the
-- “id” property. This is rarely needed directly, but it is used
-- by new.
constructMenuitemId :: (IsMenuitem o, MonadIO m) => Int32 -> m (GValueConstruct o)
-- | Get the value of the “id” property. When overloading
-- is enabled, this is equivalent to
--
--
-- get menuitem #id
--
getMenuitemId :: (MonadIO m, IsMenuitem o) => o -> m Int32
-- | Emitted when the submenu for this item is about to be shown
type MenuitemAboutToShowCallback = IO Bool
-- | Connect a signal handler for the aboutToShow signal, to be run
-- after the default handler. When overloading is enabled, this is
-- equivalent to
--
--
-- after menuitem #aboutToShow callback
--
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterMenuitemAboutToShow :: (IsMenuitem a, MonadIO m) => a -> ((?self :: a) => MenuitemAboutToShowCallback) -> m SignalHandlerId
-- | Connect a signal handler for the aboutToShow signal, to be run
-- before the default handler. When overloading is enabled, this
-- is equivalent to
--
--
-- on menuitem #aboutToShow callback
--
onMenuitemAboutToShow :: (IsMenuitem a, MonadIO m) => a -> ((?self :: a) => MenuitemAboutToShowCallback) -> m SignalHandlerId
-- | Signaled when the child menuitem has been added to the parent.
type MenuitemChildAddedCallback = -- | /@arg1@/: The t'GI.Dbusmenu.Objects.Menuitem.Menuitem' which is the child. Object -> -- | /@arg2@/: The position that the child is being added in. Word32 -> IO ()
-- | Connect a signal handler for the childAdded signal, to be run
-- after the default handler. When overloading is enabled, this is
-- equivalent to
--
--
-- after menuitem #childAdded callback
--
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterMenuitemChildAdded :: (IsMenuitem a, MonadIO m) => a -> ((?self :: a) => MenuitemChildAddedCallback) -> m SignalHandlerId
-- | Connect a signal handler for the childAdded signal, to be run
-- before the default handler. When overloading is enabled, this
-- is equivalent to
--
--
-- on menuitem #childAdded callback
--
onMenuitemChildAdded :: (IsMenuitem a, MonadIO m) => a -> ((?self :: a) => MenuitemChildAddedCallback) -> m SignalHandlerId
-- | Signaled when the child menuitem has had its location in the list
-- change.
type MenuitemChildMovedCallback = -- | /@arg1@/: The t'GI.Dbusmenu.Objects.Menuitem.Menuitem' which is the child. Object -> -- | /@arg2@/: The position that the child is being moved to. Word32 -> -- | /@arg3@/: The position that the child is was in. Word32 -> IO ()
-- | Connect a signal handler for the childMoved signal, to be run
-- after the default handler. When overloading is enabled, this is
-- equivalent to
--
--
-- after menuitem #childMoved callback
--
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterMenuitemChildMoved :: (IsMenuitem a, MonadIO m) => a -> ((?self :: a) => MenuitemChildMovedCallback) -> m SignalHandlerId
-- | Connect a signal handler for the childMoved signal, to be run
-- before the default handler. When overloading is enabled, this
-- is equivalent to
--
--
-- on menuitem #childMoved callback
--
onMenuitemChildMoved :: (IsMenuitem a, MonadIO m) => a -> ((?self :: a) => MenuitemChildMovedCallback) -> m SignalHandlerId
-- | Signaled when the child menuitem has been requested to be removed from
-- the parent. This signal is called when it has been removed from the
-- list but not yet had g_object_unref called on it.
type MenuitemChildRemovedCallback = -- | /@arg1@/: The t'GI.Dbusmenu.Objects.Menuitem.Menuitem' which was the child. Object -> IO ()
-- | Connect a signal handler for the childRemoved signal, to be run
-- after the default handler. When overloading is enabled, this is
-- equivalent to
--
--
-- after menuitem #childRemoved callback
--
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterMenuitemChildRemoved :: (IsMenuitem a, MonadIO m) => a -> ((?self :: a) => MenuitemChildRemovedCallback) -> m SignalHandlerId
-- | Connect a signal handler for the childRemoved signal, to be run
-- before the default handler. When overloading is enabled, this
-- is equivalent to
--
--
-- on menuitem #childRemoved callback
--
onMenuitemChildRemoved :: (IsMenuitem a, MonadIO m) => a -> ((?self :: a) => MenuitemChildRemovedCallback) -> m SignalHandlerId
-- | Emitted when an event is passed through. The event is signalled after
-- handle_event is called.
type MenuitemEventCallback = -- | /@arg1@/: Name of the event Text -> -- | /@arg2@/: Information passed along with the event GVariant -> -- | /@arg3@/: X11 timestamp of when the event happened Word32 -> IO Bool
-- | Connect a signal handler for the event signal, to be run after
-- the default handler. When overloading is enabled, this is
-- equivalent to
--
--
-- after menuitem #event callback
--
--
-- This signal admits a optional parameter detail. If it's not
-- Nothing, we will connect to “event::detail” instead.
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterMenuitemEvent :: (IsMenuitem a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => MenuitemEventCallback) -> m SignalHandlerId
-- | Connect a signal handler for the event signal, to be run before
-- the default handler. When overloading is enabled, this is
-- equivalent to
--
--
-- on menuitem #event callback
--
--
-- This signal admits a optional parameter detail. If it's not
-- Nothing, we will connect to “event::detail” instead.
onMenuitemEvent :: (IsMenuitem a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => MenuitemEventCallback) -> m SignalHandlerId
-- | Emitted on the objects on the server side when they are signaled on
-- the client side.
type MenuitemItemActivatedCallback = -- | /@arg1@/: The timestamp of when it was activated Word32 -> IO ()
-- | Connect a signal handler for the itemActivated signal, to be
-- run after the default handler. When overloading is enabled,
-- this is equivalent to
--
--
-- after menuitem #itemActivated callback
--
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterMenuitemItemActivated :: (IsMenuitem a, MonadIO m) => a -> ((?self :: a) => MenuitemItemActivatedCallback) -> m SignalHandlerId
-- | Connect a signal handler for the itemActivated signal, to be
-- run before the default handler. When overloading is enabled,
-- this is equivalent to
--
--
-- on menuitem #itemActivated callback
--
onMenuitemItemActivated :: (IsMenuitem a, MonadIO m) => a -> ((?self :: a) => MenuitemItemActivatedCallback) -> m SignalHandlerId
-- | Emitted everytime a property on a menuitem is either updated or added.
type MenuitemPropertyChangedCallback = -- | /@arg1@/: The name of the property that changed Text -> -- | /@arg2@/: The new value of the property GVariant -> IO ()
-- | Connect a signal handler for the propertyChanged signal, to be
-- run after the default handler. When overloading is enabled,
-- this is equivalent to
--
--
-- after menuitem #propertyChanged callback
--
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterMenuitemPropertyChanged :: (IsMenuitem a, MonadIO m) => a -> ((?self :: a) => MenuitemPropertyChangedCallback) -> m SignalHandlerId
-- | Connect a signal handler for the propertyChanged signal, to be
-- run before the default handler. When overloading is enabled,
-- this is equivalent to
--
--
-- on menuitem #propertyChanged callback
--
onMenuitemPropertyChanged :: (IsMenuitem a, MonadIO m) => a -> ((?self :: a) => MenuitemPropertyChangedCallback) -> m SignalHandlerId
-- | Emitted when the initial request for properties is complete on the
-- item. If there is a type handler configured for the "type" parameter
-- that will be executed before this is signaled.
type MenuitemRealizedCallback = IO ()
-- | Connect a signal handler for the realized signal, to be run
-- after the default handler. When overloading is enabled, this is
-- equivalent to
--
--
-- after menuitem #realized callback
--
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterMenuitemRealized :: (IsMenuitem a, MonadIO m) => a -> ((?self :: a) => MenuitemRealizedCallback) -> m SignalHandlerId
-- | Connect a signal handler for the realized signal, to be run
-- before the default handler. When overloading is enabled, this
-- is equivalent to
--
--
-- on menuitem #realized callback
--
onMenuitemRealized :: (IsMenuitem a, MonadIO m) => a -> ((?self :: a) => MenuitemRealizedCallback) -> m SignalHandlerId
-- | Signaled when the application would like the visualization of this
-- menu item shown to the user. This usually requires going over the bus
-- to get it done.
type MenuitemShowToUserCallback = -- | /@arg1@/: Timestamp the event happened at Word32 -> IO ()
-- | Connect a signal handler for the showToUser signal, to be run
-- after the default handler. When overloading is enabled, this is
-- equivalent to
--
--
-- after menuitem #showToUser callback
--
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterMenuitemShowToUser :: (IsMenuitem a, MonadIO m) => a -> ((?self :: a) => MenuitemShowToUserCallback) -> m SignalHandlerId
-- | Connect a signal handler for the showToUser signal, to be run
-- before the default handler. When overloading is enabled, this
-- is equivalent to
--
--
-- on menuitem #showToUser callback
--
onMenuitemShowToUser :: (IsMenuitem a, MonadIO m) => a -> ((?self :: a) => MenuitemShowToUserCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Dbusmenu.Objects.Menuitem.Menuitem
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Dbusmenu.Objects.Menuitem.Menuitem o) => GI.Dbusmenu.Objects.Menuitem.IsMenuitem o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Dbusmenu.Objects.Menuitem.Menuitem
instance Data.GI.Base.BasicTypes.TypedObject GI.Dbusmenu.Objects.Menuitem.Menuitem
instance Data.GI.Base.BasicTypes.GObject GI.Dbusmenu.Objects.Menuitem.Menuitem
instance Data.GI.Base.Overloading.HasParentTypes GI.Dbusmenu.Objects.Menuitem.Menuitem
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Dbusmenu.Objects.Menuitem.Menuitem)
module GI.Dbusmenu.Callbacks
-- | Type for the callback on the (unwrapped) C side.
type C_ClientTypeHandler = Ptr Menuitem -> Ptr Menuitem -> Ptr Client -> Ptr () -> IO CInt
-- | The type handler is called when a dbusmenu item is created with a
-- matching type as setup in
-- dbusmenu_client_add_type_handler
--
-- Return value: TRUE if the type has been handled.
-- FALSE if this function was somehow unable to handle
-- it.
type ClientTypeHandler = -- | /@newitem@/: The t'GI.Dbusmenu.Objects.Menuitem.Menuitem' that was created Menuitem -> -- | /@parent@/: The parent of /@newitem@/ or @/NULL/@ if none Menuitem -> -- | /@client@/: A pointer to the t'GI.Dbusmenu.Objects.Client.Client' Client -> IO Bool
-- | The type handler is called when a dbusmenu item is created with a
-- matching type as setup in
-- dbusmenu_client_add_type_handler
--
-- Return value: TRUE if the type has been handled.
-- FALSE if this function was somehow unable to handle
-- it.
type ClientTypeHandler_WithClosures = -- | /@newitem@/: The t'GI.Dbusmenu.Objects.Menuitem.Menuitem' that was created Menuitem -> -- | /@parent@/: The parent of /@newitem@/ or @/NULL/@ if none Menuitem -> -- | /@client@/: A pointer to the t'GI.Dbusmenu.Objects.Client.Client' Client -> -- | /@userData@/: The data you gave us Ptr () -> IO Bool
-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClientTypeHandler :: ClientTypeHandler -> ClientTypeHandler_WithClosures
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_ClientTypeHandler :: (HasCallStack, MonadIO m, IsMenuitem a, IsMenuitem b, IsClient c) => FunPtr C_ClientTypeHandler -> a -> b -> c -> Ptr () -> m Bool
-- | Wrap the callback into a GClosure.
genClosure_ClientTypeHandler :: MonadIO m => ClientTypeHandler -> m (GClosure C_ClientTypeHandler)
-- | Generate a function pointer callable from C code, from a
-- C_ClientTypeHandler.
mk_ClientTypeHandler :: C_ClientTypeHandler -> IO (FunPtr C_ClientTypeHandler)
-- | A convenience synonym for Nothing :: Maybe
-- ClientTypeHandler.
noClientTypeHandler :: Maybe ClientTypeHandler
-- | A convenience synonym for Nothing :: Maybe
-- ClientTypeHandler_WithClosures.
noClientTypeHandler_WithClosures :: Maybe ClientTypeHandler_WithClosures
-- | Wrap a ClientTypeHandler into a C_ClientTypeHandler.
wrap_ClientTypeHandler :: Maybe (Ptr (FunPtr C_ClientTypeHandler)) -> ClientTypeHandler_WithClosures -> C_ClientTypeHandler
-- | Type for the callback on the (unwrapped) C side.
type C_MenuitemAboutToShowCb = Ptr Menuitem -> Ptr () -> IO ()
-- | Callback prototype for a callback that is called when the menu should
-- be shown.
type MenuitemAboutToShowCb = -- | /@mi@/: Menu item that should be shown Menuitem -> IO ()
-- | Callback prototype for a callback that is called when the menu should
-- be shown.
type MenuitemAboutToShowCb_WithClosures = -- | /@mi@/: Menu item that should be shown Menuitem -> -- | /@userData@/: Extra user data sent with the function Ptr () -> IO ()
-- | A simple wrapper that ignores the closure arguments.
drop_closures_MenuitemAboutToShowCb :: MenuitemAboutToShowCb -> MenuitemAboutToShowCb_WithClosures
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_MenuitemAboutToShowCb :: (HasCallStack, MonadIO m, IsMenuitem a) => FunPtr C_MenuitemAboutToShowCb -> a -> Ptr () -> m ()
-- | Wrap the callback into a GClosure.
genClosure_MenuitemAboutToShowCb :: MonadIO m => MenuitemAboutToShowCb -> m (GClosure C_MenuitemAboutToShowCb)
-- | Generate a function pointer callable from C code, from a
-- C_MenuitemAboutToShowCb.
mk_MenuitemAboutToShowCb :: C_MenuitemAboutToShowCb -> IO (FunPtr C_MenuitemAboutToShowCb)
-- | A convenience synonym for Nothing :: Maybe
-- MenuitemAboutToShowCb.
noMenuitemAboutToShowCb :: Maybe MenuitemAboutToShowCb
-- | A convenience synonym for Nothing :: Maybe
-- MenuitemAboutToShowCb_WithClosures.
noMenuitemAboutToShowCb_WithClosures :: Maybe MenuitemAboutToShowCb_WithClosures
-- | Wrap a MenuitemAboutToShowCb into a
-- C_MenuitemAboutToShowCb.
wrap_MenuitemAboutToShowCb :: Maybe (Ptr (FunPtr C_MenuitemAboutToShowCb)) -> MenuitemAboutToShowCb_WithClosures -> C_MenuitemAboutToShowCb
-- | Type for the callback on the (unwrapped) C side.
type C_MenuitemBuildvariantSlotT = Ptr Menuitem -> CString -> IO (Ptr GVariant)
-- | This is the function that is called to represent this menu item as a
-- variant. Should call its own children.
type MenuitemBuildvariantSlotT = -- | /@mi@/: Menu item that should be built from Menuitem -> -- | /@properties@/: A list of properties that should be the only ones in the resulting variant structure Maybe Text -> -- | __Returns:__ A variant representing this item and its children IO GVariant
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_MenuitemBuildvariantSlotT :: (HasCallStack, MonadIO m, IsMenuitem a) => FunPtr C_MenuitemBuildvariantSlotT -> a -> Maybe Text -> m GVariant
-- | Wrap the callback into a GClosure.
genClosure_MenuitemBuildvariantSlotT :: MonadIO m => MenuitemBuildvariantSlotT -> m (GClosure C_MenuitemBuildvariantSlotT)
-- | Generate a function pointer callable from C code, from a
-- C_MenuitemBuildvariantSlotT.
mk_MenuitemBuildvariantSlotT :: C_MenuitemBuildvariantSlotT -> IO (FunPtr C_MenuitemBuildvariantSlotT)
-- | A convenience synonym for Nothing :: Maybe
-- MenuitemBuildvariantSlotT.
noMenuitemBuildvariantSlotT :: Maybe MenuitemBuildvariantSlotT
-- | Wrap a MenuitemBuildvariantSlotT into a
-- C_MenuitemBuildvariantSlotT.
wrap_MenuitemBuildvariantSlotT :: Maybe (Ptr (FunPtr C_MenuitemBuildvariantSlotT)) -> MenuitemBuildvariantSlotT -> C_MenuitemBuildvariantSlotT
-- | The client for a Server creating a shared object set of
-- Menuitem objects.
module GI.Dbusmenu.Objects.Client
-- | Memory-managed wrapper type.
newtype Client
Client :: ManagedPtr Client -> Client
-- | Type class for types which can be safely cast to Client, for
-- instance with toClient.
class (GObject o, IsDescendantOf Client o) => IsClient o
-- | Cast to Client, for types for which this is known to be safe.
-- For general casts, use castTo.
toClient :: (MonadIO m, IsClient o) => o -> m Client
-- | This function connects into the type handling of the Client.
-- Every new menuitem that comes in immediately gets asked for its
-- properties. When we get those properties we check the 'type' property
-- and look to see if it matches a handler that is known by the client.
-- If so, the newfunc function is executed on that
-- Menuitem. If not, then the DbusmenuClientnewMenuitem
-- signal is sent.
--
-- In the future the known types will be sent to the server so that it
-- can make choices about the menu item types availble.
clientAddTypeHandler :: (HasCallStack, MonadIO m, IsClient a) => a -> Text -> ClientTypeHandler -> m Bool
-- | This function connects into the type handling of the Client.
-- Every new menuitem that comes in immediately gets asked for its
-- properties. When we get those properties we check the 'type' property
-- and look to see if it matches a handler that is known by the client.
-- If so, the newfunc function is executed on that
-- Menuitem. If not, then the DbusmenuClientnewMenuitem
-- signal is sent.
--
-- In the future the known types will be sent to the server so that it
-- can make choices about the menu item types availble.
clientAddTypeHandlerFull :: (HasCallStack, MonadIO m, IsClient a) => a -> Text -> ClientTypeHandler -> m Bool
-- | Gets the stored and exported icon paths from the client.
clientGetIconPaths :: (HasCallStack, MonadIO m, IsClient a) => a -> m [Text]
-- | Grabs the root node for the specified client client.
-- This function may block. It will block if there is currently a call to
-- update the layout, it will block on that layout updated and then
-- return the newly updated layout. Chances are that this update is in
-- the queue for the mainloop as it would have been requested some time
-- ago, but in theory it could block longer.
clientGetRoot :: (HasCallStack, MonadIO m, IsClient a) => a -> m Menuitem
-- | Gets the recommended current status that the server is exporting for
-- the menus. In situtations where the value is
-- DBUSMENU_STATUS_NOTICE it is recommended that the
-- client show the menus to the user an a more noticible way.
--
-- Return value: Status being exported.
clientGetStatus :: (HasCallStack, MonadIO m, IsClient a) => a -> m Status
-- | Gets the text direction that the server is exporting. If the server is
-- not exporting a direction then the value
-- DBUSMENU_TEXT_DIRECTION_NONE will be returned.
--
-- Return value: Text direction being exported.
clientGetTextDirection :: (HasCallStack, MonadIO m, IsClient a) => a -> m TextDirection
-- | This function creates a new client that connects to a specific server
-- on DBus. That server is at a specific location sharing a known object.
-- The interface is assumed by the code to be the DBus menu interface.
-- The newly created client will start sending out events as it syncs up
-- with the server.
clientNew :: (HasCallStack, MonadIO m) => Text -> Text -> m Client
-- | Construct a GValueConstruct with valid value for the
-- “dbus-name” property. This is rarely needed directly, but it
-- is used by new.
constructClientDbusName :: (IsClient o, MonadIO m) => Text -> m (GValueConstruct o)
-- | Get the value of the “dbus-name” property. When
-- overloading is enabled, this is equivalent to
--
--
-- get client #dbusName
--
getClientDbusName :: (MonadIO m, IsClient o) => o -> m (Maybe Text)
-- | Construct a GValueConstruct with valid value for the
-- “dbus-object” property. This is rarely needed directly, but
-- it is used by new.
constructClientDbusObject :: (IsClient o, MonadIO m) => Text -> m (GValueConstruct o)
-- | Get the value of the “dbus-object” property. When
-- overloading is enabled, this is equivalent to
--
--
-- get client #dbusObject
--
getClientDbusObject :: (MonadIO m, IsClient o) => o -> m (Maybe Text)
-- | Construct a GValueConstruct with valid value for the
-- “group-events” property. This is rarely needed directly, but
-- it is used by new.
constructClientGroupEvents :: (IsClient o, MonadIO m) => Bool -> m (GValueConstruct o)
-- | Get the value of the “group-events” property. When
-- overloading is enabled, this is equivalent to
--
--
-- get client #groupEvents
--
getClientGroupEvents :: (MonadIO m, IsClient o) => o -> m Bool
-- | Set the value of the “group-events” property. When
-- overloading is enabled, this is equivalent to
--
--
-- set client [ #groupEvents := value ]
--
setClientGroupEvents :: (MonadIO m, IsClient o) => o -> Bool -> m ()
-- | No description available in the introspection data.
type ClientEventResultCallback = Object -> Text -> GVariant -> Word32 -> Ptr () -> IO ()
-- | Connect a signal handler for the eventResult signal, to be run
-- after the default handler. When overloading is enabled, this is
-- equivalent to
--
--
-- after client #eventResult callback
--
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterClientEventResult :: (IsClient a, MonadIO m) => a -> ((?self :: a) => ClientEventResultCallback) -> m SignalHandlerId
-- | Connect a signal handler for the eventResult signal, to be run
-- before the default handler. When overloading is enabled, this
-- is equivalent to
--
--
-- on client #eventResult callback
--
onClientEventResult :: (IsClient a, MonadIO m) => a -> ((?self :: a) => ClientEventResultCallback) -> m SignalHandlerId
-- | Signaled when the theme directories are changed by the server.
type ClientIconThemeDirsChangedCallback = -- | /@arg1@/: A @/GStrv/@ of theme directories Ptr () -> IO ()
-- | Connect a signal handler for the iconThemeDirsChanged signal,
-- to be run after the default handler. When overloading is
-- enabled, this is equivalent to
--
--
-- after client #iconThemeDirsChanged callback
--
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterClientIconThemeDirsChanged :: (IsClient a, MonadIO m) => a -> ((?self :: a) => ClientIconThemeDirsChangedCallback) -> m SignalHandlerId
-- | Connect a signal handler for the iconThemeDirsChanged signal,
-- to be run before the default handler. When overloading is
-- enabled, this is equivalent to
--
--
-- on client #iconThemeDirsChanged callback
--
onClientIconThemeDirsChanged :: (IsClient a, MonadIO m) => a -> ((?self :: a) => ClientIconThemeDirsChangedCallback) -> m SignalHandlerId
-- | Signaled when the server wants to activate an item in order to display
-- the menu.
type ClientItemActivateCallback = -- | /@arg1@/: The t'GI.Dbusmenu.Objects.Menuitem.Menuitem' activated Object -> -- | /@arg2@/: A timestamp that the event happened at Word32 -> IO ()
-- | Connect a signal handler for the itemActivate signal, to be run
-- after the default handler. When overloading is enabled, this is
-- equivalent to
--
--
-- after client #itemActivate callback
--
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterClientItemActivate :: (IsClient a, MonadIO m) => a -> ((?self :: a) => ClientItemActivateCallback) -> m SignalHandlerId
-- | Connect a signal handler for the itemActivate signal, to be run
-- before the default handler. When overloading is enabled, this
-- is equivalent to
--
--
-- on client #itemActivate callback
--
onClientItemActivate :: (IsClient a, MonadIO m) => a -> ((?self :: a) => ClientItemActivateCallback) -> m SignalHandlerId
-- | No description available in the introspection data.
type ClientLayoutUpdatedCallback = IO ()
-- | Connect a signal handler for the layoutUpdated signal, to be
-- run after the default handler. When overloading is enabled,
-- this is equivalent to
--
--
-- after client #layoutUpdated callback
--
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterClientLayoutUpdated :: (IsClient a, MonadIO m) => a -> ((?self :: a) => ClientLayoutUpdatedCallback) -> m SignalHandlerId
-- | Connect a signal handler for the layoutUpdated signal, to be
-- run before the default handler. When overloading is enabled,
-- this is equivalent to
--
--
-- on client #layoutUpdated callback
--
onClientLayoutUpdated :: (IsClient a, MonadIO m) => a -> ((?self :: a) => ClientLayoutUpdatedCallback) -> m SignalHandlerId
-- | Signaled when the client creates a new menuitem. This doesn't mean
-- that it's placed anywhere. The parent that it's applied to will signal
-- Menuitem::childAdded when it gets parented.
type ClientNewMenuitemCallback = -- | /@arg1@/: The new t'GI.Dbusmenu.Objects.Menuitem.Menuitem' created Object -> IO ()
-- | Connect a signal handler for the newMenuitem signal, to be run
-- after the default handler. When overloading is enabled, this is
-- equivalent to
--
--
-- after client #newMenuitem callback
--
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterClientNewMenuitem :: (IsClient a, MonadIO m) => a -> ((?self :: a) => ClientNewMenuitemCallback) -> m SignalHandlerId
-- | Connect a signal handler for the newMenuitem signal, to be run
-- before the default handler. When overloading is enabled, this
-- is equivalent to
--
--
-- on client #newMenuitem callback
--
onClientNewMenuitem :: (IsClient a, MonadIO m) => a -> ((?self :: a) => ClientNewMenuitemCallback) -> m SignalHandlerId
-- | The layout has changed in a way that can not be represented by the
-- individual items changing as the root of this client has changed.
type ClientRootChangedCallback = -- | /@arg1@/: The new root t'GI.Dbusmenu.Objects.Menuitem.Menuitem' Object -> IO ()
-- | Connect a signal handler for the rootChanged signal, to be run
-- after the default handler. When overloading is enabled, this is
-- equivalent to
--
--
-- after client #rootChanged callback
--
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterClientRootChanged :: (IsClient a, MonadIO m) => a -> ((?self :: a) => ClientRootChangedCallback) -> m SignalHandlerId
-- | Connect a signal handler for the rootChanged signal, to be run
-- before the default handler. When overloading is enabled, this
-- is equivalent to
--
--
-- on client #rootChanged callback
--
onClientRootChanged :: (IsClient a, MonadIO m) => a -> ((?self :: a) => ClientRootChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Dbusmenu.Objects.Client.Client
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Dbusmenu.Objects.Client.Client o) => GI.Dbusmenu.Objects.Client.IsClient o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Dbusmenu.Objects.Client.Client
instance Data.GI.Base.BasicTypes.TypedObject GI.Dbusmenu.Objects.Client.Client
instance Data.GI.Base.BasicTypes.GObject GI.Dbusmenu.Objects.Client.Client
instance Data.GI.Base.Overloading.HasParentTypes GI.Dbusmenu.Objects.Client.Client
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Dbusmenu.Objects.Client.Client)
-- | Public instance data for a MenuitemProxy.
module GI.Dbusmenu.Objects.MenuitemProxy
-- | Memory-managed wrapper type.
newtype MenuitemProxy
MenuitemProxy :: ManagedPtr MenuitemProxy -> MenuitemProxy
-- | Type class for types which can be safely cast to MenuitemProxy,
-- for instance with toMenuitemProxy.
class (GObject o, IsDescendantOf MenuitemProxy o) => IsMenuitemProxy o
-- | Cast to MenuitemProxy, for types for which this is known to be
-- safe. For general casts, use castTo.
toMenuitemProxy :: (MonadIO m, IsMenuitemProxy o) => o -> m MenuitemProxy
-- | Accesses the private variable of which Menuitem we are doing
-- the proxying for.
menuitemProxyGetWrapped :: (HasCallStack, MonadIO m, IsMenuitemProxy a) => a -> m Menuitem
-- | Builds a new MenuitemProxy object that proxies all of the
-- values for mi.
menuitemProxyNew :: (HasCallStack, MonadIO m, IsMenuitem a) => a -> m MenuitemProxy
-- | Construct a GValueConstruct with valid value for the
-- “menu-item” property. This is rarely needed directly, but it
-- is used by new.
constructMenuitemProxyMenuItem :: (IsMenuitemProxy o, MonadIO m, IsMenuitem a) => a -> m (GValueConstruct o)
-- | Get the value of the “menu-item” property. When
-- overloading is enabled, this is equivalent to
--
--
-- get menuitemProxy #menuItem
--
getMenuitemProxyMenuItem :: (MonadIO m, IsMenuitemProxy o) => o -> m (Maybe Menuitem)
instance GHC.Classes.Eq GI.Dbusmenu.Objects.MenuitemProxy.MenuitemProxy
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Dbusmenu.Objects.MenuitemProxy.MenuitemProxy o) => GI.Dbusmenu.Objects.MenuitemProxy.IsMenuitemProxy o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Dbusmenu.Objects.MenuitemProxy.MenuitemProxy
instance Data.GI.Base.BasicTypes.TypedObject GI.Dbusmenu.Objects.MenuitemProxy.MenuitemProxy
instance Data.GI.Base.BasicTypes.GObject GI.Dbusmenu.Objects.MenuitemProxy.MenuitemProxy
instance Data.GI.Base.Overloading.HasParentTypes GI.Dbusmenu.Objects.MenuitemProxy.MenuitemProxy
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Dbusmenu.Objects.MenuitemProxy.MenuitemProxy)
-- | A server which represents a sharing of a set of
-- DbusmenuMenuitems across DBus to a Client.
module GI.Dbusmenu.Objects.Server
-- | Memory-managed wrapper type.
newtype Server
Server :: ManagedPtr Server -> Server
-- | Type class for types which can be safely cast to Server, for
-- instance with toServer.
class (GObject o, IsDescendantOf Server o) => IsServer o
-- | Cast to Server, for types for which this is known to be safe.
-- For general casts, use castTo.
toServer :: (MonadIO m, IsServer o) => o -> m Server
-- | Gets the stored and exported icon paths from the server.
serverGetIconPaths :: (HasCallStack, MonadIO m, IsServer a) => a -> m [Text]
-- | Gets the current statust hat the server is sending out over DBus.
--
-- Return value: The current status the server is sending
serverGetStatus :: (HasCallStack, MonadIO m, IsServer a) => a -> m Status
-- | Returns the value of the text direction that is being exported over
-- DBus for this server. It should relate to the direction of the labels
-- and other text fields that are being exported by this server.
--
-- Return value: Text direction exported for this server.
serverGetTextDirection :: (HasCallStack, MonadIO m, IsServer a) => a -> m TextDirection
-- | Creates a new Server object with a specific object path on
-- DBus. If object is set to NULL the default object name
-- of "/com/canonical/dbusmenu" will be used.
--
-- Return value: A brand new Server
serverNew :: (HasCallStack, MonadIO m) => Text -> m Server
-- | Sets the icon paths for the server. This will replace previously set
-- icon theme paths.
serverSetIconPaths :: (HasCallStack, MonadIO m, IsServer a) => a -> [Text] -> m ()
-- | This function contains all of the Value wrapping required to
-- set the property Server:rootNode on the server
-- self.
serverSetRoot :: (HasCallStack, MonadIO m, IsServer a, IsMenuitem b) => a -> b -> m ()
-- | Changes the status of the server.
serverSetStatus :: (HasCallStack, MonadIO m, IsServer a) => a -> Status -> m ()
-- | Sets the text direction that should be exported over DBus for this
-- server. If the value is set to
-- DBUSMENU_TEXT_DIRECTION_NONE the default detection
-- will be used for setting the value and exported over DBus.
serverSetTextDirection :: (HasCallStack, MonadIO m, IsServer a) => a -> TextDirection -> m ()
-- | Construct a GValueConstruct with valid value for the
-- “dbus-object” property. This is rarely needed directly, but
-- it is used by new.
constructServerDbusObject :: (IsServer o, MonadIO m) => Text -> m (GValueConstruct o)
-- | Get the value of the “dbus-object” property. When
-- overloading is enabled, this is equivalent to
--
--
-- get server #dbusObject
--
getServerDbusObject :: (MonadIO m, IsServer o) => o -> m (Maybe Text)
-- | Set the value of the “root-node” property to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #rootNode
--
clearServerRootNode :: (MonadIO m, IsServer o) => o -> m ()
-- | Construct a GValueConstruct with valid value for the
-- “root-node” property. This is rarely needed directly, but it
-- is used by new.
constructServerRootNode :: (IsServer o, MonadIO m, IsMenuitem a) => a -> m (GValueConstruct o)
-- | Get the value of the “root-node” property. When
-- overloading is enabled, this is equivalent to
--
--
-- get server #rootNode
--
getServerRootNode :: (MonadIO m, IsServer o) => o -> m (Maybe Menuitem)
-- | Set the value of the “root-node” property. When
-- overloading is enabled, this is equivalent to
--
--
-- set server [ #rootNode := value ]
--
setServerRootNode :: (MonadIO m, IsServer o, IsMenuitem a) => o -> a -> m ()
-- | Get the value of the “version” property. When
-- overloading is enabled, this is equivalent to
--
--
-- get server #version
--
getServerVersion :: (MonadIO m, IsServer o) => o -> m Word32
-- | This is signaled when a menuitem under this server sends its activate
-- signal.
type ServerItemActivationRequestedCallback = -- | /@arg1@/: The ID of the parent for this update. Int32 -> -- | /@arg2@/: The timestamp of when the event happened Word32 -> IO ()
-- | Connect a signal handler for the itemActivationRequested
-- signal, to be run after the default handler. When overloading
-- is enabled, this is equivalent to
--
--
-- after server #itemActivationRequested callback
--
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterServerItemActivationRequested :: (IsServer a, MonadIO m) => a -> ((?self :: a) => ServerItemActivationRequestedCallback) -> m SignalHandlerId
-- | Connect a signal handler for the itemActivationRequested
-- signal, to be run before the default handler. When overloading
-- is enabled, this is equivalent to
--
--
-- on server #itemActivationRequested callback
--
onServerItemActivationRequested :: (IsServer a, MonadIO m) => a -> ((?self :: a) => ServerItemActivationRequestedCallback) -> m SignalHandlerId
-- | No description available in the introspection data.
type ServerItemPropertyUpdatedCallback = Int32 -> Text -> GVariant -> IO ()
-- | Connect a signal handler for the itemPropertyUpdated signal, to
-- be run after the default handler. When overloading is enabled,
-- this is equivalent to
--
--
-- after server #itemPropertyUpdated callback
--
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterServerItemPropertyUpdated :: (IsServer a, MonadIO m) => a -> ((?self :: a) => ServerItemPropertyUpdatedCallback) -> m SignalHandlerId
-- | Connect a signal handler for the itemPropertyUpdated signal, to
-- be run before the default handler. When overloading is enabled,
-- this is equivalent to
--
--
-- on server #itemPropertyUpdated callback
--
onServerItemPropertyUpdated :: (IsServer a, MonadIO m) => a -> ((?self :: a) => ServerItemPropertyUpdatedCallback) -> m SignalHandlerId
-- | No description available in the introspection data.
type ServerItemUpdatedCallback = Int32 -> IO ()
-- | Connect a signal handler for the itemUpdated signal, to be run
-- after the default handler. When overloading is enabled, this is
-- equivalent to
--
--
-- after server #itemUpdated callback
--
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterServerItemUpdated :: (IsServer a, MonadIO m) => a -> ((?self :: a) => ServerItemUpdatedCallback) -> m SignalHandlerId
-- | Connect a signal handler for the itemUpdated signal, to be run
-- before the default handler. When overloading is enabled, this
-- is equivalent to
--
--
-- on server #itemUpdated callback
--
onServerItemUpdated :: (IsServer a, MonadIO m) => a -> ((?self :: a) => ServerItemUpdatedCallback) -> m SignalHandlerId
-- | This signal is emitted any time the layout of the menuitems under this
-- server is changed.
type ServerLayoutUpdatedCallback = -- | /@arg1@/: A revision number representing which revision the update -- represents itself as. Word32 -> -- | /@arg2@/: The ID of the parent for this update. Int32 -> IO ()
-- | Connect a signal handler for the layoutUpdated signal, to be
-- run after the default handler. When overloading is enabled,
-- this is equivalent to
--
--
-- after server #layoutUpdated callback
--
--
-- By default the object invoking the signal is not passed to the
-- callback. If you need to access it, you can use the implit
-- ?self parameter. Note that this requires activating the
-- ImplicitParams GHC extension.
afterServerLayoutUpdated :: (IsServer a, MonadIO m) => a -> ((?self :: a) => ServerLayoutUpdatedCallback) -> m SignalHandlerId
-- | Connect a signal handler for the layoutUpdated signal, to be
-- run before the default handler. When overloading is enabled,
-- this is equivalent to
--
--
-- on server #layoutUpdated callback
--
onServerLayoutUpdated :: (IsServer a, MonadIO m) => a -> ((?self :: a) => ServerLayoutUpdatedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Dbusmenu.Objects.Server.Server
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Dbusmenu.Objects.Server.Server o) => GI.Dbusmenu.Objects.Server.IsServer o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Dbusmenu.Objects.Server.Server
instance Data.GI.Base.BasicTypes.TypedObject GI.Dbusmenu.Objects.Server.Server
instance Data.GI.Base.BasicTypes.GObject GI.Dbusmenu.Objects.Server.Server
instance Data.GI.Base.Overloading.HasParentTypes GI.Dbusmenu.Objects.Server.Server
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Dbusmenu.Objects.Server.Server)
module GI.Dbusmenu.Objects
module GI.Dbusmenu