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

-- | Build time configuration used during code generation.
module GI.Dbusmenu.Config

-- | Overrides used when generating these bindings.
overrides :: Text

-- | Modules in this package
modules :: [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.Internal.Enum.Enum GI.Dbusmenu.Enums.Status
instance GHC.Internal.Enum.Enum GI.Dbusmenu.Enums.TextDirection
instance GHC.Classes.Eq GI.Dbusmenu.Enums.Status
instance GHC.Classes.Eq GI.Dbusmenu.Enums.TextDirection
instance GHC.Classes.Ord GI.Dbusmenu.Enums.Status
instance GHC.Classes.Ord GI.Dbusmenu.Enums.TextDirection
instance GHC.Internal.Show.Show GI.Dbusmenu.Enums.Status
instance GHC.Internal.Show.Show 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 -> CSize -> 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 = Object -> 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 = Object -> Word32 -> 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 = 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 = Text -> GVariant -> 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 = 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 = Text -> 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 = 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 GI.Dbusmenu.Objects.Menuitem.Menuitem
instance Data.GI.Base.Overloading.HasParentTypes GI.Dbusmenu.Objects.Menuitem.Menuitem
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe 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

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 = Menuitem -> Menuitem -> 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 = Menuitem -> Menuitem -> Client -> 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 = Menuitem -> IO ()

-- | Callback prototype for a callback that is called when the menu should
--   be shown.
type MenuitemAboutToShowCb_WithClosures = Menuitem -> 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 = Menuitem -> Maybe Text -> 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 = 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 = Object -> 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 = 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 = 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 GI.Dbusmenu.Objects.Client.Client
instance Data.GI.Base.Overloading.HasParentTypes 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.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Dbusmenu.Objects.Client.Client)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Dbusmenu.Objects.Client.Client
instance Data.GI.Base.BasicTypes.TypedObject 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 GI.Dbusmenu.Objects.MenuitemProxy.MenuitemProxy
instance Data.GI.Base.Overloading.HasParentTypes GI.Dbusmenu.Objects.MenuitemProxy.MenuitemProxy
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe 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

-- | 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 = Int32 -> 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 = Word32 -> 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 GI.Dbusmenu.Objects.Server.Server
instance Data.GI.Base.Overloading.HasParentTypes GI.Dbusmenu.Objects.Server.Server
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe 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

module GI.Dbusmenu.Objects

module GI.Dbusmenu
