gi-dbusmenugtk3 0.4.2 → 0.4.4

raw patch · 13 files changed

+1738/−9 lines, 13 filesdep ~haskell-gidep ~haskell-gi-basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: haskell-gi, haskell-gi-base

API changes (from Hackage documentation)

Files

• ChangeLog.md +12/−0
• GI/DbusmenuGtk3.hs +50/−0
• GI/DbusmenuGtk3/Constants.hs +45/−0
• GI/DbusmenuGtk3/Functions.hs +371/−0
• GI/DbusmenuGtk3/Objects.hs +43/−0
• GI/DbusmenuGtk3/Objects/Client.hs +438/−0
• GI/DbusmenuGtk3/Objects/Client.hs-boot +44/−0
• GI/DbusmenuGtk3/Objects/Menu.hs +667/−0
• GI/DbusmenuGtk3/Objects/Menu.hs-boot +38/−0
• LICENSE +14/−0
• README.md +1/−1
• gi-dbusmenugtk3.cabal +14/−7
• stack.yaml +1/−1

@@ -1,3 +1,15 @@+### 0.4.4+++ Update to haskell-gi(-base) 0.22++### 0.4.3+++ Update stack version to 12.10++### 0.4.2+++ Add a pkg-config dependency on gtk+-3.0, see https://github.com/haskell-gi/haskell-gi/pull/172.+ ### 0.4.1  + Initial release.

@@ -0,0 +1,50 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.DbusmenuGtk3+    (     module GI.DbusmenuGtk3.Constants        ,+    module GI.DbusmenuGtk3.Functions        ,+    module GI.DbusmenuGtk3.Objects          ,++++    module Data.GI.Base                     ,+++    ) where++import GI.DbusmenuGtk3.Constants+import GI.DbusmenuGtk3.Functions+import GI.DbusmenuGtk3.Objects++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL+++import Data.GI.Base+

@@ -0,0 +1,45 @@+{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-}+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.DbusmenuGtk3.Constants+    ( +    pattern GTK_MENUITEM_H__                ,++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL+++{- |+/No description available in the introspection data./+-}+pattern GTK_MENUITEM_H__ = 1 :: Int32++

@@ -0,0 +1,371 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.DbusmenuGtk3.Functions+    ( ++ -- * Methods+-- ** gtkParseGetCachedItem #method:gtkParseGetCachedItem#++    gtkParseGetCachedItem                   ,+++-- ** gtkParseMenuStructure #method:gtkParseMenuStructure#++    gtkParseMenuStructure                   ,+++-- ** menuitemPropertyGetImage #method:menuitemPropertyGetImage#++    menuitemPropertyGetImage                ,+++-- ** menuitemPropertyGetShortcut #method:menuitemPropertyGetShortcut#++    menuitemPropertyGetShortcut             ,+++-- ** menuitemPropertySetImage #method:menuitemPropertySetImage#++    menuitemPropertySetImage                ,+++-- ** menuitemPropertySetShortcut #method:menuitemPropertySetShortcut#++    menuitemPropertySetShortcut             ,+++-- ** menuitemPropertySetShortcutMenuitem #method:menuitemPropertySetShortcutMenuitem#++    menuitemPropertySetShortcutMenuitem     ,+++-- ** menuitemPropertySetShortcutString #method:menuitemPropertySetShortcutString#++    menuitemPropertySetShortcutString       ,+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++import qualified GI.Dbusmenu.Objects.Menuitem as Dbusmenu.Menuitem+import qualified GI.Gdk.Flags as Gdk.Flags+import qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf+import qualified GI.Gtk.Objects.MenuItem as Gtk.MenuItem+import qualified GI.Gtk.Objects.Widget as Gtk.Widget++-- function dbusmenu_menuitem_property_set_shortcut_string+-- Args : [Arg {argCName = "menuitem", argType = TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #DbusmenuMenuitem to set the shortcut on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "shortcut", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "String describing the shortcut", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "dbusmenu_menuitem_property_set_shortcut_string" dbusmenu_menuitem_property_set_shortcut_string :: +    Ptr Dbusmenu.Menuitem.Menuitem ->       -- menuitem : TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"})+    CString ->                              -- shortcut : TBasicType TUTF8+    IO CInt++{- |+This function takes a GTK shortcut string as defined in+@/gtk_accelerator_parse/@ and turns that into the information+required to send it over DBusmenu.+-}+menuitemPropertySetShortcutString ::+    (B.CallStack.HasCallStack, MonadIO m, Dbusmenu.Menuitem.IsMenuitem a) =>+    a+    {- ^ /@menuitem@/: The 'GI.Dbusmenu.Objects.Menuitem.Menuitem' to set the shortcut on -}+    -> T.Text+    {- ^ /@shortcut@/: String describing the shortcut -}+    -> m Bool+    {- ^ __Returns:__ Whether it was successful at setting the property. -}+menuitemPropertySetShortcutString menuitem shortcut = liftIO $ do+    menuitem' <- unsafeManagedPtrCastPtr menuitem+    shortcut' <- textToCString shortcut+    result <- dbusmenu_menuitem_property_set_shortcut_string menuitem' shortcut'+    let result' = (/= 0) result+    touchManagedPtr menuitem+    freeMem shortcut'+    return result'+++-- function dbusmenu_menuitem_property_set_shortcut_menuitem+-- Args : [Arg {argCName = "menuitem", argType = TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #DbusmenuMenuitem to set the shortcut on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gmi", argType = TInterface (Name {namespace = "Gtk", name = "MenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A menu item to steal the shortcut off of", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "dbusmenu_menuitem_property_set_shortcut_menuitem" dbusmenu_menuitem_property_set_shortcut_menuitem :: +    Ptr Dbusmenu.Menuitem.Menuitem ->       -- menuitem : TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"})+    Ptr Gtk.MenuItem.MenuItem ->            -- gmi : TInterface (Name {namespace = "Gtk", name = "MenuItem"})+    IO CInt++{- |+Takes the shortcut that is installed on a menu item and calls+@/dbusmenu_menuitem_property_set_shortcut/@ with it.  It also sets+up listeners to watch it change.+-}+menuitemPropertySetShortcutMenuitem ::+    (B.CallStack.HasCallStack, MonadIO m, Dbusmenu.Menuitem.IsMenuitem a, Gtk.MenuItem.IsMenuItem b) =>+    a+    {- ^ /@menuitem@/: The 'GI.Dbusmenu.Objects.Menuitem.Menuitem' to set the shortcut on -}+    -> b+    {- ^ /@gmi@/: A menu item to steal the shortcut off of -}+    -> m Bool+    {- ^ __Returns:__ Whether it was successful at setting the property. -}+menuitemPropertySetShortcutMenuitem menuitem gmi = liftIO $ do+    menuitem' <- unsafeManagedPtrCastPtr menuitem+    gmi' <- unsafeManagedPtrCastPtr gmi+    result <- dbusmenu_menuitem_property_set_shortcut_menuitem menuitem' gmi'+    let result' = (/= 0) result+    touchManagedPtr menuitem+    touchManagedPtr gmi+    return result'+++-- function dbusmenu_menuitem_property_set_shortcut+-- Args : [Arg {argCName = "menuitem", argType = TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #DbusmenuMenuitem to set the shortcut on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The keycode of the key to send", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "modifier", argType = TInterface (Name {namespace = "Gdk", name = "ModifierType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A bitmask of modifiers used to activate the item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "dbusmenu_menuitem_property_set_shortcut" dbusmenu_menuitem_property_set_shortcut :: +    Ptr Dbusmenu.Menuitem.Menuitem ->       -- menuitem : TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"})+    Word32 ->                               -- key : TBasicType TUInt+    CUInt ->                                -- modifier : TInterface (Name {namespace = "Gdk", name = "ModifierType"})+    IO CInt++{- |+Takes the modifer described by /@key@/ and /@modifier@/ and places that into+the format sending across Dbus for shortcuts.+-}+menuitemPropertySetShortcut ::+    (B.CallStack.HasCallStack, MonadIO m, Dbusmenu.Menuitem.IsMenuitem a) =>+    a+    {- ^ /@menuitem@/: The 'GI.Dbusmenu.Objects.Menuitem.Menuitem' to set the shortcut on -}+    -> Word32+    {- ^ /@key@/: The keycode of the key to send -}+    -> [Gdk.Flags.ModifierType]+    {- ^ /@modifier@/: A bitmask of modifiers used to activate the item -}+    -> m Bool+    {- ^ __Returns:__ Whether it was successful at setting the property. -}+menuitemPropertySetShortcut menuitem key modifier = liftIO $ do+    menuitem' <- unsafeManagedPtrCastPtr menuitem+    let modifier' = gflagsToWord modifier+    result <- dbusmenu_menuitem_property_set_shortcut menuitem' key modifier'+    let result' = (/= 0) result+    touchManagedPtr menuitem+    return result'+++-- function dbusmenu_menuitem_property_set_image+-- Args : [Arg {argCName = "menuitem", argType = TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #DbusmenuMenuitem to set the property on.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of the property to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The image to place on the property.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "dbusmenu_menuitem_property_set_image" dbusmenu_menuitem_property_set_image :: +    Ptr Dbusmenu.Menuitem.Menuitem ->       -- menuitem : TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"})+    CString ->                              -- property : TBasicType TUTF8+    Ptr GdkPixbuf.Pixbuf.Pixbuf ->          -- data : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    IO CInt++{- |+This function takes the pixbuf that is stored in /@data@/ and+turns it into a base64 encoded PNG so that it can be placed+onto a standard 'GI.Dbusmenu.Objects.Menuitem.Menuitem' property.+-}+menuitemPropertySetImage ::+    (B.CallStack.HasCallStack, MonadIO m, Dbusmenu.Menuitem.IsMenuitem a, GdkPixbuf.Pixbuf.IsPixbuf b) =>+    a+    {- ^ /@menuitem@/: The 'GI.Dbusmenu.Objects.Menuitem.Menuitem' to set the property on. -}+    -> T.Text+    {- ^ /@property@/: Name of the property to set. -}+    -> b+    {- ^ /@data@/: The image to place on the property. -}+    -> m Bool+    {- ^ __Returns:__ Whether the function was able to set the property+	or not. -}+menuitemPropertySetImage menuitem property data_ = liftIO $ do+    menuitem' <- unsafeManagedPtrCastPtr menuitem+    property' <- textToCString property+    data_' <- unsafeManagedPtrCastPtr data_+    result <- dbusmenu_menuitem_property_set_image menuitem' property' data_'+    let result' = (/= 0) result+    touchManagedPtr menuitem+    touchManagedPtr data_+    freeMem property'+    return result'+++-- function dbusmenu_menuitem_property_get_shortcut+-- Args : [Arg {argCName = "menuitem", argType = TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #DbusmenuMenuitem to get the shortcut off", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Location to put the key value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "modifier", argType = TInterface (Name {namespace = "Gdk", name = "ModifierType"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Location to put the modifier mask", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "dbusmenu_menuitem_property_get_shortcut" dbusmenu_menuitem_property_get_shortcut :: +    Ptr Dbusmenu.Menuitem.Menuitem ->       -- menuitem : TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"})+    Ptr Word32 ->                           -- key : TBasicType TUInt+    Ptr CUInt ->                            -- modifier : TInterface (Name {namespace = "Gdk", name = "ModifierType"})+    IO ()++{- |+This function gets a GTK shortcut as a key and a mask+for use to set the accelerators.+-}+menuitemPropertyGetShortcut ::+    (B.CallStack.HasCallStack, MonadIO m, Dbusmenu.Menuitem.IsMenuitem a) =>+    a+    {- ^ /@menuitem@/: The 'GI.Dbusmenu.Objects.Menuitem.Menuitem' to get the shortcut off -}+    -> m ((Word32, [Gdk.Flags.ModifierType]))+menuitemPropertyGetShortcut menuitem = liftIO $ do+    menuitem' <- unsafeManagedPtrCastPtr menuitem+    key <- allocMem :: IO (Ptr Word32)+    modifier <- allocMem :: IO (Ptr CUInt)+    dbusmenu_menuitem_property_get_shortcut menuitem' key modifier+    key' <- peek key+    modifier' <- peek modifier+    let modifier'' = wordToGFlags modifier'+    touchManagedPtr menuitem+    freeMem key+    freeMem modifier+    return (key', modifier'')+++-- function dbusmenu_menuitem_property_get_image+-- Args : [Arg {argCName = "menuitem", argType = TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #DbusmenuMenuitem to look for the property on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The name of the property to look for.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : False+-- Skip return : False++foreign import ccall "dbusmenu_menuitem_property_get_image" dbusmenu_menuitem_property_get_image :: +    Ptr Dbusmenu.Menuitem.Menuitem ->       -- menuitem : TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"})+    CString ->                              -- property : TBasicType TUTF8+    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)++{- |+This function looks on the menu item for a property by the+name of /@property@/.  If one exists it tries to turn it into+a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf'.  It assumes that the property is a base64 encoded+PNG file like the one created by @/dbusmenu_menuite_property_set_image/@.+-}+menuitemPropertyGetImage ::+    (B.CallStack.HasCallStack, MonadIO m, Dbusmenu.Menuitem.IsMenuitem a) =>+    a+    {- ^ /@menuitem@/: The 'GI.Dbusmenu.Objects.Menuitem.Menuitem' to look for the property on -}+    -> T.Text+    {- ^ /@property@/: The name of the property to look for. -}+    -> m GdkPixbuf.Pixbuf.Pixbuf+    {- ^ __Returns:__ A pixbuf or @/NULL/@ to signal error. -}+menuitemPropertyGetImage menuitem property = liftIO $ do+    menuitem' <- unsafeManagedPtrCastPtr menuitem+    property' <- textToCString property+    result <- dbusmenu_menuitem_property_get_image menuitem' property'+    checkUnexpectedReturnNULL "menuitemPropertyGetImage" result+    result' <- (wrapObject GdkPixbuf.Pixbuf.Pixbuf) result+    touchManagedPtr menuitem+    freeMem property'+    return result'+++-- function dbusmenu_gtk_parse_menu_structure+-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkMenuItem or #GtkMenuShell to turn into a #DbusmenuMenuitem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"}))+-- throws : False+-- Skip return : False++foreign import ccall "dbusmenu_gtk_parse_menu_structure" dbusmenu_gtk_parse_menu_structure :: +    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})+    IO (Ptr Dbusmenu.Menuitem.Menuitem)++{- |+Goes through the GTK structures and turns them into the appropraite+Dbusmenu structures along with setting up all the relationships+between the objects.  It also stores the dbusmenu items as a cache+on the GTK items so that they\'ll be reused if necissary.+-}+gtkParseMenuStructure ::+    (B.CallStack.HasCallStack, MonadIO m, Gtk.Widget.IsWidget a) =>+    a+    {- ^ /@widget@/: A 'GI.Gtk.Objects.MenuItem.MenuItem' or 'GI.Gtk.Objects.MenuShell.MenuShell' to turn into a 'GI.Dbusmenu.Objects.Menuitem.Menuitem' -}+    -> m Dbusmenu.Menuitem.Menuitem+    {- ^ __Returns:__ A dbusmenu item representing the menu structure -}+gtkParseMenuStructure widget = liftIO $ do+    widget' <- unsafeManagedPtrCastPtr widget+    result <- dbusmenu_gtk_parse_menu_structure widget'+    checkUnexpectedReturnNULL "gtkParseMenuStructure" result+    result' <- (wrapObject Dbusmenu.Menuitem.Menuitem) result+    touchManagedPtr widget+    return result'+++-- function dbusmenu_gtk_parse_get_cached_item+-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkMenuItem that may have a cached #DbusmenuMenuitem from the parser", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"}))+-- throws : False+-- Skip return : False++foreign import ccall "dbusmenu_gtk_parse_get_cached_item" dbusmenu_gtk_parse_get_cached_item :: +    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})+    IO (Ptr Dbusmenu.Menuitem.Menuitem)++{- |+The Dbusmenu GTK parser adds cached items on the various+menu items throughout the tree.  Sometimes it can be useful+to get that cached item to use directly.  This function+will retrieve it for you.+-}+gtkParseGetCachedItem ::+    (B.CallStack.HasCallStack, MonadIO m, Gtk.Widget.IsWidget a) =>+    a+    {- ^ /@widget@/: A 'GI.Gtk.Objects.MenuItem.MenuItem' that may have a cached 'GI.Dbusmenu.Objects.Menuitem.Menuitem' from the parser -}+    -> m Dbusmenu.Menuitem.Menuitem+    {- ^ __Returns:__ A pointer to the cached item+or NULL if it isn\'t there. -}+gtkParseGetCachedItem widget = liftIO $ do+    widget' <- unsafeManagedPtrCastPtr widget+    result <- dbusmenu_gtk_parse_get_cached_item widget'+    checkUnexpectedReturnNULL "gtkParseGetCachedItem" result+    result' <- (newObject Dbusmenu.Menuitem.Menuitem) result+    touchManagedPtr widget+    return result'+++

@@ -0,0 +1,43 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.DbusmenuGtk3.Objects+    (     module GI.DbusmenuGtk3.Objects.Client   ,+    module GI.DbusmenuGtk3.Objects.Menu     ,+++    ) where++import GI.DbusmenuGtk3.Objects.Client+import GI.DbusmenuGtk3.Objects.Menu++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL+++

@@ -0,0 +1,438 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++A subclass of 'GI.Dbusmenu.Objects.Client.Client' to add functionality with regarding+building GTK items out of the abstract tree.+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.DbusmenuGtk3.Objects.Client+    ( ++-- * Exported types+    Client(..)                              ,+    IsClient                                ,+    toClient                                ,+    noClient                                ,+++ -- * Methods+-- ** getAccelGroup #method:getAccelGroup#++#if ENABLE_OVERLOADING+    ClientGetAccelGroupMethodInfo           ,+#endif+    clientGetAccelGroup                     ,+++-- ** menuitemGet #method:menuitemGet#++#if ENABLE_OVERLOADING+    ClientMenuitemGetMethodInfo             ,+#endif+    clientMenuitemGet                       ,+++-- ** menuitemGetSubmenu #method:menuitemGetSubmenu#++#if ENABLE_OVERLOADING+    ClientMenuitemGetSubmenuMethodInfo      ,+#endif+    clientMenuitemGetSubmenu                ,+++-- ** new #method:new#++    clientNew                               ,+++-- ** newitemBase #method:newitemBase#++#if ENABLE_OVERLOADING+    ClientNewitemBaseMethodInfo             ,+#endif+    clientNewitemBase                       ,+++-- ** setAccelGroup #method:setAccelGroup#++#if ENABLE_OVERLOADING+    ClientSetAccelGroupMethodInfo           ,+#endif+    clientSetAccelGroup                     ,+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++import qualified GI.Dbusmenu.Objects.Client as Dbusmenu.Client+import qualified GI.Dbusmenu.Objects.Menuitem as Dbusmenu.Menuitem+import qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gtk.Objects.AccelGroup as Gtk.AccelGroup+import qualified GI.Gtk.Objects.Menu as Gtk.Menu+import qualified GI.Gtk.Objects.MenuItem as Gtk.MenuItem++-- | Memory-managed wrapper type.+newtype Client = Client (ManagedPtr Client)+foreign import ccall "dbusmenu_gtkclient_get_type"+    c_dbusmenu_gtkclient_get_type :: IO GType++instance GObject Client where+    gobjectType = c_dbusmenu_gtkclient_get_type+    ++-- | Type class for types which can be safely cast to `Client`, for instance with `toClient`.+class (GObject o, O.IsDescendantOf Client o) => IsClient o+instance (GObject o, O.IsDescendantOf Client o) => IsClient o++instance O.HasParentTypes Client+type instance O.ParentTypes Client = '[Dbusmenu.Client.Client, GObject.Object.Object]++-- | Cast to `Client`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toClient :: (MonadIO m, IsClient o) => o -> m Client+toClient = liftIO . unsafeCastTo Client++-- | A convenience alias for `Nothing` :: `Maybe` `Client`.+noClient :: Maybe Client+noClient = Nothing++#if ENABLE_OVERLOADING+type family ResolveClientMethod (t :: Symbol) (o :: *) :: * where+    ResolveClientMethod "addTypeHandler" o = Dbusmenu.Client.ClientAddTypeHandlerMethodInfo+    ResolveClientMethod "addTypeHandlerFull" o = Dbusmenu.Client.ClientAddTypeHandlerFullMethodInfo+    ResolveClientMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveClientMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveClientMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveClientMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveClientMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveClientMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveClientMethod "menuitemGet" o = ClientMenuitemGetMethodInfo+    ResolveClientMethod "menuitemGetSubmenu" o = ClientMenuitemGetSubmenuMethodInfo+    ResolveClientMethod "newitemBase" o = ClientNewitemBaseMethodInfo+    ResolveClientMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveClientMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveClientMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveClientMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveClientMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveClientMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveClientMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveClientMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveClientMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveClientMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveClientMethod "getAccelGroup" o = ClientGetAccelGroupMethodInfo+    ResolveClientMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveClientMethod "getIconPaths" o = Dbusmenu.Client.ClientGetIconPathsMethodInfo+    ResolveClientMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveClientMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveClientMethod "getRoot" o = Dbusmenu.Client.ClientGetRootMethodInfo+    ResolveClientMethod "getStatus" o = Dbusmenu.Client.ClientGetStatusMethodInfo+    ResolveClientMethod "getTextDirection" o = Dbusmenu.Client.ClientGetTextDirectionMethodInfo+    ResolveClientMethod "setAccelGroup" o = ClientSetAccelGroupMethodInfo+    ResolveClientMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveClientMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveClientMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveClientMethod t Client, O.MethodInfo info Client p) => OL.IsLabel t (Client -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList Client+type instance O.AttributeList Client = ClientAttributeList+type ClientAttributeList = ('[ '("dbusName", Dbusmenu.Client.ClientDbusNamePropertyInfo), '("dbusObject", Dbusmenu.Client.ClientDbusObjectPropertyInfo), '("groupEvents", Dbusmenu.Client.ClientGroupEventsPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type instance O.SignalList Client = ClientSignalList+type ClientSignalList = ('[ '("eventResult", Dbusmenu.Client.ClientEventResultSignalInfo), '("iconThemeDirsChanged", Dbusmenu.Client.ClientIconThemeDirsChangedSignalInfo), '("itemActivate", Dbusmenu.Client.ClientItemActivateSignalInfo), '("layoutUpdated", Dbusmenu.Client.ClientLayoutUpdatedSignalInfo), '("newMenuitem", Dbusmenu.Client.ClientNewMenuitemSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("rootChanged", Dbusmenu.Client.ClientRootChangedSignalInfo)] :: [(Symbol, *)])++#endif++-- method Client::new+-- method type : Constructor+-- Args : [Arg {argCName = "dbus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of the #DbusmenuServer on DBus", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dbus_object", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of the object on the #DbusmenuServer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "DbusmenuGtk3", name = "Client"}))+-- throws : False+-- Skip return : False++foreign import ccall "dbusmenu_gtkclient_new" dbusmenu_gtkclient_new :: +    CString ->                              -- dbus_name : TBasicType TUTF8+    CString ->                              -- dbus_object : TBasicType TUTF8+    IO (Ptr Client)++{- |+Creates a new 'GI.DbusmenuGtk3.Objects.Client.Client' object and creates a 'GI.Dbusmenu.Objects.Client.Client'+that connects across DBus to a 'GI.Dbusmenu.Objects.Server.Server'.+-}+clientNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@dbusName@/: Name of the 'GI.Dbusmenu.Objects.Server.Server' on DBus -}+    -> T.Text+    {- ^ /@dbusObject@/: Name of the object on the 'GI.Dbusmenu.Objects.Server.Server' -}+    -> m Client+    {- ^ __Returns:__ A new 'GI.DbusmenuGtk3.Objects.Client.Client' sync\'d with a server -}+clientNew dbusName dbusObject = liftIO $ do+    dbusName' <- textToCString dbusName+    dbusObject' <- textToCString dbusObject+    result <- dbusmenu_gtkclient_new dbusName' dbusObject'+    checkUnexpectedReturnNULL "clientNew" result+    result' <- (wrapObject Client) result+    freeMem dbusName'+    freeMem dbusObject'+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Client::get_accel_group+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "client", argType = TInterface (Name {namespace = "DbusmenuGtk3", name = "Client"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Client to query for an accelerator group", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "AccelGroup"}))+-- throws : False+-- Skip return : False++foreign import ccall "dbusmenu_gtkclient_get_accel_group" dbusmenu_gtkclient_get_accel_group :: +    Ptr Client ->                           -- client : TInterface (Name {namespace = "DbusmenuGtk3", name = "Client"})+    IO (Ptr Gtk.AccelGroup.AccelGroup)++{- |+Gets the accel group for this client.+-}+clientGetAccelGroup ::+    (B.CallStack.HasCallStack, MonadIO m, IsClient a) =>+    a+    {- ^ /@client@/: Client to query for an accelerator group -}+    -> m Gtk.AccelGroup.AccelGroup+    {- ^ __Returns:__ Either a valid group or @/NULL/@ on error or+	none set. -}+clientGetAccelGroup client = liftIO $ do+    client' <- unsafeManagedPtrCastPtr client+    result <- dbusmenu_gtkclient_get_accel_group client'+    checkUnexpectedReturnNULL "clientGetAccelGroup" result+    result' <- (newObject Gtk.AccelGroup.AccelGroup) result+    touchManagedPtr client+    return result'++#if ENABLE_OVERLOADING+data ClientGetAccelGroupMethodInfo+instance (signature ~ (m Gtk.AccelGroup.AccelGroup), MonadIO m, IsClient a) => O.MethodInfo ClientGetAccelGroupMethodInfo a signature where+    overloadedMethod _ = clientGetAccelGroup++#endif++-- method Client::menuitem_get+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "client", argType = TInterface (Name {namespace = "DbusmenuGtk3", name = "Client"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #DbusmenuGtkClient with the item in it.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "item", argType = TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#DbusmenuMenuitem to get associated #GtkMenuItem on.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "MenuItem"}))+-- throws : False+-- Skip return : False++foreign import ccall "dbusmenu_gtkclient_menuitem_get" dbusmenu_gtkclient_menuitem_get :: +    Ptr Client ->                           -- client : TInterface (Name {namespace = "DbusmenuGtk3", name = "Client"})+    Ptr Dbusmenu.Menuitem.Menuitem ->       -- item : TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"})+    IO (Ptr Gtk.MenuItem.MenuItem)++{- |+This grabs the 'GI.Gtk.Objects.MenuItem.MenuItem' that is associated with the+'GI.Dbusmenu.Objects.Menuitem.Menuitem'.+-}+clientMenuitemGet ::+    (B.CallStack.HasCallStack, MonadIO m, IsClient a, Dbusmenu.Menuitem.IsMenuitem b) =>+    a+    {- ^ /@client@/: A 'GI.DbusmenuGtk3.Objects.Client.Client' with the item in it. -}+    -> b+    {- ^ /@item@/: 'GI.Dbusmenu.Objects.Menuitem.Menuitem' to get associated 'GI.Gtk.Objects.MenuItem.MenuItem' on. -}+    -> m Gtk.MenuItem.MenuItem+    {- ^ __Returns:__ The 'GI.Gtk.Objects.MenuItem.MenuItem' that can be played with. -}+clientMenuitemGet client item = liftIO $ do+    client' <- unsafeManagedPtrCastPtr client+    item' <- unsafeManagedPtrCastPtr item+    result <- dbusmenu_gtkclient_menuitem_get client' item'+    checkUnexpectedReturnNULL "clientMenuitemGet" result+    result' <- (newObject Gtk.MenuItem.MenuItem) result+    touchManagedPtr client+    touchManagedPtr item+    return result'++#if ENABLE_OVERLOADING+data ClientMenuitemGetMethodInfo+instance (signature ~ (b -> m Gtk.MenuItem.MenuItem), MonadIO m, IsClient a, Dbusmenu.Menuitem.IsMenuitem b) => O.MethodInfo ClientMenuitemGetMethodInfo a signature where+    overloadedMethod _ = clientMenuitemGet++#endif++-- method Client::menuitem_get_submenu+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "client", argType = TInterface (Name {namespace = "DbusmenuGtk3", name = "Client"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #DbusmenuGtkClient with the item in it.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "item", argType = TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#DbusmenuMenuitem to get associated #GtkMenu on.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Menu"}))+-- throws : False+-- Skip return : False++foreign import ccall "dbusmenu_gtkclient_menuitem_get_submenu" dbusmenu_gtkclient_menuitem_get_submenu :: +    Ptr Client ->                           -- client : TInterface (Name {namespace = "DbusmenuGtk3", name = "Client"})+    Ptr Dbusmenu.Menuitem.Menuitem ->       -- item : TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"})+    IO (Ptr Gtk.Menu.Menu)++{- |+This grabs the submenu associated with the menuitem.+-}+clientMenuitemGetSubmenu ::+    (B.CallStack.HasCallStack, MonadIO m, IsClient a, Dbusmenu.Menuitem.IsMenuitem b) =>+    a+    {- ^ /@client@/: A 'GI.DbusmenuGtk3.Objects.Client.Client' with the item in it. -}+    -> b+    {- ^ /@item@/: 'GI.Dbusmenu.Objects.Menuitem.Menuitem' to get associated 'GI.Gtk.Objects.Menu.Menu' on. -}+    -> m Gtk.Menu.Menu+    {- ^ __Returns:__ The 'GI.Gtk.Objects.Menu.Menu' if there is one. -}+clientMenuitemGetSubmenu client item = liftIO $ do+    client' <- unsafeManagedPtrCastPtr client+    item' <- unsafeManagedPtrCastPtr item+    result <- dbusmenu_gtkclient_menuitem_get_submenu client' item'+    checkUnexpectedReturnNULL "clientMenuitemGetSubmenu" result+    result' <- (newObject Gtk.Menu.Menu) result+    touchManagedPtr client+    touchManagedPtr item+    return result'++#if ENABLE_OVERLOADING+data ClientMenuitemGetSubmenuMethodInfo+instance (signature ~ (b -> m Gtk.Menu.Menu), MonadIO m, IsClient a, Dbusmenu.Menuitem.IsMenuitem b) => O.MethodInfo ClientMenuitemGetSubmenuMethodInfo a signature where+    overloadedMethod _ = clientMenuitemGetSubmenu++#endif++-- method Client::newitem_base+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "client", argType = TInterface (Name {namespace = "DbusmenuGtk3", name = "Client"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The client handling everything on this connection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "item", argType = TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #DbusmenuMenuitem to attach the GTK-isms to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gmi", argType = TInterface (Name {namespace = "Gtk", name = "MenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkMenuItem representing the GTK world's view of this menuitem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The parent #DbusmenuMenuitem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "dbusmenu_gtkclient_newitem_base" dbusmenu_gtkclient_newitem_base :: +    Ptr Client ->                           -- client : TInterface (Name {namespace = "DbusmenuGtk3", name = "Client"})+    Ptr Dbusmenu.Menuitem.Menuitem ->       -- item : TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"})+    Ptr Gtk.MenuItem.MenuItem ->            -- gmi : TInterface (Name {namespace = "Gtk", name = "MenuItem"})+    Ptr Dbusmenu.Menuitem.Menuitem ->       -- parent : TInterface (Name {namespace = "Dbusmenu", name = "Menuitem"})+    IO ()++{- |+This function provides some of the basic connectivity for being in+the GTK world.  Things like visibility and sensitivity of the item are+handled here so that the subclasses don\'t have to.  If you\'re building+your on GTK menu item you can use this function to apply those basic+attributes so that you don\'t have to deal with them either.++This also handles passing the \"activate\" signal back to the+'GI.Dbusmenu.Objects.Menuitem.Menuitem' side of thing.+-}+clientNewitemBase ::+    (B.CallStack.HasCallStack, MonadIO m, IsClient a, Dbusmenu.Menuitem.IsMenuitem b, Gtk.MenuItem.IsMenuItem c, Dbusmenu.Menuitem.IsMenuitem d) =>+    a+    {- ^ /@client@/: The client handling everything on this connection -}+    -> b+    {- ^ /@item@/: The 'GI.Dbusmenu.Objects.Menuitem.Menuitem' to attach the GTK-isms to -}+    -> c+    {- ^ /@gmi@/: A 'GI.Gtk.Objects.MenuItem.MenuItem' representing the GTK world\'s view of this menuitem -}+    -> d+    {- ^ /@parent@/: The parent 'GI.Dbusmenu.Objects.Menuitem.Menuitem' -}+    -> m ()+clientNewitemBase client item gmi parent = liftIO $ do+    client' <- unsafeManagedPtrCastPtr client+    item' <- unsafeManagedPtrCastPtr item+    gmi' <- unsafeManagedPtrCastPtr gmi+    parent' <- unsafeManagedPtrCastPtr parent+    dbusmenu_gtkclient_newitem_base client' item' gmi' parent'+    touchManagedPtr client+    touchManagedPtr item+    touchManagedPtr gmi+    touchManagedPtr parent+    return ()++#if ENABLE_OVERLOADING+data ClientNewitemBaseMethodInfo+instance (signature ~ (b -> c -> d -> m ()), MonadIO m, IsClient a, Dbusmenu.Menuitem.IsMenuitem b, Gtk.MenuItem.IsMenuItem c, Dbusmenu.Menuitem.IsMenuitem d) => O.MethodInfo ClientNewitemBaseMethodInfo a signature where+    overloadedMethod _ = clientNewitemBase++#endif++-- method Client::set_accel_group+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "client", argType = TInterface (Name {namespace = "DbusmenuGtk3", name = "Client"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "To set the group on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "agroup", argType = TInterface (Name {namespace = "Gtk", name = "AccelGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The new acceleration group", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "dbusmenu_gtkclient_set_accel_group" dbusmenu_gtkclient_set_accel_group :: +    Ptr Client ->                           -- client : TInterface (Name {namespace = "DbusmenuGtk3", name = "Client"})+    Ptr Gtk.AccelGroup.AccelGroup ->        -- agroup : TInterface (Name {namespace = "Gtk", name = "AccelGroup"})+    IO ()++{- |+Sets the acceleration group for the menu items with accelerators+on this client.+-}+clientSetAccelGroup ::+    (B.CallStack.HasCallStack, MonadIO m, IsClient a, Gtk.AccelGroup.IsAccelGroup b) =>+    a+    {- ^ /@client@/: To set the group on -}+    -> b+    {- ^ /@agroup@/: The new acceleration group -}+    -> m ()+clientSetAccelGroup client agroup = liftIO $ do+    client' <- unsafeManagedPtrCastPtr client+    agroup' <- unsafeManagedPtrCastPtr agroup+    dbusmenu_gtkclient_set_accel_group client' agroup'+    touchManagedPtr client+    touchManagedPtr agroup+    return ()++#if ENABLE_OVERLOADING+data ClientSetAccelGroupMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, IsClient a, Gtk.AccelGroup.IsAccelGroup b) => O.MethodInfo ClientSetAccelGroupMethodInfo a signature where+    overloadedMethod _ = clientSetAccelGroup++#endif++

@@ -0,0 +1,44 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.DbusmenuGtk3.Objects.Client where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++newtype Client = Client (ManagedPtr Client)+instance GObject Client where+class (GObject o, O.IsDescendantOf Client o) => IsClient o+instance (GObject o, O.IsDescendantOf Client o) => IsClient o+instance O.HasParentTypes Client+#if ENABLE_OVERLOADING+data ClientGetAccelGroupMethodInfo+#endif+#if ENABLE_OVERLOADING+data ClientMenuitemGetMethodInfo+#endif+#if ENABLE_OVERLOADING+data ClientMenuitemGetSubmenuMethodInfo+#endif+#if ENABLE_OVERLOADING+data ClientNewitemBaseMethodInfo+#endif+#if ENABLE_OVERLOADING+data ClientSetAccelGroupMethodInfo+#endif

@@ -0,0 +1,667 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++A 'GI.Gtk.Objects.Menu.Menu' that is built using an abstract tree built from+a 'GI.DbusmenuGtk3.Objects.Client.Client'.+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.DbusmenuGtk3.Objects.Menu+    ( ++-- * Exported types+    Menu(..)                                ,+    IsMenu                                  ,+    toMenu                                  ,+    noMenu                                  ,+++ -- * Methods+-- ** getClient #method:getClient#++#if ENABLE_OVERLOADING+    MenuGetClientMethodInfo                 ,+#endif+    menuGetClient                           ,+++-- ** new #method:new#++    menuNew                                 ,+++++ -- * Properties+-- ** dbusName #attr:dbusName#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    MenuDbusNamePropertyInfo                ,+#endif+    constructMenuDbusName                   ,+    getMenuDbusName                         ,+#if ENABLE_OVERLOADING+    menuDbusName                            ,+#endif+++-- ** dbusObject #attr:dbusObject#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    MenuDbusObjectPropertyInfo              ,+#endif+    constructMenuDbusObject                 ,+    getMenuDbusObject                       ,+#if ENABLE_OVERLOADING+    menuDbusObject                          ,+#endif+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface+import {-# SOURCE #-} qualified GI.DbusmenuGtk3.Objects.Client as DbusmenuGtk3.Client+import qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable+import qualified GI.Gtk.Objects.Container as Gtk.Container+import qualified GI.Gtk.Objects.Menu as Gtk.Menu+import qualified GI.Gtk.Objects.MenuShell as Gtk.MenuShell+import qualified GI.Gtk.Objects.Widget as Gtk.Widget++-- | Memory-managed wrapper type.+newtype Menu = Menu (ManagedPtr Menu)+foreign import ccall "dbusmenu_gtkmenu_get_type"+    c_dbusmenu_gtkmenu_get_type :: IO GType++instance GObject Menu where+    gobjectType = c_dbusmenu_gtkmenu_get_type+    ++-- | Type class for types which can be safely cast to `Menu`, for instance with `toMenu`.+class (GObject o, O.IsDescendantOf Menu o) => IsMenu o+instance (GObject o, O.IsDescendantOf Menu o) => IsMenu o++instance O.HasParentTypes Menu+type instance O.ParentTypes Menu = '[Gtk.Menu.Menu, Gtk.MenuShell.MenuShell, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable]++-- | Cast to `Menu`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toMenu :: (MonadIO m, IsMenu o) => o -> m Menu+toMenu = liftIO . unsafeCastTo Menu++-- | A convenience alias for `Nothing` :: `Maybe` `Menu`.+noMenu :: Maybe Menu+noMenu = Nothing++#if ENABLE_OVERLOADING+type family ResolveMenuMethod (t :: Symbol) (o :: *) :: * where+    ResolveMenuMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo+    ResolveMenuMethod "activateItem" o = Gtk.MenuShell.MenuShellActivateItemMethodInfo+    ResolveMenuMethod "add" o = Gtk.Container.ContainerAddMethodInfo+    ResolveMenuMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo+    ResolveMenuMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo+    ResolveMenuMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo+    ResolveMenuMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo+    ResolveMenuMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo+    ResolveMenuMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo+    ResolveMenuMethod "append" o = Gtk.MenuShell.MenuShellAppendMethodInfo+    ResolveMenuMethod "attach" o = Gtk.Menu.MenuAttachMethodInfo+    ResolveMenuMethod "attachToWidget" o = Gtk.Menu.MenuAttachToWidgetMethodInfo+    ResolveMenuMethod "bindModel" o = Gtk.MenuShell.MenuShellBindModelMethodInfo+    ResolveMenuMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveMenuMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveMenuMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo+    ResolveMenuMethod "cancel" o = Gtk.MenuShell.MenuShellCancelMethodInfo+    ResolveMenuMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo+    ResolveMenuMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo+    ResolveMenuMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo+    ResolveMenuMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo+    ResolveMenuMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo+    ResolveMenuMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo+    ResolveMenuMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo+    ResolveMenuMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo+    ResolveMenuMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo+    ResolveMenuMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo+    ResolveMenuMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo+    ResolveMenuMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo+    ResolveMenuMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo+    ResolveMenuMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo+    ResolveMenuMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo+    ResolveMenuMethod "deactivate" o = Gtk.MenuShell.MenuShellDeactivateMethodInfo+    ResolveMenuMethod "deselect" o = Gtk.MenuShell.MenuShellDeselectMethodInfo+    ResolveMenuMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo+    ResolveMenuMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo+    ResolveMenuMethod "detach" o = Gtk.Menu.MenuDetachMethodInfo+    ResolveMenuMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo+    ResolveMenuMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo+    ResolveMenuMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo+    ResolveMenuMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo+    ResolveMenuMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo+    ResolveMenuMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo+    ResolveMenuMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo+    ResolveMenuMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo+    ResolveMenuMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo+    ResolveMenuMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo+    ResolveMenuMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo+    ResolveMenuMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo+    ResolveMenuMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo+    ResolveMenuMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo+    ResolveMenuMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo+    ResolveMenuMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo+    ResolveMenuMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo+    ResolveMenuMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo+    ResolveMenuMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo+    ResolveMenuMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo+    ResolveMenuMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo+    ResolveMenuMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo+    ResolveMenuMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo+    ResolveMenuMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo+    ResolveMenuMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo+    ResolveMenuMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo+    ResolveMenuMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo+    ResolveMenuMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo+    ResolveMenuMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo+    ResolveMenuMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo+    ResolveMenuMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo+    ResolveMenuMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo+    ResolveMenuMethod "event" o = Gtk.Widget.WidgetEventMethodInfo+    ResolveMenuMethod "forall" o = Gtk.Container.ContainerForallMethodInfo+    ResolveMenuMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveMenuMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo+    ResolveMenuMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo+    ResolveMenuMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveMenuMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveMenuMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo+    ResolveMenuMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo+    ResolveMenuMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo+    ResolveMenuMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo+    ResolveMenuMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo+    ResolveMenuMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo+    ResolveMenuMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo+    ResolveMenuMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo+    ResolveMenuMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo+    ResolveMenuMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo+    ResolveMenuMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo+    ResolveMenuMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo+    ResolveMenuMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo+    ResolveMenuMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo+    ResolveMenuMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo+    ResolveMenuMethod "insert" o = Gtk.MenuShell.MenuShellInsertMethodInfo+    ResolveMenuMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo+    ResolveMenuMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo+    ResolveMenuMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo+    ResolveMenuMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo+    ResolveMenuMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo+    ResolveMenuMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveMenuMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo+    ResolveMenuMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo+    ResolveMenuMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo+    ResolveMenuMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo+    ResolveMenuMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo+    ResolveMenuMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo+    ResolveMenuMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo+    ResolveMenuMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo+    ResolveMenuMethod "map" o = Gtk.Widget.WidgetMapMethodInfo+    ResolveMenuMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo+    ResolveMenuMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo+    ResolveMenuMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo+    ResolveMenuMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo+    ResolveMenuMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo+    ResolveMenuMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo+    ResolveMenuMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo+    ResolveMenuMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo+    ResolveMenuMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveMenuMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveMenuMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo+    ResolveMenuMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo+    ResolveMenuMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo+    ResolveMenuMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo+    ResolveMenuMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo+    ResolveMenuMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo+    ResolveMenuMethod "path" o = Gtk.Widget.WidgetPathMethodInfo+    ResolveMenuMethod "placeOnMonitor" o = Gtk.Menu.MenuPlaceOnMonitorMethodInfo+    ResolveMenuMethod "popdown" o = Gtk.Menu.MenuPopdownMethodInfo+    ResolveMenuMethod "popup" o = Gtk.Menu.MenuPopupMethodInfo+    ResolveMenuMethod "popupAtPointer" o = Gtk.Menu.MenuPopupAtPointerMethodInfo+    ResolveMenuMethod "popupAtRect" o = Gtk.Menu.MenuPopupAtRectMethodInfo+    ResolveMenuMethod "popupAtWidget" o = Gtk.Menu.MenuPopupAtWidgetMethodInfo+    ResolveMenuMethod "popupForDevice" o = Gtk.Menu.MenuPopupForDeviceMethodInfo+    ResolveMenuMethod "prepend" o = Gtk.MenuShell.MenuShellPrependMethodInfo+    ResolveMenuMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo+    ResolveMenuMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo+    ResolveMenuMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo+    ResolveMenuMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo+    ResolveMenuMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo+    ResolveMenuMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo+    ResolveMenuMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo+    ResolveMenuMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo+    ResolveMenuMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo+    ResolveMenuMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveMenuMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveMenuMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo+    ResolveMenuMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo+    ResolveMenuMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo+    ResolveMenuMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo+    ResolveMenuMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo+    ResolveMenuMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo+    ResolveMenuMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo+    ResolveMenuMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo+    ResolveMenuMethod "reorderChild" o = Gtk.Menu.MenuReorderChildMethodInfo+    ResolveMenuMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo+    ResolveMenuMethod "reposition" o = Gtk.Menu.MenuRepositionMethodInfo+    ResolveMenuMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo+    ResolveMenuMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo+    ResolveMenuMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo+    ResolveMenuMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveMenuMethod "selectFirst" o = Gtk.MenuShell.MenuShellSelectFirstMethodInfo+    ResolveMenuMethod "selectItem" o = Gtk.MenuShell.MenuShellSelectItemMethodInfo+    ResolveMenuMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo+    ResolveMenuMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo+    ResolveMenuMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo+    ResolveMenuMethod "show" o = Gtk.Widget.WidgetShowMethodInfo+    ResolveMenuMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo+    ResolveMenuMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo+    ResolveMenuMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo+    ResolveMenuMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo+    ResolveMenuMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo+    ResolveMenuMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveMenuMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveMenuMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo+    ResolveMenuMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo+    ResolveMenuMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo+    ResolveMenuMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveMenuMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo+    ResolveMenuMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo+    ResolveMenuMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo+    ResolveMenuMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo+    ResolveMenuMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo+    ResolveMenuMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveMenuMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo+    ResolveMenuMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo+    ResolveMenuMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo+    ResolveMenuMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveMenuMethod "getAccelGroup" o = Gtk.Menu.MenuGetAccelGroupMethodInfo+    ResolveMenuMethod "getAccelPath" o = Gtk.Menu.MenuGetAccelPathMethodInfo+    ResolveMenuMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo+    ResolveMenuMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo+    ResolveMenuMethod "getActive" o = Gtk.Menu.MenuGetActiveMethodInfo+    ResolveMenuMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo+    ResolveMenuMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo+    ResolveMenuMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo+    ResolveMenuMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo+    ResolveMenuMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo+    ResolveMenuMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo+    ResolveMenuMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo+    ResolveMenuMethod "getAttachWidget" o = Gtk.Menu.MenuGetAttachWidgetMethodInfo+    ResolveMenuMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo+    ResolveMenuMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo+    ResolveMenuMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo+    ResolveMenuMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo+    ResolveMenuMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo+    ResolveMenuMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo+    ResolveMenuMethod "getClient" o = MenuGetClientMethodInfo+    ResolveMenuMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo+    ResolveMenuMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo+    ResolveMenuMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo+    ResolveMenuMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveMenuMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo+    ResolveMenuMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo+    ResolveMenuMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo+    ResolveMenuMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo+    ResolveMenuMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo+    ResolveMenuMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo+    ResolveMenuMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo+    ResolveMenuMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo+    ResolveMenuMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo+    ResolveMenuMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo+    ResolveMenuMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo+    ResolveMenuMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo+    ResolveMenuMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo+    ResolveMenuMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo+    ResolveMenuMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo+    ResolveMenuMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo+    ResolveMenuMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo+    ResolveMenuMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo+    ResolveMenuMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo+    ResolveMenuMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo+    ResolveMenuMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo+    ResolveMenuMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo+    ResolveMenuMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo+    ResolveMenuMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo+    ResolveMenuMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo+    ResolveMenuMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo+    ResolveMenuMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo+    ResolveMenuMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo+    ResolveMenuMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo+    ResolveMenuMethod "getMonitor" o = Gtk.Menu.MenuGetMonitorMethodInfo+    ResolveMenuMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo+    ResolveMenuMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo+    ResolveMenuMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo+    ResolveMenuMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo+    ResolveMenuMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo+    ResolveMenuMethod "getParentShell" o = Gtk.MenuShell.MenuShellGetParentShellMethodInfo+    ResolveMenuMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo+    ResolveMenuMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo+    ResolveMenuMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo+    ResolveMenuMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo+    ResolveMenuMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo+    ResolveMenuMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo+    ResolveMenuMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo+    ResolveMenuMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo+    ResolveMenuMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo+    ResolveMenuMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo+    ResolveMenuMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveMenuMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveMenuMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo+    ResolveMenuMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo+    ResolveMenuMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo+    ResolveMenuMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo+    ResolveMenuMethod "getReserveToggleSize" o = Gtk.Menu.MenuGetReserveToggleSizeMethodInfo+    ResolveMenuMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo+    ResolveMenuMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo+    ResolveMenuMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo+    ResolveMenuMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo+    ResolveMenuMethod "getSelectedItem" o = Gtk.MenuShell.MenuShellGetSelectedItemMethodInfo+    ResolveMenuMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo+    ResolveMenuMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo+    ResolveMenuMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo+    ResolveMenuMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo+    ResolveMenuMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo+    ResolveMenuMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo+    ResolveMenuMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo+    ResolveMenuMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo+    ResolveMenuMethod "getTakeFocus" o = Gtk.MenuShell.MenuShellGetTakeFocusMethodInfo+    ResolveMenuMethod "getTearoffState" o = Gtk.Menu.MenuGetTearoffStateMethodInfo+    ResolveMenuMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo+    ResolveMenuMethod "getTitle" o = Gtk.Menu.MenuGetTitleMethodInfo+    ResolveMenuMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo+    ResolveMenuMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo+    ResolveMenuMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo+    ResolveMenuMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo+    ResolveMenuMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo+    ResolveMenuMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo+    ResolveMenuMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo+    ResolveMenuMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo+    ResolveMenuMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo+    ResolveMenuMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo+    ResolveMenuMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo+    ResolveMenuMethod "setAccelGroup" o = Gtk.Menu.MenuSetAccelGroupMethodInfo+    ResolveMenuMethod "setAccelPath" o = Gtk.Menu.MenuSetAccelPathMethodInfo+    ResolveMenuMethod "setActive" o = Gtk.Menu.MenuSetActiveMethodInfo+    ResolveMenuMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo+    ResolveMenuMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo+    ResolveMenuMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo+    ResolveMenuMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo+    ResolveMenuMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo+    ResolveMenuMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo+    ResolveMenuMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo+    ResolveMenuMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo+    ResolveMenuMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo+    ResolveMenuMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveMenuMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo+    ResolveMenuMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo+    ResolveMenuMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo+    ResolveMenuMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo+    ResolveMenuMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo+    ResolveMenuMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo+    ResolveMenuMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo+    ResolveMenuMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo+    ResolveMenuMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo+    ResolveMenuMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo+    ResolveMenuMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo+    ResolveMenuMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo+    ResolveMenuMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo+    ResolveMenuMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo+    ResolveMenuMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo+    ResolveMenuMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo+    ResolveMenuMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo+    ResolveMenuMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo+    ResolveMenuMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo+    ResolveMenuMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo+    ResolveMenuMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo+    ResolveMenuMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo+    ResolveMenuMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo+    ResolveMenuMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo+    ResolveMenuMethod "setMonitor" o = Gtk.Menu.MenuSetMonitorMethodInfo+    ResolveMenuMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo+    ResolveMenuMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo+    ResolveMenuMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo+    ResolveMenuMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo+    ResolveMenuMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo+    ResolveMenuMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveMenuMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo+    ResolveMenuMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo+    ResolveMenuMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo+    ResolveMenuMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo+    ResolveMenuMethod "setReserveToggleSize" o = Gtk.Menu.MenuSetReserveToggleSizeMethodInfo+    ResolveMenuMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo+    ResolveMenuMethod "setScreen" o = Gtk.Menu.MenuSetScreenMethodInfo+    ResolveMenuMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo+    ResolveMenuMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo+    ResolveMenuMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo+    ResolveMenuMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo+    ResolveMenuMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo+    ResolveMenuMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo+    ResolveMenuMethod "setTakeFocus" o = Gtk.MenuShell.MenuShellSetTakeFocusMethodInfo+    ResolveMenuMethod "setTearoffState" o = Gtk.Menu.MenuSetTearoffStateMethodInfo+    ResolveMenuMethod "setTitle" o = Gtk.Menu.MenuSetTitleMethodInfo+    ResolveMenuMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo+    ResolveMenuMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo+    ResolveMenuMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo+    ResolveMenuMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo+    ResolveMenuMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo+    ResolveMenuMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo+    ResolveMenuMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo+    ResolveMenuMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo+    ResolveMenuMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo+    ResolveMenuMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveMenuMethod t Menu, O.MethodInfo info Menu p) => OL.IsLabel t (Menu -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++-- VVV Prop "dbus-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@dbus-name@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' menu #dbusName+@+-}+getMenuDbusName :: (MonadIO m, IsMenu o) => o -> m (Maybe T.Text)+getMenuDbusName obj = liftIO $ B.Properties.getObjectPropertyString obj "dbus-name"++{- |+Construct a `GValueConstruct` with valid value for the “@dbus-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructMenuDbusName :: (IsMenu o) => T.Text -> IO (GValueConstruct o)+constructMenuDbusName val = B.Properties.constructObjectPropertyString "dbus-name" (Just val)++#if ENABLE_OVERLOADING+data MenuDbusNamePropertyInfo+instance AttrInfo MenuDbusNamePropertyInfo where+    type AttrAllowedOps MenuDbusNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint MenuDbusNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint MenuDbusNamePropertyInfo = IsMenu+    type AttrGetType MenuDbusNamePropertyInfo = (Maybe T.Text)+    type AttrLabel MenuDbusNamePropertyInfo = "dbus-name"+    type AttrOrigin MenuDbusNamePropertyInfo = Menu+    attrGet _ = getMenuDbusName+    attrSet _ = undefined+    attrConstruct _ = constructMenuDbusName+    attrClear _ = undefined+#endif++-- VVV Prop "dbus-object"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@dbus-object@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' menu #dbusObject+@+-}+getMenuDbusObject :: (MonadIO m, IsMenu o) => o -> m (Maybe T.Text)+getMenuDbusObject obj = liftIO $ B.Properties.getObjectPropertyString obj "dbus-object"++{- |+Construct a `GValueConstruct` with valid value for the “@dbus-object@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructMenuDbusObject :: (IsMenu o) => T.Text -> IO (GValueConstruct o)+constructMenuDbusObject val = B.Properties.constructObjectPropertyString "dbus-object" (Just val)++#if ENABLE_OVERLOADING+data MenuDbusObjectPropertyInfo+instance AttrInfo MenuDbusObjectPropertyInfo where+    type AttrAllowedOps MenuDbusObjectPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint MenuDbusObjectPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint MenuDbusObjectPropertyInfo = IsMenu+    type AttrGetType MenuDbusObjectPropertyInfo = (Maybe T.Text)+    type AttrLabel MenuDbusObjectPropertyInfo = "dbus-object"+    type AttrOrigin MenuDbusObjectPropertyInfo = Menu+    attrGet _ = getMenuDbusObject+    attrSet _ = undefined+    attrConstruct _ = constructMenuDbusObject+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList Menu+type instance O.AttributeList Menu = MenuAttributeList+type MenuAttributeList = ('[ '("accelGroup", Gtk.Menu.MenuAccelGroupPropertyInfo), '("accelPath", Gtk.Menu.MenuAccelPathPropertyInfo), '("active", Gtk.Menu.MenuActivePropertyInfo), '("anchorHints", Gtk.Menu.MenuAnchorHintsPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("attachWidget", Gtk.Menu.MenuAttachWidgetPropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("dbusName", MenuDbusNamePropertyInfo), '("dbusObject", MenuDbusObjectPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("menuTypeHint", Gtk.Menu.MenuMenuTypeHintPropertyInfo), '("monitor", Gtk.Menu.MenuMonitorPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("rectAnchorDx", Gtk.Menu.MenuRectAnchorDxPropertyInfo), '("rectAnchorDy", Gtk.Menu.MenuRectAnchorDyPropertyInfo), '("reserveToggleSize", Gtk.Menu.MenuReserveToggleSizePropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("takeFocus", Gtk.MenuShell.MenuShellTakeFocusPropertyInfo), '("tearoffState", Gtk.Menu.MenuTearoffStatePropertyInfo), '("tearoffTitle", Gtk.Menu.MenuTearoffTitlePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+menuDbusName :: AttrLabelProxy "dbusName"+menuDbusName = AttrLabelProxy++menuDbusObject :: AttrLabelProxy "dbusObject"+menuDbusObject = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList Menu = MenuSignalList+type MenuSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("activateCurrent", Gtk.MenuShell.MenuShellActivateCurrentSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("cancel", Gtk.MenuShell.MenuShellCancelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("cycleFocus", Gtk.MenuShell.MenuShellCycleFocusSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deactivate", Gtk.MenuShell.MenuShellDeactivateSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("insert", Gtk.MenuShell.MenuShellInsertSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveCurrent", Gtk.MenuShell.MenuShellMoveCurrentSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("moveScroll", Gtk.Menu.MenuMoveScrollSignalInfo), '("moveSelected", Gtk.MenuShell.MenuShellMoveSelectedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("poppedUp", Gtk.Menu.MenuPoppedUpSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionDone", Gtk.MenuShell.MenuShellSelectionDoneSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)])++#endif++-- method Menu::new+-- method type : Constructor+-- Args : [Arg {argCName = "dbus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of the #DbusmenuServer on DBus", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dbus_object", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of the object on the #DbusmenuServer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "DbusmenuGtk3", name = "Menu"}))+-- throws : False+-- Skip return : False++foreign import ccall "dbusmenu_gtkmenu_new" dbusmenu_gtkmenu_new :: +    CString ->                              -- dbus_name : TBasicType TUTF8+    CString ->                              -- dbus_object : TBasicType TUTF8+    IO (Ptr Menu)++{- |+Creates a new 'GI.DbusmenuGtk3.Objects.Menu.Menu' object and creates a 'GI.Dbusmenu.Objects.Client.Client'+that connects across DBus to a 'GI.Dbusmenu.Objects.Server.Server'.+-}+menuNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@dbusName@/: Name of the 'GI.Dbusmenu.Objects.Server.Server' on DBus -}+    -> T.Text+    {- ^ /@dbusObject@/: Name of the object on the 'GI.Dbusmenu.Objects.Server.Server' -}+    -> m Menu+    {- ^ __Returns:__ A new 'GI.DbusmenuGtk3.Objects.Menu.Menu' sync\'d with a server -}+menuNew dbusName dbusObject = liftIO $ do+    dbusName' <- textToCString dbusName+    dbusObject' <- textToCString dbusObject+    result <- dbusmenu_gtkmenu_new dbusName' dbusObject'+    checkUnexpectedReturnNULL "menuNew" result+    result' <- (newObject Menu) result+    freeMem dbusName'+    freeMem dbusObject'+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Menu::get_client+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "DbusmenuGtk3", name = "Menu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #DbusmenuGtkMenu to get the client from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "DbusmenuGtk3", name = "Client"}))+-- throws : False+-- Skip return : False++foreign import ccall "dbusmenu_gtkmenu_get_client" dbusmenu_gtkmenu_get_client :: +    Ptr Menu ->                             -- menu : TInterface (Name {namespace = "DbusmenuGtk3", name = "Menu"})+    IO (Ptr DbusmenuGtk3.Client.Client)++{- |+An accessor for the client that this menu is using to+communicate with the server.+-}+menuGetClient ::+    (B.CallStack.HasCallStack, MonadIO m, IsMenu a) =>+    a+    {- ^ /@menu@/: The 'GI.DbusmenuGtk3.Objects.Menu.Menu' to get the client from -}+    -> m DbusmenuGtk3.Client.Client+    {- ^ __Returns:__ A valid 'GI.DbusmenuGtk3.Objects.Client.Client' or NULL on error. -}+menuGetClient menu = liftIO $ do+    menu' <- unsafeManagedPtrCastPtr menu+    result <- dbusmenu_gtkmenu_get_client menu'+    checkUnexpectedReturnNULL "menuGetClient" result+    result' <- (newObject DbusmenuGtk3.Client.Client) result+    touchManagedPtr menu+    return result'++#if ENABLE_OVERLOADING+data MenuGetClientMethodInfo+instance (signature ~ (m DbusmenuGtk3.Client.Client), MonadIO m, IsMenu a) => O.MethodInfo MenuGetClientMethodInfo a signature where+    overloadedMethod _ = menuGetClient++#endif++

@@ -0,0 +1,38 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.DbusmenuGtk3.Objects.Menu where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++newtype Menu = Menu (ManagedPtr Menu)+instance GObject Menu where+class (GObject o, O.IsDescendantOf Menu o) => IsMenu o+instance (GObject o, O.IsDescendantOf Menu o) => IsMenu o+instance O.HasParentTypes Menu+#if ENABLE_OVERLOADING+data MenuDbusNamePropertyInfo+#endif+#if ENABLE_OVERLOADING+data MenuDbusObjectPropertyInfo+#endif+#if ENABLE_OVERLOADING+data MenuGetClientMethodInfo+#endif

@@ -1,3 +1,17 @@+The gi-dbusmenugtk3 library and included works are provided under the terms of the+GNU Library General Public License (LGPL) version 2.1 with the following+exception:++Static linking of applications or any other source to the gi-dbusmenugtk3 library+does not constitute a modified or derivative work and does not require+the author(s) to provide source code for said work, to link against the+shared gi-dbusmenugtk3 libraries, or to link their applications against a+user-supplied version of gi-dbusmenugtk3. If you link applications to a modified+version of gi-dbusmenugtk3, then the changes to gi-dbusmenugtk3 must be provided under the+terms of the LGPL.++----------------------------------------------------------------------------+                   GNU LESSER GENERAL PUBLIC LICENSE                        Version 2.1, February 1999 

@@ -1,6 +1,6 @@ # Documentation Autogenerated documentation for this package can be found at -[https://hackage.haskell.org/package/gi-dbusmenugtk3-0.4.2/docs/GI-DbusmenuGtk3.html](https://hackage.haskell.org/package/gi-dbusmenugtk3-0.4.2/docs/GI-DbusmenuGtk3.html)+[https://hackage.haskell.org/package/gi-dbusmenugtk3-0.4.4/docs/GI-DbusmenuGtk3.html](https://hackage.haskell.org/package/gi-dbusmenugtk3-0.4.4/docs/GI-DbusmenuGtk3.html)  For general documentation on using [haskell-gi](https://github.com/haskell-gi/haskell-gi) based bindings, see [the project page](https://github.com/haskell-gi/haskell-gi) or [the Wiki](https://github.com/haskell-gi/haskell-gi/wiki).

@@ -1,12 +1,12 @@ name:                 gi-dbusmenugtk3-version:              0.4.2+version:              0.4.4 synopsis:             DbusmenuGtk bindings description:          Bindings for libdbusgtk3, autogenerated by haskell-gi. homepage:             https://github.com/haskell-gi/haskell-gi license:              LGPL-2.1 license-file:         LICENSE author:               Will Thompson, Iñaki García Etxebarria and Jonas Platte-maintainer:           Iñaki García Etxebarria (garetxe@gmail.com)+maintainer:           Iñaki García Etxebarria (inaki@blueleaf.cc) category:             Bindings build-type:           Custom cabal-version:        1.24@@ -14,20 +14,20 @@ extra-source-files: README.md ChangeLog.md stack.yaml DbusmenuGtk3.overrides  custom-setup-      setup-depends: base >= 4.7 && < 5,+      setup-depends: base >= 4.9 && < 5,                      Cabal >= 1.24,-                     haskell-gi >= 0.21.1 && < 0.22+                     haskell-gi >= 0.21.0 && < 0.23  library       default-language: Haskell2010-      default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts+      default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts, UndecidableSuperClasses       other-extensions: PatternSynonyms, ViewPatterns       ghc-options: -fno-warn-unused-imports -fno-warn-warnings-deprecations        pkgconfig-depends: dbusmenu-gtk3-0.4, gtk+-3.0       build-depends: base >= 4.7 && <5,-                     haskell-gi-base == 0.21.*,-                     haskell-gi >= 0.21.1 && < 0.22,+                     haskell-gi-base >= 0.21.0 && < 0.23,+                     haskell-gi >= 0.21.0 && < 0.23,                      haskell-gi-overloading < 1.1,                      gi-glib == 2.0.*,                      gi-gobject == 2.0.*,@@ -45,3 +45,10 @@       -- see https://ghc.haskell.org/trac/ghc/ticket/14382       if impl(ghc == 8.2.*)               build-depends: haskell-gi-overloading == 0.0++      exposed-modules: GI.DbusmenuGtk3,+                       GI.DbusmenuGtk3.Constants,+                       GI.DbusmenuGtk3.Functions,+                       GI.DbusmenuGtk3.Objects,+                       GI.DbusmenuGtk3.Objects.Client,+                       GI.DbusmenuGtk3.Objects.Menu

@@ -1,3 +1,3 @@ packages: - '.'-resolver: lts-9.21+resolver: lts-13.7