diff --git a/ChangeLog.md b/ChangeLog.md --- a/ChangeLog.md +++ b/ChangeLog.md @@ -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. diff --git a/GI/DbusmenuGtk3.hs b/GI/DbusmenuGtk3.hs new file mode 100644 --- /dev/null +++ b/GI/DbusmenuGtk3.hs @@ -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 + diff --git a/GI/DbusmenuGtk3/Constants.hs b/GI/DbusmenuGtk3/Constants.hs new file mode 100644 --- /dev/null +++ b/GI/DbusmenuGtk3/Constants.hs @@ -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 + + diff --git a/GI/DbusmenuGtk3/Functions.hs b/GI/DbusmenuGtk3/Functions.hs new file mode 100644 --- /dev/null +++ b/GI/DbusmenuGtk3/Functions.hs @@ -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' + + + diff --git a/GI/DbusmenuGtk3/Objects.hs b/GI/DbusmenuGtk3/Objects.hs new file mode 100644 --- /dev/null +++ b/GI/DbusmenuGtk3/Objects.hs @@ -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 + + + diff --git a/GI/DbusmenuGtk3/Objects/Client.hs b/GI/DbusmenuGtk3/Objects/Client.hs new file mode 100644 --- /dev/null +++ b/GI/DbusmenuGtk3/Objects/Client.hs @@ -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 + + diff --git a/GI/DbusmenuGtk3/Objects/Client.hs-boot b/GI/DbusmenuGtk3/Objects/Client.hs-boot new file mode 100644 --- /dev/null +++ b/GI/DbusmenuGtk3/Objects/Client.hs-boot @@ -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 diff --git a/GI/DbusmenuGtk3/Objects/Menu.hs b/GI/DbusmenuGtk3/Objects/Menu.hs new file mode 100644 --- /dev/null +++ b/GI/DbusmenuGtk3/Objects/Menu.hs @@ -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 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 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 + + diff --git a/GI/DbusmenuGtk3/Objects/Menu.hs-boot b/GI/DbusmenuGtk3/Objects/Menu.hs-boot new file mode 100644 --- /dev/null +++ b/GI/DbusmenuGtk3/Objects/Menu.hs-boot @@ -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 diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -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 diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -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). diff --git a/gi-dbusmenugtk3.cabal b/gi-dbusmenugtk3.cabal --- a/gi-dbusmenugtk3.cabal +++ b/gi-dbusmenugtk3.cabal @@ -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 diff --git a/stack.yaml b/stack.yaml --- a/stack.yaml +++ b/stack.yaml @@ -1,3 +1,3 @@ packages: - '.' -resolver: lts-9.21 +resolver: lts-13.7