packages feed

gi-handy (empty) → 0.0.1

raw patch · 43 files changed

+15975/−0 lines, 43 filesdep +basedep +bytestringdep +containersbuild-type:Customsetup-changed

Dependencies added: base, bytestring, containers, gi-atk, gi-gdk, gi-gio, gi-glib, gi-gobject, gi-gtk, haskell-gi, haskell-gi-base, haskell-gi-overloading, text, transformers

Files

+ ChangeLog.md view
@@ -0,0 +1,5 @@+0.0.1+=====++* Initial version.+
+ GI/Handy.hs view
@@ -0,0 +1,52 @@+++{- |+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.Handy+    (     module GI.Handy.Callbacks               ,+    module GI.Handy.Enums                   ,+    module GI.Handy.Functions               ,+    module GI.Handy.Objects                 ,++++    module Data.GI.Base                     ,+++    ) where++import GI.Handy.Callbacks+import GI.Handy.Enums+import GI.Handy.Functions+import GI.Handy.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+
+ GI/Handy/Callbacks.hs view
@@ -0,0 +1,259 @@+++{- |+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.Handy.Callbacks+    ( ++ -- * Signals+-- ** ComboRowGetEnumValueNameFunc #signal:ComboRowGetEnumValueNameFunc#++    C_ComboRowGetEnumValueNameFunc          ,+    ComboRowGetEnumValueNameFunc            ,+    ComboRowGetEnumValueNameFunc_WithClosures,+    drop_closures_ComboRowGetEnumValueNameFunc,+    dynamic_ComboRowGetEnumValueNameFunc    ,+    genClosure_ComboRowGetEnumValueNameFunc ,+    mk_ComboRowGetEnumValueNameFunc         ,+    noComboRowGetEnumValueNameFunc          ,+    noComboRowGetEnumValueNameFunc_WithClosures,+    wrap_ComboRowGetEnumValueNameFunc       ,+++-- ** ComboRowGetNameFunc #signal:ComboRowGetNameFunc#++    C_ComboRowGetNameFunc                   ,+    ComboRowGetNameFunc                     ,+    ComboRowGetNameFunc_WithClosures        ,+    drop_closures_ComboRowGetNameFunc       ,+    dynamic_ComboRowGetNameFunc             ,+    genClosure_ComboRowGetNameFunc          ,+    mk_ComboRowGetNameFunc                  ,+    noComboRowGetNameFunc                   ,+    noComboRowGetNameFunc_WithClosures      ,+    wrap_ComboRowGetNameFunc                ,+++++    ) 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.GObject.Objects.Object as GObject.Object+import {-# SOURCE #-} qualified GI.Handy.Objects.EnumValueObject as Handy.EnumValueObject++-- callback ComboRowGetNameFunc+--          -> Callable {returnType = Just (TBasicType TUTF8), returnMayBeNull = False, returnTransfer = TransferEverything, returnDocumentation = Documentation {rawDocText = Just "a newly allocated displayable name that represents @item", sinceVersion = Nothing}, args = [Arg {argCName = "item", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the item from the model from which to get a name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Called for combo rows that are bound to a #GListModel with\nhdy_combo_row_bind_name_model() for each item that gets added to the model.", sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_ComboRowGetNameFunc =+    Ptr GObject.Object.Object ->+    Ptr () ->+    IO CString++-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the item from the model from which to get a name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_ComboRowGetNameFunc :: FunPtr C_ComboRowGetNameFunc -> C_ComboRowGetNameFunc++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_ComboRowGetNameFunc ::+    (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>+    FunPtr C_ComboRowGetNameFunc+    -> a+    {- ^ /@item@/: the item from the model from which to get a name -}+    -> Ptr ()+    {- ^ /@userData@/: user data -}+    -> m T.Text+    {- ^ __Returns:__ a newly allocated displayable name that represents /@item@/ -}+dynamic_ComboRowGetNameFunc __funPtr item userData = liftIO $ do+    item' <- unsafeManagedPtrCastPtr item+    result <- (__dynamic_C_ComboRowGetNameFunc __funPtr) item' userData+    checkUnexpectedReturnNULL "comboRowGetNameFunc" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr item+    return result'++-- | Generate a function pointer callable from C code, from a `C_ComboRowGetNameFunc`.+foreign import ccall "wrapper"+    mk_ComboRowGetNameFunc :: C_ComboRowGetNameFunc -> IO (FunPtr C_ComboRowGetNameFunc)++{- |+Called for combo rows that are bound to a 'GI.Gio.Interfaces.ListModel.ListModel' with+'GI.Handy.Objects.ComboRow.comboRowBindNameModel' for each item that gets added to the model.+-}+type ComboRowGetNameFunc =+    GObject.Object.Object+    {- ^ /@item@/: the item from the model from which to get a name -}+    -> IO T.Text+    {- ^ __Returns:__ a newly allocated displayable name that represents /@item@/ -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `ComboRowGetNameFunc`@.+noComboRowGetNameFunc :: Maybe ComboRowGetNameFunc+noComboRowGetNameFunc = Nothing++{- |+Called for combo rows that are bound to a 'GI.Gio.Interfaces.ListModel.ListModel' with+'GI.Handy.Objects.ComboRow.comboRowBindNameModel' for each item that gets added to the model.+-}+type ComboRowGetNameFunc_WithClosures =+    GObject.Object.Object+    {- ^ /@item@/: the item from the model from which to get a name -}+    -> Ptr ()+    {- ^ /@userData@/: user data -}+    -> IO T.Text+    {- ^ __Returns:__ a newly allocated displayable name that represents /@item@/ -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `ComboRowGetNameFunc_WithClosures`@.+noComboRowGetNameFunc_WithClosures :: Maybe ComboRowGetNameFunc_WithClosures+noComboRowGetNameFunc_WithClosures = Nothing++-- | A simple wrapper that ignores the closure arguments.+drop_closures_ComboRowGetNameFunc :: ComboRowGetNameFunc -> ComboRowGetNameFunc_WithClosures+drop_closures_ComboRowGetNameFunc _f item _ = _f item++-- | Wrap the callback into a `GClosure`.+genClosure_ComboRowGetNameFunc :: MonadIO m => ComboRowGetNameFunc -> m (GClosure C_ComboRowGetNameFunc)+genClosure_ComboRowGetNameFunc cb = liftIO $ do+    let cb' = drop_closures_ComboRowGetNameFunc cb+    let cb'' = wrap_ComboRowGetNameFunc Nothing cb'+    mk_ComboRowGetNameFunc cb'' >>= B.GClosure.newGClosure+++-- | Wrap a `ComboRowGetNameFunc` into a `C_ComboRowGetNameFunc`.+wrap_ComboRowGetNameFunc ::+    Maybe (Ptr (FunPtr C_ComboRowGetNameFunc)) ->+    ComboRowGetNameFunc_WithClosures ->+    C_ComboRowGetNameFunc+wrap_ComboRowGetNameFunc funptrptr _cb item userData = do+    item' <- (newObject GObject.Object.Object) item+    result <- _cb  item' userData+    maybeReleaseFunPtr funptrptr+    result' <- textToCString result+    return result'+++-- callback ComboRowGetEnumValueNameFunc+--          -> Callable {returnType = Just (TBasicType TUTF8), returnMayBeNull = False, returnTransfer = TransferEverything, returnDocumentation = Documentation {rawDocText = Just "a newly allocated displayable name that represents @value", sinceVersion = Nothing}, args = [Arg {argCName = "value", argType = TInterface (Name {namespace = "Handy", name = "EnumValueObject"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value from the enum from which to get a name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Called for combo rows that are bound to an enumeration with\nhdy_combo_row_set_for_enum() for each value from that enumeration.", sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_ComboRowGetEnumValueNameFunc =+    Ptr Handy.EnumValueObject.EnumValueObject ->+    Ptr () ->+    IO CString++-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "Handy", name = "EnumValueObject"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value from the enum from which to get a name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_ComboRowGetEnumValueNameFunc :: FunPtr C_ComboRowGetEnumValueNameFunc -> C_ComboRowGetEnumValueNameFunc++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_ComboRowGetEnumValueNameFunc ::+    (B.CallStack.HasCallStack, MonadIO m, Handy.EnumValueObject.IsEnumValueObject a) =>+    FunPtr C_ComboRowGetEnumValueNameFunc+    -> a+    {- ^ /@value@/: the value from the enum from which to get a name -}+    -> Ptr ()+    {- ^ /@userData@/: user data -}+    -> m T.Text+    {- ^ __Returns:__ a newly allocated displayable name that represents /@value@/ -}+dynamic_ComboRowGetEnumValueNameFunc __funPtr value userData = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- (__dynamic_C_ComboRowGetEnumValueNameFunc __funPtr) value' userData+    checkUnexpectedReturnNULL "comboRowGetEnumValueNameFunc" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr value+    return result'++-- | Generate a function pointer callable from C code, from a `C_ComboRowGetEnumValueNameFunc`.+foreign import ccall "wrapper"+    mk_ComboRowGetEnumValueNameFunc :: C_ComboRowGetEnumValueNameFunc -> IO (FunPtr C_ComboRowGetEnumValueNameFunc)++{- |+Called for combo rows that are bound to an enumeration with+'GI.Handy.Objects.ComboRow.comboRowSetForEnum' for each value from that enumeration.+-}+type ComboRowGetEnumValueNameFunc =+    Handy.EnumValueObject.EnumValueObject+    {- ^ /@value@/: the value from the enum from which to get a name -}+    -> IO T.Text+    {- ^ __Returns:__ a newly allocated displayable name that represents /@value@/ -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `ComboRowGetEnumValueNameFunc`@.+noComboRowGetEnumValueNameFunc :: Maybe ComboRowGetEnumValueNameFunc+noComboRowGetEnumValueNameFunc = Nothing++{- |+Called for combo rows that are bound to an enumeration with+'GI.Handy.Objects.ComboRow.comboRowSetForEnum' for each value from that enumeration.+-}+type ComboRowGetEnumValueNameFunc_WithClosures =+    Handy.EnumValueObject.EnumValueObject+    {- ^ /@value@/: the value from the enum from which to get a name -}+    -> Ptr ()+    {- ^ /@userData@/: user data -}+    -> IO T.Text+    {- ^ __Returns:__ a newly allocated displayable name that represents /@value@/ -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `ComboRowGetEnumValueNameFunc_WithClosures`@.+noComboRowGetEnumValueNameFunc_WithClosures :: Maybe ComboRowGetEnumValueNameFunc_WithClosures+noComboRowGetEnumValueNameFunc_WithClosures = Nothing++-- | A simple wrapper that ignores the closure arguments.+drop_closures_ComboRowGetEnumValueNameFunc :: ComboRowGetEnumValueNameFunc -> ComboRowGetEnumValueNameFunc_WithClosures+drop_closures_ComboRowGetEnumValueNameFunc _f value _ = _f value++-- | Wrap the callback into a `GClosure`.+genClosure_ComboRowGetEnumValueNameFunc :: MonadIO m => ComboRowGetEnumValueNameFunc -> m (GClosure C_ComboRowGetEnumValueNameFunc)+genClosure_ComboRowGetEnumValueNameFunc cb = liftIO $ do+    let cb' = drop_closures_ComboRowGetEnumValueNameFunc cb+    let cb'' = wrap_ComboRowGetEnumValueNameFunc Nothing cb'+    mk_ComboRowGetEnumValueNameFunc cb'' >>= B.GClosure.newGClosure+++-- | Wrap a `ComboRowGetEnumValueNameFunc` into a `C_ComboRowGetEnumValueNameFunc`.+wrap_ComboRowGetEnumValueNameFunc ::+    Maybe (Ptr (FunPtr C_ComboRowGetEnumValueNameFunc)) ->+    ComboRowGetEnumValueNameFunc_WithClosures ->+    C_ComboRowGetEnumValueNameFunc+wrap_ComboRowGetEnumValueNameFunc funptrptr _cb value userData = do+    value' <- (newObject Handy.EnumValueObject.EnumValueObject) value+    result <- _cb  value' userData+    maybeReleaseFunPtr funptrptr+    result' <- textToCString result+    return result'+++
+ GI/Handy/Enums.hs view
@@ -0,0 +1,238 @@+++{- |+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.Handy.Enums+    ( ++ -- * Enumerations+-- ** ArrowsDirection #enum:ArrowsDirection#++    ArrowsDirection(..)                     ,+++-- ** Fold #enum:Fold#++    Fold(..)                                ,+++-- ** LeafletChildTransitionType #enum:LeafletChildTransitionType#++    LeafletChildTransitionType(..)          ,+++-- ** LeafletModeTransitionType #enum:LeafletModeTransitionType#++    LeafletModeTransitionType(..)           ,+++++    ) 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+++-- Enum LeafletModeTransitionType+{- |+These enumeration values describe the possible transitions between pages in a+'GI.Handy.Objects.Leaflet.Leaflet' widget.++New values may be added to this enumeration over time.+-}+data LeafletModeTransitionType = +      LeafletModeTransitionTypeNone+    {- ^+    No transition+    -}+    | LeafletModeTransitionTypeSlide+    {- ^+    Slide from left, right, up or down according to the orientation, text direction and the children order+    -}+    | AnotherLeafletModeTransitionType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum LeafletModeTransitionType where+    fromEnum LeafletModeTransitionTypeNone = 0+    fromEnum LeafletModeTransitionTypeSlide = 1+    fromEnum (AnotherLeafletModeTransitionType k) = k++    toEnum 0 = LeafletModeTransitionTypeNone+    toEnum 1 = LeafletModeTransitionTypeSlide+    toEnum k = AnotherLeafletModeTransitionType k++instance P.Ord LeafletModeTransitionType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "hdy_leaflet_mode_transition_type_get_type" c_hdy_leaflet_mode_transition_type_get_type :: +    IO GType++instance BoxedEnum LeafletModeTransitionType where+    boxedEnumType _ = c_hdy_leaflet_mode_transition_type_get_type++-- Enum LeafletChildTransitionType+{- |+These enumeration values describe the possible transitions between pages in a+'GI.Handy.Objects.Leaflet.Leaflet' widget.++New values may be added to this enumeration over time.+-}+data LeafletChildTransitionType = +      LeafletChildTransitionTypeNone+    {- ^+    No transition+    -}+    | LeafletChildTransitionTypeCrossfade+    {- ^+    A cross-fade+    -}+    | LeafletChildTransitionTypeSlide+    {- ^+    Slide from left, right, up or down according to the orientation, text direction and the children order+    -}+    | LeafletChildTransitionTypeOver+    {- ^+    Cover the old page or uncover the new page, sliding from or towards the end according to orientation, text direction and children order+    -}+    | LeafletChildTransitionTypeUnder+    {- ^+    Uncover the new page or cover the old page, sliding from or towards the start according to orientation, text direction and children order+    -}+    | AnotherLeafletChildTransitionType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum LeafletChildTransitionType where+    fromEnum LeafletChildTransitionTypeNone = 0+    fromEnum LeafletChildTransitionTypeCrossfade = 1+    fromEnum LeafletChildTransitionTypeSlide = 2+    fromEnum LeafletChildTransitionTypeOver = 3+    fromEnum LeafletChildTransitionTypeUnder = 4+    fromEnum (AnotherLeafletChildTransitionType k) = k++    toEnum 0 = LeafletChildTransitionTypeNone+    toEnum 1 = LeafletChildTransitionTypeCrossfade+    toEnum 2 = LeafletChildTransitionTypeSlide+    toEnum 3 = LeafletChildTransitionTypeOver+    toEnum 4 = LeafletChildTransitionTypeUnder+    toEnum k = AnotherLeafletChildTransitionType k++instance P.Ord LeafletChildTransitionType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "hdy_leaflet_child_transition_type_get_type" c_hdy_leaflet_child_transition_type_get_type :: +    IO GType++instance BoxedEnum LeafletChildTransitionType where+    boxedEnumType _ = c_hdy_leaflet_child_transition_type_get_type++-- Enum Fold+{- |+Represents the fold of widgets and other objects which can be switched+between folded and unfolded state on the fly, like HdyLeaflet.+-}+data Fold = +      FoldUnfolded+    {- ^+    The element isn\'t folded+    -}+    | FoldFolded+    {- ^+    The element is folded+    -}+    | AnotherFold Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum Fold where+    fromEnum FoldUnfolded = 0+    fromEnum FoldFolded = 1+    fromEnum (AnotherFold k) = k++    toEnum 0 = FoldUnfolded+    toEnum 1 = FoldFolded+    toEnum k = AnotherFold k++instance P.Ord Fold where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "hdy_fold_get_type" c_hdy_fold_get_type :: +    IO GType++instance BoxedEnum Fold where+    boxedEnumType _ = c_hdy_fold_get_type++-- Enum ArrowsDirection+{- |+/No description available in the introspection data./+-}+data ArrowsDirection = +      ArrowsDirectionUp+    {- ^+    Arrows point upwards.+    -}+    | ArrowsDirectionDown+    {- ^+    Arrows point to the left.+    -}+    | ArrowsDirectionLeft+    {- ^+    Arrows point to the right.+    -}+    | ArrowsDirectionRight+    {- ^+    Arrows point downwards+    -}+    | AnotherArrowsDirection Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum ArrowsDirection where+    fromEnum ArrowsDirectionUp = 0+    fromEnum ArrowsDirectionDown = 1+    fromEnum ArrowsDirectionLeft = 2+    fromEnum ArrowsDirectionRight = 3+    fromEnum (AnotherArrowsDirection k) = k++    toEnum 0 = ArrowsDirectionUp+    toEnum 1 = ArrowsDirectionDown+    toEnum 2 = ArrowsDirectionLeft+    toEnum 3 = ArrowsDirectionRight+    toEnum k = AnotherArrowsDirection k++instance P.Ord ArrowsDirection where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "hdy_arrows_direction_get_type" c_hdy_arrows_direction_get_type :: +    IO GType++instance BoxedEnum ArrowsDirection where+    boxedEnumType _ = c_hdy_arrows_direction_get_type++
+ GI/Handy/Enums.hs-boot view
@@ -0,0 +1,36 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Handy.Enums 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++data LeafletModeTransitionType+instance P.Enum LeafletModeTransitionType where+instance BoxedEnum LeafletModeTransitionType where+data LeafletChildTransitionType+instance P.Enum LeafletChildTransitionType where+instance BoxedEnum LeafletChildTransitionType where+data Fold+instance P.Enum Fold where+instance BoxedEnum Fold where+data ArrowsDirection+instance P.Enum ArrowsDirection where+instance BoxedEnum ArrowsDirection where
+ GI/Handy/Functions.hs view
@@ -0,0 +1,256 @@+++{- |+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.Handy.Functions+    ( ++ -- * Methods+-- ** enumValueRowName #method:enumValueRowName#++    enumValueRowName                        ,+++-- ** init #method:init#++    init                                    ,+++-- ** listBoxSeparatorHeader #method:listBoxSeparatorHeader#++    listBoxSeparatorHeader                  ,+++-- ** stringUtf8Len #method:stringUtf8Len#++    stringUtf8Len                           ,+++-- ** stringUtf8Truncate #method:stringUtf8Truncate#++    stringUtf8Truncate                      ,+++++    ) 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.GLib.Structs.String as GLib.String+import qualified GI.Gtk.Objects.ListBoxRow as Gtk.ListBoxRow+import {-# SOURCE #-} qualified GI.Handy.Objects.EnumValueObject as Handy.EnumValueObject++-- function hdy_string_utf8_truncate+-- Args : [Arg {argCName = "string", argType = TInterface (Name {namespace = "GLib", name = "String"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GString", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "len", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new size of the string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GLib", name = "String"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_string_utf8_truncate" hdy_string_utf8_truncate :: +    Ptr GLib.String.String ->               -- string : TInterface (Name {namespace = "GLib", name = "String"})+    Word64 ->                               -- len : TBasicType TUInt64+    IO (Ptr GLib.String.String)++{- |+Cut of the end of the string /@string@/ so that /@len@/ utf8 characters remain+-}+stringUtf8Truncate ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GLib.String.String+    {- ^ /@string@/: a 'GI.GLib.Structs.String.String' -}+    -> Word64+    {- ^ /@len@/: the new size of the string -}+    -> m GLib.String.String+    {- ^ __Returns:__ /@string@/ -}+stringUtf8Truncate string len = liftIO $ do+    string' <- unsafeManagedPtrGetPtr string+    result <- hdy_string_utf8_truncate string' len+    checkUnexpectedReturnNULL "stringUtf8Truncate" result+    result' <- (newBoxed GLib.String.String) result+    touchManagedPtr string+    return result'+++-- function hdy_string_utf8_len+-- Args : [Arg {argCName = "string", argType = TInterface (Name {namespace = "GLib", name = "String"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GString", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TLong)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_string_utf8_len" hdy_string_utf8_len :: +    Ptr GLib.String.String ->               -- string : TInterface (Name {namespace = "GLib", name = "String"})+    IO CLong++{- |+Computes the length of the string in utf-8 characters. See @/g_utf8_strlen/@.+-}+stringUtf8Len ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GLib.String.String+    {- ^ /@string@/: a 'GI.GLib.Structs.String.String' -}+    -> m CLong+    {- ^ __Returns:__ the length of /@string@/ in characters -}+stringUtf8Len string = liftIO $ do+    string' <- unsafeManagedPtrGetPtr string+    result <- hdy_string_utf8_len string'+    touchManagedPtr string+    return result+++-- function hdy_list_box_separator_header+-- Args : [Arg {argCName = "row", argType = TInterface (Name {namespace = "Gtk", name = "ListBoxRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the row to update", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "before", argType = TInterface (Name {namespace = "Gtk", name = "ListBoxRow"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the row before @row, or %NULL if it is first", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "unused_user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "unused user data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_list_box_separator_header" hdy_list_box_separator_header :: +    Ptr Gtk.ListBoxRow.ListBoxRow ->        -- row : TInterface (Name {namespace = "Gtk", name = "ListBoxRow"})+    Ptr Gtk.ListBoxRow.ListBoxRow ->        -- before : TInterface (Name {namespace = "Gtk", name = "ListBoxRow"})+    Ptr () ->                               -- unused_user_data : TBasicType TPtr+    IO ()++{- |+Separates rows by using 'GI.Gtk.Objects.Separator.Separator' as headers. The first row doesn\'t have+a separator as there is no row above it.++/Since: 0.0.6/+-}+listBoxSeparatorHeader ::+    (B.CallStack.HasCallStack, MonadIO m, Gtk.ListBoxRow.IsListBoxRow a, Gtk.ListBoxRow.IsListBoxRow b) =>+    a+    {- ^ /@row@/: the row to update -}+    -> Maybe (b)+    {- ^ /@before@/: the row before /@row@/, or 'Nothing' if it is first -}+    -> Ptr ()+    {- ^ /@unusedUserData@/: unused user data -}+    -> m ()+listBoxSeparatorHeader row before unusedUserData = liftIO $ do+    row' <- unsafeManagedPtrCastPtr row+    maybeBefore <- case before of+        Nothing -> return nullPtr+        Just jBefore -> do+            jBefore' <- unsafeManagedPtrCastPtr jBefore+            return jBefore'+    hdy_list_box_separator_header row' maybeBefore unusedUserData+    touchManagedPtr row+    whenJust before touchManagedPtr+    return ()+++-- function hdy_init+-- Args : [Arg {argCName = "argc", argType = TBasicType TInt, direction = DirectionInout, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Address of the <parameter>argc</parameter>\n    parameter of your main() function (or 0 if @argv is %NULL). This will be\n    changed if any arguments were handled.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "argv", argType = TCArray False (-1) 0 (TBasicType TUTF8), direction = DirectionInout, mayBeNull = True, argDoc = Documentation {rawDocText = Just "\n    Address of the <parameter>argv</parameter> parameter of main(), or %NULL.\n    Any options understood by Handy are stripped before return.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "argc", argType = TBasicType TInt, direction = DirectionInout, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Address of the <parameter>argc</parameter>\n    parameter of your main() function (or 0 if @argv is %NULL). This will be\n    changed if any arguments were handled.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_init" hdy_init :: +    Ptr Int32 ->                            -- argc : TBasicType TInt+    Ptr (Ptr CString) ->                    -- argv : TCArray False (-1) 0 (TBasicType TUTF8)+    IO CInt++{- |+Call this function before using any other Handy functions in your+GUI applications. If libhandy has already been initialized, the function will+simply return without processing the new arguments.+-}+init ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Maybe ([T.Text])+    {- ^ /@argv@/: +    Address of the \<parameter>argv\<\/parameter> parameter of @/main()/@, or 'Nothing'.+    Any options understood by Handy are stripped before return. -}+    -> m ((Bool, Maybe [T.Text]))+    {- ^ __Returns:__ 'True' if initialization was successful, 'False' otherwise. -}+init argv = liftIO $ do+    let argc = case argv of+            Nothing -> 0+            Just jArgv -> fromIntegral $ length jArgv+    argc' <- allocMem :: IO (Ptr Int32)+    poke argc' argc+    maybeArgv <- case argv of+        Nothing -> return nullPtr+        Just jArgv -> do+            jArgv' <- packUTF8CArray jArgv+            return jArgv'+    maybeArgv' <- allocMem :: IO (Ptr (Ptr CString))+    poke maybeArgv' maybeArgv+    result <- hdy_init argc' maybeArgv'+    argc'' <- peek argc'+    let result' = (/= 0) result+    maybeArgv'' <- peek maybeArgv'+    maybeMaybeArgv'' <- convertIfNonNull maybeArgv'' $ \maybeArgv''' -> do+        maybeArgv'''' <- (unpackUTF8CArrayWithLength argc'') maybeArgv'''+        return maybeArgv''''+    freeMem argc'+    freeMem maybeArgv'+    return (result', maybeMaybeArgv'')+++-- function hdy_enum_value_row_name+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "Handy", name = "EnumValueObject"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value from the enum from which to get a name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "unused user data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_enum_value_row_name" hdy_enum_value_row_name :: +    Ptr Handy.EnumValueObject.EnumValueObject -> -- value : TInterface (Name {namespace = "Handy", name = "EnumValueObject"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    IO CString++{- |+This is a default implementation of 'GI.Handy.Callbacks.ComboRowGetEnumValueNameFunc' to be+used with 'GI.Handy.Objects.ComboRow.comboRowSetForEnum'. If the enumeration has a nickname, it+will return it, otherwise it will return its name.++/Since: 0.0.6/+-}+enumValueRowName ::+    (B.CallStack.HasCallStack, MonadIO m, Handy.EnumValueObject.IsEnumValueObject a) =>+    a+    {- ^ /@value@/: the value from the enum from which to get a name -}+    -> Ptr ()+    {- ^ /@userData@/: unused user data -}+    -> m T.Text+    {- ^ __Returns:__ a newly allocated displayable name that represents /@value@/ -}+enumValueRowName value userData = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- hdy_enum_value_row_name value' userData+    checkUnexpectedReturnNULL "enumValueRowName" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr value+    return result'+++
+ GI/Handy/Objects.hs view
@@ -0,0 +1,69 @@+++{- |+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.Handy.Objects+    (     module GI.Handy.Objects.ActionRow       ,+    module GI.Handy.Objects.Arrows          ,+    module GI.Handy.Objects.Column          ,+    module GI.Handy.Objects.ComboRow        ,+    module GI.Handy.Objects.Dialer          ,+    module GI.Handy.Objects.DialerButton    ,+    module GI.Handy.Objects.DialerCycleButton,+    module GI.Handy.Objects.Dialog          ,+    module GI.Handy.Objects.EnumValueObject ,+    module GI.Handy.Objects.ExpanderRow     ,+    module GI.Handy.Objects.HeaderGroup     ,+    module GI.Handy.Objects.Leaflet         ,+    module GI.Handy.Objects.SearchBar       ,+    module GI.Handy.Objects.TitleBar        ,+    module GI.Handy.Objects.ValueObject     ,+++    ) where++import GI.Handy.Objects.ActionRow+import GI.Handy.Objects.Arrows+import GI.Handy.Objects.Column+import GI.Handy.Objects.ComboRow+import GI.Handy.Objects.Dialer+import GI.Handy.Objects.DialerButton+import GI.Handy.Objects.DialerCycleButton+import GI.Handy.Objects.Dialog+import GI.Handy.Objects.EnumValueObject+import GI.Handy.Objects.ExpanderRow+import GI.Handy.Objects.HeaderGroup+import GI.Handy.Objects.Leaflet+import GI.Handy.Objects.SearchBar+import GI.Handy.Objects.TitleBar+import GI.Handy.Objects.ValueObject++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+++
+ GI/Handy/Objects/ActionRow.hs view
@@ -0,0 +1,1465 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Handy.Objects.ActionRow+    ( ++-- * Exported types+    ActionRow(..)                           ,+    IsActionRow                             ,+    toActionRow                             ,+    noActionRow                             ,+++ -- * Methods+-- ** activate #method:activate#++#if ENABLE_OVERLOADING+    ActionRowActivateMethodInfo             ,+#endif+    actionRowActivate                       ,+++-- ** addAction #method:addAction#++#if ENABLE_OVERLOADING+    ActionRowAddActionMethodInfo            ,+#endif+    actionRowAddAction                      ,+++-- ** addPrefix #method:addPrefix#++#if ENABLE_OVERLOADING+    ActionRowAddPrefixMethodInfo            ,+#endif+    actionRowAddPrefix                      ,+++-- ** getActivatableWidget #method:getActivatableWidget#++#if ENABLE_OVERLOADING+    ActionRowGetActivatableWidgetMethodInfo ,+#endif+    actionRowGetActivatableWidget           ,+++-- ** getIconName #method:getIconName#++#if ENABLE_OVERLOADING+    ActionRowGetIconNameMethodInfo          ,+#endif+    actionRowGetIconName                    ,+++-- ** getSubtitle #method:getSubtitle#++#if ENABLE_OVERLOADING+    ActionRowGetSubtitleMethodInfo          ,+#endif+    actionRowGetSubtitle                    ,+++-- ** getTitle #method:getTitle#++#if ENABLE_OVERLOADING+    ActionRowGetTitleMethodInfo             ,+#endif+    actionRowGetTitle                       ,+++-- ** getUseUnderline #method:getUseUnderline#++#if ENABLE_OVERLOADING+    ActionRowGetUseUnderlineMethodInfo      ,+#endif+    actionRowGetUseUnderline                ,+++-- ** new #method:new#++    actionRowNew                            ,+++-- ** setActivatableWidget #method:setActivatableWidget#++#if ENABLE_OVERLOADING+    ActionRowSetActivatableWidgetMethodInfo ,+#endif+    actionRowSetActivatableWidget           ,+++-- ** setIconName #method:setIconName#++#if ENABLE_OVERLOADING+    ActionRowSetIconNameMethodInfo          ,+#endif+    actionRowSetIconName                    ,+++-- ** setSubtitle #method:setSubtitle#++#if ENABLE_OVERLOADING+    ActionRowSetSubtitleMethodInfo          ,+#endif+    actionRowSetSubtitle                    ,+++-- ** setTitle #method:setTitle#++#if ENABLE_OVERLOADING+    ActionRowSetTitleMethodInfo             ,+#endif+    actionRowSetTitle                       ,+++-- ** setUseUnderline #method:setUseUnderline#++#if ENABLE_OVERLOADING+    ActionRowSetUseUnderlineMethodInfo      ,+#endif+    actionRowSetUseUnderline                ,+++++ -- * Properties+-- ** activatableWidget #attr:activatableWidget#+{- | The activatable widget for this row.++/Since: 0.0.7/+-}+#if ENABLE_OVERLOADING+    ActionRowActivatableWidgetPropertyInfo  ,+#endif+#if ENABLE_OVERLOADING+    actionRowActivatableWidget              ,+#endif+    clearActionRowActivatableWidget         ,+    constructActionRowActivatableWidget     ,+    getActionRowActivatableWidget           ,+    setActionRowActivatableWidget           ,+++-- ** iconName #attr:iconName#+{- | The icon name for this row.++/Since: 0.0.6/+-}+#if ENABLE_OVERLOADING+    ActionRowIconNamePropertyInfo           ,+#endif+#if ENABLE_OVERLOADING+    actionRowIconName                       ,+#endif+    constructActionRowIconName              ,+    getActionRowIconName                    ,+    setActionRowIconName                    ,+++-- ** subtitle #attr:subtitle#+{- | The subtitle for this row.++/Since: 0.0.6/+-}+#if ENABLE_OVERLOADING+    ActionRowSubtitlePropertyInfo           ,+#endif+#if ENABLE_OVERLOADING+    actionRowSubtitle                       ,+#endif+    constructActionRowSubtitle              ,+    getActionRowSubtitle                    ,+    setActionRowSubtitle                    ,+++-- ** title #attr:title#+{- | The title for this row.++/Since: 0.0.6/+-}+#if ENABLE_OVERLOADING+    ActionRowTitlePropertyInfo              ,+#endif+#if ENABLE_OVERLOADING+    actionRowTitle                          ,+#endif+    constructActionRowTitle                 ,+    getActionRowTitle                       ,+    setActionRowTitle                       ,+++-- ** useUnderline #attr:useUnderline#+{- | Whether an embedded underline in the text of the title and subtitle labels+indicates a mnemonic.++/Since: 0.0.6/+-}+#if ENABLE_OVERLOADING+    ActionRowUseUnderlinePropertyInfo       ,+#endif+#if ENABLE_OVERLOADING+    actionRowUseUnderline                   ,+#endif+    constructActionRowUseUnderline          ,+    getActionRowUseUnderline                ,+    setActionRowUseUnderline                ,+++++    ) 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 qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gtk.Interfaces.Actionable as Gtk.Actionable+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable+import qualified GI.Gtk.Objects.Bin as Gtk.Bin+import qualified GI.Gtk.Objects.Container as Gtk.Container+import qualified GI.Gtk.Objects.ListBoxRow as Gtk.ListBoxRow+import qualified GI.Gtk.Objects.Widget as Gtk.Widget++-- | Memory-managed wrapper type.+newtype ActionRow = ActionRow (ManagedPtr ActionRow)+foreign import ccall "hdy_action_row_get_type"+    c_hdy_action_row_get_type :: IO GType++instance GObject ActionRow where+    gobjectType = c_hdy_action_row_get_type+    ++-- | Type class for types which can be safely cast to `ActionRow`, for instance with `toActionRow`.+class (GObject o, O.IsDescendantOf ActionRow o) => IsActionRow o+instance (GObject o, O.IsDescendantOf ActionRow o) => IsActionRow o++instance O.HasParentTypes ActionRow+type instance O.ParentTypes ActionRow = '[Gtk.ListBoxRow.ListBoxRow, Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Actionable.Actionable, Gtk.Buildable.Buildable]++-- | Cast to `ActionRow`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toActionRow :: (MonadIO m, IsActionRow o) => o -> m ActionRow+toActionRow = liftIO . unsafeCastTo ActionRow++-- | A convenience alias for `Nothing` :: `Maybe` `ActionRow`.+noActionRow :: Maybe ActionRow+noActionRow = Nothing++#if ENABLE_OVERLOADING+type family ResolveActionRowMethod (t :: Symbol) (o :: *) :: * where+    ResolveActionRowMethod "activate" o = ActionRowActivateMethodInfo+    ResolveActionRowMethod "add" o = Gtk.Container.ContainerAddMethodInfo+    ResolveActionRowMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo+    ResolveActionRowMethod "addAction" o = ActionRowAddActionMethodInfo+    ResolveActionRowMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo+    ResolveActionRowMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo+    ResolveActionRowMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo+    ResolveActionRowMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo+    ResolveActionRowMethod "addPrefix" o = ActionRowAddPrefixMethodInfo+    ResolveActionRowMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo+    ResolveActionRowMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveActionRowMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveActionRowMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo+    ResolveActionRowMethod "changed" o = Gtk.ListBoxRow.ListBoxRowChangedMethodInfo+    ResolveActionRowMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo+    ResolveActionRowMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo+    ResolveActionRowMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo+    ResolveActionRowMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo+    ResolveActionRowMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo+    ResolveActionRowMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo+    ResolveActionRowMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo+    ResolveActionRowMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo+    ResolveActionRowMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo+    ResolveActionRowMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo+    ResolveActionRowMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo+    ResolveActionRowMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo+    ResolveActionRowMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo+    ResolveActionRowMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo+    ResolveActionRowMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo+    ResolveActionRowMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo+    ResolveActionRowMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo+    ResolveActionRowMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo+    ResolveActionRowMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo+    ResolveActionRowMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo+    ResolveActionRowMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo+    ResolveActionRowMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo+    ResolveActionRowMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo+    ResolveActionRowMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo+    ResolveActionRowMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo+    ResolveActionRowMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo+    ResolveActionRowMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo+    ResolveActionRowMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo+    ResolveActionRowMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo+    ResolveActionRowMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo+    ResolveActionRowMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo+    ResolveActionRowMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo+    ResolveActionRowMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo+    ResolveActionRowMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo+    ResolveActionRowMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo+    ResolveActionRowMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo+    ResolveActionRowMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo+    ResolveActionRowMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo+    ResolveActionRowMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo+    ResolveActionRowMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo+    ResolveActionRowMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo+    ResolveActionRowMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo+    ResolveActionRowMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo+    ResolveActionRowMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo+    ResolveActionRowMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo+    ResolveActionRowMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo+    ResolveActionRowMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo+    ResolveActionRowMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo+    ResolveActionRowMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo+    ResolveActionRowMethod "event" o = Gtk.Widget.WidgetEventMethodInfo+    ResolveActionRowMethod "forall" o = Gtk.Container.ContainerForallMethodInfo+    ResolveActionRowMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveActionRowMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo+    ResolveActionRowMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo+    ResolveActionRowMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveActionRowMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveActionRowMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo+    ResolveActionRowMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo+    ResolveActionRowMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo+    ResolveActionRowMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo+    ResolveActionRowMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo+    ResolveActionRowMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo+    ResolveActionRowMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo+    ResolveActionRowMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo+    ResolveActionRowMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo+    ResolveActionRowMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo+    ResolveActionRowMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo+    ResolveActionRowMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo+    ResolveActionRowMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo+    ResolveActionRowMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo+    ResolveActionRowMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo+    ResolveActionRowMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo+    ResolveActionRowMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo+    ResolveActionRowMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo+    ResolveActionRowMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo+    ResolveActionRowMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo+    ResolveActionRowMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveActionRowMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo+    ResolveActionRowMethod "isSelected" o = Gtk.ListBoxRow.ListBoxRowIsSelectedMethodInfo+    ResolveActionRowMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo+    ResolveActionRowMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo+    ResolveActionRowMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo+    ResolveActionRowMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo+    ResolveActionRowMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo+    ResolveActionRowMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo+    ResolveActionRowMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo+    ResolveActionRowMethod "map" o = Gtk.Widget.WidgetMapMethodInfo+    ResolveActionRowMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo+    ResolveActionRowMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo+    ResolveActionRowMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo+    ResolveActionRowMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo+    ResolveActionRowMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo+    ResolveActionRowMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo+    ResolveActionRowMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo+    ResolveActionRowMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo+    ResolveActionRowMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveActionRowMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveActionRowMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo+    ResolveActionRowMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo+    ResolveActionRowMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo+    ResolveActionRowMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo+    ResolveActionRowMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo+    ResolveActionRowMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo+    ResolveActionRowMethod "path" o = Gtk.Widget.WidgetPathMethodInfo+    ResolveActionRowMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo+    ResolveActionRowMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo+    ResolveActionRowMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo+    ResolveActionRowMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo+    ResolveActionRowMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo+    ResolveActionRowMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo+    ResolveActionRowMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo+    ResolveActionRowMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo+    ResolveActionRowMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo+    ResolveActionRowMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveActionRowMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveActionRowMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo+    ResolveActionRowMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo+    ResolveActionRowMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo+    ResolveActionRowMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo+    ResolveActionRowMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo+    ResolveActionRowMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo+    ResolveActionRowMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo+    ResolveActionRowMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo+    ResolveActionRowMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo+    ResolveActionRowMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo+    ResolveActionRowMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo+    ResolveActionRowMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo+    ResolveActionRowMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveActionRowMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo+    ResolveActionRowMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo+    ResolveActionRowMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo+    ResolveActionRowMethod "show" o = Gtk.Widget.WidgetShowMethodInfo+    ResolveActionRowMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo+    ResolveActionRowMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo+    ResolveActionRowMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo+    ResolveActionRowMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo+    ResolveActionRowMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo+    ResolveActionRowMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveActionRowMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveActionRowMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo+    ResolveActionRowMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo+    ResolveActionRowMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo+    ResolveActionRowMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveActionRowMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo+    ResolveActionRowMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo+    ResolveActionRowMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo+    ResolveActionRowMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo+    ResolveActionRowMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo+    ResolveActionRowMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveActionRowMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo+    ResolveActionRowMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo+    ResolveActionRowMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo+    ResolveActionRowMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveActionRowMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo+    ResolveActionRowMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo+    ResolveActionRowMethod "getActionName" o = Gtk.Actionable.ActionableGetActionNameMethodInfo+    ResolveActionRowMethod "getActionTargetValue" o = Gtk.Actionable.ActionableGetActionTargetValueMethodInfo+    ResolveActionRowMethod "getActivatable" o = Gtk.ListBoxRow.ListBoxRowGetActivatableMethodInfo+    ResolveActionRowMethod "getActivatableWidget" o = ActionRowGetActivatableWidgetMethodInfo+    ResolveActionRowMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo+    ResolveActionRowMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo+    ResolveActionRowMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo+    ResolveActionRowMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo+    ResolveActionRowMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo+    ResolveActionRowMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo+    ResolveActionRowMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo+    ResolveActionRowMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo+    ResolveActionRowMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo+    ResolveActionRowMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo+    ResolveActionRowMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo+    ResolveActionRowMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo+    ResolveActionRowMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo+    ResolveActionRowMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo+    ResolveActionRowMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo+    ResolveActionRowMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo+    ResolveActionRowMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo+    ResolveActionRowMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveActionRowMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo+    ResolveActionRowMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo+    ResolveActionRowMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo+    ResolveActionRowMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo+    ResolveActionRowMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo+    ResolveActionRowMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo+    ResolveActionRowMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo+    ResolveActionRowMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo+    ResolveActionRowMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo+    ResolveActionRowMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo+    ResolveActionRowMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo+    ResolveActionRowMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo+    ResolveActionRowMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo+    ResolveActionRowMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo+    ResolveActionRowMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo+    ResolveActionRowMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo+    ResolveActionRowMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo+    ResolveActionRowMethod "getHeader" o = Gtk.ListBoxRow.ListBoxRowGetHeaderMethodInfo+    ResolveActionRowMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo+    ResolveActionRowMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo+    ResolveActionRowMethod "getIconName" o = ActionRowGetIconNameMethodInfo+    ResolveActionRowMethod "getIndex" o = Gtk.ListBoxRow.ListBoxRowGetIndexMethodInfo+    ResolveActionRowMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo+    ResolveActionRowMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo+    ResolveActionRowMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo+    ResolveActionRowMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo+    ResolveActionRowMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo+    ResolveActionRowMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo+    ResolveActionRowMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo+    ResolveActionRowMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo+    ResolveActionRowMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo+    ResolveActionRowMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo+    ResolveActionRowMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo+    ResolveActionRowMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo+    ResolveActionRowMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo+    ResolveActionRowMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo+    ResolveActionRowMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo+    ResolveActionRowMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo+    ResolveActionRowMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo+    ResolveActionRowMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo+    ResolveActionRowMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo+    ResolveActionRowMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo+    ResolveActionRowMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo+    ResolveActionRowMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo+    ResolveActionRowMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo+    ResolveActionRowMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo+    ResolveActionRowMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo+    ResolveActionRowMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveActionRowMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveActionRowMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo+    ResolveActionRowMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo+    ResolveActionRowMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo+    ResolveActionRowMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo+    ResolveActionRowMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo+    ResolveActionRowMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo+    ResolveActionRowMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo+    ResolveActionRowMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo+    ResolveActionRowMethod "getSelectable" o = Gtk.ListBoxRow.ListBoxRowGetSelectableMethodInfo+    ResolveActionRowMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo+    ResolveActionRowMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo+    ResolveActionRowMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo+    ResolveActionRowMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo+    ResolveActionRowMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo+    ResolveActionRowMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo+    ResolveActionRowMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo+    ResolveActionRowMethod "getSubtitle" o = ActionRowGetSubtitleMethodInfo+    ResolveActionRowMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo+    ResolveActionRowMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo+    ResolveActionRowMethod "getTitle" o = ActionRowGetTitleMethodInfo+    ResolveActionRowMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo+    ResolveActionRowMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo+    ResolveActionRowMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo+    ResolveActionRowMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo+    ResolveActionRowMethod "getUseUnderline" o = ActionRowGetUseUnderlineMethodInfo+    ResolveActionRowMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo+    ResolveActionRowMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo+    ResolveActionRowMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo+    ResolveActionRowMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo+    ResolveActionRowMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo+    ResolveActionRowMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo+    ResolveActionRowMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo+    ResolveActionRowMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo+    ResolveActionRowMethod "setActionName" o = Gtk.Actionable.ActionableSetActionNameMethodInfo+    ResolveActionRowMethod "setActionTargetValue" o = Gtk.Actionable.ActionableSetActionTargetValueMethodInfo+    ResolveActionRowMethod "setActivatable" o = Gtk.ListBoxRow.ListBoxRowSetActivatableMethodInfo+    ResolveActionRowMethod "setActivatableWidget" o = ActionRowSetActivatableWidgetMethodInfo+    ResolveActionRowMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo+    ResolveActionRowMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo+    ResolveActionRowMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo+    ResolveActionRowMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo+    ResolveActionRowMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo+    ResolveActionRowMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo+    ResolveActionRowMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo+    ResolveActionRowMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo+    ResolveActionRowMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo+    ResolveActionRowMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveActionRowMethod "setDetailedActionName" o = Gtk.Actionable.ActionableSetDetailedActionNameMethodInfo+    ResolveActionRowMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo+    ResolveActionRowMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo+    ResolveActionRowMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo+    ResolveActionRowMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo+    ResolveActionRowMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo+    ResolveActionRowMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo+    ResolveActionRowMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo+    ResolveActionRowMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo+    ResolveActionRowMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo+    ResolveActionRowMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo+    ResolveActionRowMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo+    ResolveActionRowMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo+    ResolveActionRowMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo+    ResolveActionRowMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo+    ResolveActionRowMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo+    ResolveActionRowMethod "setHeader" o = Gtk.ListBoxRow.ListBoxRowSetHeaderMethodInfo+    ResolveActionRowMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo+    ResolveActionRowMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo+    ResolveActionRowMethod "setIconName" o = ActionRowSetIconNameMethodInfo+    ResolveActionRowMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo+    ResolveActionRowMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo+    ResolveActionRowMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo+    ResolveActionRowMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo+    ResolveActionRowMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo+    ResolveActionRowMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo+    ResolveActionRowMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo+    ResolveActionRowMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo+    ResolveActionRowMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo+    ResolveActionRowMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo+    ResolveActionRowMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo+    ResolveActionRowMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo+    ResolveActionRowMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveActionRowMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo+    ResolveActionRowMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo+    ResolveActionRowMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo+    ResolveActionRowMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo+    ResolveActionRowMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo+    ResolveActionRowMethod "setSelectable" o = Gtk.ListBoxRow.ListBoxRowSetSelectableMethodInfo+    ResolveActionRowMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo+    ResolveActionRowMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo+    ResolveActionRowMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo+    ResolveActionRowMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo+    ResolveActionRowMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo+    ResolveActionRowMethod "setSubtitle" o = ActionRowSetSubtitleMethodInfo+    ResolveActionRowMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo+    ResolveActionRowMethod "setTitle" o = ActionRowSetTitleMethodInfo+    ResolveActionRowMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo+    ResolveActionRowMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo+    ResolveActionRowMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo+    ResolveActionRowMethod "setUseUnderline" o = ActionRowSetUseUnderlineMethodInfo+    ResolveActionRowMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo+    ResolveActionRowMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo+    ResolveActionRowMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo+    ResolveActionRowMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo+    ResolveActionRowMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo+    ResolveActionRowMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo+    ResolveActionRowMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveActionRowMethod t ActionRow, O.MethodInfo info ActionRow p) => OL.IsLabel t (ActionRow -> 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 "activatable-widget"+   -- Type: TInterface (Name {namespace = "Gtk", name = "Widget"})+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just True,Just True)++{- |+Get the value of the “@activatable-widget@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' actionRow #activatableWidget+@+-}+getActionRowActivatableWidget :: (MonadIO m, IsActionRow o) => o -> m (Maybe Gtk.Widget.Widget)+getActionRowActivatableWidget obj = liftIO $ B.Properties.getObjectPropertyObject obj "activatable-widget" Gtk.Widget.Widget++{- |+Set the value of the “@activatable-widget@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' actionRow [ #activatableWidget 'Data.GI.Base.Attributes.:=' value ]+@+-}+setActionRowActivatableWidget :: (MonadIO m, IsActionRow o, Gtk.Widget.IsWidget a) => o -> a -> m ()+setActionRowActivatableWidget obj val = liftIO $ B.Properties.setObjectPropertyObject obj "activatable-widget" (Just val)++{- |+Construct a `GValueConstruct` with valid value for the “@activatable-widget@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructActionRowActivatableWidget :: (IsActionRow o, Gtk.Widget.IsWidget a) => a -> IO (GValueConstruct o)+constructActionRowActivatableWidget val = B.Properties.constructObjectPropertyObject "activatable-widget" (Just val)++{- |+Set the value of the “@activatable-widget@” property to `Nothing`.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.clear' #activatableWidget+@+-}+clearActionRowActivatableWidget :: (MonadIO m, IsActionRow o) => o -> m ()+clearActionRowActivatableWidget obj = liftIO $ B.Properties.setObjectPropertyObject obj "activatable-widget" (Nothing :: Maybe Gtk.Widget.Widget)++#if ENABLE_OVERLOADING+data ActionRowActivatableWidgetPropertyInfo+instance AttrInfo ActionRowActivatableWidgetPropertyInfo where+    type AttrAllowedOps ActionRowActivatableWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint ActionRowActivatableWidgetPropertyInfo = Gtk.Widget.IsWidget+    type AttrBaseTypeConstraint ActionRowActivatableWidgetPropertyInfo = IsActionRow+    type AttrGetType ActionRowActivatableWidgetPropertyInfo = (Maybe Gtk.Widget.Widget)+    type AttrLabel ActionRowActivatableWidgetPropertyInfo = "activatable-widget"+    type AttrOrigin ActionRowActivatableWidgetPropertyInfo = ActionRow+    attrGet _ = getActionRowActivatableWidget+    attrSet _ = setActionRowActivatableWidget+    attrConstruct _ = constructActionRowActivatableWidget+    attrClear _ = clearActionRowActivatableWidget+#endif++-- VVV Prop "icon-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@icon-name@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' actionRow #iconName+@+-}+getActionRowIconName :: (MonadIO m, IsActionRow o) => o -> m T.Text+getActionRowIconName obj = liftIO $ checkUnexpectedNothing "getActionRowIconName" $ B.Properties.getObjectPropertyString obj "icon-name"++{- |+Set the value of the “@icon-name@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' actionRow [ #iconName 'Data.GI.Base.Attributes.:=' value ]+@+-}+setActionRowIconName :: (MonadIO m, IsActionRow o) => o -> T.Text -> m ()+setActionRowIconName obj val = liftIO $ B.Properties.setObjectPropertyString obj "icon-name" (Just val)++{- |+Construct a `GValueConstruct` with valid value for the “@icon-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructActionRowIconName :: (IsActionRow o) => T.Text -> IO (GValueConstruct o)+constructActionRowIconName val = B.Properties.constructObjectPropertyString "icon-name" (Just val)++#if ENABLE_OVERLOADING+data ActionRowIconNamePropertyInfo+instance AttrInfo ActionRowIconNamePropertyInfo where+    type AttrAllowedOps ActionRowIconNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionRowIconNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ActionRowIconNamePropertyInfo = IsActionRow+    type AttrGetType ActionRowIconNamePropertyInfo = T.Text+    type AttrLabel ActionRowIconNamePropertyInfo = "icon-name"+    type AttrOrigin ActionRowIconNamePropertyInfo = ActionRow+    attrGet _ = getActionRowIconName+    attrSet _ = setActionRowIconName+    attrConstruct _ = constructActionRowIconName+    attrClear _ = undefined+#endif++-- VVV Prop "subtitle"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@subtitle@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' actionRow #subtitle+@+-}+getActionRowSubtitle :: (MonadIO m, IsActionRow o) => o -> m T.Text+getActionRowSubtitle obj = liftIO $ checkUnexpectedNothing "getActionRowSubtitle" $ B.Properties.getObjectPropertyString obj "subtitle"++{- |+Set the value of the “@subtitle@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' actionRow [ #subtitle 'Data.GI.Base.Attributes.:=' value ]+@+-}+setActionRowSubtitle :: (MonadIO m, IsActionRow o) => o -> T.Text -> m ()+setActionRowSubtitle obj val = liftIO $ B.Properties.setObjectPropertyString obj "subtitle" (Just val)++{- |+Construct a `GValueConstruct` with valid value for the “@subtitle@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructActionRowSubtitle :: (IsActionRow o) => T.Text -> IO (GValueConstruct o)+constructActionRowSubtitle val = B.Properties.constructObjectPropertyString "subtitle" (Just val)++#if ENABLE_OVERLOADING+data ActionRowSubtitlePropertyInfo+instance AttrInfo ActionRowSubtitlePropertyInfo where+    type AttrAllowedOps ActionRowSubtitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionRowSubtitlePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ActionRowSubtitlePropertyInfo = IsActionRow+    type AttrGetType ActionRowSubtitlePropertyInfo = T.Text+    type AttrLabel ActionRowSubtitlePropertyInfo = "subtitle"+    type AttrOrigin ActionRowSubtitlePropertyInfo = ActionRow+    attrGet _ = getActionRowSubtitle+    attrSet _ = setActionRowSubtitle+    attrConstruct _ = constructActionRowSubtitle+    attrClear _ = undefined+#endif++-- VVV Prop "title"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@title@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' actionRow #title+@+-}+getActionRowTitle :: (MonadIO m, IsActionRow o) => o -> m T.Text+getActionRowTitle obj = liftIO $ checkUnexpectedNothing "getActionRowTitle" $ B.Properties.getObjectPropertyString obj "title"++{- |+Set the value of the “@title@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' actionRow [ #title 'Data.GI.Base.Attributes.:=' value ]+@+-}+setActionRowTitle :: (MonadIO m, IsActionRow o) => o -> T.Text -> m ()+setActionRowTitle obj val = liftIO $ B.Properties.setObjectPropertyString obj "title" (Just val)++{- |+Construct a `GValueConstruct` with valid value for the “@title@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructActionRowTitle :: (IsActionRow o) => T.Text -> IO (GValueConstruct o)+constructActionRowTitle val = B.Properties.constructObjectPropertyString "title" (Just val)++#if ENABLE_OVERLOADING+data ActionRowTitlePropertyInfo+instance AttrInfo ActionRowTitlePropertyInfo where+    type AttrAllowedOps ActionRowTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionRowTitlePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ActionRowTitlePropertyInfo = IsActionRow+    type AttrGetType ActionRowTitlePropertyInfo = T.Text+    type AttrLabel ActionRowTitlePropertyInfo = "title"+    type AttrOrigin ActionRowTitlePropertyInfo = ActionRow+    attrGet _ = getActionRowTitle+    attrSet _ = setActionRowTitle+    attrConstruct _ = constructActionRowTitle+    attrClear _ = undefined+#endif++-- VVV Prop "use-underline"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@use-underline@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' actionRow #useUnderline+@+-}+getActionRowUseUnderline :: (MonadIO m, IsActionRow o) => o -> m Bool+getActionRowUseUnderline obj = liftIO $ B.Properties.getObjectPropertyBool obj "use-underline"++{- |+Set the value of the “@use-underline@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' actionRow [ #useUnderline 'Data.GI.Base.Attributes.:=' value ]+@+-}+setActionRowUseUnderline :: (MonadIO m, IsActionRow o) => o -> Bool -> m ()+setActionRowUseUnderline obj val = liftIO $ B.Properties.setObjectPropertyBool obj "use-underline" val++{- |+Construct a `GValueConstruct` with valid value for the “@use-underline@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructActionRowUseUnderline :: (IsActionRow o) => Bool -> IO (GValueConstruct o)+constructActionRowUseUnderline val = B.Properties.constructObjectPropertyBool "use-underline" val++#if ENABLE_OVERLOADING+data ActionRowUseUnderlinePropertyInfo+instance AttrInfo ActionRowUseUnderlinePropertyInfo where+    type AttrAllowedOps ActionRowUseUnderlinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionRowUseUnderlinePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ActionRowUseUnderlinePropertyInfo = IsActionRow+    type AttrGetType ActionRowUseUnderlinePropertyInfo = Bool+    type AttrLabel ActionRowUseUnderlinePropertyInfo = "use-underline"+    type AttrOrigin ActionRowUseUnderlinePropertyInfo = ActionRow+    attrGet _ = getActionRowUseUnderline+    attrSet _ = setActionRowUseUnderline+    attrConstruct _ = constructActionRowUseUnderline+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList ActionRow+type instance O.AttributeList ActionRow = ActionRowAttributeList+type ActionRowAttributeList = ('[ '("actionName", Gtk.Actionable.ActionableActionNamePropertyInfo), '("actionTarget", Gtk.Actionable.ActionableActionTargetPropertyInfo), '("activatable", Gtk.ListBoxRow.ListBoxRowActivatablePropertyInfo), '("activatableWidget", ActionRowActivatableWidgetPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("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), '("iconName", ActionRowIconNamePropertyInfo), '("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), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("selectable", Gtk.ListBoxRow.ListBoxRowSelectablePropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("subtitle", ActionRowSubtitlePropertyInfo), '("title", ActionRowTitlePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("useUnderline", ActionRowUseUnderlinePropertyInfo), '("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+actionRowActivatableWidget :: AttrLabelProxy "activatableWidget"+actionRowActivatableWidget = AttrLabelProxy++actionRowIconName :: AttrLabelProxy "iconName"+actionRowIconName = AttrLabelProxy++actionRowSubtitle :: AttrLabelProxy "subtitle"+actionRowSubtitle = AttrLabelProxy++actionRowTitle :: AttrLabelProxy "title"+actionRowTitle = AttrLabelProxy++actionRowUseUnderline :: AttrLabelProxy "useUnderline"+actionRowUseUnderline = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList ActionRow = ActionRowSignalList+type ActionRowSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("activate", Gtk.ListBoxRow.ListBoxRowActivateSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("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), '("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), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("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), '("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 ActionRow::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "ActionRow"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_action_row_new" hdy_action_row_new :: +    IO (Ptr ActionRow)++{- |+Creates a new 'GI.Handy.Objects.ActionRow.ActionRow'.++/Since: 0.0.6/+-}+actionRowNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m ActionRow+    {- ^ __Returns:__ a new 'GI.Handy.Objects.ActionRow.ActionRow' -}+actionRowNew  = liftIO $ do+    result <- hdy_action_row_new+    checkUnexpectedReturnNULL "actionRowNew" result+    result' <- (newObject ActionRow) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method ActionRow::activate+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ActionRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_action_row_activate" hdy_action_row_activate :: +    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Handy", name = "ActionRow"})+    IO ()++{- |+/No description available in the introspection data./+-}+actionRowActivate ::+    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>+    a+    -> m ()+actionRowActivate self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    hdy_action_row_activate self'+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data ActionRowActivateMethodInfo+instance (signature ~ (m ()), MonadIO m, IsActionRow a) => O.MethodInfo ActionRowActivateMethodInfo a signature where+    overloadedMethod _ = actionRowActivate++#endif++-- method ActionRow::add_action+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ActionRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyActionRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the action widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_action_row_add_action" hdy_action_row_add_action :: +    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Handy", name = "ActionRow"})+    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})+    IO ()++{- |+Adds an action widget to /@self@/.++/Since: 0.0.6/+-}+actionRowAddAction ::+    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a, Gtk.Widget.IsWidget b) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ActionRow.ActionRow' -}+    -> Maybe (b)+    {- ^ /@widget@/: the action widget -}+    -> m ()+actionRowAddAction self widget = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            jWidget' <- unsafeManagedPtrCastPtr jWidget+            return jWidget'+    hdy_action_row_add_action self' maybeWidget+    touchManagedPtr self+    whenJust widget touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+data ActionRowAddActionMethodInfo+instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsActionRow a, Gtk.Widget.IsWidget b) => O.MethodInfo ActionRowAddActionMethodInfo a signature where+    overloadedMethod _ = actionRowAddAction++#endif++-- method ActionRow::add_prefix+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ActionRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyActionRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the prefix widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_action_row_add_prefix" hdy_action_row_add_prefix :: +    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Handy", name = "ActionRow"})+    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})+    IO ()++{- |+Adds a prefix widget to /@self@/.++/Since: 0.0.6/+-}+actionRowAddPrefix ::+    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a, Gtk.Widget.IsWidget b) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ActionRow.ActionRow' -}+    -> Maybe (b)+    {- ^ /@widget@/: the prefix widget -}+    -> m ()+actionRowAddPrefix self widget = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            jWidget' <- unsafeManagedPtrCastPtr jWidget+            return jWidget'+    hdy_action_row_add_prefix self' maybeWidget+    touchManagedPtr self+    whenJust widget touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+data ActionRowAddPrefixMethodInfo+instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsActionRow a, Gtk.Widget.IsWidget b) => O.MethodInfo ActionRowAddPrefixMethodInfo a signature where+    overloadedMethod _ = actionRowAddPrefix++#endif++-- method ActionRow::get_activatable_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ActionRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyActionRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Widget"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_action_row_get_activatable_widget" hdy_action_row_get_activatable_widget :: +    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Handy", name = "ActionRow"})+    IO (Ptr Gtk.Widget.Widget)++{- |+Gets the widget activated when /@self@/ is activated.++/Since: 0.0.7/+-}+actionRowGetActivatableWidget ::+    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ActionRow.ActionRow' -}+    -> m (Maybe Gtk.Widget.Widget)+    {- ^ __Returns:__ the widget activated when /@self@/ is+         activated, or 'Nothing' if none has been set. -}+actionRowGetActivatableWidget self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_action_row_get_activatable_widget self'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (newObject Gtk.Widget.Widget) result'+        return result''+    touchManagedPtr self+    return maybeResult++#if ENABLE_OVERLOADING+data ActionRowGetActivatableWidgetMethodInfo+instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsActionRow a) => O.MethodInfo ActionRowGetActivatableWidgetMethodInfo a signature where+    overloadedMethod _ = actionRowGetActivatableWidget++#endif++-- method ActionRow::get_icon_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ActionRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyActionRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_action_row_get_icon_name" hdy_action_row_get_icon_name :: +    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Handy", name = "ActionRow"})+    IO CString++{- |+Gets the icon name for /@self@/.++/Since: 0.0.6/+-}+actionRowGetIconName ::+    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ActionRow.ActionRow' -}+    -> m T.Text+    {- ^ __Returns:__ the icon name for /@self@/. -}+actionRowGetIconName self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_action_row_get_icon_name self'+    checkUnexpectedReturnNULL "actionRowGetIconName" result+    result' <- cstringToText result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data ActionRowGetIconNameMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsActionRow a) => O.MethodInfo ActionRowGetIconNameMethodInfo a signature where+    overloadedMethod _ = actionRowGetIconName++#endif++-- method ActionRow::get_subtitle+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ActionRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyActionRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_action_row_get_subtitle" hdy_action_row_get_subtitle :: +    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Handy", name = "ActionRow"})+    IO CString++{- |+Gets the subtitle for /@self@/.++/Since: 0.0.6/+-}+actionRowGetSubtitle ::+    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ActionRow.ActionRow' -}+    -> m T.Text+    {- ^ __Returns:__ the subtitle for /@self@/. -}+actionRowGetSubtitle self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_action_row_get_subtitle self'+    checkUnexpectedReturnNULL "actionRowGetSubtitle" result+    result' <- cstringToText result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data ActionRowGetSubtitleMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsActionRow a) => O.MethodInfo ActionRowGetSubtitleMethodInfo a signature where+    overloadedMethod _ = actionRowGetSubtitle++#endif++-- method ActionRow::get_title+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ActionRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyActionRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_action_row_get_title" hdy_action_row_get_title :: +    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Handy", name = "ActionRow"})+    IO CString++{- |+Gets the title for /@self@/.++/Since: 0.0.6/+-}+actionRowGetTitle ::+    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ActionRow.ActionRow' -}+    -> m T.Text+    {- ^ __Returns:__ the title for /@self@/. -}+actionRowGetTitle self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_action_row_get_title self'+    checkUnexpectedReturnNULL "actionRowGetTitle" result+    result' <- cstringToText result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data ActionRowGetTitleMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsActionRow a) => O.MethodInfo ActionRowGetTitleMethodInfo a signature where+    overloadedMethod _ = actionRowGetTitle++#endif++-- method ActionRow::get_use_underline+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ActionRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyActionRow", 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 "hdy_action_row_get_use_underline" hdy_action_row_get_use_underline :: +    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Handy", name = "ActionRow"})+    IO CInt++{- |+Gets whether an embedded underline in the text of the title and subtitle+labels indicates a mnemonic. See 'GI.Handy.Objects.ActionRow.actionRowSetUseUnderline'.++/Since: 0.0.6/+-}+actionRowGetUseUnderline ::+    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ActionRow.ActionRow' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if an embedded underline in the title and subtitle labels+         indicates the mnemonic accelerator keys. -}+actionRowGetUseUnderline self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_action_row_get_use_underline self'+    let result' = (/= 0) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data ActionRowGetUseUnderlineMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsActionRow a) => O.MethodInfo ActionRowGetUseUnderlineMethodInfo a signature where+    overloadedMethod _ = actionRowGetUseUnderline++#endif++-- method ActionRow::set_activatable_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ActionRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyActionRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the target #GtkWidget, or %NULL to unset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_action_row_set_activatable_widget" hdy_action_row_set_activatable_widget :: +    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Handy", name = "ActionRow"})+    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})+    IO ()++{- |+Sets the widget to activate when /@self@/ is activated, either by clicking+on it, by calling 'GI.Handy.Objects.ActionRow.actionRowActivate', or via mnemonics in the title or+the subtitle. See the “use_underline” property to enable mnemonics.++The target widget will be activated by emitting the+GtkWidget::mnemonic-activate signal on it.++/Since: 0.0.7/+-}+actionRowSetActivatableWidget ::+    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a, Gtk.Widget.IsWidget b) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ActionRow.ActionRow' -}+    -> Maybe (b)+    {- ^ /@widget@/: the target 'GI.Gtk.Objects.Widget.Widget', or 'Nothing' to unset -}+    -> m ()+actionRowSetActivatableWidget self widget = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            jWidget' <- unsafeManagedPtrCastPtr jWidget+            return jWidget'+    hdy_action_row_set_activatable_widget self' maybeWidget+    touchManagedPtr self+    whenJust widget touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+data ActionRowSetActivatableWidgetMethodInfo+instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsActionRow a, Gtk.Widget.IsWidget b) => O.MethodInfo ActionRowSetActivatableWidgetMethodInfo a signature where+    overloadedMethod _ = actionRowSetActivatableWidget++#endif++-- method ActionRow::set_icon_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ActionRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyActionRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "icon_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the icon name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_action_row_set_icon_name" hdy_action_row_set_icon_name :: +    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Handy", name = "ActionRow"})+    CString ->                              -- icon_name : TBasicType TUTF8+    IO ()++{- |+Sets the icon name for /@self@/.++/Since: 0.0.6/+-}+actionRowSetIconName ::+    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ActionRow.ActionRow' -}+    -> T.Text+    {- ^ /@iconName@/: the icon name -}+    -> m ()+actionRowSetIconName self iconName = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    iconName' <- textToCString iconName+    hdy_action_row_set_icon_name self' iconName'+    touchManagedPtr self+    freeMem iconName'+    return ()++#if ENABLE_OVERLOADING+data ActionRowSetIconNameMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m, IsActionRow a) => O.MethodInfo ActionRowSetIconNameMethodInfo a signature where+    overloadedMethod _ = actionRowSetIconName++#endif++-- method ActionRow::set_subtitle+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ActionRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyActionRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "subtitle", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the subtitle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_action_row_set_subtitle" hdy_action_row_set_subtitle :: +    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Handy", name = "ActionRow"})+    CString ->                              -- subtitle : TBasicType TUTF8+    IO ()++{- |+Sets the subtitle for /@self@/.++/Since: 0.0.6/+-}+actionRowSetSubtitle ::+    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ActionRow.ActionRow' -}+    -> T.Text+    {- ^ /@subtitle@/: the subtitle -}+    -> m ()+actionRowSetSubtitle self subtitle = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    subtitle' <- textToCString subtitle+    hdy_action_row_set_subtitle self' subtitle'+    touchManagedPtr self+    freeMem subtitle'+    return ()++#if ENABLE_OVERLOADING+data ActionRowSetSubtitleMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m, IsActionRow a) => O.MethodInfo ActionRowSetSubtitleMethodInfo a signature where+    overloadedMethod _ = actionRowSetSubtitle++#endif++-- method ActionRow::set_title+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ActionRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyActionRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "title", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the title", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_action_row_set_title" hdy_action_row_set_title :: +    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Handy", name = "ActionRow"})+    CString ->                              -- title : TBasicType TUTF8+    IO ()++{- |+Sets the title for /@self@/.++/Since: 0.0.6/+-}+actionRowSetTitle ::+    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ActionRow.ActionRow' -}+    -> T.Text+    {- ^ /@title@/: the title -}+    -> m ()+actionRowSetTitle self title = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    title' <- textToCString title+    hdy_action_row_set_title self' title'+    touchManagedPtr self+    freeMem title'+    return ()++#if ENABLE_OVERLOADING+data ActionRowSetTitleMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m, IsActionRow a) => O.MethodInfo ActionRowSetTitleMethodInfo a signature where+    overloadedMethod _ = actionRowSetTitle++#endif++-- method ActionRow::set_use_underline+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ActionRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyActionRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "use_underline", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if underlines in the text indicate mnemonics", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_action_row_set_use_underline" hdy_action_row_set_use_underline :: +    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Handy", name = "ActionRow"})+    CInt ->                                 -- use_underline : TBasicType TBoolean+    IO ()++{- |+If true, an underline in the text of the title and subtitle labels indicates+the next character should be used for the mnemonic accelerator key.++/Since: 0.0.6/+-}+actionRowSetUseUnderline ::+    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ActionRow.ActionRow' -}+    -> Bool+    {- ^ /@useUnderline@/: 'True' if underlines in the text indicate mnemonics -}+    -> m ()+actionRowSetUseUnderline self useUnderline = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    let useUnderline' = (fromIntegral . fromEnum) useUnderline+    hdy_action_row_set_use_underline self' useUnderline'+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data ActionRowSetUseUnderlineMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsActionRow a) => O.MethodInfo ActionRowSetUseUnderlineMethodInfo a signature where+    overloadedMethod _ = actionRowSetUseUnderline++#endif++
+ GI/Handy/Objects/ActionRow.hs-boot view
@@ -0,0 +1,83 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Handy.Objects.ActionRow 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 ActionRow = ActionRow (ManagedPtr ActionRow)+instance GObject ActionRow where+class (GObject o, O.IsDescendantOf ActionRow o) => IsActionRow o+instance (GObject o, O.IsDescendantOf ActionRow o) => IsActionRow o+instance O.HasParentTypes ActionRow+#if ENABLE_OVERLOADING+data ActionRowActivatableWidgetPropertyInfo+#endif+#if ENABLE_OVERLOADING+data ActionRowIconNamePropertyInfo+#endif+#if ENABLE_OVERLOADING+data ActionRowSubtitlePropertyInfo+#endif+#if ENABLE_OVERLOADING+data ActionRowTitlePropertyInfo+#endif+#if ENABLE_OVERLOADING+data ActionRowUseUnderlinePropertyInfo+#endif+#if ENABLE_OVERLOADING+data ActionRowActivateMethodInfo+#endif+#if ENABLE_OVERLOADING+data ActionRowAddActionMethodInfo+#endif+#if ENABLE_OVERLOADING+data ActionRowAddPrefixMethodInfo+#endif+#if ENABLE_OVERLOADING+data ActionRowGetActivatableWidgetMethodInfo+#endif+#if ENABLE_OVERLOADING+data ActionRowGetIconNameMethodInfo+#endif+#if ENABLE_OVERLOADING+data ActionRowGetSubtitleMethodInfo+#endif+#if ENABLE_OVERLOADING+data ActionRowGetTitleMethodInfo+#endif+#if ENABLE_OVERLOADING+data ActionRowGetUseUnderlineMethodInfo+#endif+#if ENABLE_OVERLOADING+data ActionRowSetActivatableWidgetMethodInfo+#endif+#if ENABLE_OVERLOADING+data ActionRowSetIconNameMethodInfo+#endif+#if ENABLE_OVERLOADING+data ActionRowSetSubtitleMethodInfo+#endif+#if ENABLE_OVERLOADING+data ActionRowSetTitleMethodInfo+#endif+#if ENABLE_OVERLOADING+data ActionRowSetUseUnderlineMethodInfo+#endif
+ GI/Handy/Objects/Arrows.hs view
@@ -0,0 +1,934 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Handy.Objects.Arrows+    ( ++-- * Exported types+    Arrows(..)                              ,+    IsArrows                                ,+    toArrows                                ,+    noArrows                                ,+++ -- * Methods+-- ** animate #method:animate#++#if ENABLE_OVERLOADING+    ArrowsAnimateMethodInfo                 ,+#endif+    arrowsAnimate                           ,+++-- ** getCount #method:getCount#++#if ENABLE_OVERLOADING+    ArrowsGetCountMethodInfo                ,+#endif+    arrowsGetCount                          ,+++-- ** getDirection #method:getDirection#++#if ENABLE_OVERLOADING+    ArrowsGetDirectionMethodInfo            ,+#endif+    arrowsGetDirection                      ,+++-- ** getDuration #method:getDuration#++#if ENABLE_OVERLOADING+    ArrowsGetDurationMethodInfo             ,+#endif+    arrowsGetDuration                       ,+++-- ** new #method:new#++    arrowsNew                               ,+++-- ** setCount #method:setCount#++#if ENABLE_OVERLOADING+    ArrowsSetCountMethodInfo                ,+#endif+    arrowsSetCount                          ,+++-- ** setDirection #method:setDirection#++#if ENABLE_OVERLOADING+    ArrowsSetDirectionMethodInfo            ,+#endif+    arrowsSetDirection                      ,+++-- ** setDuration #method:setDuration#++#if ENABLE_OVERLOADING+    ArrowsSetDurationMethodInfo             ,+#endif+    arrowsSetDuration                       ,+++++ -- * Properties+-- ** count #attr:count#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    ArrowsCountPropertyInfo                 ,+#endif+#if ENABLE_OVERLOADING+    arrowsCount                             ,+#endif+    constructArrowsCount                    ,+    getArrowsCount                          ,+    setArrowsCount                          ,+++-- ** direction #attr:direction#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    ArrowsDirectionPropertyInfo             ,+#endif+#if ENABLE_OVERLOADING+    arrowsDirection                         ,+#endif+    constructArrowsDirection                ,+    getArrowsDirection                      ,+    setArrowsDirection                      ,+++-- ** duration #attr:duration#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    ArrowsDurationPropertyInfo              ,+#endif+#if ENABLE_OVERLOADING+    arrowsDuration                          ,+#endif+    constructArrowsDuration                 ,+    getArrowsDuration                       ,+    setArrowsDuration                       ,+++++    ) 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 qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable+import qualified GI.Gtk.Objects.DrawingArea as Gtk.DrawingArea+import qualified GI.Gtk.Objects.Widget as Gtk.Widget+import {-# SOURCE #-} qualified GI.Handy.Enums as Handy.Enums++-- | Memory-managed wrapper type.+newtype Arrows = Arrows (ManagedPtr Arrows)+foreign import ccall "hdy_arrows_get_type"+    c_hdy_arrows_get_type :: IO GType++instance GObject Arrows where+    gobjectType = c_hdy_arrows_get_type+    ++-- | Type class for types which can be safely cast to `Arrows`, for instance with `toArrows`.+class (GObject o, O.IsDescendantOf Arrows o) => IsArrows o+instance (GObject o, O.IsDescendantOf Arrows o) => IsArrows o++instance O.HasParentTypes Arrows+type instance O.ParentTypes Arrows = '[Gtk.DrawingArea.DrawingArea, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable]++-- | Cast to `Arrows`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toArrows :: (MonadIO m, IsArrows o) => o -> m Arrows+toArrows = liftIO . unsafeCastTo Arrows++-- | A convenience alias for `Nothing` :: `Maybe` `Arrows`.+noArrows :: Maybe Arrows+noArrows = Nothing++#if ENABLE_OVERLOADING+type family ResolveArrowsMethod (t :: Symbol) (o :: *) :: * where+    ResolveArrowsMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo+    ResolveArrowsMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo+    ResolveArrowsMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo+    ResolveArrowsMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo+    ResolveArrowsMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo+    ResolveArrowsMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo+    ResolveArrowsMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo+    ResolveArrowsMethod "animate" o = ArrowsAnimateMethodInfo+    ResolveArrowsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveArrowsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveArrowsMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo+    ResolveArrowsMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo+    ResolveArrowsMethod "childNotify" o = Gtk.Widget.WidgetChildNotifyMethodInfo+    ResolveArrowsMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo+    ResolveArrowsMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo+    ResolveArrowsMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo+    ResolveArrowsMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo+    ResolveArrowsMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo+    ResolveArrowsMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo+    ResolveArrowsMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo+    ResolveArrowsMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo+    ResolveArrowsMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo+    ResolveArrowsMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo+    ResolveArrowsMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo+    ResolveArrowsMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo+    ResolveArrowsMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo+    ResolveArrowsMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo+    ResolveArrowsMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo+    ResolveArrowsMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo+    ResolveArrowsMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo+    ResolveArrowsMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo+    ResolveArrowsMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo+    ResolveArrowsMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo+    ResolveArrowsMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo+    ResolveArrowsMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo+    ResolveArrowsMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo+    ResolveArrowsMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo+    ResolveArrowsMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo+    ResolveArrowsMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo+    ResolveArrowsMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo+    ResolveArrowsMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo+    ResolveArrowsMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo+    ResolveArrowsMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo+    ResolveArrowsMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo+    ResolveArrowsMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo+    ResolveArrowsMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo+    ResolveArrowsMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo+    ResolveArrowsMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo+    ResolveArrowsMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo+    ResolveArrowsMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo+    ResolveArrowsMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo+    ResolveArrowsMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo+    ResolveArrowsMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo+    ResolveArrowsMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo+    ResolveArrowsMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo+    ResolveArrowsMethod "event" o = Gtk.Widget.WidgetEventMethodInfo+    ResolveArrowsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveArrowsMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo+    ResolveArrowsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveArrowsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveArrowsMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo+    ResolveArrowsMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo+    ResolveArrowsMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo+    ResolveArrowsMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo+    ResolveArrowsMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo+    ResolveArrowsMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo+    ResolveArrowsMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo+    ResolveArrowsMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo+    ResolveArrowsMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo+    ResolveArrowsMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo+    ResolveArrowsMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo+    ResolveArrowsMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo+    ResolveArrowsMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo+    ResolveArrowsMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo+    ResolveArrowsMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo+    ResolveArrowsMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo+    ResolveArrowsMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo+    ResolveArrowsMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo+    ResolveArrowsMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo+    ResolveArrowsMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo+    ResolveArrowsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveArrowsMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo+    ResolveArrowsMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo+    ResolveArrowsMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo+    ResolveArrowsMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo+    ResolveArrowsMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo+    ResolveArrowsMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo+    ResolveArrowsMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo+    ResolveArrowsMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo+    ResolveArrowsMethod "map" o = Gtk.Widget.WidgetMapMethodInfo+    ResolveArrowsMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo+    ResolveArrowsMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo+    ResolveArrowsMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo+    ResolveArrowsMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo+    ResolveArrowsMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo+    ResolveArrowsMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo+    ResolveArrowsMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo+    ResolveArrowsMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo+    ResolveArrowsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveArrowsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveArrowsMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo+    ResolveArrowsMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo+    ResolveArrowsMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo+    ResolveArrowsMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo+    ResolveArrowsMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo+    ResolveArrowsMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo+    ResolveArrowsMethod "path" o = Gtk.Widget.WidgetPathMethodInfo+    ResolveArrowsMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo+    ResolveArrowsMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo+    ResolveArrowsMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo+    ResolveArrowsMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo+    ResolveArrowsMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo+    ResolveArrowsMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo+    ResolveArrowsMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo+    ResolveArrowsMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo+    ResolveArrowsMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveArrowsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveArrowsMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo+    ResolveArrowsMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo+    ResolveArrowsMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo+    ResolveArrowsMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo+    ResolveArrowsMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo+    ResolveArrowsMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo+    ResolveArrowsMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo+    ResolveArrowsMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo+    ResolveArrowsMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo+    ResolveArrowsMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo+    ResolveArrowsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveArrowsMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo+    ResolveArrowsMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo+    ResolveArrowsMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo+    ResolveArrowsMethod "show" o = Gtk.Widget.WidgetShowMethodInfo+    ResolveArrowsMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo+    ResolveArrowsMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo+    ResolveArrowsMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo+    ResolveArrowsMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo+    ResolveArrowsMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo+    ResolveArrowsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveArrowsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveArrowsMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo+    ResolveArrowsMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo+    ResolveArrowsMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo+    ResolveArrowsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveArrowsMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo+    ResolveArrowsMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo+    ResolveArrowsMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo+    ResolveArrowsMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo+    ResolveArrowsMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo+    ResolveArrowsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveArrowsMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo+    ResolveArrowsMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo+    ResolveArrowsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveArrowsMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo+    ResolveArrowsMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo+    ResolveArrowsMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo+    ResolveArrowsMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo+    ResolveArrowsMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo+    ResolveArrowsMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo+    ResolveArrowsMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo+    ResolveArrowsMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo+    ResolveArrowsMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo+    ResolveArrowsMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo+    ResolveArrowsMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo+    ResolveArrowsMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo+    ResolveArrowsMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo+    ResolveArrowsMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo+    ResolveArrowsMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo+    ResolveArrowsMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo+    ResolveArrowsMethod "getCount" o = ArrowsGetCountMethodInfo+    ResolveArrowsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveArrowsMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo+    ResolveArrowsMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo+    ResolveArrowsMethod "getDirection" o = ArrowsGetDirectionMethodInfo+    ResolveArrowsMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo+    ResolveArrowsMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo+    ResolveArrowsMethod "getDuration" o = ArrowsGetDurationMethodInfo+    ResolveArrowsMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo+    ResolveArrowsMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo+    ResolveArrowsMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo+    ResolveArrowsMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo+    ResolveArrowsMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo+    ResolveArrowsMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo+    ResolveArrowsMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo+    ResolveArrowsMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo+    ResolveArrowsMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo+    ResolveArrowsMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo+    ResolveArrowsMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo+    ResolveArrowsMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo+    ResolveArrowsMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo+    ResolveArrowsMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo+    ResolveArrowsMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo+    ResolveArrowsMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo+    ResolveArrowsMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo+    ResolveArrowsMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo+    ResolveArrowsMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo+    ResolveArrowsMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo+    ResolveArrowsMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo+    ResolveArrowsMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo+    ResolveArrowsMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo+    ResolveArrowsMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo+    ResolveArrowsMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo+    ResolveArrowsMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo+    ResolveArrowsMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo+    ResolveArrowsMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo+    ResolveArrowsMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo+    ResolveArrowsMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo+    ResolveArrowsMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo+    ResolveArrowsMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo+    ResolveArrowsMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo+    ResolveArrowsMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo+    ResolveArrowsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveArrowsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveArrowsMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo+    ResolveArrowsMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo+    ResolveArrowsMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo+    ResolveArrowsMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo+    ResolveArrowsMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo+    ResolveArrowsMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo+    ResolveArrowsMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo+    ResolveArrowsMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo+    ResolveArrowsMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo+    ResolveArrowsMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo+    ResolveArrowsMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo+    ResolveArrowsMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo+    ResolveArrowsMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo+    ResolveArrowsMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo+    ResolveArrowsMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo+    ResolveArrowsMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo+    ResolveArrowsMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo+    ResolveArrowsMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo+    ResolveArrowsMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo+    ResolveArrowsMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo+    ResolveArrowsMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo+    ResolveArrowsMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo+    ResolveArrowsMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo+    ResolveArrowsMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo+    ResolveArrowsMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo+    ResolveArrowsMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo+    ResolveArrowsMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo+    ResolveArrowsMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo+    ResolveArrowsMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo+    ResolveArrowsMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo+    ResolveArrowsMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo+    ResolveArrowsMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo+    ResolveArrowsMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo+    ResolveArrowsMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo+    ResolveArrowsMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo+    ResolveArrowsMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo+    ResolveArrowsMethod "setCount" o = ArrowsSetCountMethodInfo+    ResolveArrowsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveArrowsMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo+    ResolveArrowsMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo+    ResolveArrowsMethod "setDirection" o = ArrowsSetDirectionMethodInfo+    ResolveArrowsMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo+    ResolveArrowsMethod "setDuration" o = ArrowsSetDurationMethodInfo+    ResolveArrowsMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo+    ResolveArrowsMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo+    ResolveArrowsMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo+    ResolveArrowsMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo+    ResolveArrowsMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo+    ResolveArrowsMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo+    ResolveArrowsMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo+    ResolveArrowsMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo+    ResolveArrowsMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo+    ResolveArrowsMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo+    ResolveArrowsMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo+    ResolveArrowsMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo+    ResolveArrowsMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo+    ResolveArrowsMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo+    ResolveArrowsMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo+    ResolveArrowsMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo+    ResolveArrowsMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo+    ResolveArrowsMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo+    ResolveArrowsMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo+    ResolveArrowsMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo+    ResolveArrowsMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo+    ResolveArrowsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveArrowsMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo+    ResolveArrowsMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo+    ResolveArrowsMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo+    ResolveArrowsMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo+    ResolveArrowsMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo+    ResolveArrowsMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo+    ResolveArrowsMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo+    ResolveArrowsMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo+    ResolveArrowsMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo+    ResolveArrowsMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo+    ResolveArrowsMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo+    ResolveArrowsMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo+    ResolveArrowsMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo+    ResolveArrowsMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo+    ResolveArrowsMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo+    ResolveArrowsMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo+    ResolveArrowsMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo+    ResolveArrowsMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo+    ResolveArrowsMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveArrowsMethod t Arrows, O.MethodInfo info Arrows p) => OL.IsLabel t (Arrows -> 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 "count"+   -- Type: TBasicType TUInt+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@count@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' arrows #count+@+-}+getArrowsCount :: (MonadIO m, IsArrows o) => o -> m Word32+getArrowsCount obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "count"++{- |+Set the value of the “@count@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' arrows [ #count 'Data.GI.Base.Attributes.:=' value ]+@+-}+setArrowsCount :: (MonadIO m, IsArrows o) => o -> Word32 -> m ()+setArrowsCount obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "count" val++{- |+Construct a `GValueConstruct` with valid value for the “@count@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructArrowsCount :: (IsArrows o) => Word32 -> IO (GValueConstruct o)+constructArrowsCount val = B.Properties.constructObjectPropertyUInt32 "count" val++#if ENABLE_OVERLOADING+data ArrowsCountPropertyInfo+instance AttrInfo ArrowsCountPropertyInfo where+    type AttrAllowedOps ArrowsCountPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ArrowsCountPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint ArrowsCountPropertyInfo = IsArrows+    type AttrGetType ArrowsCountPropertyInfo = Word32+    type AttrLabel ArrowsCountPropertyInfo = "count"+    type AttrOrigin ArrowsCountPropertyInfo = Arrows+    attrGet _ = getArrowsCount+    attrSet _ = setArrowsCount+    attrConstruct _ = constructArrowsCount+    attrClear _ = undefined+#endif++-- VVV Prop "direction"+   -- Type: TInterface (Name {namespace = "Handy", name = "ArrowsDirection"})+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@direction@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' arrows #direction+@+-}+getArrowsDirection :: (MonadIO m, IsArrows o) => o -> m Handy.Enums.ArrowsDirection+getArrowsDirection obj = liftIO $ B.Properties.getObjectPropertyEnum obj "direction"++{- |+Set the value of the “@direction@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' arrows [ #direction 'Data.GI.Base.Attributes.:=' value ]+@+-}+setArrowsDirection :: (MonadIO m, IsArrows o) => o -> Handy.Enums.ArrowsDirection -> m ()+setArrowsDirection obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "direction" val++{- |+Construct a `GValueConstruct` with valid value for the “@direction@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructArrowsDirection :: (IsArrows o) => Handy.Enums.ArrowsDirection -> IO (GValueConstruct o)+constructArrowsDirection val = B.Properties.constructObjectPropertyEnum "direction" val++#if ENABLE_OVERLOADING+data ArrowsDirectionPropertyInfo+instance AttrInfo ArrowsDirectionPropertyInfo where+    type AttrAllowedOps ArrowsDirectionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ArrowsDirectionPropertyInfo = (~) Handy.Enums.ArrowsDirection+    type AttrBaseTypeConstraint ArrowsDirectionPropertyInfo = IsArrows+    type AttrGetType ArrowsDirectionPropertyInfo = Handy.Enums.ArrowsDirection+    type AttrLabel ArrowsDirectionPropertyInfo = "direction"+    type AttrOrigin ArrowsDirectionPropertyInfo = Arrows+    attrGet _ = getArrowsDirection+    attrSet _ = setArrowsDirection+    attrConstruct _ = constructArrowsDirection+    attrClear _ = undefined+#endif++-- VVV Prop "duration"+   -- Type: TBasicType TUInt+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@duration@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' arrows #duration+@+-}+getArrowsDuration :: (MonadIO m, IsArrows o) => o -> m Word32+getArrowsDuration obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "duration"++{- |+Set the value of the “@duration@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' arrows [ #duration 'Data.GI.Base.Attributes.:=' value ]+@+-}+setArrowsDuration :: (MonadIO m, IsArrows o) => o -> Word32 -> m ()+setArrowsDuration obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "duration" val++{- |+Construct a `GValueConstruct` with valid value for the “@duration@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructArrowsDuration :: (IsArrows o) => Word32 -> IO (GValueConstruct o)+constructArrowsDuration val = B.Properties.constructObjectPropertyUInt32 "duration" val++#if ENABLE_OVERLOADING+data ArrowsDurationPropertyInfo+instance AttrInfo ArrowsDurationPropertyInfo where+    type AttrAllowedOps ArrowsDurationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ArrowsDurationPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint ArrowsDurationPropertyInfo = IsArrows+    type AttrGetType ArrowsDurationPropertyInfo = Word32+    type AttrLabel ArrowsDurationPropertyInfo = "duration"+    type AttrOrigin ArrowsDurationPropertyInfo = Arrows+    attrGet _ = getArrowsDuration+    attrSet _ = setArrowsDuration+    attrConstruct _ = constructArrowsDuration+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList Arrows+type instance O.AttributeList Arrows = ArrowsAttributeList+type ArrowsAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("count", ArrowsCountPropertyInfo), '("direction", ArrowsDirectionPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("duration", ArrowsDurationPropertyInfo), '("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), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("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+arrowsCount :: AttrLabelProxy "count"+arrowsCount = AttrLabelProxy++arrowsDirection :: AttrLabelProxy "direction"+arrowsDirection = AttrLabelProxy++arrowsDuration :: AttrLabelProxy "duration"+arrowsDuration = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList Arrows = ArrowsSignalList+type ArrowsSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("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), '("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), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("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 Arrows::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "Arrows"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_arrows_new" hdy_arrows_new :: +    IO (Ptr Arrows)++{- |+Create a new 'GI.Handy.Objects.Arrows.Arrows' widget.+-}+arrowsNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Arrows+    {- ^ __Returns:__ the newly created 'GI.Handy.Objects.Arrows.Arrows' widget -}+arrowsNew  = liftIO $ do+    result <- hdy_arrows_new+    checkUnexpectedReturnNULL "arrowsNew" result+    result' <- (newObject Arrows) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Arrows::animate+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Arrows"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyArrows", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_arrows_animate" hdy_arrows_animate :: +    Ptr Arrows ->                           -- self : TInterface (Name {namespace = "Handy", name = "Arrows"})+    IO ()++{- |+Render the arrows animation.+-}+arrowsAnimate ::+    (B.CallStack.HasCallStack, MonadIO m, IsArrows a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Arrows.Arrows' -}+    -> m ()+arrowsAnimate self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    hdy_arrows_animate self'+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data ArrowsAnimateMethodInfo+instance (signature ~ (m ()), MonadIO m, IsArrows a) => O.MethodInfo ArrowsAnimateMethodInfo a signature where+    overloadedMethod _ = arrowsAnimate++#endif++-- method Arrows::get_count+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Arrows"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyArrows", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_arrows_get_count" hdy_arrows_get_count :: +    Ptr Arrows ->                           -- self : TInterface (Name {namespace = "Handy", name = "Arrows"})+    IO Word32++{- |+Get the number of errors in displayed in the widget.+-}+arrowsGetCount ::+    (B.CallStack.HasCallStack, MonadIO m, IsArrows a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Arrows.Arrows' -}+    -> m Word32+    {- ^ __Returns:__ the current number of arrows -}+arrowsGetCount self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_arrows_get_count self'+    touchManagedPtr self+    return result++#if ENABLE_OVERLOADING+data ArrowsGetCountMethodInfo+instance (signature ~ (m Word32), MonadIO m, IsArrows a) => O.MethodInfo ArrowsGetCountMethodInfo a signature where+    overloadedMethod _ = arrowsGetCount++#endif++-- method Arrows::get_direction+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Arrows"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyArrows", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "ArrowsDirection"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_arrows_get_direction" hdy_arrows_get_direction :: +    Ptr Arrows ->                           -- self : TInterface (Name {namespace = "Handy", name = "Arrows"})+    IO CUInt++{- |+Get the direction the arrows point to+-}+arrowsGetDirection ::+    (B.CallStack.HasCallStack, MonadIO m, IsArrows a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Arrows.Arrows' -}+    -> m Handy.Enums.ArrowsDirection+    {- ^ __Returns:__ the arrows direction -}+arrowsGetDirection self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_arrows_get_direction self'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data ArrowsGetDirectionMethodInfo+instance (signature ~ (m Handy.Enums.ArrowsDirection), MonadIO m, IsArrows a) => O.MethodInfo ArrowsGetDirectionMethodInfo a signature where+    overloadedMethod _ = arrowsGetDirection++#endif++-- method Arrows::get_duration+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Arrows"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyArrows", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_arrows_get_duration" hdy_arrows_get_duration :: +    Ptr Arrows ->                           -- self : TInterface (Name {namespace = "Handy", name = "Arrows"})+    IO Word32++{- |+Get the duration of the arrows animation.+-}+arrowsGetDuration ::+    (B.CallStack.HasCallStack, MonadIO m, IsArrows a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Arrows.Arrows' -}+    -> m Word32+    {- ^ __Returns:__ the arrows -}+arrowsGetDuration self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_arrows_get_duration self'+    touchManagedPtr self+    return result++#if ENABLE_OVERLOADING+data ArrowsGetDurationMethodInfo+instance (signature ~ (m Word32), MonadIO m, IsArrows a) => O.MethodInfo ArrowsGetDurationMethodInfo a signature where+    overloadedMethod _ = arrowsGetDuration++#endif++-- method Arrows::set_count+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Arrows"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyArrows", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of arrows to display", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_arrows_set_count" hdy_arrows_set_count :: +    Ptr Arrows ->                           -- self : TInterface (Name {namespace = "Handy", name = "Arrows"})+    Word32 ->                               -- count : TBasicType TUInt+    IO ()++{- |+Set the number of arrows to display.+-}+arrowsSetCount ::+    (B.CallStack.HasCallStack, MonadIO m, IsArrows a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Arrows.Arrows' -}+    -> Word32+    {- ^ /@count@/: the number of arrows to display -}+    -> m ()+arrowsSetCount self count = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    hdy_arrows_set_count self' count+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data ArrowsSetCountMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m, IsArrows a) => O.MethodInfo ArrowsSetCountMethodInfo a signature where+    overloadedMethod _ = arrowsSetCount++#endif++-- method Arrows::set_direction+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Arrows"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyArrows", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "direction", argType = TInterface (Name {namespace = "Handy", name = "ArrowsDirection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the arrows direction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_arrows_set_direction" hdy_arrows_set_direction :: +    Ptr Arrows ->                           -- self : TInterface (Name {namespace = "Handy", name = "Arrows"})+    CUInt ->                                -- direction : TInterface (Name {namespace = "Handy", name = "ArrowsDirection"})+    IO ()++{- |+Set the direction the arrows should point to.+-}+arrowsSetDirection ::+    (B.CallStack.HasCallStack, MonadIO m, IsArrows a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Arrows.Arrows' -}+    -> Handy.Enums.ArrowsDirection+    {- ^ /@direction@/: the arrows direction -}+    -> m ()+arrowsSetDirection self direction = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    let direction' = (fromIntegral . fromEnum) direction+    hdy_arrows_set_direction self' direction'+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data ArrowsSetDirectionMethodInfo+instance (signature ~ (Handy.Enums.ArrowsDirection -> m ()), MonadIO m, IsArrows a) => O.MethodInfo ArrowsSetDirectionMethodInfo a signature where+    overloadedMethod _ = arrowsSetDirection++#endif++-- method Arrows::set_duration+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Arrows"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyArrows", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the duration of the animation in ms", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_arrows_set_duration" hdy_arrows_set_duration :: +    Ptr Arrows ->                           -- self : TInterface (Name {namespace = "Handy", name = "Arrows"})+    Word32 ->                               -- duration : TBasicType TUInt+    IO ()++{- |+Set the duration of the arrow animation.+-}+arrowsSetDuration ::+    (B.CallStack.HasCallStack, MonadIO m, IsArrows a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Arrows.Arrows' -}+    -> Word32+    {- ^ /@duration@/: the duration of the animation in ms -}+    -> m ()+arrowsSetDuration self duration = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    hdy_arrows_set_duration self' duration+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data ArrowsSetDurationMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m, IsArrows a) => O.MethodInfo ArrowsSetDurationMethodInfo a signature where+    overloadedMethod _ = arrowsSetDuration++#endif++
+ GI/Handy/Objects/Arrows.hs-boot view
@@ -0,0 +1,59 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Handy.Objects.Arrows 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 Arrows = Arrows (ManagedPtr Arrows)+instance GObject Arrows where+class (GObject o, O.IsDescendantOf Arrows o) => IsArrows o+instance (GObject o, O.IsDescendantOf Arrows o) => IsArrows o+instance O.HasParentTypes Arrows+#if ENABLE_OVERLOADING+data ArrowsCountPropertyInfo+#endif+#if ENABLE_OVERLOADING+data ArrowsDirectionPropertyInfo+#endif+#if ENABLE_OVERLOADING+data ArrowsDurationPropertyInfo+#endif+#if ENABLE_OVERLOADING+data ArrowsAnimateMethodInfo+#endif+#if ENABLE_OVERLOADING+data ArrowsGetCountMethodInfo+#endif+#if ENABLE_OVERLOADING+data ArrowsGetDirectionMethodInfo+#endif+#if ENABLE_OVERLOADING+data ArrowsGetDurationMethodInfo+#endif+#if ENABLE_OVERLOADING+data ArrowsSetCountMethodInfo+#endif+#if ENABLE_OVERLOADING+data ArrowsSetDirectionMethodInfo+#endif+#if ENABLE_OVERLOADING+data ArrowsSetDurationMethodInfo+#endif
+ GI/Handy/Objects/Column.hs view
@@ -0,0 +1,772 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Handy.Objects.Column+    ( ++-- * Exported types+    Column(..)                              ,+    IsColumn                                ,+    toColumn                                ,+    noColumn                                ,+++ -- * Methods+-- ** getLinearGrowthWidth #method:getLinearGrowthWidth#++#if ENABLE_OVERLOADING+    ColumnGetLinearGrowthWidthMethodInfo    ,+#endif+    columnGetLinearGrowthWidth              ,+++-- ** getMaximumWidth #method:getMaximumWidth#++#if ENABLE_OVERLOADING+    ColumnGetMaximumWidthMethodInfo         ,+#endif+    columnGetMaximumWidth                   ,+++-- ** new #method:new#++    columnNew                               ,+++-- ** setLinearGrowthWidth #method:setLinearGrowthWidth#++#if ENABLE_OVERLOADING+    ColumnSetLinearGrowthWidthMethodInfo    ,+#endif+    columnSetLinearGrowthWidth              ,+++-- ** setMaximumWidth #method:setMaximumWidth#++#if ENABLE_OVERLOADING+    ColumnSetMaximumWidthMethodInfo         ,+#endif+    columnSetMaximumWidth                   ,+++++ -- * Properties+-- ** linearGrowthWidth #attr:linearGrowthWidth#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    ColumnLinearGrowthWidthPropertyInfo     ,+#endif+#if ENABLE_OVERLOADING+    columnLinearGrowthWidth                 ,+#endif+    constructColumnLinearGrowthWidth        ,+    getColumnLinearGrowthWidth              ,+    setColumnLinearGrowthWidth              ,+++-- ** maximumWidth #attr:maximumWidth#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    ColumnMaximumWidthPropertyInfo          ,+#endif+#if ENABLE_OVERLOADING+    columnMaximumWidth                      ,+#endif+    constructColumnMaximumWidth             ,+    getColumnMaximumWidth                   ,+    setColumnMaximumWidth                   ,+++++    ) 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 qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable+import qualified GI.Gtk.Objects.Bin as Gtk.Bin+import qualified GI.Gtk.Objects.Container as Gtk.Container+import qualified GI.Gtk.Objects.Widget as Gtk.Widget++-- | Memory-managed wrapper type.+newtype Column = Column (ManagedPtr Column)+foreign import ccall "hdy_column_get_type"+    c_hdy_column_get_type :: IO GType++instance GObject Column where+    gobjectType = c_hdy_column_get_type+    ++-- | Type class for types which can be safely cast to `Column`, for instance with `toColumn`.+class (GObject o, O.IsDescendantOf Column o) => IsColumn o+instance (GObject o, O.IsDescendantOf Column o) => IsColumn o++instance O.HasParentTypes Column+type instance O.ParentTypes Column = '[Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable]++-- | Cast to `Column`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toColumn :: (MonadIO m, IsColumn o) => o -> m Column+toColumn = liftIO . unsafeCastTo Column++-- | A convenience alias for `Nothing` :: `Maybe` `Column`.+noColumn :: Maybe Column+noColumn = Nothing++#if ENABLE_OVERLOADING+type family ResolveColumnMethod (t :: Symbol) (o :: *) :: * where+    ResolveColumnMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo+    ResolveColumnMethod "add" o = Gtk.Container.ContainerAddMethodInfo+    ResolveColumnMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo+    ResolveColumnMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo+    ResolveColumnMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo+    ResolveColumnMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo+    ResolveColumnMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo+    ResolveColumnMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo+    ResolveColumnMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveColumnMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveColumnMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo+    ResolveColumnMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo+    ResolveColumnMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo+    ResolveColumnMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo+    ResolveColumnMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo+    ResolveColumnMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo+    ResolveColumnMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo+    ResolveColumnMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo+    ResolveColumnMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo+    ResolveColumnMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo+    ResolveColumnMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo+    ResolveColumnMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo+    ResolveColumnMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo+    ResolveColumnMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo+    ResolveColumnMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo+    ResolveColumnMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo+    ResolveColumnMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo+    ResolveColumnMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo+    ResolveColumnMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo+    ResolveColumnMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo+    ResolveColumnMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo+    ResolveColumnMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo+    ResolveColumnMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo+    ResolveColumnMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo+    ResolveColumnMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo+    ResolveColumnMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo+    ResolveColumnMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo+    ResolveColumnMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo+    ResolveColumnMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo+    ResolveColumnMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo+    ResolveColumnMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo+    ResolveColumnMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo+    ResolveColumnMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo+    ResolveColumnMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo+    ResolveColumnMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo+    ResolveColumnMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo+    ResolveColumnMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo+    ResolveColumnMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo+    ResolveColumnMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo+    ResolveColumnMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo+    ResolveColumnMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo+    ResolveColumnMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo+    ResolveColumnMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo+    ResolveColumnMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo+    ResolveColumnMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo+    ResolveColumnMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo+    ResolveColumnMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo+    ResolveColumnMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo+    ResolveColumnMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo+    ResolveColumnMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo+    ResolveColumnMethod "event" o = Gtk.Widget.WidgetEventMethodInfo+    ResolveColumnMethod "forall" o = Gtk.Container.ContainerForallMethodInfo+    ResolveColumnMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveColumnMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo+    ResolveColumnMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo+    ResolveColumnMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveColumnMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveColumnMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo+    ResolveColumnMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo+    ResolveColumnMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo+    ResolveColumnMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo+    ResolveColumnMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo+    ResolveColumnMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo+    ResolveColumnMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo+    ResolveColumnMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo+    ResolveColumnMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo+    ResolveColumnMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo+    ResolveColumnMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo+    ResolveColumnMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo+    ResolveColumnMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo+    ResolveColumnMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo+    ResolveColumnMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo+    ResolveColumnMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo+    ResolveColumnMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo+    ResolveColumnMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo+    ResolveColumnMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo+    ResolveColumnMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo+    ResolveColumnMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveColumnMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo+    ResolveColumnMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo+    ResolveColumnMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo+    ResolveColumnMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo+    ResolveColumnMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo+    ResolveColumnMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo+    ResolveColumnMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo+    ResolveColumnMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo+    ResolveColumnMethod "map" o = Gtk.Widget.WidgetMapMethodInfo+    ResolveColumnMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo+    ResolveColumnMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo+    ResolveColumnMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo+    ResolveColumnMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo+    ResolveColumnMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo+    ResolveColumnMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo+    ResolveColumnMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo+    ResolveColumnMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo+    ResolveColumnMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveColumnMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveColumnMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo+    ResolveColumnMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo+    ResolveColumnMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo+    ResolveColumnMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo+    ResolveColumnMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo+    ResolveColumnMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo+    ResolveColumnMethod "path" o = Gtk.Widget.WidgetPathMethodInfo+    ResolveColumnMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo+    ResolveColumnMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo+    ResolveColumnMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo+    ResolveColumnMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo+    ResolveColumnMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo+    ResolveColumnMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo+    ResolveColumnMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo+    ResolveColumnMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo+    ResolveColumnMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo+    ResolveColumnMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveColumnMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveColumnMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo+    ResolveColumnMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo+    ResolveColumnMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo+    ResolveColumnMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo+    ResolveColumnMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo+    ResolveColumnMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo+    ResolveColumnMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo+    ResolveColumnMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo+    ResolveColumnMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo+    ResolveColumnMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo+    ResolveColumnMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo+    ResolveColumnMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo+    ResolveColumnMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveColumnMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo+    ResolveColumnMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo+    ResolveColumnMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo+    ResolveColumnMethod "show" o = Gtk.Widget.WidgetShowMethodInfo+    ResolveColumnMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo+    ResolveColumnMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo+    ResolveColumnMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo+    ResolveColumnMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo+    ResolveColumnMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo+    ResolveColumnMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveColumnMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveColumnMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo+    ResolveColumnMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo+    ResolveColumnMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo+    ResolveColumnMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveColumnMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo+    ResolveColumnMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo+    ResolveColumnMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo+    ResolveColumnMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo+    ResolveColumnMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo+    ResolveColumnMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveColumnMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo+    ResolveColumnMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo+    ResolveColumnMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo+    ResolveColumnMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveColumnMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo+    ResolveColumnMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo+    ResolveColumnMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo+    ResolveColumnMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo+    ResolveColumnMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo+    ResolveColumnMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo+    ResolveColumnMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo+    ResolveColumnMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo+    ResolveColumnMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo+    ResolveColumnMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo+    ResolveColumnMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo+    ResolveColumnMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo+    ResolveColumnMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo+    ResolveColumnMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo+    ResolveColumnMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo+    ResolveColumnMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo+    ResolveColumnMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo+    ResolveColumnMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo+    ResolveColumnMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo+    ResolveColumnMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveColumnMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo+    ResolveColumnMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo+    ResolveColumnMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo+    ResolveColumnMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo+    ResolveColumnMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo+    ResolveColumnMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo+    ResolveColumnMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo+    ResolveColumnMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo+    ResolveColumnMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo+    ResolveColumnMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo+    ResolveColumnMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo+    ResolveColumnMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo+    ResolveColumnMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo+    ResolveColumnMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo+    ResolveColumnMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo+    ResolveColumnMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo+    ResolveColumnMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo+    ResolveColumnMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo+    ResolveColumnMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo+    ResolveColumnMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo+    ResolveColumnMethod "getLinearGrowthWidth" o = ColumnGetLinearGrowthWidthMethodInfo+    ResolveColumnMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo+    ResolveColumnMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo+    ResolveColumnMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo+    ResolveColumnMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo+    ResolveColumnMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo+    ResolveColumnMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo+    ResolveColumnMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo+    ResolveColumnMethod "getMaximumWidth" o = ColumnGetMaximumWidthMethodInfo+    ResolveColumnMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo+    ResolveColumnMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo+    ResolveColumnMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo+    ResolveColumnMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo+    ResolveColumnMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo+    ResolveColumnMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo+    ResolveColumnMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo+    ResolveColumnMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo+    ResolveColumnMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo+    ResolveColumnMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo+    ResolveColumnMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo+    ResolveColumnMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo+    ResolveColumnMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo+    ResolveColumnMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo+    ResolveColumnMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo+    ResolveColumnMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo+    ResolveColumnMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo+    ResolveColumnMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveColumnMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveColumnMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo+    ResolveColumnMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo+    ResolveColumnMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo+    ResolveColumnMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo+    ResolveColumnMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo+    ResolveColumnMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo+    ResolveColumnMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo+    ResolveColumnMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo+    ResolveColumnMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo+    ResolveColumnMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo+    ResolveColumnMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo+    ResolveColumnMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo+    ResolveColumnMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo+    ResolveColumnMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo+    ResolveColumnMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo+    ResolveColumnMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo+    ResolveColumnMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo+    ResolveColumnMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo+    ResolveColumnMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo+    ResolveColumnMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo+    ResolveColumnMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo+    ResolveColumnMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo+    ResolveColumnMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo+    ResolveColumnMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo+    ResolveColumnMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo+    ResolveColumnMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo+    ResolveColumnMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo+    ResolveColumnMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo+    ResolveColumnMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo+    ResolveColumnMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo+    ResolveColumnMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo+    ResolveColumnMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo+    ResolveColumnMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo+    ResolveColumnMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo+    ResolveColumnMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo+    ResolveColumnMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo+    ResolveColumnMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo+    ResolveColumnMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo+    ResolveColumnMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveColumnMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo+    ResolveColumnMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo+    ResolveColumnMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo+    ResolveColumnMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo+    ResolveColumnMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo+    ResolveColumnMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo+    ResolveColumnMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo+    ResolveColumnMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo+    ResolveColumnMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo+    ResolveColumnMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo+    ResolveColumnMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo+    ResolveColumnMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo+    ResolveColumnMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo+    ResolveColumnMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo+    ResolveColumnMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo+    ResolveColumnMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo+    ResolveColumnMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo+    ResolveColumnMethod "setLinearGrowthWidth" o = ColumnSetLinearGrowthWidthMethodInfo+    ResolveColumnMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo+    ResolveColumnMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo+    ResolveColumnMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo+    ResolveColumnMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo+    ResolveColumnMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo+    ResolveColumnMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo+    ResolveColumnMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo+    ResolveColumnMethod "setMaximumWidth" o = ColumnSetMaximumWidthMethodInfo+    ResolveColumnMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo+    ResolveColumnMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo+    ResolveColumnMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo+    ResolveColumnMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo+    ResolveColumnMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo+    ResolveColumnMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveColumnMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo+    ResolveColumnMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo+    ResolveColumnMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo+    ResolveColumnMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo+    ResolveColumnMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo+    ResolveColumnMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo+    ResolveColumnMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo+    ResolveColumnMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo+    ResolveColumnMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo+    ResolveColumnMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo+    ResolveColumnMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo+    ResolveColumnMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo+    ResolveColumnMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo+    ResolveColumnMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo+    ResolveColumnMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo+    ResolveColumnMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo+    ResolveColumnMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo+    ResolveColumnMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo+    ResolveColumnMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo+    ResolveColumnMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo+    ResolveColumnMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveColumnMethod t Column, O.MethodInfo info Column p) => OL.IsLabel t (Column -> 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 "linear-growth-width"+   -- Type: TBasicType TInt+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@linear-growth-width@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' column #linearGrowthWidth+@+-}+getColumnLinearGrowthWidth :: (MonadIO m, IsColumn o) => o -> m Int32+getColumnLinearGrowthWidth obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "linear-growth-width"++{- |+Set the value of the “@linear-growth-width@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' column [ #linearGrowthWidth 'Data.GI.Base.Attributes.:=' value ]+@+-}+setColumnLinearGrowthWidth :: (MonadIO m, IsColumn o) => o -> Int32 -> m ()+setColumnLinearGrowthWidth obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "linear-growth-width" val++{- |+Construct a `GValueConstruct` with valid value for the “@linear-growth-width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructColumnLinearGrowthWidth :: (IsColumn o) => Int32 -> IO (GValueConstruct o)+constructColumnLinearGrowthWidth val = B.Properties.constructObjectPropertyInt32 "linear-growth-width" val++#if ENABLE_OVERLOADING+data ColumnLinearGrowthWidthPropertyInfo+instance AttrInfo ColumnLinearGrowthWidthPropertyInfo where+    type AttrAllowedOps ColumnLinearGrowthWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ColumnLinearGrowthWidthPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint ColumnLinearGrowthWidthPropertyInfo = IsColumn+    type AttrGetType ColumnLinearGrowthWidthPropertyInfo = Int32+    type AttrLabel ColumnLinearGrowthWidthPropertyInfo = "linear-growth-width"+    type AttrOrigin ColumnLinearGrowthWidthPropertyInfo = Column+    attrGet _ = getColumnLinearGrowthWidth+    attrSet _ = setColumnLinearGrowthWidth+    attrConstruct _ = constructColumnLinearGrowthWidth+    attrClear _ = undefined+#endif++-- VVV Prop "maximum-width"+   -- Type: TBasicType TInt+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@maximum-width@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' column #maximumWidth+@+-}+getColumnMaximumWidth :: (MonadIO m, IsColumn o) => o -> m Int32+getColumnMaximumWidth obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "maximum-width"++{- |+Set the value of the “@maximum-width@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' column [ #maximumWidth 'Data.GI.Base.Attributes.:=' value ]+@+-}+setColumnMaximumWidth :: (MonadIO m, IsColumn o) => o -> Int32 -> m ()+setColumnMaximumWidth obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "maximum-width" val++{- |+Construct a `GValueConstruct` with valid value for the “@maximum-width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructColumnMaximumWidth :: (IsColumn o) => Int32 -> IO (GValueConstruct o)+constructColumnMaximumWidth val = B.Properties.constructObjectPropertyInt32 "maximum-width" val++#if ENABLE_OVERLOADING+data ColumnMaximumWidthPropertyInfo+instance AttrInfo ColumnMaximumWidthPropertyInfo where+    type AttrAllowedOps ColumnMaximumWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ColumnMaximumWidthPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint ColumnMaximumWidthPropertyInfo = IsColumn+    type AttrGetType ColumnMaximumWidthPropertyInfo = Int32+    type AttrLabel ColumnMaximumWidthPropertyInfo = "maximum-width"+    type AttrOrigin ColumnMaximumWidthPropertyInfo = Column+    attrGet _ = getColumnMaximumWidth+    attrSet _ = setColumnMaximumWidth+    attrConstruct _ = constructColumnMaximumWidth+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList Column+type instance O.AttributeList Column = ColumnAttributeList+type ColumnAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("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), '("linearGrowthWidth", ColumnLinearGrowthWidthPropertyInfo), '("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), '("maximumWidth", ColumnMaximumWidthPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("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+columnLinearGrowthWidth :: AttrLabelProxy "linearGrowthWidth"+columnLinearGrowthWidth = AttrLabelProxy++columnMaximumWidth :: AttrLabelProxy "maximumWidth"+columnMaximumWidth = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList Column = ColumnSignalList+type ColumnSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("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), '("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), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("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), '("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 Column::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "Column"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_column_new" hdy_column_new :: +    IO (Ptr Column)++{- |+Creates a new 'GI.Handy.Objects.Column.Column'.+-}+columnNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Column+    {- ^ __Returns:__ a new 'GI.Handy.Objects.Column.Column' -}+columnNew  = liftIO $ do+    result <- hdy_column_new+    checkUnexpectedReturnNULL "columnNew" result+    result' <- (newObject Column) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Column::get_linear_growth_width+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Column"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyColumn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_column_get_linear_growth_width" hdy_column_get_linear_growth_width :: +    Ptr Column ->                           -- self : TInterface (Name {namespace = "Handy", name = "Column"})+    IO Int32++{- |+Gets the width up to which the child will be allocated all the available+width and starting from which it will be allocated a portion of the available+width. In bith cases the allocated width won\'t exceed the declared maximum.+-}+columnGetLinearGrowthWidth ::+    (B.CallStack.HasCallStack, MonadIO m, IsColumn a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Column.Column' -}+    -> m Int32+    {- ^ __Returns:__ the width up to which the child will be allocated all the available+width. -}+columnGetLinearGrowthWidth self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_column_get_linear_growth_width self'+    touchManagedPtr self+    return result++#if ENABLE_OVERLOADING+data ColumnGetLinearGrowthWidthMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsColumn a) => O.MethodInfo ColumnGetLinearGrowthWidthMethodInfo a signature where+    overloadedMethod _ = columnGetLinearGrowthWidth++#endif++-- method Column::get_maximum_width+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Column"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyColumn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_column_get_maximum_width" hdy_column_get_maximum_width :: +    Ptr Column ->                           -- self : TInterface (Name {namespace = "Handy", name = "Column"})+    IO Int32++{- |+Gets the maximum width to allocate to the contained child.+-}+columnGetMaximumWidth ::+    (B.CallStack.HasCallStack, MonadIO m, IsColumn a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Column.Column' -}+    -> m Int32+    {- ^ __Returns:__ the maximum width to allocate to the contained child. -}+columnGetMaximumWidth self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_column_get_maximum_width self'+    touchManagedPtr self+    return result++#if ENABLE_OVERLOADING+data ColumnGetMaximumWidthMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsColumn a) => O.MethodInfo ColumnGetMaximumWidthMethodInfo a signature where+    overloadedMethod _ = columnGetMaximumWidth++#endif++-- method Column::set_linear_growth_width+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Column"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyColumn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "linear_growth_width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the linear growth width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_column_set_linear_growth_width" hdy_column_set_linear_growth_width :: +    Ptr Column ->                           -- self : TInterface (Name {namespace = "Handy", name = "Column"})+    Int32 ->                                -- linear_growth_width : TBasicType TInt+    IO ()++{- |+Sets the width up to which the child will be allocated all the available+width and starting from which it will be allocated a portion of the available+width. In bith cases the allocated width won\'t exceed the declared maximum.+-}+columnSetLinearGrowthWidth ::+    (B.CallStack.HasCallStack, MonadIO m, IsColumn a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Column.Column' -}+    -> Int32+    {- ^ /@linearGrowthWidth@/: the linear growth width -}+    -> m ()+columnSetLinearGrowthWidth self linearGrowthWidth = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    hdy_column_set_linear_growth_width self' linearGrowthWidth+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data ColumnSetLinearGrowthWidthMethodInfo+instance (signature ~ (Int32 -> m ()), MonadIO m, IsColumn a) => O.MethodInfo ColumnSetLinearGrowthWidthMethodInfo a signature where+    overloadedMethod _ = columnSetLinearGrowthWidth++#endif++-- method Column::set_maximum_width+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Column"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyColumn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "maximum_width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the maximum width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_column_set_maximum_width" hdy_column_set_maximum_width :: +    Ptr Column ->                           -- self : TInterface (Name {namespace = "Handy", name = "Column"})+    Int32 ->                                -- maximum_width : TBasicType TInt+    IO ()++{- |+Sets the maximum width to allocate to the contained child.+-}+columnSetMaximumWidth ::+    (B.CallStack.HasCallStack, MonadIO m, IsColumn a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Column.Column' -}+    -> Int32+    {- ^ /@maximumWidth@/: the maximum width -}+    -> m ()+columnSetMaximumWidth self maximumWidth = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    hdy_column_set_maximum_width self' maximumWidth+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data ColumnSetMaximumWidthMethodInfo+instance (signature ~ (Int32 -> m ()), MonadIO m, IsColumn a) => O.MethodInfo ColumnSetMaximumWidthMethodInfo a signature where+    overloadedMethod _ = columnSetMaximumWidth++#endif++
+ GI/Handy/Objects/Column.hs-boot view
@@ -0,0 +1,47 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Handy.Objects.Column 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 Column = Column (ManagedPtr Column)+instance GObject Column where+class (GObject o, O.IsDescendantOf Column o) => IsColumn o+instance (GObject o, O.IsDescendantOf Column o) => IsColumn o+instance O.HasParentTypes Column+#if ENABLE_OVERLOADING+data ColumnLinearGrowthWidthPropertyInfo+#endif+#if ENABLE_OVERLOADING+data ColumnMaximumWidthPropertyInfo+#endif+#if ENABLE_OVERLOADING+data ColumnGetLinearGrowthWidthMethodInfo+#endif+#if ENABLE_OVERLOADING+data ColumnGetMaximumWidthMethodInfo+#endif+#if ENABLE_OVERLOADING+data ColumnSetLinearGrowthWidthMethodInfo+#endif+#if ENABLE_OVERLOADING+data ColumnSetMaximumWidthMethodInfo+#endif
+ GI/Handy/Objects/ComboRow.hs view
@@ -0,0 +1,935 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Handy.Objects.ComboRow+    ( ++-- * Exported types+    ComboRow(..)                            ,+    IsComboRow                              ,+    toComboRow                              ,+    noComboRow                              ,+++ -- * Methods+-- ** bindModel #method:bindModel#++#if ENABLE_OVERLOADING+    ComboRowBindModelMethodInfo             ,+#endif+    comboRowBindModel                       ,+++-- ** bindNameModel #method:bindNameModel#++#if ENABLE_OVERLOADING+    ComboRowBindNameModelMethodInfo         ,+#endif+    comboRowBindNameModel                   ,+++-- ** getModel #method:getModel#++#if ENABLE_OVERLOADING+    ComboRowGetModelMethodInfo              ,+#endif+    comboRowGetModel                        ,+++-- ** getSelectedIndex #method:getSelectedIndex#++#if ENABLE_OVERLOADING+    ComboRowGetSelectedIndexMethodInfo      ,+#endif+    comboRowGetSelectedIndex                ,+++-- ** new #method:new#++    comboRowNew                             ,+++-- ** setForEnum #method:setForEnum#++#if ENABLE_OVERLOADING+    ComboRowSetForEnumMethodInfo            ,+#endif+    comboRowSetForEnum                      ,+++-- ** setSelectedIndex #method:setSelectedIndex#++#if ENABLE_OVERLOADING+    ComboRowSetSelectedIndexMethodInfo      ,+#endif+    comboRowSetSelectedIndex                ,+++++ -- * Properties+-- ** selectedIndex #attr:selectedIndex#+{- | The index of the selected item in its 'GI.Gio.Interfaces.ListModel.ListModel'.++/Since: 0.0.7/+-}+#if ENABLE_OVERLOADING+    ComboRowSelectedIndexPropertyInfo       ,+#endif+#if ENABLE_OVERLOADING+    comboRowSelectedIndex                   ,+#endif+    constructComboRowSelectedIndex          ,+    getComboRowSelectedIndex                ,+    setComboRowSelectedIndex                ,+++++    ) 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 qualified GI.GLib.Callbacks as GLib.Callbacks+import qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel+import qualified GI.Gtk.Callbacks as Gtk.Callbacks+import qualified GI.Gtk.Interfaces.Actionable as Gtk.Actionable+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable+import qualified GI.Gtk.Objects.Bin as Gtk.Bin+import qualified GI.Gtk.Objects.Container as Gtk.Container+import qualified GI.Gtk.Objects.ListBoxRow as Gtk.ListBoxRow+import qualified GI.Gtk.Objects.Widget as Gtk.Widget+import qualified GI.Handy.Callbacks as Handy.Callbacks+import {-# SOURCE #-} qualified GI.Handy.Objects.ActionRow as Handy.ActionRow++-- | Memory-managed wrapper type.+newtype ComboRow = ComboRow (ManagedPtr ComboRow)+foreign import ccall "hdy_combo_row_get_type"+    c_hdy_combo_row_get_type :: IO GType++instance GObject ComboRow where+    gobjectType = c_hdy_combo_row_get_type+    ++-- | Type class for types which can be safely cast to `ComboRow`, for instance with `toComboRow`.+class (GObject o, O.IsDescendantOf ComboRow o) => IsComboRow o+instance (GObject o, O.IsDescendantOf ComboRow o) => IsComboRow o++instance O.HasParentTypes ComboRow+type instance O.ParentTypes ComboRow = '[Handy.ActionRow.ActionRow, Gtk.ListBoxRow.ListBoxRow, Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Actionable.Actionable, Gtk.Buildable.Buildable]++-- | Cast to `ComboRow`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toComboRow :: (MonadIO m, IsComboRow o) => o -> m ComboRow+toComboRow = liftIO . unsafeCastTo ComboRow++-- | A convenience alias for `Nothing` :: `Maybe` `ComboRow`.+noComboRow :: Maybe ComboRow+noComboRow = Nothing++#if ENABLE_OVERLOADING+type family ResolveComboRowMethod (t :: Symbol) (o :: *) :: * where+    ResolveComboRowMethod "activate" o = Handy.ActionRow.ActionRowActivateMethodInfo+    ResolveComboRowMethod "add" o = Gtk.Container.ContainerAddMethodInfo+    ResolveComboRowMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo+    ResolveComboRowMethod "addAction" o = Handy.ActionRow.ActionRowAddActionMethodInfo+    ResolveComboRowMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo+    ResolveComboRowMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo+    ResolveComboRowMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo+    ResolveComboRowMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo+    ResolveComboRowMethod "addPrefix" o = Handy.ActionRow.ActionRowAddPrefixMethodInfo+    ResolveComboRowMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo+    ResolveComboRowMethod "bindModel" o = ComboRowBindModelMethodInfo+    ResolveComboRowMethod "bindNameModel" o = ComboRowBindNameModelMethodInfo+    ResolveComboRowMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveComboRowMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveComboRowMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo+    ResolveComboRowMethod "changed" o = Gtk.ListBoxRow.ListBoxRowChangedMethodInfo+    ResolveComboRowMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo+    ResolveComboRowMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo+    ResolveComboRowMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo+    ResolveComboRowMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo+    ResolveComboRowMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo+    ResolveComboRowMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo+    ResolveComboRowMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo+    ResolveComboRowMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo+    ResolveComboRowMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo+    ResolveComboRowMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo+    ResolveComboRowMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo+    ResolveComboRowMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo+    ResolveComboRowMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo+    ResolveComboRowMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo+    ResolveComboRowMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo+    ResolveComboRowMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo+    ResolveComboRowMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo+    ResolveComboRowMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo+    ResolveComboRowMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo+    ResolveComboRowMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo+    ResolveComboRowMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo+    ResolveComboRowMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo+    ResolveComboRowMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo+    ResolveComboRowMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo+    ResolveComboRowMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo+    ResolveComboRowMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo+    ResolveComboRowMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo+    ResolveComboRowMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo+    ResolveComboRowMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo+    ResolveComboRowMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo+    ResolveComboRowMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo+    ResolveComboRowMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo+    ResolveComboRowMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo+    ResolveComboRowMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo+    ResolveComboRowMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo+    ResolveComboRowMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo+    ResolveComboRowMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo+    ResolveComboRowMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo+    ResolveComboRowMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo+    ResolveComboRowMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo+    ResolveComboRowMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo+    ResolveComboRowMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo+    ResolveComboRowMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo+    ResolveComboRowMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo+    ResolveComboRowMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo+    ResolveComboRowMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo+    ResolveComboRowMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo+    ResolveComboRowMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo+    ResolveComboRowMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo+    ResolveComboRowMethod "event" o = Gtk.Widget.WidgetEventMethodInfo+    ResolveComboRowMethod "forall" o = Gtk.Container.ContainerForallMethodInfo+    ResolveComboRowMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveComboRowMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo+    ResolveComboRowMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo+    ResolveComboRowMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveComboRowMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveComboRowMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo+    ResolveComboRowMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo+    ResolveComboRowMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo+    ResolveComboRowMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo+    ResolveComboRowMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo+    ResolveComboRowMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo+    ResolveComboRowMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo+    ResolveComboRowMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo+    ResolveComboRowMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo+    ResolveComboRowMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo+    ResolveComboRowMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo+    ResolveComboRowMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo+    ResolveComboRowMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo+    ResolveComboRowMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo+    ResolveComboRowMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo+    ResolveComboRowMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo+    ResolveComboRowMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo+    ResolveComboRowMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo+    ResolveComboRowMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo+    ResolveComboRowMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo+    ResolveComboRowMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveComboRowMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo+    ResolveComboRowMethod "isSelected" o = Gtk.ListBoxRow.ListBoxRowIsSelectedMethodInfo+    ResolveComboRowMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo+    ResolveComboRowMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo+    ResolveComboRowMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo+    ResolveComboRowMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo+    ResolveComboRowMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo+    ResolveComboRowMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo+    ResolveComboRowMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo+    ResolveComboRowMethod "map" o = Gtk.Widget.WidgetMapMethodInfo+    ResolveComboRowMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo+    ResolveComboRowMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo+    ResolveComboRowMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo+    ResolveComboRowMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo+    ResolveComboRowMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo+    ResolveComboRowMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo+    ResolveComboRowMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo+    ResolveComboRowMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo+    ResolveComboRowMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveComboRowMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveComboRowMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo+    ResolveComboRowMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo+    ResolveComboRowMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo+    ResolveComboRowMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo+    ResolveComboRowMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo+    ResolveComboRowMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo+    ResolveComboRowMethod "path" o = Gtk.Widget.WidgetPathMethodInfo+    ResolveComboRowMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo+    ResolveComboRowMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo+    ResolveComboRowMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo+    ResolveComboRowMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo+    ResolveComboRowMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo+    ResolveComboRowMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo+    ResolveComboRowMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo+    ResolveComboRowMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo+    ResolveComboRowMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo+    ResolveComboRowMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveComboRowMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveComboRowMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo+    ResolveComboRowMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo+    ResolveComboRowMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo+    ResolveComboRowMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo+    ResolveComboRowMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo+    ResolveComboRowMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo+    ResolveComboRowMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo+    ResolveComboRowMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo+    ResolveComboRowMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo+    ResolveComboRowMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo+    ResolveComboRowMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo+    ResolveComboRowMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo+    ResolveComboRowMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveComboRowMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo+    ResolveComboRowMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo+    ResolveComboRowMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo+    ResolveComboRowMethod "show" o = Gtk.Widget.WidgetShowMethodInfo+    ResolveComboRowMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo+    ResolveComboRowMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo+    ResolveComboRowMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo+    ResolveComboRowMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo+    ResolveComboRowMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo+    ResolveComboRowMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveComboRowMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveComboRowMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo+    ResolveComboRowMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo+    ResolveComboRowMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo+    ResolveComboRowMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveComboRowMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo+    ResolveComboRowMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo+    ResolveComboRowMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo+    ResolveComboRowMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo+    ResolveComboRowMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo+    ResolveComboRowMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveComboRowMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo+    ResolveComboRowMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo+    ResolveComboRowMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo+    ResolveComboRowMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveComboRowMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo+    ResolveComboRowMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo+    ResolveComboRowMethod "getActionName" o = Gtk.Actionable.ActionableGetActionNameMethodInfo+    ResolveComboRowMethod "getActionTargetValue" o = Gtk.Actionable.ActionableGetActionTargetValueMethodInfo+    ResolveComboRowMethod "getActivatable" o = Gtk.ListBoxRow.ListBoxRowGetActivatableMethodInfo+    ResolveComboRowMethod "getActivatableWidget" o = Handy.ActionRow.ActionRowGetActivatableWidgetMethodInfo+    ResolveComboRowMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo+    ResolveComboRowMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo+    ResolveComboRowMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo+    ResolveComboRowMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo+    ResolveComboRowMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo+    ResolveComboRowMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo+    ResolveComboRowMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo+    ResolveComboRowMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo+    ResolveComboRowMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo+    ResolveComboRowMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo+    ResolveComboRowMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo+    ResolveComboRowMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo+    ResolveComboRowMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo+    ResolveComboRowMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo+    ResolveComboRowMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo+    ResolveComboRowMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo+    ResolveComboRowMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo+    ResolveComboRowMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveComboRowMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo+    ResolveComboRowMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo+    ResolveComboRowMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo+    ResolveComboRowMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo+    ResolveComboRowMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo+    ResolveComboRowMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo+    ResolveComboRowMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo+    ResolveComboRowMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo+    ResolveComboRowMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo+    ResolveComboRowMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo+    ResolveComboRowMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo+    ResolveComboRowMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo+    ResolveComboRowMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo+    ResolveComboRowMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo+    ResolveComboRowMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo+    ResolveComboRowMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo+    ResolveComboRowMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo+    ResolveComboRowMethod "getHeader" o = Gtk.ListBoxRow.ListBoxRowGetHeaderMethodInfo+    ResolveComboRowMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo+    ResolveComboRowMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo+    ResolveComboRowMethod "getIconName" o = Handy.ActionRow.ActionRowGetIconNameMethodInfo+    ResolveComboRowMethod "getIndex" o = Gtk.ListBoxRow.ListBoxRowGetIndexMethodInfo+    ResolveComboRowMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo+    ResolveComboRowMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo+    ResolveComboRowMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo+    ResolveComboRowMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo+    ResolveComboRowMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo+    ResolveComboRowMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo+    ResolveComboRowMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo+    ResolveComboRowMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo+    ResolveComboRowMethod "getModel" o = ComboRowGetModelMethodInfo+    ResolveComboRowMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo+    ResolveComboRowMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo+    ResolveComboRowMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo+    ResolveComboRowMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo+    ResolveComboRowMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo+    ResolveComboRowMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo+    ResolveComboRowMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo+    ResolveComboRowMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo+    ResolveComboRowMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo+    ResolveComboRowMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo+    ResolveComboRowMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo+    ResolveComboRowMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo+    ResolveComboRowMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo+    ResolveComboRowMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo+    ResolveComboRowMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo+    ResolveComboRowMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo+    ResolveComboRowMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo+    ResolveComboRowMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveComboRowMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveComboRowMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo+    ResolveComboRowMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo+    ResolveComboRowMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo+    ResolveComboRowMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo+    ResolveComboRowMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo+    ResolveComboRowMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo+    ResolveComboRowMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo+    ResolveComboRowMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo+    ResolveComboRowMethod "getSelectable" o = Gtk.ListBoxRow.ListBoxRowGetSelectableMethodInfo+    ResolveComboRowMethod "getSelectedIndex" o = ComboRowGetSelectedIndexMethodInfo+    ResolveComboRowMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo+    ResolveComboRowMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo+    ResolveComboRowMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo+    ResolveComboRowMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo+    ResolveComboRowMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo+    ResolveComboRowMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo+    ResolveComboRowMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo+    ResolveComboRowMethod "getSubtitle" o = Handy.ActionRow.ActionRowGetSubtitleMethodInfo+    ResolveComboRowMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo+    ResolveComboRowMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo+    ResolveComboRowMethod "getTitle" o = Handy.ActionRow.ActionRowGetTitleMethodInfo+    ResolveComboRowMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo+    ResolveComboRowMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo+    ResolveComboRowMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo+    ResolveComboRowMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo+    ResolveComboRowMethod "getUseUnderline" o = Handy.ActionRow.ActionRowGetUseUnderlineMethodInfo+    ResolveComboRowMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo+    ResolveComboRowMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo+    ResolveComboRowMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo+    ResolveComboRowMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo+    ResolveComboRowMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo+    ResolveComboRowMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo+    ResolveComboRowMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo+    ResolveComboRowMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo+    ResolveComboRowMethod "setActionName" o = Gtk.Actionable.ActionableSetActionNameMethodInfo+    ResolveComboRowMethod "setActionTargetValue" o = Gtk.Actionable.ActionableSetActionTargetValueMethodInfo+    ResolveComboRowMethod "setActivatable" o = Gtk.ListBoxRow.ListBoxRowSetActivatableMethodInfo+    ResolveComboRowMethod "setActivatableWidget" o = Handy.ActionRow.ActionRowSetActivatableWidgetMethodInfo+    ResolveComboRowMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo+    ResolveComboRowMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo+    ResolveComboRowMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo+    ResolveComboRowMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo+    ResolveComboRowMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo+    ResolveComboRowMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo+    ResolveComboRowMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo+    ResolveComboRowMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo+    ResolveComboRowMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo+    ResolveComboRowMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveComboRowMethod "setDetailedActionName" o = Gtk.Actionable.ActionableSetDetailedActionNameMethodInfo+    ResolveComboRowMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo+    ResolveComboRowMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo+    ResolveComboRowMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo+    ResolveComboRowMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo+    ResolveComboRowMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo+    ResolveComboRowMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo+    ResolveComboRowMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo+    ResolveComboRowMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo+    ResolveComboRowMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo+    ResolveComboRowMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo+    ResolveComboRowMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo+    ResolveComboRowMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo+    ResolveComboRowMethod "setForEnum" o = ComboRowSetForEnumMethodInfo+    ResolveComboRowMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo+    ResolveComboRowMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo+    ResolveComboRowMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo+    ResolveComboRowMethod "setHeader" o = Gtk.ListBoxRow.ListBoxRowSetHeaderMethodInfo+    ResolveComboRowMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo+    ResolveComboRowMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo+    ResolveComboRowMethod "setIconName" o = Handy.ActionRow.ActionRowSetIconNameMethodInfo+    ResolveComboRowMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo+    ResolveComboRowMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo+    ResolveComboRowMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo+    ResolveComboRowMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo+    ResolveComboRowMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo+    ResolveComboRowMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo+    ResolveComboRowMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo+    ResolveComboRowMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo+    ResolveComboRowMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo+    ResolveComboRowMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo+    ResolveComboRowMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo+    ResolveComboRowMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo+    ResolveComboRowMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveComboRowMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo+    ResolveComboRowMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo+    ResolveComboRowMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo+    ResolveComboRowMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo+    ResolveComboRowMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo+    ResolveComboRowMethod "setSelectable" o = Gtk.ListBoxRow.ListBoxRowSetSelectableMethodInfo+    ResolveComboRowMethod "setSelectedIndex" o = ComboRowSetSelectedIndexMethodInfo+    ResolveComboRowMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo+    ResolveComboRowMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo+    ResolveComboRowMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo+    ResolveComboRowMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo+    ResolveComboRowMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo+    ResolveComboRowMethod "setSubtitle" o = Handy.ActionRow.ActionRowSetSubtitleMethodInfo+    ResolveComboRowMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo+    ResolveComboRowMethod "setTitle" o = Handy.ActionRow.ActionRowSetTitleMethodInfo+    ResolveComboRowMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo+    ResolveComboRowMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo+    ResolveComboRowMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo+    ResolveComboRowMethod "setUseUnderline" o = Handy.ActionRow.ActionRowSetUseUnderlineMethodInfo+    ResolveComboRowMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo+    ResolveComboRowMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo+    ResolveComboRowMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo+    ResolveComboRowMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo+    ResolveComboRowMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo+    ResolveComboRowMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo+    ResolveComboRowMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveComboRowMethod t ComboRow, O.MethodInfo info ComboRow p) => OL.IsLabel t (ComboRow -> 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 "selected-index"+   -- Type: TBasicType TInt+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@selected-index@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' comboRow #selectedIndex+@+-}+getComboRowSelectedIndex :: (MonadIO m, IsComboRow o) => o -> m Int32+getComboRowSelectedIndex obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "selected-index"++{- |+Set the value of the “@selected-index@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' comboRow [ #selectedIndex 'Data.GI.Base.Attributes.:=' value ]+@+-}+setComboRowSelectedIndex :: (MonadIO m, IsComboRow o) => o -> Int32 -> m ()+setComboRowSelectedIndex obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "selected-index" val++{- |+Construct a `GValueConstruct` with valid value for the “@selected-index@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructComboRowSelectedIndex :: (IsComboRow o) => Int32 -> IO (GValueConstruct o)+constructComboRowSelectedIndex val = B.Properties.constructObjectPropertyInt32 "selected-index" val++#if ENABLE_OVERLOADING+data ComboRowSelectedIndexPropertyInfo+instance AttrInfo ComboRowSelectedIndexPropertyInfo where+    type AttrAllowedOps ComboRowSelectedIndexPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ComboRowSelectedIndexPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint ComboRowSelectedIndexPropertyInfo = IsComboRow+    type AttrGetType ComboRowSelectedIndexPropertyInfo = Int32+    type AttrLabel ComboRowSelectedIndexPropertyInfo = "selected-index"+    type AttrOrigin ComboRowSelectedIndexPropertyInfo = ComboRow+    attrGet _ = getComboRowSelectedIndex+    attrSet _ = setComboRowSelectedIndex+    attrConstruct _ = constructComboRowSelectedIndex+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList ComboRow+type instance O.AttributeList ComboRow = ComboRowAttributeList+type ComboRowAttributeList = ('[ '("actionName", Gtk.Actionable.ActionableActionNamePropertyInfo), '("actionTarget", Gtk.Actionable.ActionableActionTargetPropertyInfo), '("activatable", Gtk.ListBoxRow.ListBoxRowActivatablePropertyInfo), '("activatableWidget", Handy.ActionRow.ActionRowActivatableWidgetPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("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), '("iconName", Handy.ActionRow.ActionRowIconNamePropertyInfo), '("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), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("selectable", Gtk.ListBoxRow.ListBoxRowSelectablePropertyInfo), '("selectedIndex", ComboRowSelectedIndexPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("subtitle", Handy.ActionRow.ActionRowSubtitlePropertyInfo), '("title", Handy.ActionRow.ActionRowTitlePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("useUnderline", Handy.ActionRow.ActionRowUseUnderlinePropertyInfo), '("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+comboRowSelectedIndex :: AttrLabelProxy "selectedIndex"+comboRowSelectedIndex = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList ComboRow = ComboRowSignalList+type ComboRowSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("activate", Gtk.ListBoxRow.ListBoxRowActivateSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("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), '("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), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("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), '("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 ComboRow::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "ComboRow"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_combo_row_new" hdy_combo_row_new :: +    IO (Ptr ComboRow)++{- |+Creates a new 'GI.Handy.Objects.ComboRow.ComboRow'.++/Since: 0.0.6/+-}+comboRowNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m ComboRow+    {- ^ __Returns:__ a new 'GI.Handy.Objects.ComboRow.ComboRow' -}+comboRowNew  = liftIO $ do+    result <- hdy_combo_row_new+    checkUnexpectedReturnNULL "comboRowNew" result+    result' <- (newObject ComboRow) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method ComboRow::bind_model+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ComboRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyComboRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "model", argType = TInterface (Name {namespace = "Gio", name = "ListModel"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #GListModel to be bound to @self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "create_list_widget_func", argType = TInterface (Name {namespace = "Gtk", name = "ListBoxCreateWidgetFunc"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a function that creates\n  widgets for items to display in the list, or %NULL in case you also passed\n  %NULL as @model", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "create_current_widget_func", argType = TInterface (Name {namespace = "Gtk", name = "ListBoxCreateWidgetFunc"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a function that creates\n  widgets for items to display as the seleted item, or %NULL in case you also\n  passed %NULL as @model", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 4, argDestroy = 5, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to @create_list_widget_func and\n  @create_current_widget_func", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data_free_func", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "function for freeing @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_combo_row_bind_model" hdy_combo_row_bind_model :: +    Ptr ComboRow ->                         -- self : TInterface (Name {namespace = "Handy", name = "ComboRow"})+    Ptr Gio.ListModel.ListModel ->          -- model : TInterface (Name {namespace = "Gio", name = "ListModel"})+    FunPtr Gtk.Callbacks.C_ListBoxCreateWidgetFunc -> -- create_list_widget_func : TInterface (Name {namespace = "Gtk", name = "ListBoxCreateWidgetFunc"})+    FunPtr Gtk.Callbacks.C_ListBoxCreateWidgetFunc -> -- create_current_widget_func : TInterface (Name {namespace = "Gtk", name = "ListBoxCreateWidgetFunc"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    FunPtr GLib.Callbacks.C_DestroyNotify -> -- user_data_free_func : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})+    IO ()++{- |+Binds /@model@/ to /@self@/.++If /@self@/ was already bound to a model, that previous binding is destroyed.++The contents of /@self@/ are cleared and then filled with widgets that represent+items from /@model@/. /@self@/ is updated whenever /@model@/ changes. If /@model@/ is+'Nothing', /@self@/ is left empty.++/Since: 0.0.6/+-}+comboRowBindModel ::+    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a, Gio.ListModel.IsListModel b) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ComboRow.ComboRow' -}+    -> Maybe (b)+    {- ^ /@model@/: the 'GI.Gio.Interfaces.ListModel.ListModel' to be bound to /@self@/ -}+    -> Maybe (Gtk.Callbacks.ListBoxCreateWidgetFunc)+    {- ^ /@createListWidgetFunc@/: a function that creates+  widgets for items to display in the list, or 'Nothing' in case you also passed+  'Nothing' as /@model@/ -}+    -> Maybe (Gtk.Callbacks.ListBoxCreateWidgetFunc)+    {- ^ /@createCurrentWidgetFunc@/: a function that creates+  widgets for items to display as the seleted item, or 'Nothing' in case you also+  passed 'Nothing' as /@model@/ -}+    -> m ()+comboRowBindModel self model createListWidgetFunc createCurrentWidgetFunc = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    maybeModel <- case model of+        Nothing -> return nullPtr+        Just jModel -> do+            jModel' <- unsafeManagedPtrCastPtr jModel+            return jModel'+    maybeCreateListWidgetFunc <- case createListWidgetFunc of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCreateListWidgetFunc -> do+            jCreateListWidgetFunc' <- Gtk.Callbacks.mk_ListBoxCreateWidgetFunc (Gtk.Callbacks.wrap_ListBoxCreateWidgetFunc Nothing (Gtk.Callbacks.drop_closures_ListBoxCreateWidgetFunc jCreateListWidgetFunc))+            return jCreateListWidgetFunc'+    maybeCreateCurrentWidgetFunc <- case createCurrentWidgetFunc of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCreateCurrentWidgetFunc -> do+            jCreateCurrentWidgetFunc' <- Gtk.Callbacks.mk_ListBoxCreateWidgetFunc (Gtk.Callbacks.wrap_ListBoxCreateWidgetFunc Nothing (Gtk.Callbacks.drop_closures_ListBoxCreateWidgetFunc jCreateCurrentWidgetFunc))+            return jCreateCurrentWidgetFunc'+    let userData = castFunPtrToPtr maybeCreateCurrentWidgetFunc+    let userDataFreeFunc = safeFreeFunPtrPtr+    hdy_combo_row_bind_model self' maybeModel maybeCreateListWidgetFunc maybeCreateCurrentWidgetFunc userData userDataFreeFunc+    safeFreeFunPtr $ castFunPtrToPtr maybeCreateListWidgetFunc+    touchManagedPtr self+    whenJust model touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+data ComboRowBindModelMethodInfo+instance (signature ~ (Maybe (b) -> Maybe (Gtk.Callbacks.ListBoxCreateWidgetFunc) -> Maybe (Gtk.Callbacks.ListBoxCreateWidgetFunc) -> m ()), MonadIO m, IsComboRow a, Gio.ListModel.IsListModel b) => O.MethodInfo ComboRowBindModelMethodInfo a signature where+    overloadedMethod _ = comboRowBindModel++#endif++-- method ComboRow::bind_name_model+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ComboRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyComboRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "model", argType = TInterface (Name {namespace = "Gio", name = "ListModel"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #GListModel to be bound to @self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "get_name_func", argType = TInterface (Name {namespace = "Handy", name = "ComboRowGetNameFunc"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a function that creates names for items, or %NULL\n  in case you also passed %NULL as @model", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to @get_name_func", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data_free_func", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "function for freeing @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_combo_row_bind_name_model" hdy_combo_row_bind_name_model :: +    Ptr ComboRow ->                         -- self : TInterface (Name {namespace = "Handy", name = "ComboRow"})+    Ptr Gio.ListModel.ListModel ->          -- model : TInterface (Name {namespace = "Gio", name = "ListModel"})+    FunPtr Handy.Callbacks.C_ComboRowGetNameFunc -> -- get_name_func : TInterface (Name {namespace = "Handy", name = "ComboRowGetNameFunc"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    FunPtr GLib.Callbacks.C_DestroyNotify -> -- user_data_free_func : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})+    IO ()++{- |+Binds /@model@/ to /@self@/.++If /@self@/ was already bound to a model, that previous binding is destroyed.++The contents of /@self@/ are cleared and then filled with widgets that represent+items from /@model@/. /@self@/ is updated whenever /@model@/ changes. If /@model@/ is+'Nothing', /@self@/ is left empty.++This is more conventient to use than 'GI.Handy.Objects.ComboRow.comboRowBindModel' if you want+to represent items of the model with names.++/Since: 0.0.6/+-}+comboRowBindNameModel ::+    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a, Gio.ListModel.IsListModel b) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ComboRow.ComboRow' -}+    -> Maybe (b)+    {- ^ /@model@/: the 'GI.Gio.Interfaces.ListModel.ListModel' to be bound to /@self@/ -}+    -> Maybe (Handy.Callbacks.ComboRowGetNameFunc)+    {- ^ /@getNameFunc@/: a function that creates names for items, or 'Nothing'+  in case you also passed 'Nothing' as /@model@/ -}+    -> m ()+comboRowBindNameModel self model getNameFunc = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    maybeModel <- case model of+        Nothing -> return nullPtr+        Just jModel -> do+            jModel' <- unsafeManagedPtrCastPtr jModel+            return jModel'+    maybeGetNameFunc <- case getNameFunc of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jGetNameFunc -> do+            jGetNameFunc' <- Handy.Callbacks.mk_ComboRowGetNameFunc (Handy.Callbacks.wrap_ComboRowGetNameFunc Nothing (Handy.Callbacks.drop_closures_ComboRowGetNameFunc jGetNameFunc))+            return jGetNameFunc'+    let userData = castFunPtrToPtr maybeGetNameFunc+    let userDataFreeFunc = safeFreeFunPtrPtr+    hdy_combo_row_bind_name_model self' maybeModel maybeGetNameFunc userData userDataFreeFunc+    touchManagedPtr self+    whenJust model touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+data ComboRowBindNameModelMethodInfo+instance (signature ~ (Maybe (b) -> Maybe (Handy.Callbacks.ComboRowGetNameFunc) -> m ()), MonadIO m, IsComboRow a, Gio.ListModel.IsListModel b) => O.MethodInfo ComboRowBindNameModelMethodInfo a signature where+    overloadedMethod _ = comboRowBindNameModel++#endif++-- method ComboRow::get_model+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ComboRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyComboRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gio", name = "ListModel"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_combo_row_get_model" hdy_combo_row_get_model :: +    Ptr ComboRow ->                         -- self : TInterface (Name {namespace = "Handy", name = "ComboRow"})+    IO (Ptr Gio.ListModel.ListModel)++{- |+Gets the model bound to /@self@/, or 'Nothing' if none is bound.++/Since: 0.0.6/+-}+comboRowGetModel ::+    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ComboRow.ComboRow' -}+    -> m (Maybe Gio.ListModel.ListModel)+    {- ^ __Returns:__ the 'GI.Gio.Interfaces.ListModel.ListModel' bound to /@self@/ or 'Nothing' -}+comboRowGetModel self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_combo_row_get_model self'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (newObject Gio.ListModel.ListModel) result'+        return result''+    touchManagedPtr self+    return maybeResult++#if ENABLE_OVERLOADING+data ComboRowGetModelMethodInfo+instance (signature ~ (m (Maybe Gio.ListModel.ListModel)), MonadIO m, IsComboRow a) => O.MethodInfo ComboRowGetModelMethodInfo a signature where+    overloadedMethod _ = comboRowGetModel++#endif++-- method ComboRow::get_selected_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ComboRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkListBoxRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_combo_row_get_selected_index" hdy_combo_row_get_selected_index :: +    Ptr ComboRow ->                         -- self : TInterface (Name {namespace = "Handy", name = "ComboRow"})+    IO Int32++{- |+Gets the index of the selected item in its 'GI.Gio.Interfaces.ListModel.ListModel'.++/Since: 0.0.7/+-}+comboRowGetSelectedIndex ::+    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a) =>+    a+    {- ^ /@self@/: a 'GI.Gtk.Objects.ListBoxRow.ListBoxRow' -}+    -> m Int32+    {- ^ __Returns:__ the index of the selected item, or -1 if no item is selected -}+comboRowGetSelectedIndex self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_combo_row_get_selected_index self'+    touchManagedPtr self+    return result++#if ENABLE_OVERLOADING+data ComboRowGetSelectedIndexMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsComboRow a) => O.MethodInfo ComboRowGetSelectedIndexMethodInfo a signature where+    overloadedMethod _ = comboRowGetSelectedIndex++#endif++-- method ComboRow::set_for_enum+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ComboRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyComboRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enum_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the enumeration #GType to be bound to @self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "get_name_func", argType = TInterface (Name {namespace = "Handy", name = "ComboRowGetEnumValueNameFunc"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a function that creates names for items, or %NULL\n  in case you also passed %NULL as @model", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to @get_name_func", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data_free_func", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "function for freeing @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_combo_row_set_for_enum" hdy_combo_row_set_for_enum :: +    Ptr ComboRow ->                         -- self : TInterface (Name {namespace = "Handy", name = "ComboRow"})+    CGType ->                               -- enum_type : TBasicType TGType+    FunPtr Handy.Callbacks.C_ComboRowGetEnumValueNameFunc -> -- get_name_func : TInterface (Name {namespace = "Handy", name = "ComboRowGetEnumValueNameFunc"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    FunPtr GLib.Callbacks.C_DestroyNotify -> -- user_data_free_func : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})+    IO ()++{- |+Creates a model for /@enumType@/ and binds it to /@self@/. The items of the model+will be 'GI.Handy.Objects.EnumValueObject.EnumValueObject' objects.++If /@self@/ was already bound to a model, that previous binding is destroyed.++The contents of /@self@/ are cleared and then filled with widgets that represent+items from /@model@/. /@self@/ is updated whenever /@model@/ changes. If /@model@/ is+'Nothing', /@self@/ is left empty.++This is more conventient to use than 'GI.Handy.Objects.ComboRow.comboRowBindNameModel' if you+want to represent values of an enumeration with names.++See 'GI.Handy.Functions.enumValueRowName'.++/Since: 0.0.6/+-}+comboRowSetForEnum ::+    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ComboRow.ComboRow' -}+    -> GType+    {- ^ /@enumType@/: the enumeration 'GType' to be bound to /@self@/ -}+    -> Maybe (Handy.Callbacks.ComboRowGetEnumValueNameFunc)+    {- ^ /@getNameFunc@/: a function that creates names for items, or 'Nothing'+  in case you also passed 'Nothing' as /@model@/ -}+    -> m ()+comboRowSetForEnum self enumType getNameFunc = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    let enumType' = gtypeToCGType enumType+    maybeGetNameFunc <- case getNameFunc of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jGetNameFunc -> do+            jGetNameFunc' <- Handy.Callbacks.mk_ComboRowGetEnumValueNameFunc (Handy.Callbacks.wrap_ComboRowGetEnumValueNameFunc Nothing (Handy.Callbacks.drop_closures_ComboRowGetEnumValueNameFunc jGetNameFunc))+            return jGetNameFunc'+    let userData = castFunPtrToPtr maybeGetNameFunc+    let userDataFreeFunc = safeFreeFunPtrPtr+    hdy_combo_row_set_for_enum self' enumType' maybeGetNameFunc userData userDataFreeFunc+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data ComboRowSetForEnumMethodInfo+instance (signature ~ (GType -> Maybe (Handy.Callbacks.ComboRowGetEnumValueNameFunc) -> m ()), MonadIO m, IsComboRow a) => O.MethodInfo ComboRowSetForEnumMethodInfo a signature where+    overloadedMethod _ = comboRowSetForEnum++#endif++-- method ComboRow::set_selected_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ComboRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyComboRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "selected_index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the selected item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_combo_row_set_selected_index" hdy_combo_row_set_selected_index :: +    Ptr ComboRow ->                         -- self : TInterface (Name {namespace = "Handy", name = "ComboRow"})+    Int32 ->                                -- selected_index : TBasicType TInt+    IO ()++{- |+Sets the index of the selected item in its 'GI.Gio.Interfaces.ListModel.ListModel'.++/Since: 0.0.7/+-}+comboRowSetSelectedIndex ::+    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ComboRow.ComboRow' -}+    -> Int32+    {- ^ /@selectedIndex@/: the index of the selected item -}+    -> m ()+comboRowSetSelectedIndex self selectedIndex = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    hdy_combo_row_set_selected_index self' selectedIndex+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data ComboRowSetSelectedIndexMethodInfo+instance (signature ~ (Int32 -> m ()), MonadIO m, IsComboRow a) => O.MethodInfo ComboRowSetSelectedIndexMethodInfo a signature where+    overloadedMethod _ = comboRowSetSelectedIndex++#endif++
+ GI/Handy/Objects/ComboRow.hs-boot view
@@ -0,0 +1,50 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Handy.Objects.ComboRow 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 ComboRow = ComboRow (ManagedPtr ComboRow)+instance GObject ComboRow where+class (GObject o, O.IsDescendantOf ComboRow o) => IsComboRow o+instance (GObject o, O.IsDescendantOf ComboRow o) => IsComboRow o+instance O.HasParentTypes ComboRow+#if ENABLE_OVERLOADING+data ComboRowSelectedIndexPropertyInfo+#endif+#if ENABLE_OVERLOADING+data ComboRowBindModelMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComboRowBindNameModelMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComboRowGetModelMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComboRowGetSelectedIndexMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComboRowSetForEnumMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComboRowSetSelectedIndexMethodInfo+#endif
+ GI/Handy/Objects/Dialer.hs view
@@ -0,0 +1,1387 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Handy.Objects.Dialer+    ( ++-- * Exported types+    Dialer(..)                              ,+    IsDialer                                ,+    toDialer                                ,+    noDialer                                ,+++ -- * Methods+-- ** clearNumber #method:clearNumber#++#if ENABLE_OVERLOADING+    DialerClearNumberMethodInfo             ,+#endif+    dialerClearNumber                       ,+++-- ** getNumber #method:getNumber#++#if ENABLE_OVERLOADING+    DialerGetNumberMethodInfo               ,+#endif+    dialerGetNumber                         ,+++-- ** getRelief #method:getRelief#++#if ENABLE_OVERLOADING+    DialerGetReliefMethodInfo               ,+#endif+    dialerGetRelief                         ,+++-- ** getShowActionButtons #method:getShowActionButtons#++#if ENABLE_OVERLOADING+    DialerGetShowActionButtonsMethodInfo    ,+#endif+    dialerGetShowActionButtons              ,+++-- ** new #method:new#++    dialerNew                               ,+++-- ** setNumber #method:setNumber#++#if ENABLE_OVERLOADING+    DialerSetNumberMethodInfo               ,+#endif+    dialerSetNumber                         ,+++-- ** setRelief #method:setRelief#++#if ENABLE_OVERLOADING+    DialerSetReliefMethodInfo               ,+#endif+    dialerSetRelief                         ,+++-- ** setShowActionButtons #method:setShowActionButtons#++#if ENABLE_OVERLOADING+    DialerSetShowActionButtonsMethodInfo    ,+#endif+    dialerSetShowActionButtons              ,+++++ -- * Properties+-- ** columnSpacing #attr:columnSpacing#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    DialerColumnSpacingPropertyInfo         ,+#endif+    constructDialerColumnSpacing            ,+#if ENABLE_OVERLOADING+    dialerColumnSpacing                     ,+#endif+    getDialerColumnSpacing                  ,+    setDialerColumnSpacing                  ,+++-- ** number #attr:number#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    DialerNumberPropertyInfo                ,+#endif+    constructDialerNumber                   ,+#if ENABLE_OVERLOADING+    dialerNumber                            ,+#endif+    getDialerNumber                         ,+    setDialerNumber                         ,+++-- ** relief #attr:relief#+{- | The relief style of the edges of the main buttons.+-}+#if ENABLE_OVERLOADING+    DialerReliefPropertyInfo                ,+#endif+    constructDialerRelief                   ,+#if ENABLE_OVERLOADING+    dialerRelief                            ,+#endif+    getDialerRelief                         ,+    setDialerRelief                         ,+++-- ** rowSpacing #attr:rowSpacing#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    DialerRowSpacingPropertyInfo            ,+#endif+    constructDialerRowSpacing               ,+#if ENABLE_OVERLOADING+    dialerRowSpacing                        ,+#endif+    getDialerRowSpacing                     ,+    setDialerRowSpacing                     ,+++-- ** showActionButtons #attr:showActionButtons#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    DialerShowActionButtonsPropertyInfo     ,+#endif+    constructDialerShowActionButtons        ,+#if ENABLE_OVERLOADING+    dialerShowActionButtons                 ,+#endif+    getDialerShowActionButtons              ,+    setDialerShowActionButtons              ,+++++ -- * Signals+-- ** deleted #signal:deleted#++    C_DialerDeletedCallback                 ,+    DialerDeletedCallback                   ,+#if ENABLE_OVERLOADING+    DialerDeletedSignalInfo                 ,+#endif+    afterDialerDeleted                      ,+    genClosure_DialerDeleted                ,+    mk_DialerDeletedCallback                ,+    noDialerDeletedCallback                 ,+    onDialerDeleted                         ,+    wrap_DialerDeletedCallback              ,+++-- ** submitted #signal:submitted#++    C_DialerSubmittedCallback               ,+    DialerSubmittedCallback                 ,+#if ENABLE_OVERLOADING+    DialerSubmittedSignalInfo               ,+#endif+    afterDialerSubmitted                    ,+    genClosure_DialerSubmitted              ,+    mk_DialerSubmittedCallback              ,+    noDialerSubmittedCallback               ,+    onDialerSubmitted                       ,+    wrap_DialerSubmittedCallback            ,+++-- ** symbolClicked #signal:symbolClicked#++    C_DialerSymbolClickedCallback           ,+    DialerSymbolClickedCallback             ,+#if ENABLE_OVERLOADING+    DialerSymbolClickedSignalInfo           ,+#endif+    afterDialerSymbolClicked                ,+    genClosure_DialerSymbolClicked          ,+    mk_DialerSymbolClickedCallback          ,+    noDialerSymbolClickedCallback           ,+    onDialerSymbolClicked                   ,+    wrap_DialerSymbolClickedCallback        ,+++++    ) 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 qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gtk.Enums as Gtk.Enums+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable+import qualified GI.Gtk.Objects.Bin as Gtk.Bin+import qualified GI.Gtk.Objects.Container as Gtk.Container+import qualified GI.Gtk.Objects.Widget as Gtk.Widget++-- | Memory-managed wrapper type.+newtype Dialer = Dialer (ManagedPtr Dialer)+foreign import ccall "hdy_dialer_get_type"+    c_hdy_dialer_get_type :: IO GType++instance GObject Dialer where+    gobjectType = c_hdy_dialer_get_type+    ++-- | Type class for types which can be safely cast to `Dialer`, for instance with `toDialer`.+class (GObject o, O.IsDescendantOf Dialer o) => IsDialer o+instance (GObject o, O.IsDescendantOf Dialer o) => IsDialer o++instance O.HasParentTypes Dialer+type instance O.ParentTypes Dialer = '[Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable]++-- | Cast to `Dialer`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toDialer :: (MonadIO m, IsDialer o) => o -> m Dialer+toDialer = liftIO . unsafeCastTo Dialer++-- | A convenience alias for `Nothing` :: `Maybe` `Dialer`.+noDialer :: Maybe Dialer+noDialer = Nothing++#if ENABLE_OVERLOADING+type family ResolveDialerMethod (t :: Symbol) (o :: *) :: * where+    ResolveDialerMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo+    ResolveDialerMethod "add" o = Gtk.Container.ContainerAddMethodInfo+    ResolveDialerMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo+    ResolveDialerMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo+    ResolveDialerMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo+    ResolveDialerMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo+    ResolveDialerMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo+    ResolveDialerMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo+    ResolveDialerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveDialerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveDialerMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo+    ResolveDialerMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo+    ResolveDialerMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo+    ResolveDialerMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo+    ResolveDialerMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo+    ResolveDialerMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo+    ResolveDialerMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo+    ResolveDialerMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo+    ResolveDialerMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo+    ResolveDialerMethod "clearNumber" o = DialerClearNumberMethodInfo+    ResolveDialerMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo+    ResolveDialerMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo+    ResolveDialerMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo+    ResolveDialerMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo+    ResolveDialerMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo+    ResolveDialerMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo+    ResolveDialerMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo+    ResolveDialerMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo+    ResolveDialerMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo+    ResolveDialerMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo+    ResolveDialerMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo+    ResolveDialerMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo+    ResolveDialerMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo+    ResolveDialerMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo+    ResolveDialerMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo+    ResolveDialerMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo+    ResolveDialerMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo+    ResolveDialerMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo+    ResolveDialerMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo+    ResolveDialerMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo+    ResolveDialerMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo+    ResolveDialerMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo+    ResolveDialerMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo+    ResolveDialerMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo+    ResolveDialerMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo+    ResolveDialerMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo+    ResolveDialerMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo+    ResolveDialerMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo+    ResolveDialerMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo+    ResolveDialerMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo+    ResolveDialerMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo+    ResolveDialerMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo+    ResolveDialerMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo+    ResolveDialerMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo+    ResolveDialerMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo+    ResolveDialerMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo+    ResolveDialerMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo+    ResolveDialerMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo+    ResolveDialerMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo+    ResolveDialerMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo+    ResolveDialerMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo+    ResolveDialerMethod "event" o = Gtk.Widget.WidgetEventMethodInfo+    ResolveDialerMethod "forall" o = Gtk.Container.ContainerForallMethodInfo+    ResolveDialerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveDialerMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo+    ResolveDialerMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo+    ResolveDialerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveDialerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveDialerMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo+    ResolveDialerMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo+    ResolveDialerMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo+    ResolveDialerMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo+    ResolveDialerMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo+    ResolveDialerMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo+    ResolveDialerMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo+    ResolveDialerMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo+    ResolveDialerMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo+    ResolveDialerMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo+    ResolveDialerMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo+    ResolveDialerMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo+    ResolveDialerMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo+    ResolveDialerMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo+    ResolveDialerMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo+    ResolveDialerMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo+    ResolveDialerMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo+    ResolveDialerMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo+    ResolveDialerMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo+    ResolveDialerMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo+    ResolveDialerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveDialerMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo+    ResolveDialerMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo+    ResolveDialerMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo+    ResolveDialerMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo+    ResolveDialerMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo+    ResolveDialerMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo+    ResolveDialerMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo+    ResolveDialerMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo+    ResolveDialerMethod "map" o = Gtk.Widget.WidgetMapMethodInfo+    ResolveDialerMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo+    ResolveDialerMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo+    ResolveDialerMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo+    ResolveDialerMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo+    ResolveDialerMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo+    ResolveDialerMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo+    ResolveDialerMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo+    ResolveDialerMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo+    ResolveDialerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveDialerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveDialerMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo+    ResolveDialerMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo+    ResolveDialerMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo+    ResolveDialerMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo+    ResolveDialerMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo+    ResolveDialerMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo+    ResolveDialerMethod "path" o = Gtk.Widget.WidgetPathMethodInfo+    ResolveDialerMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo+    ResolveDialerMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo+    ResolveDialerMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo+    ResolveDialerMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo+    ResolveDialerMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo+    ResolveDialerMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo+    ResolveDialerMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo+    ResolveDialerMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo+    ResolveDialerMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo+    ResolveDialerMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveDialerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveDialerMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo+    ResolveDialerMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo+    ResolveDialerMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo+    ResolveDialerMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo+    ResolveDialerMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo+    ResolveDialerMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo+    ResolveDialerMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo+    ResolveDialerMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo+    ResolveDialerMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo+    ResolveDialerMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo+    ResolveDialerMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo+    ResolveDialerMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo+    ResolveDialerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveDialerMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo+    ResolveDialerMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo+    ResolveDialerMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo+    ResolveDialerMethod "show" o = Gtk.Widget.WidgetShowMethodInfo+    ResolveDialerMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo+    ResolveDialerMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo+    ResolveDialerMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo+    ResolveDialerMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo+    ResolveDialerMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo+    ResolveDialerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveDialerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveDialerMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo+    ResolveDialerMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo+    ResolveDialerMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo+    ResolveDialerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveDialerMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo+    ResolveDialerMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo+    ResolveDialerMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo+    ResolveDialerMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo+    ResolveDialerMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo+    ResolveDialerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveDialerMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo+    ResolveDialerMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo+    ResolveDialerMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo+    ResolveDialerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveDialerMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo+    ResolveDialerMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo+    ResolveDialerMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo+    ResolveDialerMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo+    ResolveDialerMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo+    ResolveDialerMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo+    ResolveDialerMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo+    ResolveDialerMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo+    ResolveDialerMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo+    ResolveDialerMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo+    ResolveDialerMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo+    ResolveDialerMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo+    ResolveDialerMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo+    ResolveDialerMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo+    ResolveDialerMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo+    ResolveDialerMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo+    ResolveDialerMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo+    ResolveDialerMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo+    ResolveDialerMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo+    ResolveDialerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveDialerMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo+    ResolveDialerMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo+    ResolveDialerMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo+    ResolveDialerMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo+    ResolveDialerMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo+    ResolveDialerMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo+    ResolveDialerMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo+    ResolveDialerMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo+    ResolveDialerMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo+    ResolveDialerMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo+    ResolveDialerMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo+    ResolveDialerMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo+    ResolveDialerMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo+    ResolveDialerMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo+    ResolveDialerMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo+    ResolveDialerMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo+    ResolveDialerMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo+    ResolveDialerMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo+    ResolveDialerMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo+    ResolveDialerMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo+    ResolveDialerMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo+    ResolveDialerMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo+    ResolveDialerMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo+    ResolveDialerMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo+    ResolveDialerMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo+    ResolveDialerMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo+    ResolveDialerMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo+    ResolveDialerMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo+    ResolveDialerMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo+    ResolveDialerMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo+    ResolveDialerMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo+    ResolveDialerMethod "getNumber" o = DialerGetNumberMethodInfo+    ResolveDialerMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo+    ResolveDialerMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo+    ResolveDialerMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo+    ResolveDialerMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo+    ResolveDialerMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo+    ResolveDialerMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo+    ResolveDialerMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo+    ResolveDialerMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo+    ResolveDialerMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo+    ResolveDialerMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo+    ResolveDialerMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo+    ResolveDialerMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo+    ResolveDialerMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo+    ResolveDialerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveDialerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveDialerMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo+    ResolveDialerMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo+    ResolveDialerMethod "getRelief" o = DialerGetReliefMethodInfo+    ResolveDialerMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo+    ResolveDialerMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo+    ResolveDialerMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo+    ResolveDialerMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo+    ResolveDialerMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo+    ResolveDialerMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo+    ResolveDialerMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo+    ResolveDialerMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo+    ResolveDialerMethod "getShowActionButtons" o = DialerGetShowActionButtonsMethodInfo+    ResolveDialerMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo+    ResolveDialerMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo+    ResolveDialerMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo+    ResolveDialerMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo+    ResolveDialerMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo+    ResolveDialerMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo+    ResolveDialerMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo+    ResolveDialerMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo+    ResolveDialerMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo+    ResolveDialerMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo+    ResolveDialerMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo+    ResolveDialerMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo+    ResolveDialerMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo+    ResolveDialerMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo+    ResolveDialerMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo+    ResolveDialerMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo+    ResolveDialerMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo+    ResolveDialerMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo+    ResolveDialerMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo+    ResolveDialerMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo+    ResolveDialerMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo+    ResolveDialerMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo+    ResolveDialerMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo+    ResolveDialerMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo+    ResolveDialerMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo+    ResolveDialerMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo+    ResolveDialerMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo+    ResolveDialerMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo+    ResolveDialerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveDialerMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo+    ResolveDialerMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo+    ResolveDialerMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo+    ResolveDialerMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo+    ResolveDialerMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo+    ResolveDialerMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo+    ResolveDialerMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo+    ResolveDialerMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo+    ResolveDialerMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo+    ResolveDialerMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo+    ResolveDialerMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo+    ResolveDialerMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo+    ResolveDialerMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo+    ResolveDialerMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo+    ResolveDialerMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo+    ResolveDialerMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo+    ResolveDialerMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo+    ResolveDialerMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo+    ResolveDialerMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo+    ResolveDialerMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo+    ResolveDialerMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo+    ResolveDialerMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo+    ResolveDialerMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo+    ResolveDialerMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo+    ResolveDialerMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo+    ResolveDialerMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo+    ResolveDialerMethod "setNumber" o = DialerSetNumberMethodInfo+    ResolveDialerMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo+    ResolveDialerMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo+    ResolveDialerMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo+    ResolveDialerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveDialerMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo+    ResolveDialerMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo+    ResolveDialerMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo+    ResolveDialerMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo+    ResolveDialerMethod "setRelief" o = DialerSetReliefMethodInfo+    ResolveDialerMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo+    ResolveDialerMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo+    ResolveDialerMethod "setShowActionButtons" o = DialerSetShowActionButtonsMethodInfo+    ResolveDialerMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo+    ResolveDialerMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo+    ResolveDialerMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo+    ResolveDialerMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo+    ResolveDialerMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo+    ResolveDialerMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo+    ResolveDialerMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo+    ResolveDialerMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo+    ResolveDialerMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo+    ResolveDialerMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo+    ResolveDialerMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo+    ResolveDialerMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo+    ResolveDialerMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo+    ResolveDialerMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo+    ResolveDialerMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveDialerMethod t Dialer, O.MethodInfo info Dialer p) => OL.IsLabel t (Dialer -> 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++-- signal Dialer::deleted+{- |+This signal is emitted when the dialer\'s \'deleted\' button is clicked+to delete the last symbol.+-}+type DialerDeletedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `DialerDeletedCallback`@.+noDialerDeletedCallback :: Maybe DialerDeletedCallback+noDialerDeletedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_DialerDeletedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_DialerDeletedCallback`.+foreign import ccall "wrapper"+    mk_DialerDeletedCallback :: C_DialerDeletedCallback -> IO (FunPtr C_DialerDeletedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_DialerDeleted :: MonadIO m => DialerDeletedCallback -> m (GClosure C_DialerDeletedCallback)+genClosure_DialerDeleted cb = liftIO $ do+    let cb' = wrap_DialerDeletedCallback cb+    mk_DialerDeletedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `DialerDeletedCallback` into a `C_DialerDeletedCallback`.+wrap_DialerDeletedCallback ::+    DialerDeletedCallback ->+    C_DialerDeletedCallback+wrap_DialerDeletedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@deleted@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' dialer #deleted callback+@+-}+onDialerDeleted :: (IsDialer a, MonadIO m) => a -> DialerDeletedCallback -> m SignalHandlerId+onDialerDeleted obj cb = liftIO $ do+    let cb' = wrap_DialerDeletedCallback cb+    cb'' <- mk_DialerDeletedCallback cb'+    connectSignalFunPtr obj "deleted" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@deleted@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' dialer #deleted callback+@+-}+afterDialerDeleted :: (IsDialer a, MonadIO m) => a -> DialerDeletedCallback -> m SignalHandlerId+afterDialerDeleted obj cb = liftIO $ do+    let cb' = wrap_DialerDeletedCallback cb+    cb'' <- mk_DialerDeletedCallback cb'+    connectSignalFunPtr obj "deleted" cb'' SignalConnectAfter+++-- signal Dialer::submitted+{- |+This signal is emitted when the dialer\'s \'dial\' button is activated.+Connect to this signal to perform to get notified when the user+wants to submit the dialed number.+-}+type DialerSubmittedCallback =+    T.Text+    {- ^ /@number@/: The number at the time of activation. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `DialerSubmittedCallback`@.+noDialerSubmittedCallback :: Maybe DialerSubmittedCallback+noDialerSubmittedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_DialerSubmittedCallback =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_DialerSubmittedCallback`.+foreign import ccall "wrapper"+    mk_DialerSubmittedCallback :: C_DialerSubmittedCallback -> IO (FunPtr C_DialerSubmittedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_DialerSubmitted :: MonadIO m => DialerSubmittedCallback -> m (GClosure C_DialerSubmittedCallback)+genClosure_DialerSubmitted cb = liftIO $ do+    let cb' = wrap_DialerSubmittedCallback cb+    mk_DialerSubmittedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `DialerSubmittedCallback` into a `C_DialerSubmittedCallback`.+wrap_DialerSubmittedCallback ::+    DialerSubmittedCallback ->+    C_DialerSubmittedCallback+wrap_DialerSubmittedCallback _cb _ number _ = do+    number' <- cstringToText number+    _cb  number'+++{- |+Connect a signal handler for the “@submitted@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' dialer #submitted callback+@+-}+onDialerSubmitted :: (IsDialer a, MonadIO m) => a -> DialerSubmittedCallback -> m SignalHandlerId+onDialerSubmitted obj cb = liftIO $ do+    let cb' = wrap_DialerSubmittedCallback cb+    cb'' <- mk_DialerSubmittedCallback cb'+    connectSignalFunPtr obj "submitted" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@submitted@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' dialer #submitted callback+@+-}+afterDialerSubmitted :: (IsDialer a, MonadIO m) => a -> DialerSubmittedCallback -> m SignalHandlerId+afterDialerSubmitted obj cb = liftIO $ do+    let cb' = wrap_DialerSubmittedCallback cb+    cb'' <- mk_DialerSubmittedCallback cb'+    connectSignalFunPtr obj "submitted" cb'' SignalConnectAfter+++-- signal Dialer::symbol-clicked+{- |+This signal is emitted when one of the symbol buttons (0-9, # or *)+is clicked. Connect to this signal to find out which button was pressed.+This doesn\'t take any cycling modes into account. So the button with \"*\"+and \"+\" on it will always send \"*\".  Delete and Submit buttons will+not trigger this signal.+-}+type DialerSymbolClickedCallback =+    Int8+    {- ^ /@button@/: The main symbol on the button that was clicked -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `DialerSymbolClickedCallback`@.+noDialerSymbolClickedCallback :: Maybe DialerSymbolClickedCallback+noDialerSymbolClickedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_DialerSymbolClickedCallback =+    Ptr () ->                               -- object+    Int8 ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_DialerSymbolClickedCallback`.+foreign import ccall "wrapper"+    mk_DialerSymbolClickedCallback :: C_DialerSymbolClickedCallback -> IO (FunPtr C_DialerSymbolClickedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_DialerSymbolClicked :: MonadIO m => DialerSymbolClickedCallback -> m (GClosure C_DialerSymbolClickedCallback)+genClosure_DialerSymbolClicked cb = liftIO $ do+    let cb' = wrap_DialerSymbolClickedCallback cb+    mk_DialerSymbolClickedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `DialerSymbolClickedCallback` into a `C_DialerSymbolClickedCallback`.+wrap_DialerSymbolClickedCallback ::+    DialerSymbolClickedCallback ->+    C_DialerSymbolClickedCallback+wrap_DialerSymbolClickedCallback _cb _ button _ = do+    _cb  button+++{- |+Connect a signal handler for the “@symbol-clicked@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' dialer #symbolClicked callback+@+-}+onDialerSymbolClicked :: (IsDialer a, MonadIO m) => a -> DialerSymbolClickedCallback -> m SignalHandlerId+onDialerSymbolClicked obj cb = liftIO $ do+    let cb' = wrap_DialerSymbolClickedCallback cb+    cb'' <- mk_DialerSymbolClickedCallback cb'+    connectSignalFunPtr obj "symbol-clicked" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@symbol-clicked@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' dialer #symbolClicked callback+@+-}+afterDialerSymbolClicked :: (IsDialer a, MonadIO m) => a -> DialerSymbolClickedCallback -> m SignalHandlerId+afterDialerSymbolClicked obj cb = liftIO $ do+    let cb' = wrap_DialerSymbolClickedCallback cb+    cb'' <- mk_DialerSymbolClickedCallback cb'+    connectSignalFunPtr obj "symbol-clicked" cb'' SignalConnectAfter+++-- VVV Prop "column-spacing"+   -- Type: TBasicType TUInt+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@column-spacing@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' dialer #columnSpacing+@+-}+getDialerColumnSpacing :: (MonadIO m, IsDialer o) => o -> m Word32+getDialerColumnSpacing obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "column-spacing"++{- |+Set the value of the “@column-spacing@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' dialer [ #columnSpacing 'Data.GI.Base.Attributes.:=' value ]+@+-}+setDialerColumnSpacing :: (MonadIO m, IsDialer o) => o -> Word32 -> m ()+setDialerColumnSpacing obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "column-spacing" val++{- |+Construct a `GValueConstruct` with valid value for the “@column-spacing@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructDialerColumnSpacing :: (IsDialer o) => Word32 -> IO (GValueConstruct o)+constructDialerColumnSpacing val = B.Properties.constructObjectPropertyUInt32 "column-spacing" val++#if ENABLE_OVERLOADING+data DialerColumnSpacingPropertyInfo+instance AttrInfo DialerColumnSpacingPropertyInfo where+    type AttrAllowedOps DialerColumnSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DialerColumnSpacingPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint DialerColumnSpacingPropertyInfo = IsDialer+    type AttrGetType DialerColumnSpacingPropertyInfo = Word32+    type AttrLabel DialerColumnSpacingPropertyInfo = "column-spacing"+    type AttrOrigin DialerColumnSpacingPropertyInfo = Dialer+    attrGet _ = getDialerColumnSpacing+    attrSet _ = setDialerColumnSpacing+    attrConstruct _ = constructDialerColumnSpacing+    attrClear _ = undefined+#endif++-- VVV Prop "number"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@number@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' dialer #number+@+-}+getDialerNumber :: (MonadIO m, IsDialer o) => o -> m T.Text+getDialerNumber obj = liftIO $ checkUnexpectedNothing "getDialerNumber" $ B.Properties.getObjectPropertyString obj "number"++{- |+Set the value of the “@number@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' dialer [ #number 'Data.GI.Base.Attributes.:=' value ]+@+-}+setDialerNumber :: (MonadIO m, IsDialer o) => o -> T.Text -> m ()+setDialerNumber obj val = liftIO $ B.Properties.setObjectPropertyString obj "number" (Just val)++{- |+Construct a `GValueConstruct` with valid value for the “@number@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructDialerNumber :: (IsDialer o) => T.Text -> IO (GValueConstruct o)+constructDialerNumber val = B.Properties.constructObjectPropertyString "number" (Just val)++#if ENABLE_OVERLOADING+data DialerNumberPropertyInfo+instance AttrInfo DialerNumberPropertyInfo where+    type AttrAllowedOps DialerNumberPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DialerNumberPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint DialerNumberPropertyInfo = IsDialer+    type AttrGetType DialerNumberPropertyInfo = T.Text+    type AttrLabel DialerNumberPropertyInfo = "number"+    type AttrOrigin DialerNumberPropertyInfo = Dialer+    attrGet _ = getDialerNumber+    attrSet _ = setDialerNumber+    attrConstruct _ = constructDialerNumber+    attrClear _ = undefined+#endif++-- VVV Prop "relief"+   -- Type: TInterface (Name {namespace = "Gtk", name = "ReliefStyle"})+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@relief@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' dialer #relief+@+-}+getDialerRelief :: (MonadIO m, IsDialer o) => o -> m Gtk.Enums.ReliefStyle+getDialerRelief obj = liftIO $ B.Properties.getObjectPropertyEnum obj "relief"++{- |+Set the value of the “@relief@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' dialer [ #relief 'Data.GI.Base.Attributes.:=' value ]+@+-}+setDialerRelief :: (MonadIO m, IsDialer o) => o -> Gtk.Enums.ReliefStyle -> m ()+setDialerRelief obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "relief" val++{- |+Construct a `GValueConstruct` with valid value for the “@relief@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructDialerRelief :: (IsDialer o) => Gtk.Enums.ReliefStyle -> IO (GValueConstruct o)+constructDialerRelief val = B.Properties.constructObjectPropertyEnum "relief" val++#if ENABLE_OVERLOADING+data DialerReliefPropertyInfo+instance AttrInfo DialerReliefPropertyInfo where+    type AttrAllowedOps DialerReliefPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DialerReliefPropertyInfo = (~) Gtk.Enums.ReliefStyle+    type AttrBaseTypeConstraint DialerReliefPropertyInfo = IsDialer+    type AttrGetType DialerReliefPropertyInfo = Gtk.Enums.ReliefStyle+    type AttrLabel DialerReliefPropertyInfo = "relief"+    type AttrOrigin DialerReliefPropertyInfo = Dialer+    attrGet _ = getDialerRelief+    attrSet _ = setDialerRelief+    attrConstruct _ = constructDialerRelief+    attrClear _ = undefined+#endif++-- VVV Prop "row-spacing"+   -- Type: TBasicType TUInt+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@row-spacing@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' dialer #rowSpacing+@+-}+getDialerRowSpacing :: (MonadIO m, IsDialer o) => o -> m Word32+getDialerRowSpacing obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "row-spacing"++{- |+Set the value of the “@row-spacing@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' dialer [ #rowSpacing 'Data.GI.Base.Attributes.:=' value ]+@+-}+setDialerRowSpacing :: (MonadIO m, IsDialer o) => o -> Word32 -> m ()+setDialerRowSpacing obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "row-spacing" val++{- |+Construct a `GValueConstruct` with valid value for the “@row-spacing@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructDialerRowSpacing :: (IsDialer o) => Word32 -> IO (GValueConstruct o)+constructDialerRowSpacing val = B.Properties.constructObjectPropertyUInt32 "row-spacing" val++#if ENABLE_OVERLOADING+data DialerRowSpacingPropertyInfo+instance AttrInfo DialerRowSpacingPropertyInfo where+    type AttrAllowedOps DialerRowSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DialerRowSpacingPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint DialerRowSpacingPropertyInfo = IsDialer+    type AttrGetType DialerRowSpacingPropertyInfo = Word32+    type AttrLabel DialerRowSpacingPropertyInfo = "row-spacing"+    type AttrOrigin DialerRowSpacingPropertyInfo = Dialer+    attrGet _ = getDialerRowSpacing+    attrSet _ = setDialerRowSpacing+    attrConstruct _ = constructDialerRowSpacing+    attrClear _ = undefined+#endif++-- VVV Prop "show-action-buttons"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@show-action-buttons@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' dialer #showActionButtons+@+-}+getDialerShowActionButtons :: (MonadIO m, IsDialer o) => o -> m Bool+getDialerShowActionButtons obj = liftIO $ B.Properties.getObjectPropertyBool obj "show-action-buttons"++{- |+Set the value of the “@show-action-buttons@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' dialer [ #showActionButtons 'Data.GI.Base.Attributes.:=' value ]+@+-}+setDialerShowActionButtons :: (MonadIO m, IsDialer o) => o -> Bool -> m ()+setDialerShowActionButtons obj val = liftIO $ B.Properties.setObjectPropertyBool obj "show-action-buttons" val++{- |+Construct a `GValueConstruct` with valid value for the “@show-action-buttons@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructDialerShowActionButtons :: (IsDialer o) => Bool -> IO (GValueConstruct o)+constructDialerShowActionButtons val = B.Properties.constructObjectPropertyBool "show-action-buttons" val++#if ENABLE_OVERLOADING+data DialerShowActionButtonsPropertyInfo+instance AttrInfo DialerShowActionButtonsPropertyInfo where+    type AttrAllowedOps DialerShowActionButtonsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DialerShowActionButtonsPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint DialerShowActionButtonsPropertyInfo = IsDialer+    type AttrGetType DialerShowActionButtonsPropertyInfo = Bool+    type AttrLabel DialerShowActionButtonsPropertyInfo = "show-action-buttons"+    type AttrOrigin DialerShowActionButtonsPropertyInfo = Dialer+    attrGet _ = getDialerShowActionButtons+    attrSet _ = setDialerShowActionButtons+    attrConstruct _ = constructDialerShowActionButtons+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList Dialer+type instance O.AttributeList Dialer = DialerAttributeList+type DialerAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("columnSpacing", DialerColumnSpacingPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("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), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("number", DialerNumberPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("relief", DialerReliefPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("rowSpacing", DialerRowSpacingPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("showActionButtons", DialerShowActionButtonsPropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("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+dialerColumnSpacing :: AttrLabelProxy "columnSpacing"+dialerColumnSpacing = AttrLabelProxy++dialerNumber :: AttrLabelProxy "number"+dialerNumber = AttrLabelProxy++dialerRelief :: AttrLabelProxy "relief"+dialerRelief = AttrLabelProxy++dialerRowSpacing :: AttrLabelProxy "rowSpacing"+dialerRowSpacing = AttrLabelProxy++dialerShowActionButtons :: AttrLabelProxy "showActionButtons"+dialerShowActionButtons = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+data DialerDeletedSignalInfo+instance SignalInfo DialerDeletedSignalInfo where+    type HaskellCallbackType DialerDeletedSignalInfo = DialerDeletedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_DialerDeletedCallback cb+        cb'' <- mk_DialerDeletedCallback cb'+        connectSignalFunPtr obj "deleted" cb'' connectMode++data DialerSubmittedSignalInfo+instance SignalInfo DialerSubmittedSignalInfo where+    type HaskellCallbackType DialerSubmittedSignalInfo = DialerSubmittedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_DialerSubmittedCallback cb+        cb'' <- mk_DialerSubmittedCallback cb'+        connectSignalFunPtr obj "submitted" cb'' connectMode++data DialerSymbolClickedSignalInfo+instance SignalInfo DialerSymbolClickedSignalInfo where+    type HaskellCallbackType DialerSymbolClickedSignalInfo = DialerSymbolClickedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_DialerSymbolClickedCallback cb+        cb'' <- mk_DialerSymbolClickedCallback cb'+        connectSignalFunPtr obj "symbol-clicked" cb'' connectMode++type instance O.SignalList Dialer = DialerSignalList+type DialerSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("deleted", DialerDeletedSignalInfo), '("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), '("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), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("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), '("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), '("submitted", DialerSubmittedSignalInfo), '("symbolClicked", DialerSymbolClickedSignalInfo), '("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 Dialer::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "Dialer"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_dialer_new" hdy_dialer_new :: +    IO (Ptr Dialer)++{- |+Create a new 'GI.Handy.Objects.Dialer.Dialer' widget.+-}+dialerNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Dialer+    {- ^ __Returns:__ the newly created 'GI.Handy.Objects.Dialer.Dialer' widget -}+dialerNew  = liftIO $ do+    result <- hdy_dialer_new+    checkUnexpectedReturnNULL "dialerNew" result+    result' <- (newObject Dialer) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Dialer::clear_number+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Dialer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyDialer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_dialer_clear_number" hdy_dialer_clear_number :: +    Ptr Dialer ->                           -- self : TInterface (Name {namespace = "Handy", name = "Dialer"})+    IO ()++{- |+Set the current number to the empty string. When the number is already+cleared no action is performed.+-}+dialerClearNumber ::+    (B.CallStack.HasCallStack, MonadIO m, IsDialer a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Dialer.Dialer' -}+    -> m ()+dialerClearNumber self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    hdy_dialer_clear_number self'+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data DialerClearNumberMethodInfo+instance (signature ~ (m ()), MonadIO m, IsDialer a) => O.MethodInfo DialerClearNumberMethodInfo a signature where+    overloadedMethod _ = dialerClearNumber++#endif++-- method Dialer::get_number+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Dialer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyDialer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_dialer_get_number" hdy_dialer_get_number :: +    Ptr Dialer ->                           -- self : TInterface (Name {namespace = "Handy", name = "Dialer"})+    IO CString++{- |+Get the currently displayed number.+-}+dialerGetNumber ::+    (B.CallStack.HasCallStack, MonadIO m, IsDialer a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Dialer.Dialer' -}+    -> m T.Text+    {- ^ __Returns:__ the current number in the display -}+dialerGetNumber self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_dialer_get_number self'+    checkUnexpectedReturnNULL "dialerGetNumber" result+    result' <- cstringToText result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data DialerGetNumberMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsDialer a) => O.MethodInfo DialerGetNumberMethodInfo a signature where+    overloadedMethod _ = dialerGetNumber++#endif++-- method Dialer::get_relief+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Dialer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #HdyDialer whose main buttons you want the #GtkReliefStyle from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "ReliefStyle"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_dialer_get_relief" hdy_dialer_get_relief :: +    Ptr Dialer ->                           -- self : TInterface (Name {namespace = "Handy", name = "Dialer"})+    IO CUInt++{- |+Returns the current relief style of the main buttons for the given+'GI.Handy.Objects.Dialer.Dialer'.+-}+dialerGetRelief ::+    (B.CallStack.HasCallStack, MonadIO m, IsDialer a) =>+    a+    {- ^ /@self@/: The 'GI.Handy.Objects.Dialer.Dialer' whose main buttons you want the 'GI.Gtk.Enums.ReliefStyle' from -}+    -> m Gtk.Enums.ReliefStyle+    {- ^ __Returns:__ The current 'GI.Gtk.Enums.ReliefStyle' -}+dialerGetRelief self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_dialer_get_relief self'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data DialerGetReliefMethodInfo+instance (signature ~ (m Gtk.Enums.ReliefStyle), MonadIO m, IsDialer a) => O.MethodInfo DialerGetReliefMethodInfo a signature where+    overloadedMethod _ = dialerGetRelief++#endif++-- method Dialer::get_show_action_buttons+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Dialer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyDialer", 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 "hdy_dialer_get_show_action_buttons" hdy_dialer_get_show_action_buttons :: +    Ptr Dialer ->                           -- self : TInterface (Name {namespace = "Handy", name = "Dialer"})+    IO CInt++{- |+Get whether the submit and delete buttons are to be shown.+-}+dialerGetShowActionButtons ::+    (B.CallStack.HasCallStack, MonadIO m, IsDialer a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Dialer.Dialer' -}+    -> m Bool+    {- ^ __Returns:__ whether the buttons are to be shown -}+dialerGetShowActionButtons self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_dialer_get_show_action_buttons self'+    let result' = (/= 0) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data DialerGetShowActionButtonsMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsDialer a) => O.MethodInfo DialerGetShowActionButtonsMethodInfo a signature where+    overloadedMethod _ = dialerGetShowActionButtons++#endif++-- method Dialer::set_number+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Dialer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyDialer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "number", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_dialer_set_number" hdy_dialer_set_number :: +    Ptr Dialer ->                           -- self : TInterface (Name {namespace = "Handy", name = "Dialer"})+    CString ->                              -- number : TBasicType TUTF8+    IO ()++{- |+Set the currently displayed number.+-}+dialerSetNumber ::+    (B.CallStack.HasCallStack, MonadIO m, IsDialer a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Dialer.Dialer' -}+    -> T.Text+    {- ^ /@number@/: the number to set -}+    -> m ()+dialerSetNumber self number = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    number' <- textToCString number+    hdy_dialer_set_number self' number'+    touchManagedPtr self+    freeMem number'+    return ()++#if ENABLE_OVERLOADING+data DialerSetNumberMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m, IsDialer a) => O.MethodInfo DialerSetNumberMethodInfo a signature where+    overloadedMethod _ = dialerSetNumber++#endif++-- method Dialer::set_relief+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Dialer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #HdyDialer whose main buttons you want to set relief styles of", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "relief", argType = TInterface (Name {namespace = "Gtk", name = "ReliefStyle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkReliefStyle as described above", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_dialer_set_relief" hdy_dialer_set_relief :: +    Ptr Dialer ->                           -- self : TInterface (Name {namespace = "Handy", name = "Dialer"})+    CUInt ->                                -- relief : TInterface (Name {namespace = "Gtk", name = "ReliefStyle"})+    IO ()++{- |+Sets the relief style of the edges of the main buttons for the given+'GI.Handy.Objects.Dialer.Dialer' widget.+Two styles exist, 'GI.Gtk.Enums.ReliefStyleNormal' and 'GI.Gtk.Enums.ReliefStyleNone'.+The default style is, as one can guess, 'GI.Gtk.Enums.ReliefStyleNormal'.+-}+dialerSetRelief ::+    (B.CallStack.HasCallStack, MonadIO m, IsDialer a) =>+    a+    {- ^ /@self@/: The 'GI.Handy.Objects.Dialer.Dialer' whose main buttons you want to set relief styles of -}+    -> Gtk.Enums.ReliefStyle+    {- ^ /@relief@/: The 'GI.Gtk.Enums.ReliefStyle' as described above -}+    -> m ()+dialerSetRelief self relief = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    let relief' = (fromIntegral . fromEnum) relief+    hdy_dialer_set_relief self' relief'+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data DialerSetReliefMethodInfo+instance (signature ~ (Gtk.Enums.ReliefStyle -> m ()), MonadIO m, IsDialer a) => O.MethodInfo DialerSetReliefMethodInfo a signature where+    overloadedMethod _ = dialerSetRelief++#endif++-- method Dialer::set_show_action_buttons+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Dialer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyDialer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "show", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to show the buttons", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_dialer_set_show_action_buttons" hdy_dialer_set_show_action_buttons :: +    Ptr Dialer ->                           -- self : TInterface (Name {namespace = "Handy", name = "Dialer"})+    CInt ->                                 -- show : TBasicType TBoolean+    IO ()++{- |+Set whether to show the submit and delete buttons.+-}+dialerSetShowActionButtons ::+    (B.CallStack.HasCallStack, MonadIO m, IsDialer a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Dialer.Dialer' -}+    -> Bool+    {- ^ /@show@/: whether to show the buttons -}+    -> m ()+dialerSetShowActionButtons self show_ = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    let show_' = (fromIntegral . fromEnum) show_+    hdy_dialer_set_show_action_buttons self' show_'+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data DialerSetShowActionButtonsMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsDialer a) => O.MethodInfo DialerSetShowActionButtonsMethodInfo a signature where+    overloadedMethod _ = dialerSetShowActionButtons++#endif++
+ GI/Handy/Objects/Dialer.hs-boot view
@@ -0,0 +1,74 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Handy.Objects.Dialer 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 Dialer = Dialer (ManagedPtr Dialer)+instance GObject Dialer where+class (GObject o, O.IsDescendantOf Dialer o) => IsDialer o+instance (GObject o, O.IsDescendantOf Dialer o) => IsDialer o+instance O.HasParentTypes Dialer+#if ENABLE_OVERLOADING+data DialerColumnSpacingPropertyInfo+#endif+#if ENABLE_OVERLOADING+data DialerNumberPropertyInfo+#endif+#if ENABLE_OVERLOADING+data DialerReliefPropertyInfo+#endif+#if ENABLE_OVERLOADING+data DialerRowSpacingPropertyInfo+#endif+#if ENABLE_OVERLOADING+data DialerShowActionButtonsPropertyInfo+#endif+#if ENABLE_OVERLOADING+data DialerDeletedSignalInfo+#endif+#if ENABLE_OVERLOADING+data DialerSubmittedSignalInfo+#endif+#if ENABLE_OVERLOADING+data DialerSymbolClickedSignalInfo+#endif+#if ENABLE_OVERLOADING+data DialerClearNumberMethodInfo+#endif+#if ENABLE_OVERLOADING+data DialerGetNumberMethodInfo+#endif+#if ENABLE_OVERLOADING+data DialerGetReliefMethodInfo+#endif+#if ENABLE_OVERLOADING+data DialerGetShowActionButtonsMethodInfo+#endif+#if ENABLE_OVERLOADING+data DialerSetNumberMethodInfo+#endif+#if ENABLE_OVERLOADING+data DialerSetReliefMethodInfo+#endif+#if ENABLE_OVERLOADING+data DialerSetShowActionButtonsMethodInfo+#endif
+ GI/Handy/Objects/DialerButton.hs view
@@ -0,0 +1,719 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Handy.Objects.DialerButton+    ( ++-- * Exported types+    DialerButton(..)                        ,+    IsDialerButton                          ,+    toDialerButton                          ,+    noDialerButton                          ,+++ -- * Methods+-- ** getDigit #method:getDigit#++#if ENABLE_OVERLOADING+    DialerButtonGetDigitMethodInfo          ,+#endif+    dialerButtonGetDigit                    ,+++-- ** getSymbols #method:getSymbols#++#if ENABLE_OVERLOADING+    DialerButtonGetSymbolsMethodInfo        ,+#endif+    dialerButtonGetSymbols                  ,+++-- ** new #method:new#++    dialerButtonNew                         ,+++++ -- * Properties+-- ** digit #attr:digit#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    DialerButtonDigitPropertyInfo           ,+#endif+#if ENABLE_OVERLOADING+    dialerButtonDigit                       ,+#endif+    getDialerButtonDigit                    ,+++-- ** symbols #attr:symbols#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    DialerButtonSymbolsPropertyInfo         ,+#endif+    clearDialerButtonSymbols                ,+    constructDialerButtonSymbols            ,+#if ENABLE_OVERLOADING+    dialerButtonSymbols                     ,+#endif+    getDialerButtonSymbols                  ,+    setDialerButtonSymbols                  ,+++++    ) 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 qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gtk.Interfaces.Actionable as Gtk.Actionable+import qualified GI.Gtk.Interfaces.Activatable as Gtk.Activatable+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable+import qualified GI.Gtk.Objects.Bin as Gtk.Bin+import qualified GI.Gtk.Objects.Button as Gtk.Button+import qualified GI.Gtk.Objects.Container as Gtk.Container+import qualified GI.Gtk.Objects.Widget as Gtk.Widget++-- | Memory-managed wrapper type.+newtype DialerButton = DialerButton (ManagedPtr DialerButton)+foreign import ccall "hdy_dialer_button_get_type"+    c_hdy_dialer_button_get_type :: IO GType++instance GObject DialerButton where+    gobjectType = c_hdy_dialer_button_get_type+    ++-- | Type class for types which can be safely cast to `DialerButton`, for instance with `toDialerButton`.+class (GObject o, O.IsDescendantOf DialerButton o) => IsDialerButton o+instance (GObject o, O.IsDescendantOf DialerButton o) => IsDialerButton o++instance O.HasParentTypes DialerButton+type instance O.ParentTypes DialerButton = '[Gtk.Button.Button, Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Actionable.Actionable, Gtk.Activatable.Activatable, Gtk.Buildable.Buildable]++-- | Cast to `DialerButton`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toDialerButton :: (MonadIO m, IsDialerButton o) => o -> m DialerButton+toDialerButton = liftIO . unsafeCastTo DialerButton++-- | A convenience alias for `Nothing` :: `Maybe` `DialerButton`.+noDialerButton :: Maybe DialerButton+noDialerButton = Nothing++#if ENABLE_OVERLOADING+type family ResolveDialerButtonMethod (t :: Symbol) (o :: *) :: * where+    ResolveDialerButtonMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo+    ResolveDialerButtonMethod "add" o = Gtk.Container.ContainerAddMethodInfo+    ResolveDialerButtonMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo+    ResolveDialerButtonMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo+    ResolveDialerButtonMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo+    ResolveDialerButtonMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo+    ResolveDialerButtonMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo+    ResolveDialerButtonMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo+    ResolveDialerButtonMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveDialerButtonMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveDialerButtonMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo+    ResolveDialerButtonMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo+    ResolveDialerButtonMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo+    ResolveDialerButtonMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo+    ResolveDialerButtonMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo+    ResolveDialerButtonMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo+    ResolveDialerButtonMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo+    ResolveDialerButtonMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo+    ResolveDialerButtonMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo+    ResolveDialerButtonMethod "clicked" o = Gtk.Button.ButtonClickedMethodInfo+    ResolveDialerButtonMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo+    ResolveDialerButtonMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo+    ResolveDialerButtonMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo+    ResolveDialerButtonMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo+    ResolveDialerButtonMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo+    ResolveDialerButtonMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo+    ResolveDialerButtonMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo+    ResolveDialerButtonMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo+    ResolveDialerButtonMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo+    ResolveDialerButtonMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo+    ResolveDialerButtonMethod "doSetRelatedAction" o = Gtk.Activatable.ActivatableDoSetRelatedActionMethodInfo+    ResolveDialerButtonMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo+    ResolveDialerButtonMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo+    ResolveDialerButtonMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo+    ResolveDialerButtonMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo+    ResolveDialerButtonMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo+    ResolveDialerButtonMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo+    ResolveDialerButtonMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo+    ResolveDialerButtonMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo+    ResolveDialerButtonMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo+    ResolveDialerButtonMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo+    ResolveDialerButtonMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo+    ResolveDialerButtonMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo+    ResolveDialerButtonMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo+    ResolveDialerButtonMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo+    ResolveDialerButtonMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo+    ResolveDialerButtonMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo+    ResolveDialerButtonMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo+    ResolveDialerButtonMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo+    ResolveDialerButtonMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo+    ResolveDialerButtonMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo+    ResolveDialerButtonMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo+    ResolveDialerButtonMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo+    ResolveDialerButtonMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo+    ResolveDialerButtonMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo+    ResolveDialerButtonMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo+    ResolveDialerButtonMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo+    ResolveDialerButtonMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo+    ResolveDialerButtonMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo+    ResolveDialerButtonMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo+    ResolveDialerButtonMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo+    ResolveDialerButtonMethod "enter" o = Gtk.Button.ButtonEnterMethodInfo+    ResolveDialerButtonMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo+    ResolveDialerButtonMethod "event" o = Gtk.Widget.WidgetEventMethodInfo+    ResolveDialerButtonMethod "forall" o = Gtk.Container.ContainerForallMethodInfo+    ResolveDialerButtonMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveDialerButtonMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo+    ResolveDialerButtonMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo+    ResolveDialerButtonMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveDialerButtonMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveDialerButtonMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo+    ResolveDialerButtonMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo+    ResolveDialerButtonMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo+    ResolveDialerButtonMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo+    ResolveDialerButtonMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo+    ResolveDialerButtonMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo+    ResolveDialerButtonMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo+    ResolveDialerButtonMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo+    ResolveDialerButtonMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo+    ResolveDialerButtonMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo+    ResolveDialerButtonMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo+    ResolveDialerButtonMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo+    ResolveDialerButtonMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo+    ResolveDialerButtonMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo+    ResolveDialerButtonMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo+    ResolveDialerButtonMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo+    ResolveDialerButtonMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo+    ResolveDialerButtonMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo+    ResolveDialerButtonMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo+    ResolveDialerButtonMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo+    ResolveDialerButtonMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveDialerButtonMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo+    ResolveDialerButtonMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo+    ResolveDialerButtonMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo+    ResolveDialerButtonMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo+    ResolveDialerButtonMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo+    ResolveDialerButtonMethod "leave" o = Gtk.Button.ButtonLeaveMethodInfo+    ResolveDialerButtonMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo+    ResolveDialerButtonMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo+    ResolveDialerButtonMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo+    ResolveDialerButtonMethod "map" o = Gtk.Widget.WidgetMapMethodInfo+    ResolveDialerButtonMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo+    ResolveDialerButtonMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo+    ResolveDialerButtonMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo+    ResolveDialerButtonMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo+    ResolveDialerButtonMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo+    ResolveDialerButtonMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo+    ResolveDialerButtonMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo+    ResolveDialerButtonMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo+    ResolveDialerButtonMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveDialerButtonMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveDialerButtonMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo+    ResolveDialerButtonMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo+    ResolveDialerButtonMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo+    ResolveDialerButtonMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo+    ResolveDialerButtonMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo+    ResolveDialerButtonMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo+    ResolveDialerButtonMethod "path" o = Gtk.Widget.WidgetPathMethodInfo+    ResolveDialerButtonMethod "pressed" o = Gtk.Button.ButtonPressedMethodInfo+    ResolveDialerButtonMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo+    ResolveDialerButtonMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo+    ResolveDialerButtonMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo+    ResolveDialerButtonMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo+    ResolveDialerButtonMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo+    ResolveDialerButtonMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo+    ResolveDialerButtonMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo+    ResolveDialerButtonMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo+    ResolveDialerButtonMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo+    ResolveDialerButtonMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveDialerButtonMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveDialerButtonMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo+    ResolveDialerButtonMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo+    ResolveDialerButtonMethod "released" o = Gtk.Button.ButtonReleasedMethodInfo+    ResolveDialerButtonMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo+    ResolveDialerButtonMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo+    ResolveDialerButtonMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo+    ResolveDialerButtonMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo+    ResolveDialerButtonMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo+    ResolveDialerButtonMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo+    ResolveDialerButtonMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo+    ResolveDialerButtonMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo+    ResolveDialerButtonMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo+    ResolveDialerButtonMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo+    ResolveDialerButtonMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveDialerButtonMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo+    ResolveDialerButtonMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo+    ResolveDialerButtonMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo+    ResolveDialerButtonMethod "show" o = Gtk.Widget.WidgetShowMethodInfo+    ResolveDialerButtonMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo+    ResolveDialerButtonMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo+    ResolveDialerButtonMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo+    ResolveDialerButtonMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo+    ResolveDialerButtonMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo+    ResolveDialerButtonMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveDialerButtonMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveDialerButtonMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo+    ResolveDialerButtonMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo+    ResolveDialerButtonMethod "syncActionProperties" o = Gtk.Activatable.ActivatableSyncActionPropertiesMethodInfo+    ResolveDialerButtonMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo+    ResolveDialerButtonMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveDialerButtonMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo+    ResolveDialerButtonMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo+    ResolveDialerButtonMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo+    ResolveDialerButtonMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo+    ResolveDialerButtonMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo+    ResolveDialerButtonMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveDialerButtonMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo+    ResolveDialerButtonMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo+    ResolveDialerButtonMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo+    ResolveDialerButtonMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveDialerButtonMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo+    ResolveDialerButtonMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo+    ResolveDialerButtonMethod "getActionName" o = Gtk.Actionable.ActionableGetActionNameMethodInfo+    ResolveDialerButtonMethod "getActionTargetValue" o = Gtk.Actionable.ActionableGetActionTargetValueMethodInfo+    ResolveDialerButtonMethod "getAlignment" o = Gtk.Button.ButtonGetAlignmentMethodInfo+    ResolveDialerButtonMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo+    ResolveDialerButtonMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo+    ResolveDialerButtonMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo+    ResolveDialerButtonMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo+    ResolveDialerButtonMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo+    ResolveDialerButtonMethod "getAlwaysShowImage" o = Gtk.Button.ButtonGetAlwaysShowImageMethodInfo+    ResolveDialerButtonMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo+    ResolveDialerButtonMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo+    ResolveDialerButtonMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo+    ResolveDialerButtonMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo+    ResolveDialerButtonMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo+    ResolveDialerButtonMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo+    ResolveDialerButtonMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo+    ResolveDialerButtonMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo+    ResolveDialerButtonMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo+    ResolveDialerButtonMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo+    ResolveDialerButtonMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo+    ResolveDialerButtonMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo+    ResolveDialerButtonMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveDialerButtonMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo+    ResolveDialerButtonMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo+    ResolveDialerButtonMethod "getDigit" o = DialerButtonGetDigitMethodInfo+    ResolveDialerButtonMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo+    ResolveDialerButtonMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo+    ResolveDialerButtonMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo+    ResolveDialerButtonMethod "getEventWindow" o = Gtk.Button.ButtonGetEventWindowMethodInfo+    ResolveDialerButtonMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo+    ResolveDialerButtonMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo+    ResolveDialerButtonMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo+    ResolveDialerButtonMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo+    ResolveDialerButtonMethod "getFocusOnClick" o = Gtk.Button.ButtonGetFocusOnClickMethodInfo+    ResolveDialerButtonMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo+    ResolveDialerButtonMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo+    ResolveDialerButtonMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo+    ResolveDialerButtonMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo+    ResolveDialerButtonMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo+    ResolveDialerButtonMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo+    ResolveDialerButtonMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo+    ResolveDialerButtonMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo+    ResolveDialerButtonMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo+    ResolveDialerButtonMethod "getImage" o = Gtk.Button.ButtonGetImageMethodInfo+    ResolveDialerButtonMethod "getImagePosition" o = Gtk.Button.ButtonGetImagePositionMethodInfo+    ResolveDialerButtonMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo+    ResolveDialerButtonMethod "getLabel" o = Gtk.Button.ButtonGetLabelMethodInfo+    ResolveDialerButtonMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo+    ResolveDialerButtonMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo+    ResolveDialerButtonMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo+    ResolveDialerButtonMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo+    ResolveDialerButtonMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo+    ResolveDialerButtonMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo+    ResolveDialerButtonMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo+    ResolveDialerButtonMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo+    ResolveDialerButtonMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo+    ResolveDialerButtonMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo+    ResolveDialerButtonMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo+    ResolveDialerButtonMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo+    ResolveDialerButtonMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo+    ResolveDialerButtonMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo+    ResolveDialerButtonMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo+    ResolveDialerButtonMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo+    ResolveDialerButtonMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo+    ResolveDialerButtonMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo+    ResolveDialerButtonMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo+    ResolveDialerButtonMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo+    ResolveDialerButtonMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo+    ResolveDialerButtonMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo+    ResolveDialerButtonMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo+    ResolveDialerButtonMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo+    ResolveDialerButtonMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveDialerButtonMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveDialerButtonMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo+    ResolveDialerButtonMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo+    ResolveDialerButtonMethod "getRelatedAction" o = Gtk.Activatable.ActivatableGetRelatedActionMethodInfo+    ResolveDialerButtonMethod "getRelief" o = Gtk.Button.ButtonGetReliefMethodInfo+    ResolveDialerButtonMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo+    ResolveDialerButtonMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo+    ResolveDialerButtonMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo+    ResolveDialerButtonMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo+    ResolveDialerButtonMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo+    ResolveDialerButtonMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo+    ResolveDialerButtonMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo+    ResolveDialerButtonMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo+    ResolveDialerButtonMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo+    ResolveDialerButtonMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo+    ResolveDialerButtonMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo+    ResolveDialerButtonMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo+    ResolveDialerButtonMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo+    ResolveDialerButtonMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo+    ResolveDialerButtonMethod "getSymbols" o = DialerButtonGetSymbolsMethodInfo+    ResolveDialerButtonMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo+    ResolveDialerButtonMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo+    ResolveDialerButtonMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo+    ResolveDialerButtonMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo+    ResolveDialerButtonMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo+    ResolveDialerButtonMethod "getUseActionAppearance" o = Gtk.Activatable.ActivatableGetUseActionAppearanceMethodInfo+    ResolveDialerButtonMethod "getUseStock" o = Gtk.Button.ButtonGetUseStockMethodInfo+    ResolveDialerButtonMethod "getUseUnderline" o = Gtk.Button.ButtonGetUseUnderlineMethodInfo+    ResolveDialerButtonMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo+    ResolveDialerButtonMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo+    ResolveDialerButtonMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo+    ResolveDialerButtonMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo+    ResolveDialerButtonMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo+    ResolveDialerButtonMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo+    ResolveDialerButtonMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo+    ResolveDialerButtonMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo+    ResolveDialerButtonMethod "setActionName" o = Gtk.Actionable.ActionableSetActionNameMethodInfo+    ResolveDialerButtonMethod "setActionTargetValue" o = Gtk.Actionable.ActionableSetActionTargetValueMethodInfo+    ResolveDialerButtonMethod "setAlignment" o = Gtk.Button.ButtonSetAlignmentMethodInfo+    ResolveDialerButtonMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo+    ResolveDialerButtonMethod "setAlwaysShowImage" o = Gtk.Button.ButtonSetAlwaysShowImageMethodInfo+    ResolveDialerButtonMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo+    ResolveDialerButtonMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo+    ResolveDialerButtonMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo+    ResolveDialerButtonMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo+    ResolveDialerButtonMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo+    ResolveDialerButtonMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo+    ResolveDialerButtonMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo+    ResolveDialerButtonMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo+    ResolveDialerButtonMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveDialerButtonMethod "setDetailedActionName" o = Gtk.Actionable.ActionableSetDetailedActionNameMethodInfo+    ResolveDialerButtonMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo+    ResolveDialerButtonMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo+    ResolveDialerButtonMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo+    ResolveDialerButtonMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo+    ResolveDialerButtonMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo+    ResolveDialerButtonMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo+    ResolveDialerButtonMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo+    ResolveDialerButtonMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo+    ResolveDialerButtonMethod "setFocusOnClick" o = Gtk.Button.ButtonSetFocusOnClickMethodInfo+    ResolveDialerButtonMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo+    ResolveDialerButtonMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo+    ResolveDialerButtonMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo+    ResolveDialerButtonMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo+    ResolveDialerButtonMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo+    ResolveDialerButtonMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo+    ResolveDialerButtonMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo+    ResolveDialerButtonMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo+    ResolveDialerButtonMethod "setImage" o = Gtk.Button.ButtonSetImageMethodInfo+    ResolveDialerButtonMethod "setImagePosition" o = Gtk.Button.ButtonSetImagePositionMethodInfo+    ResolveDialerButtonMethod "setLabel" o = Gtk.Button.ButtonSetLabelMethodInfo+    ResolveDialerButtonMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo+    ResolveDialerButtonMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo+    ResolveDialerButtonMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo+    ResolveDialerButtonMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo+    ResolveDialerButtonMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo+    ResolveDialerButtonMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo+    ResolveDialerButtonMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo+    ResolveDialerButtonMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo+    ResolveDialerButtonMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo+    ResolveDialerButtonMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo+    ResolveDialerButtonMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo+    ResolveDialerButtonMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo+    ResolveDialerButtonMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveDialerButtonMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo+    ResolveDialerButtonMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo+    ResolveDialerButtonMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo+    ResolveDialerButtonMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo+    ResolveDialerButtonMethod "setRelatedAction" o = Gtk.Activatable.ActivatableSetRelatedActionMethodInfo+    ResolveDialerButtonMethod "setRelief" o = Gtk.Button.ButtonSetReliefMethodInfo+    ResolveDialerButtonMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo+    ResolveDialerButtonMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo+    ResolveDialerButtonMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo+    ResolveDialerButtonMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo+    ResolveDialerButtonMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo+    ResolveDialerButtonMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo+    ResolveDialerButtonMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo+    ResolveDialerButtonMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo+    ResolveDialerButtonMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo+    ResolveDialerButtonMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo+    ResolveDialerButtonMethod "setUseActionAppearance" o = Gtk.Activatable.ActivatableSetUseActionAppearanceMethodInfo+    ResolveDialerButtonMethod "setUseStock" o = Gtk.Button.ButtonSetUseStockMethodInfo+    ResolveDialerButtonMethod "setUseUnderline" o = Gtk.Button.ButtonSetUseUnderlineMethodInfo+    ResolveDialerButtonMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo+    ResolveDialerButtonMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo+    ResolveDialerButtonMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo+    ResolveDialerButtonMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo+    ResolveDialerButtonMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo+    ResolveDialerButtonMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo+    ResolveDialerButtonMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveDialerButtonMethod t DialerButton, O.MethodInfo info DialerButton p) => OL.IsLabel t (DialerButton -> 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 "digit"+   -- Type: TBasicType TInt+   -- Flags: [PropertyReadable]+   -- Nullable: (Just False,Nothing)++{- |+Get the value of the “@digit@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' dialerButton #digit+@+-}+getDialerButtonDigit :: (MonadIO m, IsDialerButton o) => o -> m Int32+getDialerButtonDigit obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "digit"++#if ENABLE_OVERLOADING+data DialerButtonDigitPropertyInfo+instance AttrInfo DialerButtonDigitPropertyInfo where+    type AttrAllowedOps DialerButtonDigitPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DialerButtonDigitPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DialerButtonDigitPropertyInfo = IsDialerButton+    type AttrGetType DialerButtonDigitPropertyInfo = Int32+    type AttrLabel DialerButtonDigitPropertyInfo = "digit"+    type AttrOrigin DialerButtonDigitPropertyInfo = DialerButton+    attrGet _ = getDialerButtonDigit+    attrSet _ = undefined+    attrConstruct _ = undefined+    attrClear _ = undefined+#endif++-- VVV Prop "symbols"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Nothing)++{- |+Get the value of the “@symbols@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' dialerButton #symbols+@+-}+getDialerButtonSymbols :: (MonadIO m, IsDialerButton o) => o -> m T.Text+getDialerButtonSymbols obj = liftIO $ checkUnexpectedNothing "getDialerButtonSymbols" $ B.Properties.getObjectPropertyString obj "symbols"++{- |+Set the value of the “@symbols@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' dialerButton [ #symbols 'Data.GI.Base.Attributes.:=' value ]+@+-}+setDialerButtonSymbols :: (MonadIO m, IsDialerButton o) => o -> T.Text -> m ()+setDialerButtonSymbols obj val = liftIO $ B.Properties.setObjectPropertyString obj "symbols" (Just val)++{- |+Construct a `GValueConstruct` with valid value for the “@symbols@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructDialerButtonSymbols :: (IsDialerButton o) => T.Text -> IO (GValueConstruct o)+constructDialerButtonSymbols val = B.Properties.constructObjectPropertyString "symbols" (Just val)++{- |+Set the value of the “@symbols@” property to `Nothing`.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.clear' #symbols+@+-}+clearDialerButtonSymbols :: (MonadIO m, IsDialerButton o) => o -> m ()+clearDialerButtonSymbols obj = liftIO $ B.Properties.setObjectPropertyString obj "symbols" (Nothing :: Maybe T.Text)++#if ENABLE_OVERLOADING+data DialerButtonSymbolsPropertyInfo+instance AttrInfo DialerButtonSymbolsPropertyInfo where+    type AttrAllowedOps DialerButtonSymbolsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint DialerButtonSymbolsPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint DialerButtonSymbolsPropertyInfo = IsDialerButton+    type AttrGetType DialerButtonSymbolsPropertyInfo = T.Text+    type AttrLabel DialerButtonSymbolsPropertyInfo = "symbols"+    type AttrOrigin DialerButtonSymbolsPropertyInfo = DialerButton+    attrGet _ = getDialerButtonSymbols+    attrSet _ = setDialerButtonSymbols+    attrConstruct _ = constructDialerButtonSymbols+    attrClear _ = clearDialerButtonSymbols+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList DialerButton+type instance O.AttributeList DialerButton = DialerButtonAttributeList+type DialerButtonAttributeList = ('[ '("actionName", Gtk.Actionable.ActionableActionNamePropertyInfo), '("actionTarget", Gtk.Actionable.ActionableActionTargetPropertyInfo), '("alwaysShowImage", Gtk.Button.ButtonAlwaysShowImagePropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("digit", DialerButtonDigitPropertyInfo), '("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), '("image", Gtk.Button.ButtonImagePropertyInfo), '("imagePosition", Gtk.Button.ButtonImagePositionPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("label", Gtk.Button.ButtonLabelPropertyInfo), '("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), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("relatedAction", Gtk.Activatable.ActivatableRelatedActionPropertyInfo), '("relief", Gtk.Button.ButtonReliefPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("symbols", DialerButtonSymbolsPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("useActionAppearance", Gtk.Activatable.ActivatableUseActionAppearancePropertyInfo), '("useStock", Gtk.Button.ButtonUseStockPropertyInfo), '("useUnderline", Gtk.Button.ButtonUseUnderlinePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo), '("xalign", Gtk.Button.ButtonXalignPropertyInfo), '("yalign", Gtk.Button.ButtonYalignPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+dialerButtonDigit :: AttrLabelProxy "digit"+dialerButtonDigit = AttrLabelProxy++dialerButtonSymbols :: AttrLabelProxy "symbols"+dialerButtonSymbols = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList DialerButton = DialerButtonSignalList+type DialerButtonSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("activate", Gtk.Button.ButtonActivateSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("clicked", Gtk.Button.ButtonClickedSignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("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), '("enter", Gtk.Button.ButtonEnterSignalInfo), '("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), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leave", Gtk.Button.ButtonLeaveSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("pressed", Gtk.Button.ButtonPressedSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("released", Gtk.Button.ButtonReleasedSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("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 DialerButton::new+-- method type : Constructor+-- Args : [Arg {argCName = "symbols", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the symbols displayed on the #HdyDialerButton", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "DialerButton"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_dialer_button_new" hdy_dialer_button_new :: +    CString ->                              -- symbols : TBasicType TUTF8+    IO (Ptr DialerButton)++{- |+Create a new 'GI.Handy.Objects.DialerButton.DialerButton' which displays+/@symbols@/. If+/@symbols@/ is 'Nothing' no symbols will be displayed.+-}+dialerButtonNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Maybe (T.Text)+    {- ^ /@symbols@/: the symbols displayed on the 'GI.Handy.Objects.DialerButton.DialerButton' -}+    -> m DialerButton+    {- ^ __Returns:__ the newly created 'GI.Handy.Objects.DialerButton.DialerButton' widget -}+dialerButtonNew symbols = liftIO $ do+    maybeSymbols <- case symbols of+        Nothing -> return nullPtr+        Just jSymbols -> do+            jSymbols' <- textToCString jSymbols+            return jSymbols'+    result <- hdy_dialer_button_new maybeSymbols+    checkUnexpectedReturnNULL "dialerButtonNew" result+    result' <- (newObject DialerButton) result+    freeMem maybeSymbols+    return result'++#if ENABLE_OVERLOADING+#endif++-- method DialerButton::get_digit+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "DialerButton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyDialerButton", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_dialer_button_get_digit" hdy_dialer_button_get_digit :: +    Ptr DialerButton ->                     -- self : TInterface (Name {namespace = "Handy", name = "DialerButton"})+    IO Int32++{- |+Get the 'GI.Handy.Objects.DialerButton.DialerButton'\'s digit.+-}+dialerButtonGetDigit ::+    (B.CallStack.HasCallStack, MonadIO m, IsDialerButton a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.DialerButton.DialerButton' -}+    -> m Int32+    {- ^ __Returns:__ the button\'s digit -}+dialerButtonGetDigit self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_dialer_button_get_digit self'+    touchManagedPtr self+    return result++#if ENABLE_OVERLOADING+data DialerButtonGetDigitMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsDialerButton a) => O.MethodInfo DialerButtonGetDigitMethodInfo a signature where+    overloadedMethod _ = dialerButtonGetDigit++#endif++-- method DialerButton::get_symbols+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "DialerButton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyDialerButton", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_dialer_button_get_symbols" hdy_dialer_button_get_symbols :: +    Ptr DialerButton ->                     -- self : TInterface (Name {namespace = "Handy", name = "DialerButton"})+    IO CString++{- |+Get the 'GI.Handy.Objects.DialerButton.DialerButton'\'s symbols.+-}+dialerButtonGetSymbols ::+    (B.CallStack.HasCallStack, MonadIO m, IsDialerButton a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.DialerButton.DialerButton' -}+    -> m T.Text+    {- ^ __Returns:__ the button\'s symbols. -}+dialerButtonGetSymbols self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_dialer_button_get_symbols self'+    checkUnexpectedReturnNULL "dialerButtonGetSymbols" result+    result' <- cstringToText result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data DialerButtonGetSymbolsMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsDialerButton a) => O.MethodInfo DialerButtonGetSymbolsMethodInfo a signature where+    overloadedMethod _ = dialerButtonGetSymbols++#endif++
+ GI/Handy/Objects/DialerButton.hs-boot view
@@ -0,0 +1,41 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Handy.Objects.DialerButton 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 DialerButton = DialerButton (ManagedPtr DialerButton)+instance GObject DialerButton where+class (GObject o, O.IsDescendantOf DialerButton o) => IsDialerButton o+instance (GObject o, O.IsDescendantOf DialerButton o) => IsDialerButton o+instance O.HasParentTypes DialerButton+#if ENABLE_OVERLOADING+data DialerButtonDigitPropertyInfo+#endif+#if ENABLE_OVERLOADING+data DialerButtonSymbolsPropertyInfo+#endif+#if ENABLE_OVERLOADING+data DialerButtonGetDigitMethodInfo+#endif+#if ENABLE_OVERLOADING+data DialerButtonGetSymbolsMethodInfo+#endif
+ GI/Handy/Objects/DialerCycleButton.hs view
@@ -0,0 +1,971 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Handy.Objects.DialerCycleButton+    ( ++-- * Exported types+    DialerCycleButton(..)                   ,+    IsDialerCycleButton                     ,+    toDialerCycleButton                     ,+    noDialerCycleButton                     ,+++ -- * Methods+-- ** getCurrentSymbol #method:getCurrentSymbol#++#if ENABLE_OVERLOADING+    DialerCycleButtonGetCurrentSymbolMethodInfo,+#endif+    dialerCycleButtonGetCurrentSymbol       ,+++-- ** getCycleTimeout #method:getCycleTimeout#++#if ENABLE_OVERLOADING+    DialerCycleButtonGetCycleTimeoutMethodInfo,+#endif+    dialerCycleButtonGetCycleTimeout        ,+++-- ** isCycling #method:isCycling#++#if ENABLE_OVERLOADING+    DialerCycleButtonIsCyclingMethodInfo    ,+#endif+    dialerCycleButtonIsCycling              ,+++-- ** new #method:new#++    dialerCycleButtonNew                    ,+++-- ** setCycleTimeout #method:setCycleTimeout#++#if ENABLE_OVERLOADING+    DialerCycleButtonSetCycleTimeoutMethodInfo,+#endif+    dialerCycleButtonSetCycleTimeout        ,+++-- ** stopCycle #method:stopCycle#++#if ENABLE_OVERLOADING+    DialerCycleButtonStopCycleMethodInfo    ,+#endif+    dialerCycleButtonStopCycle              ,+++++ -- * Properties+-- ** cycleTimeout #attr:cycleTimeout#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    DialerCycleButtonCycleTimeoutPropertyInfo,+#endif+    constructDialerCycleButtonCycleTimeout  ,+#if ENABLE_OVERLOADING+    dialerCycleButtonCycleTimeout           ,+#endif+    getDialerCycleButtonCycleTimeout        ,+    setDialerCycleButtonCycleTimeout        ,+++++ -- * Signals+-- ** cycleEnd #signal:cycleEnd#++    C_DialerCycleButtonCycleEndCallback     ,+    DialerCycleButtonCycleEndCallback       ,+#if ENABLE_OVERLOADING+    DialerCycleButtonCycleEndSignalInfo     ,+#endif+    afterDialerCycleButtonCycleEnd          ,+    genClosure_DialerCycleButtonCycleEnd    ,+    mk_DialerCycleButtonCycleEndCallback    ,+    noDialerCycleButtonCycleEndCallback     ,+    onDialerCycleButtonCycleEnd             ,+    wrap_DialerCycleButtonCycleEndCallback  ,+++-- ** cycleStart #signal:cycleStart#++    C_DialerCycleButtonCycleStartCallback   ,+    DialerCycleButtonCycleStartCallback     ,+#if ENABLE_OVERLOADING+    DialerCycleButtonCycleStartSignalInfo   ,+#endif+    afterDialerCycleButtonCycleStart        ,+    genClosure_DialerCycleButtonCycleStart  ,+    mk_DialerCycleButtonCycleStartCallback  ,+    noDialerCycleButtonCycleStartCallback   ,+    onDialerCycleButtonCycleStart           ,+    wrap_DialerCycleButtonCycleStartCallback,+++++    ) 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 qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gtk.Interfaces.Actionable as Gtk.Actionable+import qualified GI.Gtk.Interfaces.Activatable as Gtk.Activatable+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable+import qualified GI.Gtk.Objects.Bin as Gtk.Bin+import qualified GI.Gtk.Objects.Button as Gtk.Button+import qualified GI.Gtk.Objects.Container as Gtk.Container+import qualified GI.Gtk.Objects.Widget as Gtk.Widget+import {-# SOURCE #-} qualified GI.Handy.Objects.DialerButton as Handy.DialerButton++-- | Memory-managed wrapper type.+newtype DialerCycleButton = DialerCycleButton (ManagedPtr DialerCycleButton)+foreign import ccall "hdy_dialer_cycle_button_get_type"+    c_hdy_dialer_cycle_button_get_type :: IO GType++instance GObject DialerCycleButton where+    gobjectType = c_hdy_dialer_cycle_button_get_type+    ++-- | Type class for types which can be safely cast to `DialerCycleButton`, for instance with `toDialerCycleButton`.+class (GObject o, O.IsDescendantOf DialerCycleButton o) => IsDialerCycleButton o+instance (GObject o, O.IsDescendantOf DialerCycleButton o) => IsDialerCycleButton o++instance O.HasParentTypes DialerCycleButton+type instance O.ParentTypes DialerCycleButton = '[Handy.DialerButton.DialerButton, Gtk.Button.Button, Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Actionable.Actionable, Gtk.Activatable.Activatable, Gtk.Buildable.Buildable]++-- | Cast to `DialerCycleButton`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toDialerCycleButton :: (MonadIO m, IsDialerCycleButton o) => o -> m DialerCycleButton+toDialerCycleButton = liftIO . unsafeCastTo DialerCycleButton++-- | A convenience alias for `Nothing` :: `Maybe` `DialerCycleButton`.+noDialerCycleButton :: Maybe DialerCycleButton+noDialerCycleButton = Nothing++#if ENABLE_OVERLOADING+type family ResolveDialerCycleButtonMethod (t :: Symbol) (o :: *) :: * where+    ResolveDialerCycleButtonMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo+    ResolveDialerCycleButtonMethod "add" o = Gtk.Container.ContainerAddMethodInfo+    ResolveDialerCycleButtonMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo+    ResolveDialerCycleButtonMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo+    ResolveDialerCycleButtonMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo+    ResolveDialerCycleButtonMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo+    ResolveDialerCycleButtonMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo+    ResolveDialerCycleButtonMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo+    ResolveDialerCycleButtonMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveDialerCycleButtonMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveDialerCycleButtonMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo+    ResolveDialerCycleButtonMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo+    ResolveDialerCycleButtonMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo+    ResolveDialerCycleButtonMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo+    ResolveDialerCycleButtonMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo+    ResolveDialerCycleButtonMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo+    ResolveDialerCycleButtonMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo+    ResolveDialerCycleButtonMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo+    ResolveDialerCycleButtonMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo+    ResolveDialerCycleButtonMethod "clicked" o = Gtk.Button.ButtonClickedMethodInfo+    ResolveDialerCycleButtonMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo+    ResolveDialerCycleButtonMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo+    ResolveDialerCycleButtonMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo+    ResolveDialerCycleButtonMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo+    ResolveDialerCycleButtonMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo+    ResolveDialerCycleButtonMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo+    ResolveDialerCycleButtonMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo+    ResolveDialerCycleButtonMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo+    ResolveDialerCycleButtonMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo+    ResolveDialerCycleButtonMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo+    ResolveDialerCycleButtonMethod "doSetRelatedAction" o = Gtk.Activatable.ActivatableDoSetRelatedActionMethodInfo+    ResolveDialerCycleButtonMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo+    ResolveDialerCycleButtonMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo+    ResolveDialerCycleButtonMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo+    ResolveDialerCycleButtonMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo+    ResolveDialerCycleButtonMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo+    ResolveDialerCycleButtonMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo+    ResolveDialerCycleButtonMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo+    ResolveDialerCycleButtonMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo+    ResolveDialerCycleButtonMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo+    ResolveDialerCycleButtonMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo+    ResolveDialerCycleButtonMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo+    ResolveDialerCycleButtonMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo+    ResolveDialerCycleButtonMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo+    ResolveDialerCycleButtonMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo+    ResolveDialerCycleButtonMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo+    ResolveDialerCycleButtonMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo+    ResolveDialerCycleButtonMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo+    ResolveDialerCycleButtonMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo+    ResolveDialerCycleButtonMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo+    ResolveDialerCycleButtonMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo+    ResolveDialerCycleButtonMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo+    ResolveDialerCycleButtonMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo+    ResolveDialerCycleButtonMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo+    ResolveDialerCycleButtonMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo+    ResolveDialerCycleButtonMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo+    ResolveDialerCycleButtonMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo+    ResolveDialerCycleButtonMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo+    ResolveDialerCycleButtonMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo+    ResolveDialerCycleButtonMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo+    ResolveDialerCycleButtonMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo+    ResolveDialerCycleButtonMethod "enter" o = Gtk.Button.ButtonEnterMethodInfo+    ResolveDialerCycleButtonMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo+    ResolveDialerCycleButtonMethod "event" o = Gtk.Widget.WidgetEventMethodInfo+    ResolveDialerCycleButtonMethod "forall" o = Gtk.Container.ContainerForallMethodInfo+    ResolveDialerCycleButtonMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveDialerCycleButtonMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo+    ResolveDialerCycleButtonMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo+    ResolveDialerCycleButtonMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveDialerCycleButtonMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveDialerCycleButtonMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo+    ResolveDialerCycleButtonMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo+    ResolveDialerCycleButtonMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo+    ResolveDialerCycleButtonMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo+    ResolveDialerCycleButtonMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo+    ResolveDialerCycleButtonMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo+    ResolveDialerCycleButtonMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo+    ResolveDialerCycleButtonMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo+    ResolveDialerCycleButtonMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo+    ResolveDialerCycleButtonMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo+    ResolveDialerCycleButtonMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo+    ResolveDialerCycleButtonMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo+    ResolveDialerCycleButtonMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo+    ResolveDialerCycleButtonMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo+    ResolveDialerCycleButtonMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo+    ResolveDialerCycleButtonMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo+    ResolveDialerCycleButtonMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo+    ResolveDialerCycleButtonMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo+    ResolveDialerCycleButtonMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo+    ResolveDialerCycleButtonMethod "isCycling" o = DialerCycleButtonIsCyclingMethodInfo+    ResolveDialerCycleButtonMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo+    ResolveDialerCycleButtonMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveDialerCycleButtonMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo+    ResolveDialerCycleButtonMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo+    ResolveDialerCycleButtonMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo+    ResolveDialerCycleButtonMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo+    ResolveDialerCycleButtonMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo+    ResolveDialerCycleButtonMethod "leave" o = Gtk.Button.ButtonLeaveMethodInfo+    ResolveDialerCycleButtonMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo+    ResolveDialerCycleButtonMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo+    ResolveDialerCycleButtonMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo+    ResolveDialerCycleButtonMethod "map" o = Gtk.Widget.WidgetMapMethodInfo+    ResolveDialerCycleButtonMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo+    ResolveDialerCycleButtonMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo+    ResolveDialerCycleButtonMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo+    ResolveDialerCycleButtonMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo+    ResolveDialerCycleButtonMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo+    ResolveDialerCycleButtonMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo+    ResolveDialerCycleButtonMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo+    ResolveDialerCycleButtonMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo+    ResolveDialerCycleButtonMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveDialerCycleButtonMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveDialerCycleButtonMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo+    ResolveDialerCycleButtonMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo+    ResolveDialerCycleButtonMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo+    ResolveDialerCycleButtonMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo+    ResolveDialerCycleButtonMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo+    ResolveDialerCycleButtonMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo+    ResolveDialerCycleButtonMethod "path" o = Gtk.Widget.WidgetPathMethodInfo+    ResolveDialerCycleButtonMethod "pressed" o = Gtk.Button.ButtonPressedMethodInfo+    ResolveDialerCycleButtonMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo+    ResolveDialerCycleButtonMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo+    ResolveDialerCycleButtonMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo+    ResolveDialerCycleButtonMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo+    ResolveDialerCycleButtonMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo+    ResolveDialerCycleButtonMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo+    ResolveDialerCycleButtonMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo+    ResolveDialerCycleButtonMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo+    ResolveDialerCycleButtonMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo+    ResolveDialerCycleButtonMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveDialerCycleButtonMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveDialerCycleButtonMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo+    ResolveDialerCycleButtonMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo+    ResolveDialerCycleButtonMethod "released" o = Gtk.Button.ButtonReleasedMethodInfo+    ResolveDialerCycleButtonMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo+    ResolveDialerCycleButtonMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo+    ResolveDialerCycleButtonMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo+    ResolveDialerCycleButtonMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo+    ResolveDialerCycleButtonMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo+    ResolveDialerCycleButtonMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo+    ResolveDialerCycleButtonMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo+    ResolveDialerCycleButtonMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo+    ResolveDialerCycleButtonMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo+    ResolveDialerCycleButtonMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo+    ResolveDialerCycleButtonMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveDialerCycleButtonMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo+    ResolveDialerCycleButtonMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo+    ResolveDialerCycleButtonMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo+    ResolveDialerCycleButtonMethod "show" o = Gtk.Widget.WidgetShowMethodInfo+    ResolveDialerCycleButtonMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo+    ResolveDialerCycleButtonMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo+    ResolveDialerCycleButtonMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo+    ResolveDialerCycleButtonMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo+    ResolveDialerCycleButtonMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo+    ResolveDialerCycleButtonMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveDialerCycleButtonMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveDialerCycleButtonMethod "stopCycle" o = DialerCycleButtonStopCycleMethodInfo+    ResolveDialerCycleButtonMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo+    ResolveDialerCycleButtonMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo+    ResolveDialerCycleButtonMethod "syncActionProperties" o = Gtk.Activatable.ActivatableSyncActionPropertiesMethodInfo+    ResolveDialerCycleButtonMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo+    ResolveDialerCycleButtonMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveDialerCycleButtonMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo+    ResolveDialerCycleButtonMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo+    ResolveDialerCycleButtonMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo+    ResolveDialerCycleButtonMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo+    ResolveDialerCycleButtonMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo+    ResolveDialerCycleButtonMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveDialerCycleButtonMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo+    ResolveDialerCycleButtonMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo+    ResolveDialerCycleButtonMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo+    ResolveDialerCycleButtonMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveDialerCycleButtonMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo+    ResolveDialerCycleButtonMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo+    ResolveDialerCycleButtonMethod "getActionName" o = Gtk.Actionable.ActionableGetActionNameMethodInfo+    ResolveDialerCycleButtonMethod "getActionTargetValue" o = Gtk.Actionable.ActionableGetActionTargetValueMethodInfo+    ResolveDialerCycleButtonMethod "getAlignment" o = Gtk.Button.ButtonGetAlignmentMethodInfo+    ResolveDialerCycleButtonMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo+    ResolveDialerCycleButtonMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo+    ResolveDialerCycleButtonMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo+    ResolveDialerCycleButtonMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo+    ResolveDialerCycleButtonMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo+    ResolveDialerCycleButtonMethod "getAlwaysShowImage" o = Gtk.Button.ButtonGetAlwaysShowImageMethodInfo+    ResolveDialerCycleButtonMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo+    ResolveDialerCycleButtonMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo+    ResolveDialerCycleButtonMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo+    ResolveDialerCycleButtonMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo+    ResolveDialerCycleButtonMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo+    ResolveDialerCycleButtonMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo+    ResolveDialerCycleButtonMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo+    ResolveDialerCycleButtonMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo+    ResolveDialerCycleButtonMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo+    ResolveDialerCycleButtonMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo+    ResolveDialerCycleButtonMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo+    ResolveDialerCycleButtonMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo+    ResolveDialerCycleButtonMethod "getCurrentSymbol" o = DialerCycleButtonGetCurrentSymbolMethodInfo+    ResolveDialerCycleButtonMethod "getCycleTimeout" o = DialerCycleButtonGetCycleTimeoutMethodInfo+    ResolveDialerCycleButtonMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveDialerCycleButtonMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo+    ResolveDialerCycleButtonMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo+    ResolveDialerCycleButtonMethod "getDigit" o = Handy.DialerButton.DialerButtonGetDigitMethodInfo+    ResolveDialerCycleButtonMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo+    ResolveDialerCycleButtonMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo+    ResolveDialerCycleButtonMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo+    ResolveDialerCycleButtonMethod "getEventWindow" o = Gtk.Button.ButtonGetEventWindowMethodInfo+    ResolveDialerCycleButtonMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo+    ResolveDialerCycleButtonMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo+    ResolveDialerCycleButtonMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo+    ResolveDialerCycleButtonMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo+    ResolveDialerCycleButtonMethod "getFocusOnClick" o = Gtk.Button.ButtonGetFocusOnClickMethodInfo+    ResolveDialerCycleButtonMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo+    ResolveDialerCycleButtonMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo+    ResolveDialerCycleButtonMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo+    ResolveDialerCycleButtonMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo+    ResolveDialerCycleButtonMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo+    ResolveDialerCycleButtonMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo+    ResolveDialerCycleButtonMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo+    ResolveDialerCycleButtonMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo+    ResolveDialerCycleButtonMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo+    ResolveDialerCycleButtonMethod "getImage" o = Gtk.Button.ButtonGetImageMethodInfo+    ResolveDialerCycleButtonMethod "getImagePosition" o = Gtk.Button.ButtonGetImagePositionMethodInfo+    ResolveDialerCycleButtonMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo+    ResolveDialerCycleButtonMethod "getLabel" o = Gtk.Button.ButtonGetLabelMethodInfo+    ResolveDialerCycleButtonMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo+    ResolveDialerCycleButtonMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo+    ResolveDialerCycleButtonMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo+    ResolveDialerCycleButtonMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo+    ResolveDialerCycleButtonMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo+    ResolveDialerCycleButtonMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo+    ResolveDialerCycleButtonMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo+    ResolveDialerCycleButtonMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo+    ResolveDialerCycleButtonMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo+    ResolveDialerCycleButtonMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo+    ResolveDialerCycleButtonMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo+    ResolveDialerCycleButtonMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo+    ResolveDialerCycleButtonMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo+    ResolveDialerCycleButtonMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo+    ResolveDialerCycleButtonMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo+    ResolveDialerCycleButtonMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo+    ResolveDialerCycleButtonMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo+    ResolveDialerCycleButtonMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo+    ResolveDialerCycleButtonMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo+    ResolveDialerCycleButtonMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo+    ResolveDialerCycleButtonMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo+    ResolveDialerCycleButtonMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo+    ResolveDialerCycleButtonMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo+    ResolveDialerCycleButtonMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo+    ResolveDialerCycleButtonMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveDialerCycleButtonMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveDialerCycleButtonMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo+    ResolveDialerCycleButtonMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo+    ResolveDialerCycleButtonMethod "getRelatedAction" o = Gtk.Activatable.ActivatableGetRelatedActionMethodInfo+    ResolveDialerCycleButtonMethod "getRelief" o = Gtk.Button.ButtonGetReliefMethodInfo+    ResolveDialerCycleButtonMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo+    ResolveDialerCycleButtonMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo+    ResolveDialerCycleButtonMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo+    ResolveDialerCycleButtonMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo+    ResolveDialerCycleButtonMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo+    ResolveDialerCycleButtonMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo+    ResolveDialerCycleButtonMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo+    ResolveDialerCycleButtonMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo+    ResolveDialerCycleButtonMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo+    ResolveDialerCycleButtonMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo+    ResolveDialerCycleButtonMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo+    ResolveDialerCycleButtonMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo+    ResolveDialerCycleButtonMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo+    ResolveDialerCycleButtonMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo+    ResolveDialerCycleButtonMethod "getSymbols" o = Handy.DialerButton.DialerButtonGetSymbolsMethodInfo+    ResolveDialerCycleButtonMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo+    ResolveDialerCycleButtonMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo+    ResolveDialerCycleButtonMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo+    ResolveDialerCycleButtonMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo+    ResolveDialerCycleButtonMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo+    ResolveDialerCycleButtonMethod "getUseActionAppearance" o = Gtk.Activatable.ActivatableGetUseActionAppearanceMethodInfo+    ResolveDialerCycleButtonMethod "getUseStock" o = Gtk.Button.ButtonGetUseStockMethodInfo+    ResolveDialerCycleButtonMethod "getUseUnderline" o = Gtk.Button.ButtonGetUseUnderlineMethodInfo+    ResolveDialerCycleButtonMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo+    ResolveDialerCycleButtonMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo+    ResolveDialerCycleButtonMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo+    ResolveDialerCycleButtonMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo+    ResolveDialerCycleButtonMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo+    ResolveDialerCycleButtonMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo+    ResolveDialerCycleButtonMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo+    ResolveDialerCycleButtonMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo+    ResolveDialerCycleButtonMethod "setActionName" o = Gtk.Actionable.ActionableSetActionNameMethodInfo+    ResolveDialerCycleButtonMethod "setActionTargetValue" o = Gtk.Actionable.ActionableSetActionTargetValueMethodInfo+    ResolveDialerCycleButtonMethod "setAlignment" o = Gtk.Button.ButtonSetAlignmentMethodInfo+    ResolveDialerCycleButtonMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo+    ResolveDialerCycleButtonMethod "setAlwaysShowImage" o = Gtk.Button.ButtonSetAlwaysShowImageMethodInfo+    ResolveDialerCycleButtonMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo+    ResolveDialerCycleButtonMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo+    ResolveDialerCycleButtonMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo+    ResolveDialerCycleButtonMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo+    ResolveDialerCycleButtonMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo+    ResolveDialerCycleButtonMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo+    ResolveDialerCycleButtonMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo+    ResolveDialerCycleButtonMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo+    ResolveDialerCycleButtonMethod "setCycleTimeout" o = DialerCycleButtonSetCycleTimeoutMethodInfo+    ResolveDialerCycleButtonMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveDialerCycleButtonMethod "setDetailedActionName" o = Gtk.Actionable.ActionableSetDetailedActionNameMethodInfo+    ResolveDialerCycleButtonMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo+    ResolveDialerCycleButtonMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo+    ResolveDialerCycleButtonMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo+    ResolveDialerCycleButtonMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo+    ResolveDialerCycleButtonMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo+    ResolveDialerCycleButtonMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo+    ResolveDialerCycleButtonMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo+    ResolveDialerCycleButtonMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo+    ResolveDialerCycleButtonMethod "setFocusOnClick" o = Gtk.Button.ButtonSetFocusOnClickMethodInfo+    ResolveDialerCycleButtonMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo+    ResolveDialerCycleButtonMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo+    ResolveDialerCycleButtonMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo+    ResolveDialerCycleButtonMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo+    ResolveDialerCycleButtonMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo+    ResolveDialerCycleButtonMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo+    ResolveDialerCycleButtonMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo+    ResolveDialerCycleButtonMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo+    ResolveDialerCycleButtonMethod "setImage" o = Gtk.Button.ButtonSetImageMethodInfo+    ResolveDialerCycleButtonMethod "setImagePosition" o = Gtk.Button.ButtonSetImagePositionMethodInfo+    ResolveDialerCycleButtonMethod "setLabel" o = Gtk.Button.ButtonSetLabelMethodInfo+    ResolveDialerCycleButtonMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo+    ResolveDialerCycleButtonMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo+    ResolveDialerCycleButtonMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo+    ResolveDialerCycleButtonMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo+    ResolveDialerCycleButtonMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo+    ResolveDialerCycleButtonMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo+    ResolveDialerCycleButtonMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo+    ResolveDialerCycleButtonMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo+    ResolveDialerCycleButtonMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo+    ResolveDialerCycleButtonMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo+    ResolveDialerCycleButtonMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo+    ResolveDialerCycleButtonMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo+    ResolveDialerCycleButtonMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveDialerCycleButtonMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo+    ResolveDialerCycleButtonMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo+    ResolveDialerCycleButtonMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo+    ResolveDialerCycleButtonMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo+    ResolveDialerCycleButtonMethod "setRelatedAction" o = Gtk.Activatable.ActivatableSetRelatedActionMethodInfo+    ResolveDialerCycleButtonMethod "setRelief" o = Gtk.Button.ButtonSetReliefMethodInfo+    ResolveDialerCycleButtonMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo+    ResolveDialerCycleButtonMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo+    ResolveDialerCycleButtonMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo+    ResolveDialerCycleButtonMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo+    ResolveDialerCycleButtonMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo+    ResolveDialerCycleButtonMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo+    ResolveDialerCycleButtonMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo+    ResolveDialerCycleButtonMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo+    ResolveDialerCycleButtonMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo+    ResolveDialerCycleButtonMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo+    ResolveDialerCycleButtonMethod "setUseActionAppearance" o = Gtk.Activatable.ActivatableSetUseActionAppearanceMethodInfo+    ResolveDialerCycleButtonMethod "setUseStock" o = Gtk.Button.ButtonSetUseStockMethodInfo+    ResolveDialerCycleButtonMethod "setUseUnderline" o = Gtk.Button.ButtonSetUseUnderlineMethodInfo+    ResolveDialerCycleButtonMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo+    ResolveDialerCycleButtonMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo+    ResolveDialerCycleButtonMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo+    ResolveDialerCycleButtonMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo+    ResolveDialerCycleButtonMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo+    ResolveDialerCycleButtonMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo+    ResolveDialerCycleButtonMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveDialerCycleButtonMethod t DialerCycleButton, O.MethodInfo info DialerCycleButton p) => OL.IsLabel t (DialerCycleButton -> 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++-- signal DialerCycleButton::cycle-end+{- |+This signal is emitted when the cycle ends. This can either be+because of timeout or because @/hdy_dialer_cycle_stop_cycle/@ got+called.+-}+type DialerCycleButtonCycleEndCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `DialerCycleButtonCycleEndCallback`@.+noDialerCycleButtonCycleEndCallback :: Maybe DialerCycleButtonCycleEndCallback+noDialerCycleButtonCycleEndCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_DialerCycleButtonCycleEndCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_DialerCycleButtonCycleEndCallback`.+foreign import ccall "wrapper"+    mk_DialerCycleButtonCycleEndCallback :: C_DialerCycleButtonCycleEndCallback -> IO (FunPtr C_DialerCycleButtonCycleEndCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_DialerCycleButtonCycleEnd :: MonadIO m => DialerCycleButtonCycleEndCallback -> m (GClosure C_DialerCycleButtonCycleEndCallback)+genClosure_DialerCycleButtonCycleEnd cb = liftIO $ do+    let cb' = wrap_DialerCycleButtonCycleEndCallback cb+    mk_DialerCycleButtonCycleEndCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `DialerCycleButtonCycleEndCallback` into a `C_DialerCycleButtonCycleEndCallback`.+wrap_DialerCycleButtonCycleEndCallback ::+    DialerCycleButtonCycleEndCallback ->+    C_DialerCycleButtonCycleEndCallback+wrap_DialerCycleButtonCycleEndCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@cycle-end@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' dialerCycleButton #cycleEnd callback+@+-}+onDialerCycleButtonCycleEnd :: (IsDialerCycleButton a, MonadIO m) => a -> DialerCycleButtonCycleEndCallback -> m SignalHandlerId+onDialerCycleButtonCycleEnd obj cb = liftIO $ do+    let cb' = wrap_DialerCycleButtonCycleEndCallback cb+    cb'' <- mk_DialerCycleButtonCycleEndCallback cb'+    connectSignalFunPtr obj "cycle-end" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@cycle-end@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' dialerCycleButton #cycleEnd callback+@+-}+afterDialerCycleButtonCycleEnd :: (IsDialerCycleButton a, MonadIO m) => a -> DialerCycleButtonCycleEndCallback -> m SignalHandlerId+afterDialerCycleButtonCycleEnd obj cb = liftIO $ do+    let cb' = wrap_DialerCycleButtonCycleEndCallback cb+    cb'' <- mk_DialerCycleButtonCycleEndCallback cb'+    connectSignalFunPtr obj "cycle-end" cb'' SignalConnectAfter+++-- signal DialerCycleButton::cycle-start+{- |+This signal is emitted when the button starts cycling (that is on+the first button press).+-}+type DialerCycleButtonCycleStartCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `DialerCycleButtonCycleStartCallback`@.+noDialerCycleButtonCycleStartCallback :: Maybe DialerCycleButtonCycleStartCallback+noDialerCycleButtonCycleStartCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_DialerCycleButtonCycleStartCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_DialerCycleButtonCycleStartCallback`.+foreign import ccall "wrapper"+    mk_DialerCycleButtonCycleStartCallback :: C_DialerCycleButtonCycleStartCallback -> IO (FunPtr C_DialerCycleButtonCycleStartCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_DialerCycleButtonCycleStart :: MonadIO m => DialerCycleButtonCycleStartCallback -> m (GClosure C_DialerCycleButtonCycleStartCallback)+genClosure_DialerCycleButtonCycleStart cb = liftIO $ do+    let cb' = wrap_DialerCycleButtonCycleStartCallback cb+    mk_DialerCycleButtonCycleStartCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `DialerCycleButtonCycleStartCallback` into a `C_DialerCycleButtonCycleStartCallback`.+wrap_DialerCycleButtonCycleStartCallback ::+    DialerCycleButtonCycleStartCallback ->+    C_DialerCycleButtonCycleStartCallback+wrap_DialerCycleButtonCycleStartCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@cycle-start@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' dialerCycleButton #cycleStart callback+@+-}+onDialerCycleButtonCycleStart :: (IsDialerCycleButton a, MonadIO m) => a -> DialerCycleButtonCycleStartCallback -> m SignalHandlerId+onDialerCycleButtonCycleStart obj cb = liftIO $ do+    let cb' = wrap_DialerCycleButtonCycleStartCallback cb+    cb'' <- mk_DialerCycleButtonCycleStartCallback cb'+    connectSignalFunPtr obj "cycle-start" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@cycle-start@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' dialerCycleButton #cycleStart callback+@+-}+afterDialerCycleButtonCycleStart :: (IsDialerCycleButton a, MonadIO m) => a -> DialerCycleButtonCycleStartCallback -> m SignalHandlerId+afterDialerCycleButtonCycleStart obj cb = liftIO $ do+    let cb' = wrap_DialerCycleButtonCycleStartCallback cb+    cb'' <- mk_DialerCycleButtonCycleStartCallback cb'+    connectSignalFunPtr obj "cycle-start" cb'' SignalConnectAfter+++-- VVV Prop "cycle-timeout"+   -- Type: TBasicType TInt+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@cycle-timeout@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' dialerCycleButton #cycleTimeout+@+-}+getDialerCycleButtonCycleTimeout :: (MonadIO m, IsDialerCycleButton o) => o -> m Int32+getDialerCycleButtonCycleTimeout obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "cycle-timeout"++{- |+Set the value of the “@cycle-timeout@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' dialerCycleButton [ #cycleTimeout 'Data.GI.Base.Attributes.:=' value ]+@+-}+setDialerCycleButtonCycleTimeout :: (MonadIO m, IsDialerCycleButton o) => o -> Int32 -> m ()+setDialerCycleButtonCycleTimeout obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "cycle-timeout" val++{- |+Construct a `GValueConstruct` with valid value for the “@cycle-timeout@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructDialerCycleButtonCycleTimeout :: (IsDialerCycleButton o) => Int32 -> IO (GValueConstruct o)+constructDialerCycleButtonCycleTimeout val = B.Properties.constructObjectPropertyInt32 "cycle-timeout" val++#if ENABLE_OVERLOADING+data DialerCycleButtonCycleTimeoutPropertyInfo+instance AttrInfo DialerCycleButtonCycleTimeoutPropertyInfo where+    type AttrAllowedOps DialerCycleButtonCycleTimeoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DialerCycleButtonCycleTimeoutPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint DialerCycleButtonCycleTimeoutPropertyInfo = IsDialerCycleButton+    type AttrGetType DialerCycleButtonCycleTimeoutPropertyInfo = Int32+    type AttrLabel DialerCycleButtonCycleTimeoutPropertyInfo = "cycle-timeout"+    type AttrOrigin DialerCycleButtonCycleTimeoutPropertyInfo = DialerCycleButton+    attrGet _ = getDialerCycleButtonCycleTimeout+    attrSet _ = setDialerCycleButtonCycleTimeout+    attrConstruct _ = constructDialerCycleButtonCycleTimeout+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList DialerCycleButton+type instance O.AttributeList DialerCycleButton = DialerCycleButtonAttributeList+type DialerCycleButtonAttributeList = ('[ '("actionName", Gtk.Actionable.ActionableActionNamePropertyInfo), '("actionTarget", Gtk.Actionable.ActionableActionTargetPropertyInfo), '("alwaysShowImage", Gtk.Button.ButtonAlwaysShowImagePropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("cycleTimeout", DialerCycleButtonCycleTimeoutPropertyInfo), '("digit", Handy.DialerButton.DialerButtonDigitPropertyInfo), '("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), '("image", Gtk.Button.ButtonImagePropertyInfo), '("imagePosition", Gtk.Button.ButtonImagePositionPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("label", Gtk.Button.ButtonLabelPropertyInfo), '("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), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("relatedAction", Gtk.Activatable.ActivatableRelatedActionPropertyInfo), '("relief", Gtk.Button.ButtonReliefPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("symbols", Handy.DialerButton.DialerButtonSymbolsPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("useActionAppearance", Gtk.Activatable.ActivatableUseActionAppearancePropertyInfo), '("useStock", Gtk.Button.ButtonUseStockPropertyInfo), '("useUnderline", Gtk.Button.ButtonUseUnderlinePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo), '("xalign", Gtk.Button.ButtonXalignPropertyInfo), '("yalign", Gtk.Button.ButtonYalignPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+dialerCycleButtonCycleTimeout :: AttrLabelProxy "cycleTimeout"+dialerCycleButtonCycleTimeout = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+data DialerCycleButtonCycleEndSignalInfo+instance SignalInfo DialerCycleButtonCycleEndSignalInfo where+    type HaskellCallbackType DialerCycleButtonCycleEndSignalInfo = DialerCycleButtonCycleEndCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_DialerCycleButtonCycleEndCallback cb+        cb'' <- mk_DialerCycleButtonCycleEndCallback cb'+        connectSignalFunPtr obj "cycle-end" cb'' connectMode++data DialerCycleButtonCycleStartSignalInfo+instance SignalInfo DialerCycleButtonCycleStartSignalInfo where+    type HaskellCallbackType DialerCycleButtonCycleStartSignalInfo = DialerCycleButtonCycleStartCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_DialerCycleButtonCycleStartCallback cb+        cb'' <- mk_DialerCycleButtonCycleStartCallback cb'+        connectSignalFunPtr obj "cycle-start" cb'' connectMode++type instance O.SignalList DialerCycleButton = DialerCycleButtonSignalList+type DialerCycleButtonSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("activate", Gtk.Button.ButtonActivateSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("clicked", Gtk.Button.ButtonClickedSignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("cycleEnd", DialerCycleButtonCycleEndSignalInfo), '("cycleStart", DialerCycleButtonCycleStartSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("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), '("enter", Gtk.Button.ButtonEnterSignalInfo), '("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), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leave", Gtk.Button.ButtonLeaveSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("pressed", Gtk.Button.ButtonPressedSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("released", Gtk.Button.ButtonReleasedSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("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 DialerCycleButton::new+-- method type : Constructor+-- Args : [Arg {argCName = "symbols", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the symbols displayed on the #HdyDialerCycleButton", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "DialerCycleButton"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_dialer_cycle_button_new" hdy_dialer_cycle_button_new :: +    CString ->                              -- symbols : TBasicType TUTF8+    IO (Ptr DialerCycleButton)++{- |+Create a new 'GI.Handy.Objects.DialerCycleButton.DialerCycleButton' which displays /@symbols@/. The+symbols can by cycled through by pressing the button multiple+times.+-}+dialerCycleButtonNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@symbols@/: the symbols displayed on the 'GI.Handy.Objects.DialerCycleButton.DialerCycleButton' -}+    -> m DialerCycleButton+    {- ^ __Returns:__ the newly created 'GI.Handy.Objects.DialerCycleButton.DialerCycleButton' widget -}+dialerCycleButtonNew symbols = liftIO $ do+    symbols' <- textToCString symbols+    result <- hdy_dialer_cycle_button_new symbols'+    checkUnexpectedReturnNULL "dialerCycleButtonNew" result+    result' <- (newObject DialerCycleButton) result+    freeMem symbols'+    return result'++#if ENABLE_OVERLOADING+#endif++-- method DialerCycleButton::get_current_symbol+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "DialerCycleButton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyDialerCycleButton", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUniChar)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_dialer_cycle_button_get_current_symbol" hdy_dialer_cycle_button_get_current_symbol :: +    Ptr DialerCycleButton ->                -- self : TInterface (Name {namespace = "Handy", name = "DialerCycleButton"})+    IO CInt++{- |+Get the symbol the dialer should display+-}+dialerCycleButtonGetCurrentSymbol ::+    (B.CallStack.HasCallStack, MonadIO m, IsDialerCycleButton a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.DialerCycleButton.DialerCycleButton' -}+    -> m Char+    {- ^ __Returns:__ a pointer to the symbol -}+dialerCycleButtonGetCurrentSymbol self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_dialer_cycle_button_get_current_symbol self'+    let result' = (chr . fromIntegral) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data DialerCycleButtonGetCurrentSymbolMethodInfo+instance (signature ~ (m Char), MonadIO m, IsDialerCycleButton a) => O.MethodInfo DialerCycleButtonGetCurrentSymbolMethodInfo a signature where+    overloadedMethod _ = dialerCycleButtonGetCurrentSymbol++#endif++-- method DialerCycleButton::get_cycle_timeout+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "DialerCycleButton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyDialerCycleButton", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_dialer_cycle_button_get_cycle_timeout" hdy_dialer_cycle_button_get_cycle_timeout :: +    Ptr DialerCycleButton ->                -- self : TInterface (Name {namespace = "Handy", name = "DialerCycleButton"})+    IO Int32++{- |+Get the cycle timeout in milliseconds.+-}+dialerCycleButtonGetCycleTimeout ::+    (B.CallStack.HasCallStack, MonadIO m, IsDialerCycleButton a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.DialerCycleButton.DialerCycleButton' -}+    -> m Int32+dialerCycleButtonGetCycleTimeout self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_dialer_cycle_button_get_cycle_timeout self'+    touchManagedPtr self+    return result++#if ENABLE_OVERLOADING+data DialerCycleButtonGetCycleTimeoutMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsDialerCycleButton a) => O.MethodInfo DialerCycleButtonGetCycleTimeoutMethodInfo a signature where+    overloadedMethod _ = dialerCycleButtonGetCycleTimeout++#endif++-- method DialerCycleButton::is_cycling+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "DialerCycleButton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyDialerCycleButton", 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 "hdy_dialer_cycle_button_is_cycling" hdy_dialer_cycle_button_is_cycling :: +    Ptr DialerCycleButton ->                -- self : TInterface (Name {namespace = "Handy", name = "DialerCycleButton"})+    IO CInt++{- |+Check whether the button is in cycling mode.+-}+dialerCycleButtonIsCycling ::+    (B.CallStack.HasCallStack, MonadIO m, IsDialerCycleButton a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.DialerCycleButton.DialerCycleButton' -}+    -> m Bool+    {- ^ __Returns:__ @/TRUE/@ if the in cycling mode otherwise @/FALSE/@ -}+dialerCycleButtonIsCycling self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_dialer_cycle_button_is_cycling self'+    let result' = (/= 0) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data DialerCycleButtonIsCyclingMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsDialerCycleButton a) => O.MethodInfo DialerCycleButtonIsCyclingMethodInfo a signature where+    overloadedMethod _ = dialerCycleButtonIsCycling++#endif++-- method DialerCycleButton::set_cycle_timeout+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "DialerCycleButton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyDialerCycleButton", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the timeout in milliseconds", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_dialer_cycle_button_set_cycle_timeout" hdy_dialer_cycle_button_set_cycle_timeout :: +    Ptr DialerCycleButton ->                -- self : TInterface (Name {namespace = "Handy", name = "DialerCycleButton"})+    Int32 ->                                -- timeout : TBasicType TInt+    IO ()++{- |+Set the cycle timeout in milliseconds.+-}+dialerCycleButtonSetCycleTimeout ::+    (B.CallStack.HasCallStack, MonadIO m, IsDialerCycleButton a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.DialerCycleButton.DialerCycleButton' -}+    -> Int32+    {- ^ /@timeout@/: the timeout in milliseconds -}+    -> m ()+dialerCycleButtonSetCycleTimeout self timeout = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    hdy_dialer_cycle_button_set_cycle_timeout self' timeout+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data DialerCycleButtonSetCycleTimeoutMethodInfo+instance (signature ~ (Int32 -> m ()), MonadIO m, IsDialerCycleButton a) => O.MethodInfo DialerCycleButtonSetCycleTimeoutMethodInfo a signature where+    overloadedMethod _ = dialerCycleButtonSetCycleTimeout++#endif++-- method DialerCycleButton::stop_cycle+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "DialerCycleButton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyDialerCycleButton", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_dialer_cycle_button_stop_cycle" hdy_dialer_cycle_button_stop_cycle :: +    Ptr DialerCycleButton ->                -- self : TInterface (Name {namespace = "Handy", name = "DialerCycleButton"})+    IO ()++{- |+Stop the cycling mode.+-}+dialerCycleButtonStopCycle ::+    (B.CallStack.HasCallStack, MonadIO m, IsDialerCycleButton a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.DialerCycleButton.DialerCycleButton' -}+    -> m ()+dialerCycleButtonStopCycle self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    hdy_dialer_cycle_button_stop_cycle self'+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data DialerCycleButtonStopCycleMethodInfo+instance (signature ~ (m ()), MonadIO m, IsDialerCycleButton a) => O.MethodInfo DialerCycleButtonStopCycleMethodInfo a signature where+    overloadedMethod _ = dialerCycleButtonStopCycle++#endif++
+ GI/Handy/Objects/DialerCycleButton.hs-boot view
@@ -0,0 +1,53 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Handy.Objects.DialerCycleButton 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 DialerCycleButton = DialerCycleButton (ManagedPtr DialerCycleButton)+instance GObject DialerCycleButton where+class (GObject o, O.IsDescendantOf DialerCycleButton o) => IsDialerCycleButton o+instance (GObject o, O.IsDescendantOf DialerCycleButton o) => IsDialerCycleButton o+instance O.HasParentTypes DialerCycleButton+#if ENABLE_OVERLOADING+data DialerCycleButtonCycleTimeoutPropertyInfo+#endif+#if ENABLE_OVERLOADING+data DialerCycleButtonCycleEndSignalInfo+#endif+#if ENABLE_OVERLOADING+data DialerCycleButtonCycleStartSignalInfo+#endif+#if ENABLE_OVERLOADING+data DialerCycleButtonGetCurrentSymbolMethodInfo+#endif+#if ENABLE_OVERLOADING+data DialerCycleButtonGetCycleTimeoutMethodInfo+#endif+#if ENABLE_OVERLOADING+data DialerCycleButtonIsCyclingMethodInfo+#endif+#if ENABLE_OVERLOADING+data DialerCycleButtonSetCycleTimeoutMethodInfo+#endif+#if ENABLE_OVERLOADING+data DialerCycleButtonStopCycleMethodInfo+#endif
+ GI/Handy/Objects/Dialog.hs view
@@ -0,0 +1,604 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Handy.Objects.Dialog+    ( ++-- * Exported types+    Dialog(..)                              ,+    IsDialog                                ,+    toDialog                                ,+    noDialog                                ,+++ -- * Methods+-- ** new #method:new#++    dialogNew                               ,+++++    ) 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 qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable+import qualified GI.Gtk.Objects.Bin as Gtk.Bin+import qualified GI.Gtk.Objects.Container as Gtk.Container+import qualified GI.Gtk.Objects.Dialog as Gtk.Dialog+import qualified GI.Gtk.Objects.Widget as Gtk.Widget+import qualified GI.Gtk.Objects.Window as Gtk.Window++-- | Memory-managed wrapper type.+newtype Dialog = Dialog (ManagedPtr Dialog)+foreign import ccall "hdy_dialog_get_type"+    c_hdy_dialog_get_type :: IO GType++instance GObject Dialog where+    gobjectType = c_hdy_dialog_get_type+    ++-- | Type class for types which can be safely cast to `Dialog`, for instance with `toDialog`.+class (GObject o, O.IsDescendantOf Dialog o) => IsDialog o+instance (GObject o, O.IsDescendantOf Dialog o) => IsDialog o++instance O.HasParentTypes Dialog+type instance O.ParentTypes Dialog = '[Gtk.Dialog.Dialog, Gtk.Window.Window, Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable]++-- | Cast to `Dialog`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toDialog :: (MonadIO m, IsDialog o) => o -> m Dialog+toDialog = liftIO . unsafeCastTo Dialog++-- | A convenience alias for `Nothing` :: `Maybe` `Dialog`.+noDialog :: Maybe Dialog+noDialog = Nothing++#if ENABLE_OVERLOADING+type family ResolveDialogMethod (t :: Symbol) (o :: *) :: * where+    ResolveDialogMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo+    ResolveDialogMethod "activateDefault" o = Gtk.Window.WindowActivateDefaultMethodInfo+    ResolveDialogMethod "activateFocus" o = Gtk.Window.WindowActivateFocusMethodInfo+    ResolveDialogMethod "activateKey" o = Gtk.Window.WindowActivateKeyMethodInfo+    ResolveDialogMethod "add" o = Gtk.Container.ContainerAddMethodInfo+    ResolveDialogMethod "addAccelGroup" o = Gtk.Window.WindowAddAccelGroupMethodInfo+    ResolveDialogMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo+    ResolveDialogMethod "addActionWidget" o = Gtk.Dialog.DialogAddActionWidgetMethodInfo+    ResolveDialogMethod "addButton" o = Gtk.Dialog.DialogAddButtonMethodInfo+    ResolveDialogMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo+    ResolveDialogMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo+    ResolveDialogMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo+    ResolveDialogMethod "addMnemonic" o = Gtk.Window.WindowAddMnemonicMethodInfo+    ResolveDialogMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo+    ResolveDialogMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo+    ResolveDialogMethod "beginMoveDrag" o = Gtk.Window.WindowBeginMoveDragMethodInfo+    ResolveDialogMethod "beginResizeDrag" o = Gtk.Window.WindowBeginResizeDragMethodInfo+    ResolveDialogMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveDialogMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveDialogMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo+    ResolveDialogMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo+    ResolveDialogMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo+    ResolveDialogMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo+    ResolveDialogMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo+    ResolveDialogMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo+    ResolveDialogMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo+    ResolveDialogMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo+    ResolveDialogMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo+    ResolveDialogMethod "close" o = Gtk.Window.WindowCloseMethodInfo+    ResolveDialogMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo+    ResolveDialogMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo+    ResolveDialogMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo+    ResolveDialogMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo+    ResolveDialogMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo+    ResolveDialogMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo+    ResolveDialogMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo+    ResolveDialogMethod "deiconify" o = Gtk.Window.WindowDeiconifyMethodInfo+    ResolveDialogMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo+    ResolveDialogMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo+    ResolveDialogMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo+    ResolveDialogMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo+    ResolveDialogMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo+    ResolveDialogMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo+    ResolveDialogMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo+    ResolveDialogMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo+    ResolveDialogMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo+    ResolveDialogMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo+    ResolveDialogMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo+    ResolveDialogMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo+    ResolveDialogMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo+    ResolveDialogMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo+    ResolveDialogMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo+    ResolveDialogMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo+    ResolveDialogMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo+    ResolveDialogMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo+    ResolveDialogMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo+    ResolveDialogMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo+    ResolveDialogMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo+    ResolveDialogMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo+    ResolveDialogMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo+    ResolveDialogMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo+    ResolveDialogMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo+    ResolveDialogMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo+    ResolveDialogMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo+    ResolveDialogMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo+    ResolveDialogMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo+    ResolveDialogMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo+    ResolveDialogMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo+    ResolveDialogMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo+    ResolveDialogMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo+    ResolveDialogMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo+    ResolveDialogMethod "event" o = Gtk.Widget.WidgetEventMethodInfo+    ResolveDialogMethod "forall" o = Gtk.Container.ContainerForallMethodInfo+    ResolveDialogMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveDialogMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo+    ResolveDialogMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo+    ResolveDialogMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveDialogMethod "fullscreen" o = Gtk.Window.WindowFullscreenMethodInfo+    ResolveDialogMethod "fullscreenOnMonitor" o = Gtk.Window.WindowFullscreenOnMonitorMethodInfo+    ResolveDialogMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveDialogMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo+    ResolveDialogMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo+    ResolveDialogMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo+    ResolveDialogMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo+    ResolveDialogMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo+    ResolveDialogMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo+    ResolveDialogMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo+    ResolveDialogMethod "hasGroup" o = Gtk.Window.WindowHasGroupMethodInfo+    ResolveDialogMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo+    ResolveDialogMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo+    ResolveDialogMethod "hasToplevelFocus" o = Gtk.Window.WindowHasToplevelFocusMethodInfo+    ResolveDialogMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo+    ResolveDialogMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo+    ResolveDialogMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo+    ResolveDialogMethod "iconify" o = Gtk.Window.WindowIconifyMethodInfo+    ResolveDialogMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo+    ResolveDialogMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo+    ResolveDialogMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo+    ResolveDialogMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo+    ResolveDialogMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo+    ResolveDialogMethod "isActive" o = Gtk.Window.WindowIsActiveMethodInfo+    ResolveDialogMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo+    ResolveDialogMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo+    ResolveDialogMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo+    ResolveDialogMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveDialogMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo+    ResolveDialogMethod "isMaximized" o = Gtk.Window.WindowIsMaximizedMethodInfo+    ResolveDialogMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo+    ResolveDialogMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo+    ResolveDialogMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo+    ResolveDialogMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo+    ResolveDialogMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo+    ResolveDialogMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo+    ResolveDialogMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo+    ResolveDialogMethod "map" o = Gtk.Widget.WidgetMapMethodInfo+    ResolveDialogMethod "maximize" o = Gtk.Window.WindowMaximizeMethodInfo+    ResolveDialogMethod "mnemonicActivate" o = Gtk.Window.WindowMnemonicActivateMethodInfo+    ResolveDialogMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo+    ResolveDialogMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo+    ResolveDialogMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo+    ResolveDialogMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo+    ResolveDialogMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo+    ResolveDialogMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo+    ResolveDialogMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo+    ResolveDialogMethod "move" o = Gtk.Window.WindowMoveMethodInfo+    ResolveDialogMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveDialogMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveDialogMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo+    ResolveDialogMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo+    ResolveDialogMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo+    ResolveDialogMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo+    ResolveDialogMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo+    ResolveDialogMethod "parseGeometry" o = Gtk.Window.WindowParseGeometryMethodInfo+    ResolveDialogMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo+    ResolveDialogMethod "path" o = Gtk.Widget.WidgetPathMethodInfo+    ResolveDialogMethod "present" o = Gtk.Window.WindowPresentMethodInfo+    ResolveDialogMethod "presentWithTime" o = Gtk.Window.WindowPresentWithTimeMethodInfo+    ResolveDialogMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo+    ResolveDialogMethod "propagateKeyEvent" o = Gtk.Window.WindowPropagateKeyEventMethodInfo+    ResolveDialogMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo+    ResolveDialogMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo+    ResolveDialogMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo+    ResolveDialogMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo+    ResolveDialogMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo+    ResolveDialogMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo+    ResolveDialogMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo+    ResolveDialogMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo+    ResolveDialogMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveDialogMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveDialogMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo+    ResolveDialogMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo+    ResolveDialogMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo+    ResolveDialogMethod "removeAccelGroup" o = Gtk.Window.WindowRemoveAccelGroupMethodInfo+    ResolveDialogMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo+    ResolveDialogMethod "removeMnemonic" o = Gtk.Window.WindowRemoveMnemonicMethodInfo+    ResolveDialogMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo+    ResolveDialogMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo+    ResolveDialogMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo+    ResolveDialogMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo+    ResolveDialogMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo+    ResolveDialogMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo+    ResolveDialogMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo+    ResolveDialogMethod "reshowWithInitialSize" o = Gtk.Window.WindowReshowWithInitialSizeMethodInfo+    ResolveDialogMethod "resize" o = Gtk.Window.WindowResizeMethodInfo+    ResolveDialogMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo+    ResolveDialogMethod "resizeGripIsVisible" o = Gtk.Window.WindowResizeGripIsVisibleMethodInfo+    ResolveDialogMethod "resizeToGeometry" o = Gtk.Window.WindowResizeToGeometryMethodInfo+    ResolveDialogMethod "response" o = Gtk.Dialog.DialogResponseMethodInfo+    ResolveDialogMethod "run" o = Gtk.Dialog.DialogRunMethodInfo+    ResolveDialogMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveDialogMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo+    ResolveDialogMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo+    ResolveDialogMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo+    ResolveDialogMethod "show" o = Gtk.Widget.WidgetShowMethodInfo+    ResolveDialogMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo+    ResolveDialogMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo+    ResolveDialogMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo+    ResolveDialogMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo+    ResolveDialogMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo+    ResolveDialogMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveDialogMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveDialogMethod "stick" o = Gtk.Window.WindowStickMethodInfo+    ResolveDialogMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo+    ResolveDialogMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo+    ResolveDialogMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo+    ResolveDialogMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveDialogMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo+    ResolveDialogMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo+    ResolveDialogMethod "unfullscreen" o = Gtk.Window.WindowUnfullscreenMethodInfo+    ResolveDialogMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo+    ResolveDialogMethod "unmaximize" o = Gtk.Window.WindowUnmaximizeMethodInfo+    ResolveDialogMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo+    ResolveDialogMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo+    ResolveDialogMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveDialogMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo+    ResolveDialogMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo+    ResolveDialogMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo+    ResolveDialogMethod "unstick" o = Gtk.Window.WindowUnstickMethodInfo+    ResolveDialogMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveDialogMethod "getAcceptFocus" o = Gtk.Window.WindowGetAcceptFocusMethodInfo+    ResolveDialogMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo+    ResolveDialogMethod "getActionArea" o = Gtk.Dialog.DialogGetActionAreaMethodInfo+    ResolveDialogMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo+    ResolveDialogMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo+    ResolveDialogMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo+    ResolveDialogMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo+    ResolveDialogMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo+    ResolveDialogMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo+    ResolveDialogMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo+    ResolveDialogMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo+    ResolveDialogMethod "getApplication" o = Gtk.Window.WindowGetApplicationMethodInfo+    ResolveDialogMethod "getAttachedTo" o = Gtk.Window.WindowGetAttachedToMethodInfo+    ResolveDialogMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo+    ResolveDialogMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo+    ResolveDialogMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo+    ResolveDialogMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo+    ResolveDialogMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo+    ResolveDialogMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo+    ResolveDialogMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo+    ResolveDialogMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo+    ResolveDialogMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo+    ResolveDialogMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo+    ResolveDialogMethod "getContentArea" o = Gtk.Dialog.DialogGetContentAreaMethodInfo+    ResolveDialogMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveDialogMethod "getDecorated" o = Gtk.Window.WindowGetDecoratedMethodInfo+    ResolveDialogMethod "getDefaultSize" o = Gtk.Window.WindowGetDefaultSizeMethodInfo+    ResolveDialogMethod "getDefaultWidget" o = Gtk.Window.WindowGetDefaultWidgetMethodInfo+    ResolveDialogMethod "getDeletable" o = Gtk.Window.WindowGetDeletableMethodInfo+    ResolveDialogMethod "getDestroyWithParent" o = Gtk.Window.WindowGetDestroyWithParentMethodInfo+    ResolveDialogMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo+    ResolveDialogMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo+    ResolveDialogMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo+    ResolveDialogMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo+    ResolveDialogMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo+    ResolveDialogMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo+    ResolveDialogMethod "getFocus" o = Gtk.Window.WindowGetFocusMethodInfo+    ResolveDialogMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo+    ResolveDialogMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo+    ResolveDialogMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo+    ResolveDialogMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo+    ResolveDialogMethod "getFocusOnMap" o = Gtk.Window.WindowGetFocusOnMapMethodInfo+    ResolveDialogMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo+    ResolveDialogMethod "getFocusVisible" o = Gtk.Window.WindowGetFocusVisibleMethodInfo+    ResolveDialogMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo+    ResolveDialogMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo+    ResolveDialogMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo+    ResolveDialogMethod "getGravity" o = Gtk.Window.WindowGetGravityMethodInfo+    ResolveDialogMethod "getGroup" o = Gtk.Window.WindowGetGroupMethodInfo+    ResolveDialogMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo+    ResolveDialogMethod "getHasResizeGrip" o = Gtk.Window.WindowGetHasResizeGripMethodInfo+    ResolveDialogMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo+    ResolveDialogMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo+    ResolveDialogMethod "getHeaderBar" o = Gtk.Dialog.DialogGetHeaderBarMethodInfo+    ResolveDialogMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo+    ResolveDialogMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo+    ResolveDialogMethod "getHideTitlebarWhenMaximized" o = Gtk.Window.WindowGetHideTitlebarWhenMaximizedMethodInfo+    ResolveDialogMethod "getIcon" o = Gtk.Window.WindowGetIconMethodInfo+    ResolveDialogMethod "getIconList" o = Gtk.Window.WindowGetIconListMethodInfo+    ResolveDialogMethod "getIconName" o = Gtk.Window.WindowGetIconNameMethodInfo+    ResolveDialogMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo+    ResolveDialogMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo+    ResolveDialogMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo+    ResolveDialogMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo+    ResolveDialogMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo+    ResolveDialogMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo+    ResolveDialogMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo+    ResolveDialogMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo+    ResolveDialogMethod "getMnemonicModifier" o = Gtk.Window.WindowGetMnemonicModifierMethodInfo+    ResolveDialogMethod "getMnemonicsVisible" o = Gtk.Window.WindowGetMnemonicsVisibleMethodInfo+    ResolveDialogMethod "getModal" o = Gtk.Window.WindowGetModalMethodInfo+    ResolveDialogMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo+    ResolveDialogMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo+    ResolveDialogMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo+    ResolveDialogMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo+    ResolveDialogMethod "getOpacity" o = Gtk.Window.WindowGetOpacityMethodInfo+    ResolveDialogMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo+    ResolveDialogMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo+    ResolveDialogMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo+    ResolveDialogMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo+    ResolveDialogMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo+    ResolveDialogMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo+    ResolveDialogMethod "getPosition" o = Gtk.Window.WindowGetPositionMethodInfo+    ResolveDialogMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo+    ResolveDialogMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo+    ResolveDialogMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo+    ResolveDialogMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo+    ResolveDialogMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo+    ResolveDialogMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo+    ResolveDialogMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveDialogMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveDialogMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo+    ResolveDialogMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo+    ResolveDialogMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo+    ResolveDialogMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo+    ResolveDialogMethod "getResizable" o = Gtk.Window.WindowGetResizableMethodInfo+    ResolveDialogMethod "getResizeGripArea" o = Gtk.Window.WindowGetResizeGripAreaMethodInfo+    ResolveDialogMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo+    ResolveDialogMethod "getResponseForWidget" o = Gtk.Dialog.DialogGetResponseForWidgetMethodInfo+    ResolveDialogMethod "getRole" o = Gtk.Window.WindowGetRoleMethodInfo+    ResolveDialogMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo+    ResolveDialogMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo+    ResolveDialogMethod "getScreen" o = Gtk.Window.WindowGetScreenMethodInfo+    ResolveDialogMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo+    ResolveDialogMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo+    ResolveDialogMethod "getSize" o = Gtk.Window.WindowGetSizeMethodInfo+    ResolveDialogMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo+    ResolveDialogMethod "getSkipPagerHint" o = Gtk.Window.WindowGetSkipPagerHintMethodInfo+    ResolveDialogMethod "getSkipTaskbarHint" o = Gtk.Window.WindowGetSkipTaskbarHintMethodInfo+    ResolveDialogMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo+    ResolveDialogMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo+    ResolveDialogMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo+    ResolveDialogMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo+    ResolveDialogMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo+    ResolveDialogMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo+    ResolveDialogMethod "getTitle" o = Gtk.Window.WindowGetTitleMethodInfo+    ResolveDialogMethod "getTitlebar" o = Gtk.Window.WindowGetTitlebarMethodInfo+    ResolveDialogMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo+    ResolveDialogMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo+    ResolveDialogMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo+    ResolveDialogMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo+    ResolveDialogMethod "getTransientFor" o = Gtk.Window.WindowGetTransientForMethodInfo+    ResolveDialogMethod "getTypeHint" o = Gtk.Window.WindowGetTypeHintMethodInfo+    ResolveDialogMethod "getUrgencyHint" o = Gtk.Window.WindowGetUrgencyHintMethodInfo+    ResolveDialogMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo+    ResolveDialogMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo+    ResolveDialogMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo+    ResolveDialogMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo+    ResolveDialogMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo+    ResolveDialogMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo+    ResolveDialogMethod "getWidgetForResponse" o = Gtk.Dialog.DialogGetWidgetForResponseMethodInfo+    ResolveDialogMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo+    ResolveDialogMethod "getWindowType" o = Gtk.Window.WindowGetWindowTypeMethodInfo+    ResolveDialogMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo+    ResolveDialogMethod "setAcceptFocus" o = Gtk.Window.WindowSetAcceptFocusMethodInfo+    ResolveDialogMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo+    ResolveDialogMethod "setAlternativeButtonOrderFromArray" o = Gtk.Dialog.DialogSetAlternativeButtonOrderFromArrayMethodInfo+    ResolveDialogMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo+    ResolveDialogMethod "setApplication" o = Gtk.Window.WindowSetApplicationMethodInfo+    ResolveDialogMethod "setAttachedTo" o = Gtk.Window.WindowSetAttachedToMethodInfo+    ResolveDialogMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo+    ResolveDialogMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo+    ResolveDialogMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo+    ResolveDialogMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo+    ResolveDialogMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo+    ResolveDialogMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo+    ResolveDialogMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo+    ResolveDialogMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveDialogMethod "setDecorated" o = Gtk.Window.WindowSetDecoratedMethodInfo+    ResolveDialogMethod "setDefault" o = Gtk.Window.WindowSetDefaultMethodInfo+    ResolveDialogMethod "setDefaultGeometry" o = Gtk.Window.WindowSetDefaultGeometryMethodInfo+    ResolveDialogMethod "setDefaultResponse" o = Gtk.Dialog.DialogSetDefaultResponseMethodInfo+    ResolveDialogMethod "setDefaultSize" o = Gtk.Window.WindowSetDefaultSizeMethodInfo+    ResolveDialogMethod "setDeletable" o = Gtk.Window.WindowSetDeletableMethodInfo+    ResolveDialogMethod "setDestroyWithParent" o = Gtk.Window.WindowSetDestroyWithParentMethodInfo+    ResolveDialogMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo+    ResolveDialogMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo+    ResolveDialogMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo+    ResolveDialogMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo+    ResolveDialogMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo+    ResolveDialogMethod "setFocus" o = Gtk.Window.WindowSetFocusMethodInfo+    ResolveDialogMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo+    ResolveDialogMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo+    ResolveDialogMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo+    ResolveDialogMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo+    ResolveDialogMethod "setFocusOnMap" o = Gtk.Window.WindowSetFocusOnMapMethodInfo+    ResolveDialogMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo+    ResolveDialogMethod "setFocusVisible" o = Gtk.Window.WindowSetFocusVisibleMethodInfo+    ResolveDialogMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo+    ResolveDialogMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo+    ResolveDialogMethod "setGeometryHints" o = Gtk.Window.WindowSetGeometryHintsMethodInfo+    ResolveDialogMethod "setGravity" o = Gtk.Window.WindowSetGravityMethodInfo+    ResolveDialogMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo+    ResolveDialogMethod "setHasResizeGrip" o = Gtk.Window.WindowSetHasResizeGripMethodInfo+    ResolveDialogMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo+    ResolveDialogMethod "setHasUserRefCount" o = Gtk.Window.WindowSetHasUserRefCountMethodInfo+    ResolveDialogMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo+    ResolveDialogMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo+    ResolveDialogMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo+    ResolveDialogMethod "setHideTitlebarWhenMaximized" o = Gtk.Window.WindowSetHideTitlebarWhenMaximizedMethodInfo+    ResolveDialogMethod "setIcon" o = Gtk.Window.WindowSetIconMethodInfo+    ResolveDialogMethod "setIconFromFile" o = Gtk.Window.WindowSetIconFromFileMethodInfo+    ResolveDialogMethod "setIconList" o = Gtk.Window.WindowSetIconListMethodInfo+    ResolveDialogMethod "setIconName" o = Gtk.Window.WindowSetIconNameMethodInfo+    ResolveDialogMethod "setKeepAbove" o = Gtk.Window.WindowSetKeepAboveMethodInfo+    ResolveDialogMethod "setKeepBelow" o = Gtk.Window.WindowSetKeepBelowMethodInfo+    ResolveDialogMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo+    ResolveDialogMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo+    ResolveDialogMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo+    ResolveDialogMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo+    ResolveDialogMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo+    ResolveDialogMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo+    ResolveDialogMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo+    ResolveDialogMethod "setMnemonicModifier" o = Gtk.Window.WindowSetMnemonicModifierMethodInfo+    ResolveDialogMethod "setMnemonicsVisible" o = Gtk.Window.WindowSetMnemonicsVisibleMethodInfo+    ResolveDialogMethod "setModal" o = Gtk.Window.WindowSetModalMethodInfo+    ResolveDialogMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo+    ResolveDialogMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo+    ResolveDialogMethod "setOpacity" o = Gtk.Window.WindowSetOpacityMethodInfo+    ResolveDialogMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo+    ResolveDialogMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo+    ResolveDialogMethod "setPosition" o = Gtk.Window.WindowSetPositionMethodInfo+    ResolveDialogMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveDialogMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo+    ResolveDialogMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo+    ResolveDialogMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo+    ResolveDialogMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo+    ResolveDialogMethod "setResizable" o = Gtk.Window.WindowSetResizableMethodInfo+    ResolveDialogMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo+    ResolveDialogMethod "setResponseSensitive" o = Gtk.Dialog.DialogSetResponseSensitiveMethodInfo+    ResolveDialogMethod "setRole" o = Gtk.Window.WindowSetRoleMethodInfo+    ResolveDialogMethod "setScreen" o = Gtk.Window.WindowSetScreenMethodInfo+    ResolveDialogMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo+    ResolveDialogMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo+    ResolveDialogMethod "setSkipPagerHint" o = Gtk.Window.WindowSetSkipPagerHintMethodInfo+    ResolveDialogMethod "setSkipTaskbarHint" o = Gtk.Window.WindowSetSkipTaskbarHintMethodInfo+    ResolveDialogMethod "setStartupId" o = Gtk.Window.WindowSetStartupIdMethodInfo+    ResolveDialogMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo+    ResolveDialogMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo+    ResolveDialogMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo+    ResolveDialogMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo+    ResolveDialogMethod "setTitle" o = Gtk.Window.WindowSetTitleMethodInfo+    ResolveDialogMethod "setTitlebar" o = Gtk.Window.WindowSetTitlebarMethodInfo+    ResolveDialogMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo+    ResolveDialogMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo+    ResolveDialogMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo+    ResolveDialogMethod "setTransientFor" o = Gtk.Window.WindowSetTransientForMethodInfo+    ResolveDialogMethod "setTypeHint" o = Gtk.Window.WindowSetTypeHintMethodInfo+    ResolveDialogMethod "setUrgencyHint" o = Gtk.Window.WindowSetUrgencyHintMethodInfo+    ResolveDialogMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo+    ResolveDialogMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo+    ResolveDialogMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo+    ResolveDialogMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo+    ResolveDialogMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo+    ResolveDialogMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo+    ResolveDialogMethod "setWmclass" o = Gtk.Window.WindowSetWmclassMethodInfo+    ResolveDialogMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveDialogMethod t Dialog, O.MethodInfo info Dialog p) => OL.IsLabel t (Dialog -> 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 Dialog+type instance O.AttributeList Dialog = DialogAttributeList+type DialogAttributeList = ('[ '("acceptFocus", Gtk.Window.WindowAcceptFocusPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("application", Gtk.Window.WindowApplicationPropertyInfo), '("attachedTo", Gtk.Window.WindowAttachedToPropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("decorated", Gtk.Window.WindowDecoratedPropertyInfo), '("defaultHeight", Gtk.Window.WindowDefaultHeightPropertyInfo), '("defaultWidth", Gtk.Window.WindowDefaultWidthPropertyInfo), '("deletable", Gtk.Window.WindowDeletablePropertyInfo), '("destroyWithParent", Gtk.Window.WindowDestroyWithParentPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusOnMap", Gtk.Window.WindowFocusOnMapPropertyInfo), '("focusVisible", Gtk.Window.WindowFocusVisiblePropertyInfo), '("gravity", Gtk.Window.WindowGravityPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasResizeGrip", Gtk.Window.WindowHasResizeGripPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("hasToplevelFocus", Gtk.Window.WindowHasToplevelFocusPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("hideTitlebarWhenMaximized", Gtk.Window.WindowHideTitlebarWhenMaximizedPropertyInfo), '("icon", Gtk.Window.WindowIconPropertyInfo), '("iconName", Gtk.Window.WindowIconNamePropertyInfo), '("isActive", Gtk.Window.WindowIsActivePropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("isMaximized", Gtk.Window.WindowIsMaximizedPropertyInfo), '("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), '("mnemonicsVisible", Gtk.Window.WindowMnemonicsVisiblePropertyInfo), '("modal", Gtk.Window.WindowModalPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizable", Gtk.Window.WindowResizablePropertyInfo), '("resizeGripVisible", Gtk.Window.WindowResizeGripVisiblePropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("role", Gtk.Window.WindowRolePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("screen", Gtk.Window.WindowScreenPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("skipPagerHint", Gtk.Window.WindowSkipPagerHintPropertyInfo), '("skipTaskbarHint", Gtk.Window.WindowSkipTaskbarHintPropertyInfo), '("startupId", Gtk.Window.WindowStartupIdPropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("title", Gtk.Window.WindowTitlePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("transientFor", Gtk.Window.WindowTransientForPropertyInfo), '("type", Gtk.Window.WindowTypePropertyInfo), '("typeHint", Gtk.Window.WindowTypeHintPropertyInfo), '("urgencyHint", Gtk.Window.WindowUrgencyHintPropertyInfo), '("useHeaderBar", Gtk.Dialog.DialogUseHeaderBarPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo), '("windowPosition", Gtk.Window.WindowWindowPositionPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type instance O.SignalList Dialog = DialogSignalList+type DialogSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("activateDefault", Gtk.Window.WindowActivateDefaultSignalInfo), '("activateFocus", Gtk.Window.WindowActivateFocusSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("close", Gtk.Dialog.DialogCloseSignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("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), '("enableDebugging", Gtk.Window.WindowEnableDebuggingSignalInfo), '("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), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("keysChanged", Gtk.Window.WindowKeysChangedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("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), '("response", Gtk.Dialog.DialogResponseSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocus", Gtk.Window.WindowSetFocusSignalInfo), '("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 Dialog::new+-- method type : Constructor+-- Args : [Arg {argCName = "parent", argType = TInterface (Name {namespace = "Gtk", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GtkWindow this dialog is a child of", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "Dialog"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_dialog_new" hdy_dialog_new :: +    Ptr Gtk.Window.Window ->                -- parent : TInterface (Name {namespace = "Gtk", name = "Window"})+    IO (Ptr Dialog)++{- |+Create a 'GI.Handy.Objects.Dialog.Dialog' with 'GI.Gtk.Objects.Window.Window':@/transient-for/@ set to parent++C Usage++=== /C code/+>+>GtkWidget *dlg = hdy_dialog_new (GTK_WINDOW (main_window));+++Vala Usage++=== /Vala code/+>+>var dlg = new Hdy.Dialog (main_window);+++Python Usage++=== /Python code/+>+>dlg = Handy.Dialog.new (main_window);+++/Since: 0.0.7/+-}+dialogNew ::+    (B.CallStack.HasCallStack, MonadIO m, Gtk.Window.IsWindow a) =>+    a+    {- ^ /@parent@/: 'GI.Gtk.Objects.Window.Window' this dialog is a child of -}+    -> m Dialog+dialogNew parent = liftIO $ do+    parent' <- unsafeManagedPtrCastPtr parent+    result <- hdy_dialog_new parent'+    checkUnexpectedReturnNULL "dialogNew" result+    result' <- (newObject Dialog) result+    touchManagedPtr parent+    return result'++#if ENABLE_OVERLOADING+#endif++
+ GI/Handy/Objects/Dialog.hs-boot view
@@ -0,0 +1,29 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Handy.Objects.Dialog 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 Dialog = Dialog (ManagedPtr Dialog)+instance GObject Dialog where+class (GObject o, O.IsDescendantOf Dialog o) => IsDialog o+instance (GObject o, O.IsDescendantOf Dialog o) => IsDialog o+instance O.HasParentTypes Dialog
+ GI/Handy/Objects/EnumValueObject.hs view
@@ -0,0 +1,287 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Handy.Objects.EnumValueObject+    ( ++-- * Exported types+    EnumValueObject(..)                     ,+    IsEnumValueObject                       ,+    toEnumValueObject                       ,+    noEnumValueObject                       ,+++ -- * Methods+-- ** getName #method:getName#++#if ENABLE_OVERLOADING+    EnumValueObjectGetNameMethodInfo        ,+#endif+    enumValueObjectGetName                  ,+++-- ** getNick #method:getNick#++#if ENABLE_OVERLOADING+    EnumValueObjectGetNickMethodInfo        ,+#endif+    enumValueObjectGetNick                  ,+++-- ** getValue #method:getValue#++#if ENABLE_OVERLOADING+    EnumValueObjectGetValueMethodInfo       ,+#endif+    enumValueObjectGetValue                 ,+++-- ** new #method:new#++    enumValueObjectNew                      ,+++++    ) 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.GObject.Objects.Object as GObject.Object+import qualified GI.GObject.Structs.EnumValue as GObject.EnumValue++-- | Memory-managed wrapper type.+newtype EnumValueObject = EnumValueObject (ManagedPtr EnumValueObject)+foreign import ccall "hdy_enum_value_object_get_type"+    c_hdy_enum_value_object_get_type :: IO GType++instance GObject EnumValueObject where+    gobjectType = c_hdy_enum_value_object_get_type+    ++-- | Type class for types which can be safely cast to `EnumValueObject`, for instance with `toEnumValueObject`.+class (GObject o, O.IsDescendantOf EnumValueObject o) => IsEnumValueObject o+instance (GObject o, O.IsDescendantOf EnumValueObject o) => IsEnumValueObject o++instance O.HasParentTypes EnumValueObject+type instance O.ParentTypes EnumValueObject = '[GObject.Object.Object]++-- | Cast to `EnumValueObject`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toEnumValueObject :: (MonadIO m, IsEnumValueObject o) => o -> m EnumValueObject+toEnumValueObject = liftIO . unsafeCastTo EnumValueObject++-- | A convenience alias for `Nothing` :: `Maybe` `EnumValueObject`.+noEnumValueObject :: Maybe EnumValueObject+noEnumValueObject = Nothing++#if ENABLE_OVERLOADING+type family ResolveEnumValueObjectMethod (t :: Symbol) (o :: *) :: * where+    ResolveEnumValueObjectMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveEnumValueObjectMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveEnumValueObjectMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveEnumValueObjectMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveEnumValueObjectMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveEnumValueObjectMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveEnumValueObjectMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveEnumValueObjectMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveEnumValueObjectMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveEnumValueObjectMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveEnumValueObjectMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveEnumValueObjectMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveEnumValueObjectMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveEnumValueObjectMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveEnumValueObjectMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveEnumValueObjectMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveEnumValueObjectMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveEnumValueObjectMethod "getName" o = EnumValueObjectGetNameMethodInfo+    ResolveEnumValueObjectMethod "getNick" o = EnumValueObjectGetNickMethodInfo+    ResolveEnumValueObjectMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveEnumValueObjectMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveEnumValueObjectMethod "getValue" o = EnumValueObjectGetValueMethodInfo+    ResolveEnumValueObjectMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveEnumValueObjectMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveEnumValueObjectMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveEnumValueObjectMethod t EnumValueObject, O.MethodInfo info EnumValueObject p) => OL.IsLabel t (EnumValueObject -> 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 EnumValueObject+type instance O.AttributeList EnumValueObject = EnumValueObjectAttributeList+type EnumValueObjectAttributeList = ('[ ] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type instance O.SignalList EnumValueObject = EnumValueObjectSignalList+type EnumValueObjectSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++-- method EnumValueObject::new+-- method type : Constructor+-- Args : [Arg {argCName = "enum_value", argType = TInterface (Name {namespace = "GObject", name = "EnumValue"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "EnumValueObject"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_enum_value_object_new" hdy_enum_value_object_new :: +    Ptr GObject.EnumValue.EnumValue ->      -- enum_value : TInterface (Name {namespace = "GObject", name = "EnumValue"})+    IO (Ptr EnumValueObject)++{- |+/No description available in the introspection data./+-}+enumValueObjectNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GObject.EnumValue.EnumValue+    -> m EnumValueObject+enumValueObjectNew enumValue = liftIO $ do+    enumValue' <- unsafeManagedPtrGetPtr enumValue+    result <- hdy_enum_value_object_new enumValue'+    checkUnexpectedReturnNULL "enumValueObjectNew" result+    result' <- (wrapObject EnumValueObject) result+    touchManagedPtr enumValue+    return result'++#if ENABLE_OVERLOADING+#endif++-- method EnumValueObject::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "EnumValueObject"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_enum_value_object_get_name" hdy_enum_value_object_get_name :: +    Ptr EnumValueObject ->                  -- self : TInterface (Name {namespace = "Handy", name = "EnumValueObject"})+    IO CString++{- |+/No description available in the introspection data./+-}+enumValueObjectGetName ::+    (B.CallStack.HasCallStack, MonadIO m, IsEnumValueObject a) =>+    a+    -> m T.Text+enumValueObjectGetName self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_enum_value_object_get_name self'+    checkUnexpectedReturnNULL "enumValueObjectGetName" result+    result' <- cstringToText result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data EnumValueObjectGetNameMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsEnumValueObject a) => O.MethodInfo EnumValueObjectGetNameMethodInfo a signature where+    overloadedMethod _ = enumValueObjectGetName++#endif++-- method EnumValueObject::get_nick+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "EnumValueObject"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_enum_value_object_get_nick" hdy_enum_value_object_get_nick :: +    Ptr EnumValueObject ->                  -- self : TInterface (Name {namespace = "Handy", name = "EnumValueObject"})+    IO CString++{- |+/No description available in the introspection data./+-}+enumValueObjectGetNick ::+    (B.CallStack.HasCallStack, MonadIO m, IsEnumValueObject a) =>+    a+    -> m T.Text+enumValueObjectGetNick self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_enum_value_object_get_nick self'+    checkUnexpectedReturnNULL "enumValueObjectGetNick" result+    result' <- cstringToText result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data EnumValueObjectGetNickMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsEnumValueObject a) => O.MethodInfo EnumValueObjectGetNickMethodInfo a signature where+    overloadedMethod _ = enumValueObjectGetNick++#endif++-- method EnumValueObject::get_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "EnumValueObject"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_enum_value_object_get_value" hdy_enum_value_object_get_value :: +    Ptr EnumValueObject ->                  -- self : TInterface (Name {namespace = "Handy", name = "EnumValueObject"})+    IO Int32++{- |+/No description available in the introspection data./+-}+enumValueObjectGetValue ::+    (B.CallStack.HasCallStack, MonadIO m, IsEnumValueObject a) =>+    a+    -> m Int32+enumValueObjectGetValue self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_enum_value_object_get_value self'+    touchManagedPtr self+    return result++#if ENABLE_OVERLOADING+data EnumValueObjectGetValueMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsEnumValueObject a) => O.MethodInfo EnumValueObjectGetValueMethodInfo a signature where+    overloadedMethod _ = enumValueObjectGetValue++#endif++
+ GI/Handy/Objects/EnumValueObject.hs-boot view
@@ -0,0 +1,38 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Handy.Objects.EnumValueObject 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 EnumValueObject = EnumValueObject (ManagedPtr EnumValueObject)+instance GObject EnumValueObject where+class (GObject o, O.IsDescendantOf EnumValueObject o) => IsEnumValueObject o+instance (GObject o, O.IsDescendantOf EnumValueObject o) => IsEnumValueObject o+instance O.HasParentTypes EnumValueObject+#if ENABLE_OVERLOADING+data EnumValueObjectGetNameMethodInfo+#endif+#if ENABLE_OVERLOADING+data EnumValueObjectGetNickMethodInfo+#endif+#if ENABLE_OVERLOADING+data EnumValueObjectGetValueMethodInfo+#endif
+ GI/Handy/Objects/ExpanderRow.hs view
@@ -0,0 +1,961 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Handy.Objects.ExpanderRow+    ( ++-- * Exported types+    ExpanderRow(..)                         ,+    IsExpanderRow                           ,+    toExpanderRow                           ,+    noExpanderRow                           ,+++ -- * Methods+-- ** getEnableExpansion #method:getEnableExpansion#++#if ENABLE_OVERLOADING+    ExpanderRowGetEnableExpansionMethodInfo ,+#endif+    expanderRowGetEnableExpansion           ,+++-- ** getExpanded #method:getExpanded#++#if ENABLE_OVERLOADING+    ExpanderRowGetExpandedMethodInfo        ,+#endif+    expanderRowGetExpanded                  ,+++-- ** getShowEnableSwitch #method:getShowEnableSwitch#++#if ENABLE_OVERLOADING+    ExpanderRowGetShowEnableSwitchMethodInfo,+#endif+    expanderRowGetShowEnableSwitch          ,+++-- ** new #method:new#++    expanderRowNew                          ,+++-- ** setEnableExpansion #method:setEnableExpansion#++#if ENABLE_OVERLOADING+    ExpanderRowSetEnableExpansionMethodInfo ,+#endif+    expanderRowSetEnableExpansion           ,+++-- ** setExpanded #method:setExpanded#++#if ENABLE_OVERLOADING+    ExpanderRowSetExpandedMethodInfo        ,+#endif+    expanderRowSetExpanded                  ,+++-- ** setShowEnableSwitch #method:setShowEnableSwitch#++#if ENABLE_OVERLOADING+    ExpanderRowSetShowEnableSwitchMethodInfo,+#endif+    expanderRowSetShowEnableSwitch          ,+++++ -- * Properties+-- ** enableExpansion #attr:enableExpansion#+{- | 'True' if the expansion is enabled.+-}+#if ENABLE_OVERLOADING+    ExpanderRowEnableExpansionPropertyInfo  ,+#endif+    constructExpanderRowEnableExpansion     ,+#if ENABLE_OVERLOADING+    expanderRowEnableExpansion              ,+#endif+    getExpanderRowEnableExpansion           ,+    setExpanderRowEnableExpansion           ,+++-- ** expanded #attr:expanded#+{- | 'True' if the row is expanded.+-}+#if ENABLE_OVERLOADING+    ExpanderRowExpandedPropertyInfo         ,+#endif+    constructExpanderRowExpanded            ,+#if ENABLE_OVERLOADING+    expanderRowExpanded                     ,+#endif+    getExpanderRowExpanded                  ,+    setExpanderRowExpanded                  ,+++-- ** showEnableSwitch #attr:showEnableSwitch#+{- | 'True' if the switch enabling the expansion is visible.+-}+#if ENABLE_OVERLOADING+    ExpanderRowShowEnableSwitchPropertyInfo ,+#endif+    constructExpanderRowShowEnableSwitch    ,+#if ENABLE_OVERLOADING+    expanderRowShowEnableSwitch             ,+#endif+    getExpanderRowShowEnableSwitch          ,+    setExpanderRowShowEnableSwitch          ,+++++    ) 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 qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gtk.Interfaces.Actionable as Gtk.Actionable+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable+import qualified GI.Gtk.Objects.Bin as Gtk.Bin+import qualified GI.Gtk.Objects.Container as Gtk.Container+import qualified GI.Gtk.Objects.ListBoxRow as Gtk.ListBoxRow+import qualified GI.Gtk.Objects.Widget as Gtk.Widget+import {-# SOURCE #-} qualified GI.Handy.Objects.ActionRow as Handy.ActionRow++-- | Memory-managed wrapper type.+newtype ExpanderRow = ExpanderRow (ManagedPtr ExpanderRow)+foreign import ccall "hdy_expander_row_get_type"+    c_hdy_expander_row_get_type :: IO GType++instance GObject ExpanderRow where+    gobjectType = c_hdy_expander_row_get_type+    ++-- | Type class for types which can be safely cast to `ExpanderRow`, for instance with `toExpanderRow`.+class (GObject o, O.IsDescendantOf ExpanderRow o) => IsExpanderRow o+instance (GObject o, O.IsDescendantOf ExpanderRow o) => IsExpanderRow o++instance O.HasParentTypes ExpanderRow+type instance O.ParentTypes ExpanderRow = '[Handy.ActionRow.ActionRow, Gtk.ListBoxRow.ListBoxRow, Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Actionable.Actionable, Gtk.Buildable.Buildable]++-- | Cast to `ExpanderRow`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toExpanderRow :: (MonadIO m, IsExpanderRow o) => o -> m ExpanderRow+toExpanderRow = liftIO . unsafeCastTo ExpanderRow++-- | A convenience alias for `Nothing` :: `Maybe` `ExpanderRow`.+noExpanderRow :: Maybe ExpanderRow+noExpanderRow = Nothing++#if ENABLE_OVERLOADING+type family ResolveExpanderRowMethod (t :: Symbol) (o :: *) :: * where+    ResolveExpanderRowMethod "activate" o = Handy.ActionRow.ActionRowActivateMethodInfo+    ResolveExpanderRowMethod "add" o = Gtk.Container.ContainerAddMethodInfo+    ResolveExpanderRowMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo+    ResolveExpanderRowMethod "addAction" o = Handy.ActionRow.ActionRowAddActionMethodInfo+    ResolveExpanderRowMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo+    ResolveExpanderRowMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo+    ResolveExpanderRowMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo+    ResolveExpanderRowMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo+    ResolveExpanderRowMethod "addPrefix" o = Handy.ActionRow.ActionRowAddPrefixMethodInfo+    ResolveExpanderRowMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo+    ResolveExpanderRowMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveExpanderRowMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveExpanderRowMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo+    ResolveExpanderRowMethod "changed" o = Gtk.ListBoxRow.ListBoxRowChangedMethodInfo+    ResolveExpanderRowMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo+    ResolveExpanderRowMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo+    ResolveExpanderRowMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo+    ResolveExpanderRowMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo+    ResolveExpanderRowMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo+    ResolveExpanderRowMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo+    ResolveExpanderRowMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo+    ResolveExpanderRowMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo+    ResolveExpanderRowMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo+    ResolveExpanderRowMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo+    ResolveExpanderRowMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo+    ResolveExpanderRowMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo+    ResolveExpanderRowMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo+    ResolveExpanderRowMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo+    ResolveExpanderRowMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo+    ResolveExpanderRowMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo+    ResolveExpanderRowMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo+    ResolveExpanderRowMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo+    ResolveExpanderRowMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo+    ResolveExpanderRowMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo+    ResolveExpanderRowMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo+    ResolveExpanderRowMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo+    ResolveExpanderRowMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo+    ResolveExpanderRowMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo+    ResolveExpanderRowMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo+    ResolveExpanderRowMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo+    ResolveExpanderRowMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo+    ResolveExpanderRowMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo+    ResolveExpanderRowMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo+    ResolveExpanderRowMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo+    ResolveExpanderRowMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo+    ResolveExpanderRowMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo+    ResolveExpanderRowMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo+    ResolveExpanderRowMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo+    ResolveExpanderRowMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo+    ResolveExpanderRowMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo+    ResolveExpanderRowMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo+    ResolveExpanderRowMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo+    ResolveExpanderRowMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo+    ResolveExpanderRowMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo+    ResolveExpanderRowMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo+    ResolveExpanderRowMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo+    ResolveExpanderRowMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo+    ResolveExpanderRowMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo+    ResolveExpanderRowMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo+    ResolveExpanderRowMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo+    ResolveExpanderRowMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo+    ResolveExpanderRowMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo+    ResolveExpanderRowMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo+    ResolveExpanderRowMethod "event" o = Gtk.Widget.WidgetEventMethodInfo+    ResolveExpanderRowMethod "forall" o = Gtk.Container.ContainerForallMethodInfo+    ResolveExpanderRowMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveExpanderRowMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo+    ResolveExpanderRowMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo+    ResolveExpanderRowMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveExpanderRowMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveExpanderRowMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo+    ResolveExpanderRowMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo+    ResolveExpanderRowMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo+    ResolveExpanderRowMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo+    ResolveExpanderRowMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo+    ResolveExpanderRowMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo+    ResolveExpanderRowMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo+    ResolveExpanderRowMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo+    ResolveExpanderRowMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo+    ResolveExpanderRowMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo+    ResolveExpanderRowMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo+    ResolveExpanderRowMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo+    ResolveExpanderRowMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo+    ResolveExpanderRowMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo+    ResolveExpanderRowMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo+    ResolveExpanderRowMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo+    ResolveExpanderRowMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo+    ResolveExpanderRowMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo+    ResolveExpanderRowMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo+    ResolveExpanderRowMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo+    ResolveExpanderRowMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveExpanderRowMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo+    ResolveExpanderRowMethod "isSelected" o = Gtk.ListBoxRow.ListBoxRowIsSelectedMethodInfo+    ResolveExpanderRowMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo+    ResolveExpanderRowMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo+    ResolveExpanderRowMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo+    ResolveExpanderRowMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo+    ResolveExpanderRowMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo+    ResolveExpanderRowMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo+    ResolveExpanderRowMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo+    ResolveExpanderRowMethod "map" o = Gtk.Widget.WidgetMapMethodInfo+    ResolveExpanderRowMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo+    ResolveExpanderRowMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo+    ResolveExpanderRowMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo+    ResolveExpanderRowMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo+    ResolveExpanderRowMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo+    ResolveExpanderRowMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo+    ResolveExpanderRowMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo+    ResolveExpanderRowMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo+    ResolveExpanderRowMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveExpanderRowMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveExpanderRowMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo+    ResolveExpanderRowMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo+    ResolveExpanderRowMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo+    ResolveExpanderRowMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo+    ResolveExpanderRowMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo+    ResolveExpanderRowMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo+    ResolveExpanderRowMethod "path" o = Gtk.Widget.WidgetPathMethodInfo+    ResolveExpanderRowMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo+    ResolveExpanderRowMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo+    ResolveExpanderRowMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo+    ResolveExpanderRowMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo+    ResolveExpanderRowMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo+    ResolveExpanderRowMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo+    ResolveExpanderRowMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo+    ResolveExpanderRowMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo+    ResolveExpanderRowMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo+    ResolveExpanderRowMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveExpanderRowMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveExpanderRowMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo+    ResolveExpanderRowMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo+    ResolveExpanderRowMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo+    ResolveExpanderRowMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo+    ResolveExpanderRowMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo+    ResolveExpanderRowMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo+    ResolveExpanderRowMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo+    ResolveExpanderRowMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo+    ResolveExpanderRowMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo+    ResolveExpanderRowMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo+    ResolveExpanderRowMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo+    ResolveExpanderRowMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo+    ResolveExpanderRowMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveExpanderRowMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo+    ResolveExpanderRowMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo+    ResolveExpanderRowMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo+    ResolveExpanderRowMethod "show" o = Gtk.Widget.WidgetShowMethodInfo+    ResolveExpanderRowMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo+    ResolveExpanderRowMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo+    ResolveExpanderRowMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo+    ResolveExpanderRowMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo+    ResolveExpanderRowMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo+    ResolveExpanderRowMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveExpanderRowMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveExpanderRowMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo+    ResolveExpanderRowMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo+    ResolveExpanderRowMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo+    ResolveExpanderRowMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveExpanderRowMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo+    ResolveExpanderRowMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo+    ResolveExpanderRowMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo+    ResolveExpanderRowMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo+    ResolveExpanderRowMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo+    ResolveExpanderRowMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveExpanderRowMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo+    ResolveExpanderRowMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo+    ResolveExpanderRowMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo+    ResolveExpanderRowMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveExpanderRowMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo+    ResolveExpanderRowMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo+    ResolveExpanderRowMethod "getActionName" o = Gtk.Actionable.ActionableGetActionNameMethodInfo+    ResolveExpanderRowMethod "getActionTargetValue" o = Gtk.Actionable.ActionableGetActionTargetValueMethodInfo+    ResolveExpanderRowMethod "getActivatable" o = Gtk.ListBoxRow.ListBoxRowGetActivatableMethodInfo+    ResolveExpanderRowMethod "getActivatableWidget" o = Handy.ActionRow.ActionRowGetActivatableWidgetMethodInfo+    ResolveExpanderRowMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo+    ResolveExpanderRowMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo+    ResolveExpanderRowMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo+    ResolveExpanderRowMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo+    ResolveExpanderRowMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo+    ResolveExpanderRowMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo+    ResolveExpanderRowMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo+    ResolveExpanderRowMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo+    ResolveExpanderRowMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo+    ResolveExpanderRowMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo+    ResolveExpanderRowMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo+    ResolveExpanderRowMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo+    ResolveExpanderRowMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo+    ResolveExpanderRowMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo+    ResolveExpanderRowMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo+    ResolveExpanderRowMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo+    ResolveExpanderRowMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo+    ResolveExpanderRowMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveExpanderRowMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo+    ResolveExpanderRowMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo+    ResolveExpanderRowMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo+    ResolveExpanderRowMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo+    ResolveExpanderRowMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo+    ResolveExpanderRowMethod "getEnableExpansion" o = ExpanderRowGetEnableExpansionMethodInfo+    ResolveExpanderRowMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo+    ResolveExpanderRowMethod "getExpanded" o = ExpanderRowGetExpandedMethodInfo+    ResolveExpanderRowMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo+    ResolveExpanderRowMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo+    ResolveExpanderRowMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo+    ResolveExpanderRowMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo+    ResolveExpanderRowMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo+    ResolveExpanderRowMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo+    ResolveExpanderRowMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo+    ResolveExpanderRowMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo+    ResolveExpanderRowMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo+    ResolveExpanderRowMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo+    ResolveExpanderRowMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo+    ResolveExpanderRowMethod "getHeader" o = Gtk.ListBoxRow.ListBoxRowGetHeaderMethodInfo+    ResolveExpanderRowMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo+    ResolveExpanderRowMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo+    ResolveExpanderRowMethod "getIconName" o = Handy.ActionRow.ActionRowGetIconNameMethodInfo+    ResolveExpanderRowMethod "getIndex" o = Gtk.ListBoxRow.ListBoxRowGetIndexMethodInfo+    ResolveExpanderRowMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo+    ResolveExpanderRowMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo+    ResolveExpanderRowMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo+    ResolveExpanderRowMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo+    ResolveExpanderRowMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo+    ResolveExpanderRowMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo+    ResolveExpanderRowMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo+    ResolveExpanderRowMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo+    ResolveExpanderRowMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo+    ResolveExpanderRowMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo+    ResolveExpanderRowMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo+    ResolveExpanderRowMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo+    ResolveExpanderRowMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo+    ResolveExpanderRowMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo+    ResolveExpanderRowMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo+    ResolveExpanderRowMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo+    ResolveExpanderRowMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo+    ResolveExpanderRowMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo+    ResolveExpanderRowMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo+    ResolveExpanderRowMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo+    ResolveExpanderRowMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo+    ResolveExpanderRowMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo+    ResolveExpanderRowMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo+    ResolveExpanderRowMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo+    ResolveExpanderRowMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo+    ResolveExpanderRowMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveExpanderRowMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveExpanderRowMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo+    ResolveExpanderRowMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo+    ResolveExpanderRowMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo+    ResolveExpanderRowMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo+    ResolveExpanderRowMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo+    ResolveExpanderRowMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo+    ResolveExpanderRowMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo+    ResolveExpanderRowMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo+    ResolveExpanderRowMethod "getSelectable" o = Gtk.ListBoxRow.ListBoxRowGetSelectableMethodInfo+    ResolveExpanderRowMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo+    ResolveExpanderRowMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo+    ResolveExpanderRowMethod "getShowEnableSwitch" o = ExpanderRowGetShowEnableSwitchMethodInfo+    ResolveExpanderRowMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo+    ResolveExpanderRowMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo+    ResolveExpanderRowMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo+    ResolveExpanderRowMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo+    ResolveExpanderRowMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo+    ResolveExpanderRowMethod "getSubtitle" o = Handy.ActionRow.ActionRowGetSubtitleMethodInfo+    ResolveExpanderRowMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo+    ResolveExpanderRowMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo+    ResolveExpanderRowMethod "getTitle" o = Handy.ActionRow.ActionRowGetTitleMethodInfo+    ResolveExpanderRowMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo+    ResolveExpanderRowMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo+    ResolveExpanderRowMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo+    ResolveExpanderRowMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo+    ResolveExpanderRowMethod "getUseUnderline" o = Handy.ActionRow.ActionRowGetUseUnderlineMethodInfo+    ResolveExpanderRowMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo+    ResolveExpanderRowMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo+    ResolveExpanderRowMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo+    ResolveExpanderRowMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo+    ResolveExpanderRowMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo+    ResolveExpanderRowMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo+    ResolveExpanderRowMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo+    ResolveExpanderRowMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo+    ResolveExpanderRowMethod "setActionName" o = Gtk.Actionable.ActionableSetActionNameMethodInfo+    ResolveExpanderRowMethod "setActionTargetValue" o = Gtk.Actionable.ActionableSetActionTargetValueMethodInfo+    ResolveExpanderRowMethod "setActivatable" o = Gtk.ListBoxRow.ListBoxRowSetActivatableMethodInfo+    ResolveExpanderRowMethod "setActivatableWidget" o = Handy.ActionRow.ActionRowSetActivatableWidgetMethodInfo+    ResolveExpanderRowMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo+    ResolveExpanderRowMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo+    ResolveExpanderRowMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo+    ResolveExpanderRowMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo+    ResolveExpanderRowMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo+    ResolveExpanderRowMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo+    ResolveExpanderRowMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo+    ResolveExpanderRowMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo+    ResolveExpanderRowMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo+    ResolveExpanderRowMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveExpanderRowMethod "setDetailedActionName" o = Gtk.Actionable.ActionableSetDetailedActionNameMethodInfo+    ResolveExpanderRowMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo+    ResolveExpanderRowMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo+    ResolveExpanderRowMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo+    ResolveExpanderRowMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo+    ResolveExpanderRowMethod "setEnableExpansion" o = ExpanderRowSetEnableExpansionMethodInfo+    ResolveExpanderRowMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo+    ResolveExpanderRowMethod "setExpanded" o = ExpanderRowSetExpandedMethodInfo+    ResolveExpanderRowMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo+    ResolveExpanderRowMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo+    ResolveExpanderRowMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo+    ResolveExpanderRowMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo+    ResolveExpanderRowMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo+    ResolveExpanderRowMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo+    ResolveExpanderRowMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo+    ResolveExpanderRowMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo+    ResolveExpanderRowMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo+    ResolveExpanderRowMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo+    ResolveExpanderRowMethod "setHeader" o = Gtk.ListBoxRow.ListBoxRowSetHeaderMethodInfo+    ResolveExpanderRowMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo+    ResolveExpanderRowMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo+    ResolveExpanderRowMethod "setIconName" o = Handy.ActionRow.ActionRowSetIconNameMethodInfo+    ResolveExpanderRowMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo+    ResolveExpanderRowMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo+    ResolveExpanderRowMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo+    ResolveExpanderRowMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo+    ResolveExpanderRowMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo+    ResolveExpanderRowMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo+    ResolveExpanderRowMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo+    ResolveExpanderRowMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo+    ResolveExpanderRowMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo+    ResolveExpanderRowMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo+    ResolveExpanderRowMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo+    ResolveExpanderRowMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo+    ResolveExpanderRowMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveExpanderRowMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo+    ResolveExpanderRowMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo+    ResolveExpanderRowMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo+    ResolveExpanderRowMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo+    ResolveExpanderRowMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo+    ResolveExpanderRowMethod "setSelectable" o = Gtk.ListBoxRow.ListBoxRowSetSelectableMethodInfo+    ResolveExpanderRowMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo+    ResolveExpanderRowMethod "setShowEnableSwitch" o = ExpanderRowSetShowEnableSwitchMethodInfo+    ResolveExpanderRowMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo+    ResolveExpanderRowMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo+    ResolveExpanderRowMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo+    ResolveExpanderRowMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo+    ResolveExpanderRowMethod "setSubtitle" o = Handy.ActionRow.ActionRowSetSubtitleMethodInfo+    ResolveExpanderRowMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo+    ResolveExpanderRowMethod "setTitle" o = Handy.ActionRow.ActionRowSetTitleMethodInfo+    ResolveExpanderRowMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo+    ResolveExpanderRowMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo+    ResolveExpanderRowMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo+    ResolveExpanderRowMethod "setUseUnderline" o = Handy.ActionRow.ActionRowSetUseUnderlineMethodInfo+    ResolveExpanderRowMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo+    ResolveExpanderRowMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo+    ResolveExpanderRowMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo+    ResolveExpanderRowMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo+    ResolveExpanderRowMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo+    ResolveExpanderRowMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo+    ResolveExpanderRowMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveExpanderRowMethod t ExpanderRow, O.MethodInfo info ExpanderRow p) => OL.IsLabel t (ExpanderRow -> 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 "enable-expansion"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@enable-expansion@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' expanderRow #enableExpansion+@+-}+getExpanderRowEnableExpansion :: (MonadIO m, IsExpanderRow o) => o -> m Bool+getExpanderRowEnableExpansion obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-expansion"++{- |+Set the value of the “@enable-expansion@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' expanderRow [ #enableExpansion 'Data.GI.Base.Attributes.:=' value ]+@+-}+setExpanderRowEnableExpansion :: (MonadIO m, IsExpanderRow o) => o -> Bool -> m ()+setExpanderRowEnableExpansion obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-expansion" val++{- |+Construct a `GValueConstruct` with valid value for the “@enable-expansion@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructExpanderRowEnableExpansion :: (IsExpanderRow o) => Bool -> IO (GValueConstruct o)+constructExpanderRowEnableExpansion val = B.Properties.constructObjectPropertyBool "enable-expansion" val++#if ENABLE_OVERLOADING+data ExpanderRowEnableExpansionPropertyInfo+instance AttrInfo ExpanderRowEnableExpansionPropertyInfo where+    type AttrAllowedOps ExpanderRowEnableExpansionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ExpanderRowEnableExpansionPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ExpanderRowEnableExpansionPropertyInfo = IsExpanderRow+    type AttrGetType ExpanderRowEnableExpansionPropertyInfo = Bool+    type AttrLabel ExpanderRowEnableExpansionPropertyInfo = "enable-expansion"+    type AttrOrigin ExpanderRowEnableExpansionPropertyInfo = ExpanderRow+    attrGet _ = getExpanderRowEnableExpansion+    attrSet _ = setExpanderRowEnableExpansion+    attrConstruct _ = constructExpanderRowEnableExpansion+    attrClear _ = undefined+#endif++-- VVV Prop "expanded"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@expanded@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' expanderRow #expanded+@+-}+getExpanderRowExpanded :: (MonadIO m, IsExpanderRow o) => o -> m Bool+getExpanderRowExpanded obj = liftIO $ B.Properties.getObjectPropertyBool obj "expanded"++{- |+Set the value of the “@expanded@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' expanderRow [ #expanded 'Data.GI.Base.Attributes.:=' value ]+@+-}+setExpanderRowExpanded :: (MonadIO m, IsExpanderRow o) => o -> Bool -> m ()+setExpanderRowExpanded obj val = liftIO $ B.Properties.setObjectPropertyBool obj "expanded" val++{- |+Construct a `GValueConstruct` with valid value for the “@expanded@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructExpanderRowExpanded :: (IsExpanderRow o) => Bool -> IO (GValueConstruct o)+constructExpanderRowExpanded val = B.Properties.constructObjectPropertyBool "expanded" val++#if ENABLE_OVERLOADING+data ExpanderRowExpandedPropertyInfo+instance AttrInfo ExpanderRowExpandedPropertyInfo where+    type AttrAllowedOps ExpanderRowExpandedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ExpanderRowExpandedPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ExpanderRowExpandedPropertyInfo = IsExpanderRow+    type AttrGetType ExpanderRowExpandedPropertyInfo = Bool+    type AttrLabel ExpanderRowExpandedPropertyInfo = "expanded"+    type AttrOrigin ExpanderRowExpandedPropertyInfo = ExpanderRow+    attrGet _ = getExpanderRowExpanded+    attrSet _ = setExpanderRowExpanded+    attrConstruct _ = constructExpanderRowExpanded+    attrClear _ = undefined+#endif++-- VVV Prop "show-enable-switch"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@show-enable-switch@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' expanderRow #showEnableSwitch+@+-}+getExpanderRowShowEnableSwitch :: (MonadIO m, IsExpanderRow o) => o -> m Bool+getExpanderRowShowEnableSwitch obj = liftIO $ B.Properties.getObjectPropertyBool obj "show-enable-switch"++{- |+Set the value of the “@show-enable-switch@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' expanderRow [ #showEnableSwitch 'Data.GI.Base.Attributes.:=' value ]+@+-}+setExpanderRowShowEnableSwitch :: (MonadIO m, IsExpanderRow o) => o -> Bool -> m ()+setExpanderRowShowEnableSwitch obj val = liftIO $ B.Properties.setObjectPropertyBool obj "show-enable-switch" val++{- |+Construct a `GValueConstruct` with valid value for the “@show-enable-switch@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructExpanderRowShowEnableSwitch :: (IsExpanderRow o) => Bool -> IO (GValueConstruct o)+constructExpanderRowShowEnableSwitch val = B.Properties.constructObjectPropertyBool "show-enable-switch" val++#if ENABLE_OVERLOADING+data ExpanderRowShowEnableSwitchPropertyInfo+instance AttrInfo ExpanderRowShowEnableSwitchPropertyInfo where+    type AttrAllowedOps ExpanderRowShowEnableSwitchPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ExpanderRowShowEnableSwitchPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ExpanderRowShowEnableSwitchPropertyInfo = IsExpanderRow+    type AttrGetType ExpanderRowShowEnableSwitchPropertyInfo = Bool+    type AttrLabel ExpanderRowShowEnableSwitchPropertyInfo = "show-enable-switch"+    type AttrOrigin ExpanderRowShowEnableSwitchPropertyInfo = ExpanderRow+    attrGet _ = getExpanderRowShowEnableSwitch+    attrSet _ = setExpanderRowShowEnableSwitch+    attrConstruct _ = constructExpanderRowShowEnableSwitch+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList ExpanderRow+type instance O.AttributeList ExpanderRow = ExpanderRowAttributeList+type ExpanderRowAttributeList = ('[ '("actionName", Gtk.Actionable.ActionableActionNamePropertyInfo), '("actionTarget", Gtk.Actionable.ActionableActionTargetPropertyInfo), '("activatable", Gtk.ListBoxRow.ListBoxRowActivatablePropertyInfo), '("activatableWidget", Handy.ActionRow.ActionRowActivatableWidgetPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("enableExpansion", ExpanderRowEnableExpansionPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("expanded", ExpanderRowExpandedPropertyInfo), '("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), '("iconName", Handy.ActionRow.ActionRowIconNamePropertyInfo), '("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), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("selectable", Gtk.ListBoxRow.ListBoxRowSelectablePropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("showEnableSwitch", ExpanderRowShowEnableSwitchPropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("subtitle", Handy.ActionRow.ActionRowSubtitlePropertyInfo), '("title", Handy.ActionRow.ActionRowTitlePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("useUnderline", Handy.ActionRow.ActionRowUseUnderlinePropertyInfo), '("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+expanderRowEnableExpansion :: AttrLabelProxy "enableExpansion"+expanderRowEnableExpansion = AttrLabelProxy++expanderRowExpanded :: AttrLabelProxy "expanded"+expanderRowExpanded = AttrLabelProxy++expanderRowShowEnableSwitch :: AttrLabelProxy "showEnableSwitch"+expanderRowShowEnableSwitch = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList ExpanderRow = ExpanderRowSignalList+type ExpanderRowSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("activate", Gtk.ListBoxRow.ListBoxRowActivateSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("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), '("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), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("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), '("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 ExpanderRow::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "ExpanderRow"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_expander_row_new" hdy_expander_row_new :: +    IO (Ptr ExpanderRow)++{- |+Creates a new 'GI.Handy.Objects.ExpanderRow.ExpanderRow'.++/Since: 0.0.6/+-}+expanderRowNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m ExpanderRow+    {- ^ __Returns:__ a new 'GI.Handy.Objects.ExpanderRow.ExpanderRow' -}+expanderRowNew  = liftIO $ do+    result <- hdy_expander_row_new+    checkUnexpectedReturnNULL "expanderRowNew" result+    result' <- (newObject ExpanderRow) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method ExpanderRow::get_enable_expansion+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ExpanderRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyExpanderRow", 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 "hdy_expander_row_get_enable_expansion" hdy_expander_row_get_enable_expansion :: +    Ptr ExpanderRow ->                      -- self : TInterface (Name {namespace = "Handy", name = "ExpanderRow"})+    IO CInt++{- |+Gets whether the expansion of /@self@/ is enabled.++/Since: 0.0.6/+-}+expanderRowGetEnableExpansion ::+    (B.CallStack.HasCallStack, MonadIO m, IsExpanderRow a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ExpanderRow.ExpanderRow' -}+    -> m Bool+    {- ^ __Returns:__ whether the expansion of /@self@/ is enabled. -}+expanderRowGetEnableExpansion self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_expander_row_get_enable_expansion self'+    let result' = (/= 0) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data ExpanderRowGetEnableExpansionMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsExpanderRow a) => O.MethodInfo ExpanderRowGetEnableExpansionMethodInfo a signature where+    overloadedMethod _ = expanderRowGetEnableExpansion++#endif++-- method ExpanderRow::get_expanded+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ExpanderRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, 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 "hdy_expander_row_get_expanded" hdy_expander_row_get_expanded :: +    Ptr ExpanderRow ->                      -- self : TInterface (Name {namespace = "Handy", name = "ExpanderRow"})+    IO CInt++{- |+/No description available in the introspection data./+-}+expanderRowGetExpanded ::+    (B.CallStack.HasCallStack, MonadIO m, IsExpanderRow a) =>+    a+    -> m Bool+expanderRowGetExpanded self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_expander_row_get_expanded self'+    let result' = (/= 0) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data ExpanderRowGetExpandedMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsExpanderRow a) => O.MethodInfo ExpanderRowGetExpandedMethodInfo a signature where+    overloadedMethod _ = expanderRowGetExpanded++#endif++-- method ExpanderRow::get_show_enable_switch+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ExpanderRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyExpanderRow", 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 "hdy_expander_row_get_show_enable_switch" hdy_expander_row_get_show_enable_switch :: +    Ptr ExpanderRow ->                      -- self : TInterface (Name {namespace = "Handy", name = "ExpanderRow"})+    IO CInt++{- |+Gets whether the switch enabling the expansion of /@self@/ is visible.++/Since: 0.0.6/+-}+expanderRowGetShowEnableSwitch ::+    (B.CallStack.HasCallStack, MonadIO m, IsExpanderRow a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ExpanderRow.ExpanderRow' -}+    -> m Bool+    {- ^ __Returns:__ whether the switch enabling the expansion of /@self@/ is visible. -}+expanderRowGetShowEnableSwitch self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_expander_row_get_show_enable_switch self'+    let result' = (/= 0) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data ExpanderRowGetShowEnableSwitchMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsExpanderRow a) => O.MethodInfo ExpanderRowGetShowEnableSwitchMethodInfo a signature where+    overloadedMethod _ = expanderRowGetShowEnableSwitch++#endif++-- method ExpanderRow::set_enable_expansion+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ExpanderRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyExpanderRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enable_expansion", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to enable the expansion", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_expander_row_set_enable_expansion" hdy_expander_row_set_enable_expansion :: +    Ptr ExpanderRow ->                      -- self : TInterface (Name {namespace = "Handy", name = "ExpanderRow"})+    CInt ->                                 -- enable_expansion : TBasicType TBoolean+    IO ()++{- |+Sets whether the expansion of /@self@/ is enabled.++/Since: 0.0.6/+-}+expanderRowSetEnableExpansion ::+    (B.CallStack.HasCallStack, MonadIO m, IsExpanderRow a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ExpanderRow.ExpanderRow' -}+    -> Bool+    {- ^ /@enableExpansion@/: 'True' to enable the expansion -}+    -> m ()+expanderRowSetEnableExpansion self enableExpansion = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    let enableExpansion' = (fromIntegral . fromEnum) enableExpansion+    hdy_expander_row_set_enable_expansion self' enableExpansion'+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data ExpanderRowSetEnableExpansionMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsExpanderRow a) => O.MethodInfo ExpanderRowSetEnableExpansionMethodInfo a signature where+    overloadedMethod _ = expanderRowSetEnableExpansion++#endif++-- method ExpanderRow::set_expanded+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ExpanderRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "expanded", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_expander_row_set_expanded" hdy_expander_row_set_expanded :: +    Ptr ExpanderRow ->                      -- self : TInterface (Name {namespace = "Handy", name = "ExpanderRow"})+    CInt ->                                 -- expanded : TBasicType TBoolean+    IO ()++{- |+/No description available in the introspection data./+-}+expanderRowSetExpanded ::+    (B.CallStack.HasCallStack, MonadIO m, IsExpanderRow a) =>+    a+    -> Bool+    -> m ()+expanderRowSetExpanded self expanded = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    let expanded' = (fromIntegral . fromEnum) expanded+    hdy_expander_row_set_expanded self' expanded'+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data ExpanderRowSetExpandedMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsExpanderRow a) => O.MethodInfo ExpanderRowSetExpandedMethodInfo a signature where+    overloadedMethod _ = expanderRowSetExpanded++#endif++-- method ExpanderRow::set_show_enable_switch+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "ExpanderRow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyExpanderRow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "show_enable_switch", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to show the switch enabling the expansion", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_expander_row_set_show_enable_switch" hdy_expander_row_set_show_enable_switch :: +    Ptr ExpanderRow ->                      -- self : TInterface (Name {namespace = "Handy", name = "ExpanderRow"})+    CInt ->                                 -- show_enable_switch : TBasicType TBoolean+    IO ()++{- |+Sets whether the switch enabling the expansion of /@self@/ is visible.++/Since: 0.0.6/+-}+expanderRowSetShowEnableSwitch ::+    (B.CallStack.HasCallStack, MonadIO m, IsExpanderRow a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.ExpanderRow.ExpanderRow' -}+    -> Bool+    {- ^ /@showEnableSwitch@/: 'True' to show the switch enabling the expansion -}+    -> m ()+expanderRowSetShowEnableSwitch self showEnableSwitch = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    let showEnableSwitch' = (fromIntegral . fromEnum) showEnableSwitch+    hdy_expander_row_set_show_enable_switch self' showEnableSwitch'+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data ExpanderRowSetShowEnableSwitchMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsExpanderRow a) => O.MethodInfo ExpanderRowSetShowEnableSwitchMethodInfo a signature where+    overloadedMethod _ = expanderRowSetShowEnableSwitch++#endif++
+ GI/Handy/Objects/ExpanderRow.hs-boot view
@@ -0,0 +1,56 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Handy.Objects.ExpanderRow 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 ExpanderRow = ExpanderRow (ManagedPtr ExpanderRow)+instance GObject ExpanderRow where+class (GObject o, O.IsDescendantOf ExpanderRow o) => IsExpanderRow o+instance (GObject o, O.IsDescendantOf ExpanderRow o) => IsExpanderRow o+instance O.HasParentTypes ExpanderRow+#if ENABLE_OVERLOADING+data ExpanderRowEnableExpansionPropertyInfo+#endif+#if ENABLE_OVERLOADING+data ExpanderRowExpandedPropertyInfo+#endif+#if ENABLE_OVERLOADING+data ExpanderRowShowEnableSwitchPropertyInfo+#endif+#if ENABLE_OVERLOADING+data ExpanderRowGetEnableExpansionMethodInfo+#endif+#if ENABLE_OVERLOADING+data ExpanderRowGetExpandedMethodInfo+#endif+#if ENABLE_OVERLOADING+data ExpanderRowGetShowEnableSwitchMethodInfo+#endif+#if ENABLE_OVERLOADING+data ExpanderRowSetEnableExpansionMethodInfo+#endif+#if ENABLE_OVERLOADING+data ExpanderRowSetExpandedMethodInfo+#endif+#if ENABLE_OVERLOADING+data ExpanderRowSetShowEnableSwitchMethodInfo+#endif
+ GI/Handy/Objects/HeaderGroup.hs view
@@ -0,0 +1,496 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Handy.Objects.HeaderGroup+    ( ++-- * Exported types+    HeaderGroup(..)                         ,+    IsHeaderGroup                           ,+    toHeaderGroup                           ,+    noHeaderGroup                           ,+++ -- * Methods+-- ** addHeaderBar #method:addHeaderBar#++#if ENABLE_OVERLOADING+    HeaderGroupAddHeaderBarMethodInfo       ,+#endif+    headerGroupAddHeaderBar                 ,+++-- ** getFocus #method:getFocus#++#if ENABLE_OVERLOADING+    HeaderGroupGetFocusMethodInfo           ,+#endif+    headerGroupGetFocus                     ,+++-- ** getHeaderBars #method:getHeaderBars#++#if ENABLE_OVERLOADING+    HeaderGroupGetHeaderBarsMethodInfo      ,+#endif+    headerGroupGetHeaderBars                ,+++-- ** new #method:new#++    headerGroupNew                          ,+++-- ** removeHeaderBar #method:removeHeaderBar#++#if ENABLE_OVERLOADING+    HeaderGroupRemoveHeaderBarMethodInfo    ,+#endif+    headerGroupRemoveHeaderBar              ,+++-- ** setFocus #method:setFocus#++#if ENABLE_OVERLOADING+    HeaderGroupSetFocusMethodInfo           ,+#endif+    headerGroupSetFocus                     ,+++++ -- * Properties+-- ** focus #attr:focus#+{- | The the currently focused header bar. If 'Nothing', the decoration will be+spread as if the header bars of the group were only one, otherwise the+focused header bar will be the only one to receive the decoration.+-}+#if ENABLE_OVERLOADING+    HeaderGroupFocusPropertyInfo            ,+#endif+    clearHeaderGroupFocus                   ,+    constructHeaderGroupFocus               ,+    getHeaderGroupFocus                     ,+#if ENABLE_OVERLOADING+    headerGroupFocus                        ,+#endif+    setHeaderGroupFocus                     ,+++++    ) 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.GObject.Objects.Object as GObject.Object+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable+import qualified GI.Gtk.Objects.HeaderBar as Gtk.HeaderBar++-- | Memory-managed wrapper type.+newtype HeaderGroup = HeaderGroup (ManagedPtr HeaderGroup)+foreign import ccall "hdy_header_group_get_type"+    c_hdy_header_group_get_type :: IO GType++instance GObject HeaderGroup where+    gobjectType = c_hdy_header_group_get_type+    ++-- | Type class for types which can be safely cast to `HeaderGroup`, for instance with `toHeaderGroup`.+class (GObject o, O.IsDescendantOf HeaderGroup o) => IsHeaderGroup o+instance (GObject o, O.IsDescendantOf HeaderGroup o) => IsHeaderGroup o++instance O.HasParentTypes HeaderGroup+type instance O.ParentTypes HeaderGroup = '[GObject.Object.Object, Gtk.Buildable.Buildable]++-- | Cast to `HeaderGroup`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toHeaderGroup :: (MonadIO m, IsHeaderGroup o) => o -> m HeaderGroup+toHeaderGroup = liftIO . unsafeCastTo HeaderGroup++-- | A convenience alias for `Nothing` :: `Maybe` `HeaderGroup`.+noHeaderGroup :: Maybe HeaderGroup+noHeaderGroup = Nothing++#if ENABLE_OVERLOADING+type family ResolveHeaderGroupMethod (t :: Symbol) (o :: *) :: * where+    ResolveHeaderGroupMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo+    ResolveHeaderGroupMethod "addHeaderBar" o = HeaderGroupAddHeaderBarMethodInfo+    ResolveHeaderGroupMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveHeaderGroupMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveHeaderGroupMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo+    ResolveHeaderGroupMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo+    ResolveHeaderGroupMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo+    ResolveHeaderGroupMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo+    ResolveHeaderGroupMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveHeaderGroupMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveHeaderGroupMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveHeaderGroupMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveHeaderGroupMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveHeaderGroupMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveHeaderGroupMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo+    ResolveHeaderGroupMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveHeaderGroupMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveHeaderGroupMethod "removeHeaderBar" o = HeaderGroupRemoveHeaderBarMethodInfo+    ResolveHeaderGroupMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveHeaderGroupMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveHeaderGroupMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveHeaderGroupMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveHeaderGroupMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveHeaderGroupMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveHeaderGroupMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveHeaderGroupMethod "getFocus" o = HeaderGroupGetFocusMethodInfo+    ResolveHeaderGroupMethod "getHeaderBars" o = HeaderGroupGetHeaderBarsMethodInfo+    ResolveHeaderGroupMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo+    ResolveHeaderGroupMethod "getName" o = Gtk.Buildable.BuildableGetNameMethodInfo+    ResolveHeaderGroupMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveHeaderGroupMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveHeaderGroupMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo+    ResolveHeaderGroupMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveHeaderGroupMethod "setFocus" o = HeaderGroupSetFocusMethodInfo+    ResolveHeaderGroupMethod "setName" o = Gtk.Buildable.BuildableSetNameMethodInfo+    ResolveHeaderGroupMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveHeaderGroupMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveHeaderGroupMethod t HeaderGroup, O.MethodInfo info HeaderGroup p) => OL.IsLabel t (HeaderGroup -> 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 "focus"+   -- Type: TInterface (Name {namespace = "Gtk", name = "HeaderBar"})+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just True,Just True)++{- |+Get the value of the “@focus@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' headerGroup #focus+@+-}+getHeaderGroupFocus :: (MonadIO m, IsHeaderGroup o) => o -> m (Maybe Gtk.HeaderBar.HeaderBar)+getHeaderGroupFocus obj = liftIO $ B.Properties.getObjectPropertyObject obj "focus" Gtk.HeaderBar.HeaderBar++{- |+Set the value of the “@focus@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' headerGroup [ #focus 'Data.GI.Base.Attributes.:=' value ]+@+-}+setHeaderGroupFocus :: (MonadIO m, IsHeaderGroup o, Gtk.HeaderBar.IsHeaderBar a) => o -> a -> m ()+setHeaderGroupFocus obj val = liftIO $ B.Properties.setObjectPropertyObject obj "focus" (Just val)++{- |+Construct a `GValueConstruct` with valid value for the “@focus@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructHeaderGroupFocus :: (IsHeaderGroup o, Gtk.HeaderBar.IsHeaderBar a) => a -> IO (GValueConstruct o)+constructHeaderGroupFocus val = B.Properties.constructObjectPropertyObject "focus" (Just val)++{- |+Set the value of the “@focus@” property to `Nothing`.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.clear' #focus+@+-}+clearHeaderGroupFocus :: (MonadIO m, IsHeaderGroup o) => o -> m ()+clearHeaderGroupFocus obj = liftIO $ B.Properties.setObjectPropertyObject obj "focus" (Nothing :: Maybe Gtk.HeaderBar.HeaderBar)++#if ENABLE_OVERLOADING+data HeaderGroupFocusPropertyInfo+instance AttrInfo HeaderGroupFocusPropertyInfo where+    type AttrAllowedOps HeaderGroupFocusPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint HeaderGroupFocusPropertyInfo = Gtk.HeaderBar.IsHeaderBar+    type AttrBaseTypeConstraint HeaderGroupFocusPropertyInfo = IsHeaderGroup+    type AttrGetType HeaderGroupFocusPropertyInfo = (Maybe Gtk.HeaderBar.HeaderBar)+    type AttrLabel HeaderGroupFocusPropertyInfo = "focus"+    type AttrOrigin HeaderGroupFocusPropertyInfo = HeaderGroup+    attrGet _ = getHeaderGroupFocus+    attrSet _ = setHeaderGroupFocus+    attrConstruct _ = constructHeaderGroupFocus+    attrClear _ = clearHeaderGroupFocus+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList HeaderGroup+type instance O.AttributeList HeaderGroup = HeaderGroupAttributeList+type HeaderGroupAttributeList = ('[ '("focus", HeaderGroupFocusPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+headerGroupFocus :: AttrLabelProxy "focus"+headerGroupFocus = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList HeaderGroup = HeaderGroupSignalList+type HeaderGroupSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++-- method HeaderGroup::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "HeaderGroup"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_header_group_new" hdy_header_group_new :: +    IO (Ptr HeaderGroup)++{- |+/No description available in the introspection data./+-}+headerGroupNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m HeaderGroup+headerGroupNew  = liftIO $ do+    result <- hdy_header_group_new+    checkUnexpectedReturnNULL "headerGroupNew" result+    result' <- (wrapObject HeaderGroup) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method HeaderGroup::add_header_bar+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "HeaderGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyHeaderGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "header_bar", argType = TInterface (Name {namespace = "Gtk", name = "HeaderBar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkHeaderBar to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_header_group_add_header_bar" hdy_header_group_add_header_bar :: +    Ptr HeaderGroup ->                      -- self : TInterface (Name {namespace = "Handy", name = "HeaderGroup"})+    Ptr Gtk.HeaderBar.HeaderBar ->          -- header_bar : TInterface (Name {namespace = "Gtk", name = "HeaderBar"})+    IO ()++{- |+Adds a header bar to a 'GI.Handy.Objects.HeaderGroup.HeaderGroup'. The decoration layout of the+widgets will be edited depending on their position in the composite header+bar, the start widget displaying only the start of the user\'s decoration+layout and the end widget displaying only its end while widgets in the middle+won\'t display anything. A header bar can be set as having the focus to+display all the decorations. See 'GI.Gtk.Objects.HeaderBar.headerBarSetDecorationLayout'.++When the widget is destroyed or no longer referenced elsewhere, it will+be removed from the header group.+-}+headerGroupAddHeaderBar ::+    (B.CallStack.HasCallStack, MonadIO m, IsHeaderGroup a, Gtk.HeaderBar.IsHeaderBar b) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.HeaderGroup.HeaderGroup' -}+    -> b+    {- ^ /@headerBar@/: the 'GI.Gtk.Objects.HeaderBar.HeaderBar' to add -}+    -> m ()+headerGroupAddHeaderBar self headerBar = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    headerBar' <- unsafeManagedPtrCastPtr headerBar+    hdy_header_group_add_header_bar self' headerBar'+    touchManagedPtr self+    touchManagedPtr headerBar+    return ()++#if ENABLE_OVERLOADING+data HeaderGroupAddHeaderBarMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, IsHeaderGroup a, Gtk.HeaderBar.IsHeaderBar b) => O.MethodInfo HeaderGroupAddHeaderBarMethodInfo a signature where+    overloadedMethod _ = headerGroupAddHeaderBar++#endif++-- method HeaderGroup::get_focus+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "HeaderGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyHeaderGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "HeaderBar"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_header_group_get_focus" hdy_header_group_get_focus :: +    Ptr HeaderGroup ->                      -- self : TInterface (Name {namespace = "Handy", name = "HeaderGroup"})+    IO (Ptr Gtk.HeaderBar.HeaderBar)++{- |+/No description available in the introspection data./+-}+headerGroupGetFocus ::+    (B.CallStack.HasCallStack, MonadIO m, IsHeaderGroup a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.HeaderGroup.HeaderGroup' -}+    -> m (Maybe Gtk.HeaderBar.HeaderBar)+    {- ^ __Returns:__ The currently focused header bar -}+headerGroupGetFocus self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_header_group_get_focus self'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (newObject Gtk.HeaderBar.HeaderBar) result'+        return result''+    touchManagedPtr self+    return maybeResult++#if ENABLE_OVERLOADING+data HeaderGroupGetFocusMethodInfo+instance (signature ~ (m (Maybe Gtk.HeaderBar.HeaderBar)), MonadIO m, IsHeaderGroup a) => O.MethodInfo HeaderGroupGetFocusMethodInfo a signature where+    overloadedMethod _ = headerGroupGetFocus++#endif++-- method HeaderGroup::get_header_bars+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "HeaderGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyHeaderGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TGSList (TInterface (Name {namespace = "Gtk", name = "HeaderBar"})))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_header_group_get_header_bars" hdy_header_group_get_header_bars :: +    Ptr HeaderGroup ->                      -- self : TInterface (Name {namespace = "Handy", name = "HeaderGroup"})+    IO (Ptr (GSList (Ptr Gtk.HeaderBar.HeaderBar)))++{- |+Returns the list of headerbars associated with /@self@/.+-}+headerGroupGetHeaderBars ::+    (B.CallStack.HasCallStack, MonadIO m, IsHeaderGroup a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.HeaderGroup.HeaderGroup' -}+    -> m [Gtk.HeaderBar.HeaderBar]+    {- ^ __Returns:__ a 'GI.GLib.Structs.SList.SList' of+  headerbars. The list is owned by libhandy and should not be modified. -}+headerGroupGetHeaderBars self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_header_group_get_header_bars self'+    result' <- unpackGSList result+    result'' <- mapM (newObject Gtk.HeaderBar.HeaderBar) result'+    touchManagedPtr self+    return result''++#if ENABLE_OVERLOADING+data HeaderGroupGetHeaderBarsMethodInfo+instance (signature ~ (m [Gtk.HeaderBar.HeaderBar]), MonadIO m, IsHeaderGroup a) => O.MethodInfo HeaderGroupGetHeaderBarsMethodInfo a signature where+    overloadedMethod _ = headerGroupGetHeaderBars++#endif++-- method HeaderGroup::remove_header_bar+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "HeaderGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyHeaderGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "header_bar", argType = TInterface (Name {namespace = "Gtk", name = "HeaderBar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkHeaderBar to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_header_group_remove_header_bar" hdy_header_group_remove_header_bar :: +    Ptr HeaderGroup ->                      -- self : TInterface (Name {namespace = "Handy", name = "HeaderGroup"})+    Ptr Gtk.HeaderBar.HeaderBar ->          -- header_bar : TInterface (Name {namespace = "Gtk", name = "HeaderBar"})+    IO ()++{- |+Removes a widget from a 'GI.Handy.Objects.HeaderGroup.HeaderGroup'+-}+headerGroupRemoveHeaderBar ::+    (B.CallStack.HasCallStack, MonadIO m, IsHeaderGroup a, Gtk.HeaderBar.IsHeaderBar b) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.HeaderGroup.HeaderGroup' -}+    -> b+    {- ^ /@headerBar@/: the 'GI.Gtk.Objects.HeaderBar.HeaderBar' to remove -}+    -> m ()+headerGroupRemoveHeaderBar self headerBar = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    headerBar' <- unsafeManagedPtrCastPtr headerBar+    hdy_header_group_remove_header_bar self' headerBar'+    touchManagedPtr self+    touchManagedPtr headerBar+    return ()++#if ENABLE_OVERLOADING+data HeaderGroupRemoveHeaderBarMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, IsHeaderGroup a, Gtk.HeaderBar.IsHeaderBar b) => O.MethodInfo HeaderGroupRemoveHeaderBarMethodInfo a signature where+    overloadedMethod _ = headerGroupRemoveHeaderBar++#endif++-- method HeaderGroup::set_focus+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "HeaderGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyHeaderGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "header_bar", argType = TInterface (Name {namespace = "Gtk", name = "HeaderBar"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkHeaderBar of @self, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_header_group_set_focus" hdy_header_group_set_focus :: +    Ptr HeaderGroup ->                      -- self : TInterface (Name {namespace = "Handy", name = "HeaderGroup"})+    Ptr Gtk.HeaderBar.HeaderBar ->          -- header_bar : TInterface (Name {namespace = "Gtk", name = "HeaderBar"})+    IO ()++{- |+Sets the the currently focused header bar. If /@headerBar@/ is 'Nothing', the+decoration will be spread as if the header bars of the group were only one,+otherwise /@headerBar@/ will be the only one to receive the decoration.+-}+headerGroupSetFocus ::+    (B.CallStack.HasCallStack, MonadIO m, IsHeaderGroup a, Gtk.HeaderBar.IsHeaderBar b) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.HeaderGroup.HeaderGroup' -}+    -> Maybe (b)+    {- ^ /@headerBar@/: a 'GI.Gtk.Objects.HeaderBar.HeaderBar' of /@self@/, or 'Nothing' -}+    -> m ()+headerGroupSetFocus self headerBar = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    maybeHeaderBar <- case headerBar of+        Nothing -> return nullPtr+        Just jHeaderBar -> do+            jHeaderBar' <- unsafeManagedPtrCastPtr jHeaderBar+            return jHeaderBar'+    hdy_header_group_set_focus self' maybeHeaderBar+    touchManagedPtr self+    whenJust headerBar touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+data HeaderGroupSetFocusMethodInfo+instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsHeaderGroup a, Gtk.HeaderBar.IsHeaderBar b) => O.MethodInfo HeaderGroupSetFocusMethodInfo a signature where+    overloadedMethod _ = headerGroupSetFocus++#endif++
+ GI/Handy/Objects/HeaderGroup.hs-boot view
@@ -0,0 +1,47 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Handy.Objects.HeaderGroup 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 HeaderGroup = HeaderGroup (ManagedPtr HeaderGroup)+instance GObject HeaderGroup where+class (GObject o, O.IsDescendantOf HeaderGroup o) => IsHeaderGroup o+instance (GObject o, O.IsDescendantOf HeaderGroup o) => IsHeaderGroup o+instance O.HasParentTypes HeaderGroup+#if ENABLE_OVERLOADING+data HeaderGroupFocusPropertyInfo+#endif+#if ENABLE_OVERLOADING+data HeaderGroupAddHeaderBarMethodInfo+#endif+#if ENABLE_OVERLOADING+data HeaderGroupGetFocusMethodInfo+#endif+#if ENABLE_OVERLOADING+data HeaderGroupGetHeaderBarsMethodInfo+#endif+#if ENABLE_OVERLOADING+data HeaderGroupRemoveHeaderBarMethodInfo+#endif+#if ENABLE_OVERLOADING+data HeaderGroupSetFocusMethodInfo+#endif
+ GI/Handy/Objects/Leaflet.hs view
@@ -0,0 +1,2171 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Handy.Objects.Leaflet+    ( ++-- * Exported types+    Leaflet(..)                             ,+    IsLeaflet                               ,+    toLeaflet                               ,+    noLeaflet                               ,+++ -- * Methods+-- ** getChildTransitionDuration #method:getChildTransitionDuration#++#if ENABLE_OVERLOADING+    LeafletGetChildTransitionDurationMethodInfo,+#endif+    leafletGetChildTransitionDuration       ,+++-- ** getChildTransitionRunning #method:getChildTransitionRunning#++#if ENABLE_OVERLOADING+    LeafletGetChildTransitionRunningMethodInfo,+#endif+    leafletGetChildTransitionRunning        ,+++-- ** getChildTransitionType #method:getChildTransitionType#++#if ENABLE_OVERLOADING+    LeafletGetChildTransitionTypeMethodInfo ,+#endif+    leafletGetChildTransitionType           ,+++-- ** getFold #method:getFold#++#if ENABLE_OVERLOADING+    LeafletGetFoldMethodInfo                ,+#endif+    leafletGetFold                          ,+++-- ** getHomogeneous #method:getHomogeneous#++#if ENABLE_OVERLOADING+    LeafletGetHomogeneousMethodInfo         ,+#endif+    leafletGetHomogeneous                   ,+++-- ** getInterpolateSize #method:getInterpolateSize#++#if ENABLE_OVERLOADING+    LeafletGetInterpolateSizeMethodInfo     ,+#endif+    leafletGetInterpolateSize               ,+++-- ** getModeTransitionDuration #method:getModeTransitionDuration#++#if ENABLE_OVERLOADING+    LeafletGetModeTransitionDurationMethodInfo,+#endif+    leafletGetModeTransitionDuration        ,+++-- ** getModeTransitionType #method:getModeTransitionType#++#if ENABLE_OVERLOADING+    LeafletGetModeTransitionTypeMethodInfo  ,+#endif+    leafletGetModeTransitionType            ,+++-- ** getVisibleChild #method:getVisibleChild#++#if ENABLE_OVERLOADING+    LeafletGetVisibleChildMethodInfo        ,+#endif+    leafletGetVisibleChild                  ,+++-- ** getVisibleChildName #method:getVisibleChildName#++#if ENABLE_OVERLOADING+    LeafletGetVisibleChildNameMethodInfo    ,+#endif+    leafletGetVisibleChildName              ,+++-- ** new #method:new#++    leafletNew                              ,+++-- ** setChildTransitionDuration #method:setChildTransitionDuration#++#if ENABLE_OVERLOADING+    LeafletSetChildTransitionDurationMethodInfo,+#endif+    leafletSetChildTransitionDuration       ,+++-- ** setChildTransitionType #method:setChildTransitionType#++#if ENABLE_OVERLOADING+    LeafletSetChildTransitionTypeMethodInfo ,+#endif+    leafletSetChildTransitionType           ,+++-- ** setHomogeneous #method:setHomogeneous#++#if ENABLE_OVERLOADING+    LeafletSetHomogeneousMethodInfo         ,+#endif+    leafletSetHomogeneous                   ,+++-- ** setInterpolateSize #method:setInterpolateSize#++#if ENABLE_OVERLOADING+    LeafletSetInterpolateSizeMethodInfo     ,+#endif+    leafletSetInterpolateSize               ,+++-- ** setModeTransitionDuration #method:setModeTransitionDuration#++#if ENABLE_OVERLOADING+    LeafletSetModeTransitionDurationMethodInfo,+#endif+    leafletSetModeTransitionDuration        ,+++-- ** setModeTransitionType #method:setModeTransitionType#++#if ENABLE_OVERLOADING+    LeafletSetModeTransitionTypeMethodInfo  ,+#endif+    leafletSetModeTransitionType            ,+++-- ** setVisibleChild #method:setVisibleChild#++#if ENABLE_OVERLOADING+    LeafletSetVisibleChildMethodInfo        ,+#endif+    leafletSetVisibleChild                  ,+++-- ** setVisibleChildName #method:setVisibleChildName#++#if ENABLE_OVERLOADING+    LeafletSetVisibleChildNameMethodInfo    ,+#endif+    leafletSetVisibleChildName              ,+++++ -- * Properties+-- ** childTransitionDuration #attr:childTransitionDuration#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    LeafletChildTransitionDurationPropertyInfo,+#endif+    constructLeafletChildTransitionDuration ,+    getLeafletChildTransitionDuration       ,+#if ENABLE_OVERLOADING+    leafletChildTransitionDuration          ,+#endif+    setLeafletChildTransitionDuration       ,+++-- ** childTransitionRunning #attr:childTransitionRunning#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    LeafletChildTransitionRunningPropertyInfo,+#endif+    getLeafletChildTransitionRunning        ,+#if ENABLE_OVERLOADING+    leafletChildTransitionRunning           ,+#endif+++-- ** childTransitionType #attr:childTransitionType#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    LeafletChildTransitionTypePropertyInfo  ,+#endif+    constructLeafletChildTransitionType     ,+    getLeafletChildTransitionType           ,+#if ENABLE_OVERLOADING+    leafletChildTransitionType              ,+#endif+    setLeafletChildTransitionType           ,+++-- ** fold #attr:fold#+{- | The fold of the leaflet.++The leaflet will be folded if the size allocated to it is smaller than the+sum of the natural size of its children, it will be unfolded otherwise.++See also: 'GI.Handy.Objects.Leaflet.Leaflet':@/folded/@.+-}+#if ENABLE_OVERLOADING+    LeafletFoldPropertyInfo                 ,+#endif+    getLeafletFold                          ,+#if ENABLE_OVERLOADING+    leafletFold                             ,+#endif+++-- ** folded #attr:folded#+{- | 'True' if the leaflet is folded.++This is similar to the 'GI.Handy.Objects.Leaflet.Leaflet':@/fold/@ property but expressed as a+'Bool' rather than a @/GEnum/@. This makes it convenient to bind the+'GI.Handy.Objects.Leaflet.Leaflet':@/fold/@ of a leaflet to any other 'Bool' property of other+'GI.GObject.Objects.Object.Object'\'s using @/g_object_bind_property/@().+-}+#if ENABLE_OVERLOADING+    LeafletFoldedPropertyInfo               ,+#endif+    getLeafletFolded                        ,+#if ENABLE_OVERLOADING+    leafletFolded                           ,+#endif+++-- ** hhomogeneousFolded #attr:hhomogeneousFolded#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    LeafletHhomogeneousFoldedPropertyInfo   ,+#endif+    constructLeafletHhomogeneousFolded      ,+    getLeafletHhomogeneousFolded            ,+#if ENABLE_OVERLOADING+    leafletHhomogeneousFolded               ,+#endif+    setLeafletHhomogeneousFolded            ,+++-- ** hhomogeneousUnfolded #attr:hhomogeneousUnfolded#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    LeafletHhomogeneousUnfoldedPropertyInfo ,+#endif+    constructLeafletHhomogeneousUnfolded    ,+    getLeafletHhomogeneousUnfolded          ,+#if ENABLE_OVERLOADING+    leafletHhomogeneousUnfolded             ,+#endif+    setLeafletHhomogeneousUnfolded          ,+++-- ** interpolateSize #attr:interpolateSize#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    LeafletInterpolateSizePropertyInfo      ,+#endif+    constructLeafletInterpolateSize         ,+    getLeafletInterpolateSize               ,+#if ENABLE_OVERLOADING+    leafletInterpolateSize                  ,+#endif+    setLeafletInterpolateSize               ,+++-- ** modeTransitionDuration #attr:modeTransitionDuration#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    LeafletModeTransitionDurationPropertyInfo,+#endif+    constructLeafletModeTransitionDuration  ,+    getLeafletModeTransitionDuration        ,+#if ENABLE_OVERLOADING+    leafletModeTransitionDuration           ,+#endif+    setLeafletModeTransitionDuration        ,+++-- ** modeTransitionType #attr:modeTransitionType#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    LeafletModeTransitionTypePropertyInfo   ,+#endif+    constructLeafletModeTransitionType      ,+    getLeafletModeTransitionType            ,+#if ENABLE_OVERLOADING+    leafletModeTransitionType               ,+#endif+    setLeafletModeTransitionType            ,+++-- ** vhomogeneousFolded #attr:vhomogeneousFolded#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    LeafletVhomogeneousFoldedPropertyInfo   ,+#endif+    constructLeafletVhomogeneousFolded      ,+    getLeafletVhomogeneousFolded            ,+#if ENABLE_OVERLOADING+    leafletVhomogeneousFolded               ,+#endif+    setLeafletVhomogeneousFolded            ,+++-- ** vhomogeneousUnfolded #attr:vhomogeneousUnfolded#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    LeafletVhomogeneousUnfoldedPropertyInfo ,+#endif+    constructLeafletVhomogeneousUnfolded    ,+    getLeafletVhomogeneousUnfolded          ,+#if ENABLE_OVERLOADING+    leafletVhomogeneousUnfolded             ,+#endif+    setLeafletVhomogeneousUnfolded          ,+++-- ** visibleChild #attr:visibleChild#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    LeafletVisibleChildPropertyInfo         ,+#endif+    constructLeafletVisibleChild            ,+    getLeafletVisibleChild                  ,+#if ENABLE_OVERLOADING+    leafletVisibleChild                     ,+#endif+    setLeafletVisibleChild                  ,+++-- ** visibleChildName #attr:visibleChildName#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    LeafletVisibleChildNamePropertyInfo     ,+#endif+    constructLeafletVisibleChildName        ,+    getLeafletVisibleChildName              ,+#if ENABLE_OVERLOADING+    leafletVisibleChildName                 ,+#endif+    setLeafletVisibleChildName              ,+++++    ) 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 qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gtk.Enums as Gtk.Enums+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable+import qualified GI.Gtk.Interfaces.Orientable as Gtk.Orientable+import qualified GI.Gtk.Objects.Container as Gtk.Container+import qualified GI.Gtk.Objects.Widget as Gtk.Widget+import {-# SOURCE #-} qualified GI.Handy.Enums as Handy.Enums++-- | Memory-managed wrapper type.+newtype Leaflet = Leaflet (ManagedPtr Leaflet)+foreign import ccall "hdy_leaflet_get_type"+    c_hdy_leaflet_get_type :: IO GType++instance GObject Leaflet where+    gobjectType = c_hdy_leaflet_get_type+    ++-- | Type class for types which can be safely cast to `Leaflet`, for instance with `toLeaflet`.+class (GObject o, O.IsDescendantOf Leaflet o) => IsLeaflet o+instance (GObject o, O.IsDescendantOf Leaflet o) => IsLeaflet o++instance O.HasParentTypes Leaflet+type instance O.ParentTypes Leaflet = '[Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable, Gtk.Orientable.Orientable]++-- | Cast to `Leaflet`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toLeaflet :: (MonadIO m, IsLeaflet o) => o -> m Leaflet+toLeaflet = liftIO . unsafeCastTo Leaflet++-- | A convenience alias for `Nothing` :: `Maybe` `Leaflet`.+noLeaflet :: Maybe Leaflet+noLeaflet = Nothing++#if ENABLE_OVERLOADING+type family ResolveLeafletMethod (t :: Symbol) (o :: *) :: * where+    ResolveLeafletMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo+    ResolveLeafletMethod "add" o = Gtk.Container.ContainerAddMethodInfo+    ResolveLeafletMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo+    ResolveLeafletMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo+    ResolveLeafletMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo+    ResolveLeafletMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo+    ResolveLeafletMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo+    ResolveLeafletMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo+    ResolveLeafletMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveLeafletMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveLeafletMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo+    ResolveLeafletMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo+    ResolveLeafletMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo+    ResolveLeafletMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo+    ResolveLeafletMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo+    ResolveLeafletMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo+    ResolveLeafletMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo+    ResolveLeafletMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo+    ResolveLeafletMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo+    ResolveLeafletMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo+    ResolveLeafletMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo+    ResolveLeafletMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo+    ResolveLeafletMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo+    ResolveLeafletMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo+    ResolveLeafletMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo+    ResolveLeafletMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo+    ResolveLeafletMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo+    ResolveLeafletMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo+    ResolveLeafletMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo+    ResolveLeafletMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo+    ResolveLeafletMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo+    ResolveLeafletMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo+    ResolveLeafletMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo+    ResolveLeafletMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo+    ResolveLeafletMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo+    ResolveLeafletMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo+    ResolveLeafletMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo+    ResolveLeafletMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo+    ResolveLeafletMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo+    ResolveLeafletMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo+    ResolveLeafletMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo+    ResolveLeafletMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo+    ResolveLeafletMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo+    ResolveLeafletMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo+    ResolveLeafletMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo+    ResolveLeafletMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo+    ResolveLeafletMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo+    ResolveLeafletMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo+    ResolveLeafletMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo+    ResolveLeafletMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo+    ResolveLeafletMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo+    ResolveLeafletMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo+    ResolveLeafletMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo+    ResolveLeafletMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo+    ResolveLeafletMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo+    ResolveLeafletMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo+    ResolveLeafletMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo+    ResolveLeafletMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo+    ResolveLeafletMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo+    ResolveLeafletMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo+    ResolveLeafletMethod "event" o = Gtk.Widget.WidgetEventMethodInfo+    ResolveLeafletMethod "forall" o = Gtk.Container.ContainerForallMethodInfo+    ResolveLeafletMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveLeafletMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo+    ResolveLeafletMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo+    ResolveLeafletMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveLeafletMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveLeafletMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo+    ResolveLeafletMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo+    ResolveLeafletMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo+    ResolveLeafletMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo+    ResolveLeafletMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo+    ResolveLeafletMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo+    ResolveLeafletMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo+    ResolveLeafletMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo+    ResolveLeafletMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo+    ResolveLeafletMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo+    ResolveLeafletMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo+    ResolveLeafletMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo+    ResolveLeafletMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo+    ResolveLeafletMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo+    ResolveLeafletMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo+    ResolveLeafletMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo+    ResolveLeafletMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo+    ResolveLeafletMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo+    ResolveLeafletMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo+    ResolveLeafletMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo+    ResolveLeafletMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveLeafletMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo+    ResolveLeafletMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo+    ResolveLeafletMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo+    ResolveLeafletMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo+    ResolveLeafletMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo+    ResolveLeafletMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo+    ResolveLeafletMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo+    ResolveLeafletMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo+    ResolveLeafletMethod "map" o = Gtk.Widget.WidgetMapMethodInfo+    ResolveLeafletMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo+    ResolveLeafletMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo+    ResolveLeafletMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo+    ResolveLeafletMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo+    ResolveLeafletMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo+    ResolveLeafletMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo+    ResolveLeafletMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo+    ResolveLeafletMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo+    ResolveLeafletMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveLeafletMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveLeafletMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo+    ResolveLeafletMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo+    ResolveLeafletMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo+    ResolveLeafletMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo+    ResolveLeafletMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo+    ResolveLeafletMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo+    ResolveLeafletMethod "path" o = Gtk.Widget.WidgetPathMethodInfo+    ResolveLeafletMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo+    ResolveLeafletMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo+    ResolveLeafletMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo+    ResolveLeafletMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo+    ResolveLeafletMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo+    ResolveLeafletMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo+    ResolveLeafletMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo+    ResolveLeafletMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo+    ResolveLeafletMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo+    ResolveLeafletMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveLeafletMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveLeafletMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo+    ResolveLeafletMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo+    ResolveLeafletMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo+    ResolveLeafletMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo+    ResolveLeafletMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo+    ResolveLeafletMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo+    ResolveLeafletMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo+    ResolveLeafletMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo+    ResolveLeafletMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo+    ResolveLeafletMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo+    ResolveLeafletMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo+    ResolveLeafletMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo+    ResolveLeafletMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveLeafletMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo+    ResolveLeafletMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo+    ResolveLeafletMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo+    ResolveLeafletMethod "show" o = Gtk.Widget.WidgetShowMethodInfo+    ResolveLeafletMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo+    ResolveLeafletMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo+    ResolveLeafletMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo+    ResolveLeafletMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo+    ResolveLeafletMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo+    ResolveLeafletMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveLeafletMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveLeafletMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo+    ResolveLeafletMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo+    ResolveLeafletMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo+    ResolveLeafletMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveLeafletMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo+    ResolveLeafletMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo+    ResolveLeafletMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo+    ResolveLeafletMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo+    ResolveLeafletMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo+    ResolveLeafletMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveLeafletMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo+    ResolveLeafletMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo+    ResolveLeafletMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo+    ResolveLeafletMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveLeafletMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo+    ResolveLeafletMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo+    ResolveLeafletMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo+    ResolveLeafletMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo+    ResolveLeafletMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo+    ResolveLeafletMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo+    ResolveLeafletMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo+    ResolveLeafletMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo+    ResolveLeafletMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo+    ResolveLeafletMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo+    ResolveLeafletMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo+    ResolveLeafletMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo+    ResolveLeafletMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo+    ResolveLeafletMethod "getChildTransitionDuration" o = LeafletGetChildTransitionDurationMethodInfo+    ResolveLeafletMethod "getChildTransitionRunning" o = LeafletGetChildTransitionRunningMethodInfo+    ResolveLeafletMethod "getChildTransitionType" o = LeafletGetChildTransitionTypeMethodInfo+    ResolveLeafletMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo+    ResolveLeafletMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo+    ResolveLeafletMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo+    ResolveLeafletMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo+    ResolveLeafletMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo+    ResolveLeafletMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveLeafletMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo+    ResolveLeafletMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo+    ResolveLeafletMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo+    ResolveLeafletMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo+    ResolveLeafletMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo+    ResolveLeafletMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo+    ResolveLeafletMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo+    ResolveLeafletMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo+    ResolveLeafletMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo+    ResolveLeafletMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo+    ResolveLeafletMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo+    ResolveLeafletMethod "getFold" o = LeafletGetFoldMethodInfo+    ResolveLeafletMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo+    ResolveLeafletMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo+    ResolveLeafletMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo+    ResolveLeafletMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo+    ResolveLeafletMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo+    ResolveLeafletMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo+    ResolveLeafletMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo+    ResolveLeafletMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo+    ResolveLeafletMethod "getHomogeneous" o = LeafletGetHomogeneousMethodInfo+    ResolveLeafletMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo+    ResolveLeafletMethod "getInterpolateSize" o = LeafletGetInterpolateSizeMethodInfo+    ResolveLeafletMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo+    ResolveLeafletMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo+    ResolveLeafletMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo+    ResolveLeafletMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo+    ResolveLeafletMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo+    ResolveLeafletMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo+    ResolveLeafletMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo+    ResolveLeafletMethod "getModeTransitionDuration" o = LeafletGetModeTransitionDurationMethodInfo+    ResolveLeafletMethod "getModeTransitionType" o = LeafletGetModeTransitionTypeMethodInfo+    ResolveLeafletMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo+    ResolveLeafletMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo+    ResolveLeafletMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo+    ResolveLeafletMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo+    ResolveLeafletMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo+    ResolveLeafletMethod "getOrientation" o = Gtk.Orientable.OrientableGetOrientationMethodInfo+    ResolveLeafletMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo+    ResolveLeafletMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo+    ResolveLeafletMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo+    ResolveLeafletMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo+    ResolveLeafletMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo+    ResolveLeafletMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo+    ResolveLeafletMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo+    ResolveLeafletMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo+    ResolveLeafletMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo+    ResolveLeafletMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo+    ResolveLeafletMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo+    ResolveLeafletMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo+    ResolveLeafletMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveLeafletMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveLeafletMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo+    ResolveLeafletMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo+    ResolveLeafletMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo+    ResolveLeafletMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo+    ResolveLeafletMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo+    ResolveLeafletMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo+    ResolveLeafletMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo+    ResolveLeafletMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo+    ResolveLeafletMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo+    ResolveLeafletMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo+    ResolveLeafletMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo+    ResolveLeafletMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo+    ResolveLeafletMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo+    ResolveLeafletMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo+    ResolveLeafletMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo+    ResolveLeafletMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo+    ResolveLeafletMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo+    ResolveLeafletMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo+    ResolveLeafletMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo+    ResolveLeafletMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo+    ResolveLeafletMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo+    ResolveLeafletMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo+    ResolveLeafletMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo+    ResolveLeafletMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo+    ResolveLeafletMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo+    ResolveLeafletMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo+    ResolveLeafletMethod "getVisibleChild" o = LeafletGetVisibleChildMethodInfo+    ResolveLeafletMethod "getVisibleChildName" o = LeafletGetVisibleChildNameMethodInfo+    ResolveLeafletMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo+    ResolveLeafletMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo+    ResolveLeafletMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo+    ResolveLeafletMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo+    ResolveLeafletMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo+    ResolveLeafletMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo+    ResolveLeafletMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo+    ResolveLeafletMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo+    ResolveLeafletMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo+    ResolveLeafletMethod "setChildTransitionDuration" o = LeafletSetChildTransitionDurationMethodInfo+    ResolveLeafletMethod "setChildTransitionType" o = LeafletSetChildTransitionTypeMethodInfo+    ResolveLeafletMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo+    ResolveLeafletMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo+    ResolveLeafletMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo+    ResolveLeafletMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveLeafletMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo+    ResolveLeafletMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo+    ResolveLeafletMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo+    ResolveLeafletMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo+    ResolveLeafletMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo+    ResolveLeafletMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo+    ResolveLeafletMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo+    ResolveLeafletMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo+    ResolveLeafletMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo+    ResolveLeafletMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo+    ResolveLeafletMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo+    ResolveLeafletMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo+    ResolveLeafletMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo+    ResolveLeafletMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo+    ResolveLeafletMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo+    ResolveLeafletMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo+    ResolveLeafletMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo+    ResolveLeafletMethod "setHomogeneous" o = LeafletSetHomogeneousMethodInfo+    ResolveLeafletMethod "setInterpolateSize" o = LeafletSetInterpolateSizeMethodInfo+    ResolveLeafletMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo+    ResolveLeafletMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo+    ResolveLeafletMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo+    ResolveLeafletMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo+    ResolveLeafletMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo+    ResolveLeafletMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo+    ResolveLeafletMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo+    ResolveLeafletMethod "setModeTransitionDuration" o = LeafletSetModeTransitionDurationMethodInfo+    ResolveLeafletMethod "setModeTransitionType" o = LeafletSetModeTransitionTypeMethodInfo+    ResolveLeafletMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo+    ResolveLeafletMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo+    ResolveLeafletMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo+    ResolveLeafletMethod "setOrientation" o = Gtk.Orientable.OrientableSetOrientationMethodInfo+    ResolveLeafletMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo+    ResolveLeafletMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo+    ResolveLeafletMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveLeafletMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo+    ResolveLeafletMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo+    ResolveLeafletMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo+    ResolveLeafletMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo+    ResolveLeafletMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo+    ResolveLeafletMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo+    ResolveLeafletMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo+    ResolveLeafletMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo+    ResolveLeafletMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo+    ResolveLeafletMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo+    ResolveLeafletMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo+    ResolveLeafletMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo+    ResolveLeafletMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo+    ResolveLeafletMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo+    ResolveLeafletMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo+    ResolveLeafletMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo+    ResolveLeafletMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo+    ResolveLeafletMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo+    ResolveLeafletMethod "setVisibleChild" o = LeafletSetVisibleChildMethodInfo+    ResolveLeafletMethod "setVisibleChildName" o = LeafletSetVisibleChildNameMethodInfo+    ResolveLeafletMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo+    ResolveLeafletMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo+    ResolveLeafletMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveLeafletMethod t Leaflet, O.MethodInfo info Leaflet p) => OL.IsLabel t (Leaflet -> 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 "child-transition-duration"+   -- Type: TBasicType TUInt+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@child-transition-duration@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' leaflet #childTransitionDuration+@+-}+getLeafletChildTransitionDuration :: (MonadIO m, IsLeaflet o) => o -> m Word32+getLeafletChildTransitionDuration obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "child-transition-duration"++{- |+Set the value of the “@child-transition-duration@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' leaflet [ #childTransitionDuration 'Data.GI.Base.Attributes.:=' value ]+@+-}+setLeafletChildTransitionDuration :: (MonadIO m, IsLeaflet o) => o -> Word32 -> m ()+setLeafletChildTransitionDuration obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "child-transition-duration" val++{- |+Construct a `GValueConstruct` with valid value for the “@child-transition-duration@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructLeafletChildTransitionDuration :: (IsLeaflet o) => Word32 -> IO (GValueConstruct o)+constructLeafletChildTransitionDuration val = B.Properties.constructObjectPropertyUInt32 "child-transition-duration" val++#if ENABLE_OVERLOADING+data LeafletChildTransitionDurationPropertyInfo+instance AttrInfo LeafletChildTransitionDurationPropertyInfo where+    type AttrAllowedOps LeafletChildTransitionDurationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LeafletChildTransitionDurationPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint LeafletChildTransitionDurationPropertyInfo = IsLeaflet+    type AttrGetType LeafletChildTransitionDurationPropertyInfo = Word32+    type AttrLabel LeafletChildTransitionDurationPropertyInfo = "child-transition-duration"+    type AttrOrigin LeafletChildTransitionDurationPropertyInfo = Leaflet+    attrGet _ = getLeafletChildTransitionDuration+    attrSet _ = setLeafletChildTransitionDuration+    attrConstruct _ = constructLeafletChildTransitionDuration+    attrClear _ = undefined+#endif++-- VVV Prop "child-transition-running"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]+   -- Nullable: (Just False,Nothing)++{- |+Get the value of the “@child-transition-running@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' leaflet #childTransitionRunning+@+-}+getLeafletChildTransitionRunning :: (MonadIO m, IsLeaflet o) => o -> m Bool+getLeafletChildTransitionRunning obj = liftIO $ B.Properties.getObjectPropertyBool obj "child-transition-running"++#if ENABLE_OVERLOADING+data LeafletChildTransitionRunningPropertyInfo+instance AttrInfo LeafletChildTransitionRunningPropertyInfo where+    type AttrAllowedOps LeafletChildTransitionRunningPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint LeafletChildTransitionRunningPropertyInfo = (~) ()+    type AttrBaseTypeConstraint LeafletChildTransitionRunningPropertyInfo = IsLeaflet+    type AttrGetType LeafletChildTransitionRunningPropertyInfo = Bool+    type AttrLabel LeafletChildTransitionRunningPropertyInfo = "child-transition-running"+    type AttrOrigin LeafletChildTransitionRunningPropertyInfo = Leaflet+    attrGet _ = getLeafletChildTransitionRunning+    attrSet _ = undefined+    attrConstruct _ = undefined+    attrClear _ = undefined+#endif++-- VVV Prop "child-transition-type"+   -- Type: TInterface (Name {namespace = "Handy", name = "LeafletChildTransitionType"})+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@child-transition-type@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' leaflet #childTransitionType+@+-}+getLeafletChildTransitionType :: (MonadIO m, IsLeaflet o) => o -> m Handy.Enums.LeafletChildTransitionType+getLeafletChildTransitionType obj = liftIO $ B.Properties.getObjectPropertyEnum obj "child-transition-type"++{- |+Set the value of the “@child-transition-type@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' leaflet [ #childTransitionType 'Data.GI.Base.Attributes.:=' value ]+@+-}+setLeafletChildTransitionType :: (MonadIO m, IsLeaflet o) => o -> Handy.Enums.LeafletChildTransitionType -> m ()+setLeafletChildTransitionType obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "child-transition-type" val++{- |+Construct a `GValueConstruct` with valid value for the “@child-transition-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructLeafletChildTransitionType :: (IsLeaflet o) => Handy.Enums.LeafletChildTransitionType -> IO (GValueConstruct o)+constructLeafletChildTransitionType val = B.Properties.constructObjectPropertyEnum "child-transition-type" val++#if ENABLE_OVERLOADING+data LeafletChildTransitionTypePropertyInfo+instance AttrInfo LeafletChildTransitionTypePropertyInfo where+    type AttrAllowedOps LeafletChildTransitionTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LeafletChildTransitionTypePropertyInfo = (~) Handy.Enums.LeafletChildTransitionType+    type AttrBaseTypeConstraint LeafletChildTransitionTypePropertyInfo = IsLeaflet+    type AttrGetType LeafletChildTransitionTypePropertyInfo = Handy.Enums.LeafletChildTransitionType+    type AttrLabel LeafletChildTransitionTypePropertyInfo = "child-transition-type"+    type AttrOrigin LeafletChildTransitionTypePropertyInfo = Leaflet+    attrGet _ = getLeafletChildTransitionType+    attrSet _ = setLeafletChildTransitionType+    attrConstruct _ = constructLeafletChildTransitionType+    attrClear _ = undefined+#endif++-- VVV Prop "fold"+   -- Type: TInterface (Name {namespace = "Handy", name = "Fold"})+   -- Flags: [PropertyReadable]+   -- Nullable: (Just False,Nothing)++{- |+Get the value of the “@fold@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' leaflet #fold+@+-}+getLeafletFold :: (MonadIO m, IsLeaflet o) => o -> m Handy.Enums.Fold+getLeafletFold obj = liftIO $ B.Properties.getObjectPropertyEnum obj "fold"++#if ENABLE_OVERLOADING+data LeafletFoldPropertyInfo+instance AttrInfo LeafletFoldPropertyInfo where+    type AttrAllowedOps LeafletFoldPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint LeafletFoldPropertyInfo = (~) ()+    type AttrBaseTypeConstraint LeafletFoldPropertyInfo = IsLeaflet+    type AttrGetType LeafletFoldPropertyInfo = Handy.Enums.Fold+    type AttrLabel LeafletFoldPropertyInfo = "fold"+    type AttrOrigin LeafletFoldPropertyInfo = Leaflet+    attrGet _ = getLeafletFold+    attrSet _ = undefined+    attrConstruct _ = undefined+    attrClear _ = undefined+#endif++-- VVV Prop "folded"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@folded@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' leaflet #folded+@+-}+getLeafletFolded :: (MonadIO m, IsLeaflet o) => o -> m Bool+getLeafletFolded obj = liftIO $ B.Properties.getObjectPropertyBool obj "folded"++#if ENABLE_OVERLOADING+data LeafletFoldedPropertyInfo+instance AttrInfo LeafletFoldedPropertyInfo where+    type AttrAllowedOps LeafletFoldedPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint LeafletFoldedPropertyInfo = (~) ()+    type AttrBaseTypeConstraint LeafletFoldedPropertyInfo = IsLeaflet+    type AttrGetType LeafletFoldedPropertyInfo = Bool+    type AttrLabel LeafletFoldedPropertyInfo = "folded"+    type AttrOrigin LeafletFoldedPropertyInfo = Leaflet+    attrGet _ = getLeafletFolded+    attrSet _ = undefined+    attrConstruct _ = undefined+    attrClear _ = undefined+#endif++-- VVV Prop "hhomogeneous-folded"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@hhomogeneous-folded@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' leaflet #hhomogeneousFolded+@+-}+getLeafletHhomogeneousFolded :: (MonadIO m, IsLeaflet o) => o -> m Bool+getLeafletHhomogeneousFolded obj = liftIO $ B.Properties.getObjectPropertyBool obj "hhomogeneous-folded"++{- |+Set the value of the “@hhomogeneous-folded@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' leaflet [ #hhomogeneousFolded 'Data.GI.Base.Attributes.:=' value ]+@+-}+setLeafletHhomogeneousFolded :: (MonadIO m, IsLeaflet o) => o -> Bool -> m ()+setLeafletHhomogeneousFolded obj val = liftIO $ B.Properties.setObjectPropertyBool obj "hhomogeneous-folded" val++{- |+Construct a `GValueConstruct` with valid value for the “@hhomogeneous-folded@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructLeafletHhomogeneousFolded :: (IsLeaflet o) => Bool -> IO (GValueConstruct o)+constructLeafletHhomogeneousFolded val = B.Properties.constructObjectPropertyBool "hhomogeneous-folded" val++#if ENABLE_OVERLOADING+data LeafletHhomogeneousFoldedPropertyInfo+instance AttrInfo LeafletHhomogeneousFoldedPropertyInfo where+    type AttrAllowedOps LeafletHhomogeneousFoldedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LeafletHhomogeneousFoldedPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint LeafletHhomogeneousFoldedPropertyInfo = IsLeaflet+    type AttrGetType LeafletHhomogeneousFoldedPropertyInfo = Bool+    type AttrLabel LeafletHhomogeneousFoldedPropertyInfo = "hhomogeneous-folded"+    type AttrOrigin LeafletHhomogeneousFoldedPropertyInfo = Leaflet+    attrGet _ = getLeafletHhomogeneousFolded+    attrSet _ = setLeafletHhomogeneousFolded+    attrConstruct _ = constructLeafletHhomogeneousFolded+    attrClear _ = undefined+#endif++-- VVV Prop "hhomogeneous-unfolded"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@hhomogeneous-unfolded@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' leaflet #hhomogeneousUnfolded+@+-}+getLeafletHhomogeneousUnfolded :: (MonadIO m, IsLeaflet o) => o -> m Bool+getLeafletHhomogeneousUnfolded obj = liftIO $ B.Properties.getObjectPropertyBool obj "hhomogeneous-unfolded"++{- |+Set the value of the “@hhomogeneous-unfolded@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' leaflet [ #hhomogeneousUnfolded 'Data.GI.Base.Attributes.:=' value ]+@+-}+setLeafletHhomogeneousUnfolded :: (MonadIO m, IsLeaflet o) => o -> Bool -> m ()+setLeafletHhomogeneousUnfolded obj val = liftIO $ B.Properties.setObjectPropertyBool obj "hhomogeneous-unfolded" val++{- |+Construct a `GValueConstruct` with valid value for the “@hhomogeneous-unfolded@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructLeafletHhomogeneousUnfolded :: (IsLeaflet o) => Bool -> IO (GValueConstruct o)+constructLeafletHhomogeneousUnfolded val = B.Properties.constructObjectPropertyBool "hhomogeneous-unfolded" val++#if ENABLE_OVERLOADING+data LeafletHhomogeneousUnfoldedPropertyInfo+instance AttrInfo LeafletHhomogeneousUnfoldedPropertyInfo where+    type AttrAllowedOps LeafletHhomogeneousUnfoldedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LeafletHhomogeneousUnfoldedPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint LeafletHhomogeneousUnfoldedPropertyInfo = IsLeaflet+    type AttrGetType LeafletHhomogeneousUnfoldedPropertyInfo = Bool+    type AttrLabel LeafletHhomogeneousUnfoldedPropertyInfo = "hhomogeneous-unfolded"+    type AttrOrigin LeafletHhomogeneousUnfoldedPropertyInfo = Leaflet+    attrGet _ = getLeafletHhomogeneousUnfolded+    attrSet _ = setLeafletHhomogeneousUnfolded+    attrConstruct _ = constructLeafletHhomogeneousUnfolded+    attrClear _ = undefined+#endif++-- VVV Prop "interpolate-size"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@interpolate-size@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' leaflet #interpolateSize+@+-}+getLeafletInterpolateSize :: (MonadIO m, IsLeaflet o) => o -> m Bool+getLeafletInterpolateSize obj = liftIO $ B.Properties.getObjectPropertyBool obj "interpolate-size"++{- |+Set the value of the “@interpolate-size@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' leaflet [ #interpolateSize 'Data.GI.Base.Attributes.:=' value ]+@+-}+setLeafletInterpolateSize :: (MonadIO m, IsLeaflet o) => o -> Bool -> m ()+setLeafletInterpolateSize obj val = liftIO $ B.Properties.setObjectPropertyBool obj "interpolate-size" val++{- |+Construct a `GValueConstruct` with valid value for the “@interpolate-size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructLeafletInterpolateSize :: (IsLeaflet o) => Bool -> IO (GValueConstruct o)+constructLeafletInterpolateSize val = B.Properties.constructObjectPropertyBool "interpolate-size" val++#if ENABLE_OVERLOADING+data LeafletInterpolateSizePropertyInfo+instance AttrInfo LeafletInterpolateSizePropertyInfo where+    type AttrAllowedOps LeafletInterpolateSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LeafletInterpolateSizePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint LeafletInterpolateSizePropertyInfo = IsLeaflet+    type AttrGetType LeafletInterpolateSizePropertyInfo = Bool+    type AttrLabel LeafletInterpolateSizePropertyInfo = "interpolate-size"+    type AttrOrigin LeafletInterpolateSizePropertyInfo = Leaflet+    attrGet _ = getLeafletInterpolateSize+    attrSet _ = setLeafletInterpolateSize+    attrConstruct _ = constructLeafletInterpolateSize+    attrClear _ = undefined+#endif++-- VVV Prop "mode-transition-duration"+   -- Type: TBasicType TUInt+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@mode-transition-duration@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' leaflet #modeTransitionDuration+@+-}+getLeafletModeTransitionDuration :: (MonadIO m, IsLeaflet o) => o -> m Word32+getLeafletModeTransitionDuration obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "mode-transition-duration"++{- |+Set the value of the “@mode-transition-duration@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' leaflet [ #modeTransitionDuration 'Data.GI.Base.Attributes.:=' value ]+@+-}+setLeafletModeTransitionDuration :: (MonadIO m, IsLeaflet o) => o -> Word32 -> m ()+setLeafletModeTransitionDuration obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "mode-transition-duration" val++{- |+Construct a `GValueConstruct` with valid value for the “@mode-transition-duration@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructLeafletModeTransitionDuration :: (IsLeaflet o) => Word32 -> IO (GValueConstruct o)+constructLeafletModeTransitionDuration val = B.Properties.constructObjectPropertyUInt32 "mode-transition-duration" val++#if ENABLE_OVERLOADING+data LeafletModeTransitionDurationPropertyInfo+instance AttrInfo LeafletModeTransitionDurationPropertyInfo where+    type AttrAllowedOps LeafletModeTransitionDurationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LeafletModeTransitionDurationPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint LeafletModeTransitionDurationPropertyInfo = IsLeaflet+    type AttrGetType LeafletModeTransitionDurationPropertyInfo = Word32+    type AttrLabel LeafletModeTransitionDurationPropertyInfo = "mode-transition-duration"+    type AttrOrigin LeafletModeTransitionDurationPropertyInfo = Leaflet+    attrGet _ = getLeafletModeTransitionDuration+    attrSet _ = setLeafletModeTransitionDuration+    attrConstruct _ = constructLeafletModeTransitionDuration+    attrClear _ = undefined+#endif++-- VVV Prop "mode-transition-type"+   -- Type: TInterface (Name {namespace = "Handy", name = "LeafletModeTransitionType"})+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@mode-transition-type@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' leaflet #modeTransitionType+@+-}+getLeafletModeTransitionType :: (MonadIO m, IsLeaflet o) => o -> m Handy.Enums.LeafletModeTransitionType+getLeafletModeTransitionType obj = liftIO $ B.Properties.getObjectPropertyEnum obj "mode-transition-type"++{- |+Set the value of the “@mode-transition-type@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' leaflet [ #modeTransitionType 'Data.GI.Base.Attributes.:=' value ]+@+-}+setLeafletModeTransitionType :: (MonadIO m, IsLeaflet o) => o -> Handy.Enums.LeafletModeTransitionType -> m ()+setLeafletModeTransitionType obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "mode-transition-type" val++{- |+Construct a `GValueConstruct` with valid value for the “@mode-transition-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructLeafletModeTransitionType :: (IsLeaflet o) => Handy.Enums.LeafletModeTransitionType -> IO (GValueConstruct o)+constructLeafletModeTransitionType val = B.Properties.constructObjectPropertyEnum "mode-transition-type" val++#if ENABLE_OVERLOADING+data LeafletModeTransitionTypePropertyInfo+instance AttrInfo LeafletModeTransitionTypePropertyInfo where+    type AttrAllowedOps LeafletModeTransitionTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LeafletModeTransitionTypePropertyInfo = (~) Handy.Enums.LeafletModeTransitionType+    type AttrBaseTypeConstraint LeafletModeTransitionTypePropertyInfo = IsLeaflet+    type AttrGetType LeafletModeTransitionTypePropertyInfo = Handy.Enums.LeafletModeTransitionType+    type AttrLabel LeafletModeTransitionTypePropertyInfo = "mode-transition-type"+    type AttrOrigin LeafletModeTransitionTypePropertyInfo = Leaflet+    attrGet _ = getLeafletModeTransitionType+    attrSet _ = setLeafletModeTransitionType+    attrConstruct _ = constructLeafletModeTransitionType+    attrClear _ = undefined+#endif++-- VVV Prop "vhomogeneous-folded"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@vhomogeneous-folded@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' leaflet #vhomogeneousFolded+@+-}+getLeafletVhomogeneousFolded :: (MonadIO m, IsLeaflet o) => o -> m Bool+getLeafletVhomogeneousFolded obj = liftIO $ B.Properties.getObjectPropertyBool obj "vhomogeneous-folded"++{- |+Set the value of the “@vhomogeneous-folded@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' leaflet [ #vhomogeneousFolded 'Data.GI.Base.Attributes.:=' value ]+@+-}+setLeafletVhomogeneousFolded :: (MonadIO m, IsLeaflet o) => o -> Bool -> m ()+setLeafletVhomogeneousFolded obj val = liftIO $ B.Properties.setObjectPropertyBool obj "vhomogeneous-folded" val++{- |+Construct a `GValueConstruct` with valid value for the “@vhomogeneous-folded@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructLeafletVhomogeneousFolded :: (IsLeaflet o) => Bool -> IO (GValueConstruct o)+constructLeafletVhomogeneousFolded val = B.Properties.constructObjectPropertyBool "vhomogeneous-folded" val++#if ENABLE_OVERLOADING+data LeafletVhomogeneousFoldedPropertyInfo+instance AttrInfo LeafletVhomogeneousFoldedPropertyInfo where+    type AttrAllowedOps LeafletVhomogeneousFoldedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LeafletVhomogeneousFoldedPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint LeafletVhomogeneousFoldedPropertyInfo = IsLeaflet+    type AttrGetType LeafletVhomogeneousFoldedPropertyInfo = Bool+    type AttrLabel LeafletVhomogeneousFoldedPropertyInfo = "vhomogeneous-folded"+    type AttrOrigin LeafletVhomogeneousFoldedPropertyInfo = Leaflet+    attrGet _ = getLeafletVhomogeneousFolded+    attrSet _ = setLeafletVhomogeneousFolded+    attrConstruct _ = constructLeafletVhomogeneousFolded+    attrClear _ = undefined+#endif++-- VVV Prop "vhomogeneous-unfolded"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@vhomogeneous-unfolded@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' leaflet #vhomogeneousUnfolded+@+-}+getLeafletVhomogeneousUnfolded :: (MonadIO m, IsLeaflet o) => o -> m Bool+getLeafletVhomogeneousUnfolded obj = liftIO $ B.Properties.getObjectPropertyBool obj "vhomogeneous-unfolded"++{- |+Set the value of the “@vhomogeneous-unfolded@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' leaflet [ #vhomogeneousUnfolded 'Data.GI.Base.Attributes.:=' value ]+@+-}+setLeafletVhomogeneousUnfolded :: (MonadIO m, IsLeaflet o) => o -> Bool -> m ()+setLeafletVhomogeneousUnfolded obj val = liftIO $ B.Properties.setObjectPropertyBool obj "vhomogeneous-unfolded" val++{- |+Construct a `GValueConstruct` with valid value for the “@vhomogeneous-unfolded@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructLeafletVhomogeneousUnfolded :: (IsLeaflet o) => Bool -> IO (GValueConstruct o)+constructLeafletVhomogeneousUnfolded val = B.Properties.constructObjectPropertyBool "vhomogeneous-unfolded" val++#if ENABLE_OVERLOADING+data LeafletVhomogeneousUnfoldedPropertyInfo+instance AttrInfo LeafletVhomogeneousUnfoldedPropertyInfo where+    type AttrAllowedOps LeafletVhomogeneousUnfoldedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LeafletVhomogeneousUnfoldedPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint LeafletVhomogeneousUnfoldedPropertyInfo = IsLeaflet+    type AttrGetType LeafletVhomogeneousUnfoldedPropertyInfo = Bool+    type AttrLabel LeafletVhomogeneousUnfoldedPropertyInfo = "vhomogeneous-unfolded"+    type AttrOrigin LeafletVhomogeneousUnfoldedPropertyInfo = Leaflet+    attrGet _ = getLeafletVhomogeneousUnfolded+    attrSet _ = setLeafletVhomogeneousUnfolded+    attrConstruct _ = constructLeafletVhomogeneousUnfolded+    attrClear _ = undefined+#endif++-- VVV Prop "visible-child"+   -- Type: TInterface (Name {namespace = "Gtk", name = "Widget"})+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@visible-child@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' leaflet #visibleChild+@+-}+getLeafletVisibleChild :: (MonadIO m, IsLeaflet o) => o -> m Gtk.Widget.Widget+getLeafletVisibleChild obj = liftIO $ checkUnexpectedNothing "getLeafletVisibleChild" $ B.Properties.getObjectPropertyObject obj "visible-child" Gtk.Widget.Widget++{- |+Set the value of the “@visible-child@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' leaflet [ #visibleChild 'Data.GI.Base.Attributes.:=' value ]+@+-}+setLeafletVisibleChild :: (MonadIO m, IsLeaflet o, Gtk.Widget.IsWidget a) => o -> a -> m ()+setLeafletVisibleChild obj val = liftIO $ B.Properties.setObjectPropertyObject obj "visible-child" (Just val)++{- |+Construct a `GValueConstruct` with valid value for the “@visible-child@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructLeafletVisibleChild :: (IsLeaflet o, Gtk.Widget.IsWidget a) => a -> IO (GValueConstruct o)+constructLeafletVisibleChild val = B.Properties.constructObjectPropertyObject "visible-child" (Just val)++#if ENABLE_OVERLOADING+data LeafletVisibleChildPropertyInfo+instance AttrInfo LeafletVisibleChildPropertyInfo where+    type AttrAllowedOps LeafletVisibleChildPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LeafletVisibleChildPropertyInfo = Gtk.Widget.IsWidget+    type AttrBaseTypeConstraint LeafletVisibleChildPropertyInfo = IsLeaflet+    type AttrGetType LeafletVisibleChildPropertyInfo = Gtk.Widget.Widget+    type AttrLabel LeafletVisibleChildPropertyInfo = "visible-child"+    type AttrOrigin LeafletVisibleChildPropertyInfo = Leaflet+    attrGet _ = getLeafletVisibleChild+    attrSet _ = setLeafletVisibleChild+    attrConstruct _ = constructLeafletVisibleChild+    attrClear _ = undefined+#endif++-- VVV Prop "visible-child-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@visible-child-name@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' leaflet #visibleChildName+@+-}+getLeafletVisibleChildName :: (MonadIO m, IsLeaflet o) => o -> m T.Text+getLeafletVisibleChildName obj = liftIO $ checkUnexpectedNothing "getLeafletVisibleChildName" $ B.Properties.getObjectPropertyString obj "visible-child-name"++{- |+Set the value of the “@visible-child-name@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' leaflet [ #visibleChildName 'Data.GI.Base.Attributes.:=' value ]+@+-}+setLeafletVisibleChildName :: (MonadIO m, IsLeaflet o) => o -> T.Text -> m ()+setLeafletVisibleChildName obj val = liftIO $ B.Properties.setObjectPropertyString obj "visible-child-name" (Just val)++{- |+Construct a `GValueConstruct` with valid value for the “@visible-child-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructLeafletVisibleChildName :: (IsLeaflet o) => T.Text -> IO (GValueConstruct o)+constructLeafletVisibleChildName val = B.Properties.constructObjectPropertyString "visible-child-name" (Just val)++#if ENABLE_OVERLOADING+data LeafletVisibleChildNamePropertyInfo+instance AttrInfo LeafletVisibleChildNamePropertyInfo where+    type AttrAllowedOps LeafletVisibleChildNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LeafletVisibleChildNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint LeafletVisibleChildNamePropertyInfo = IsLeaflet+    type AttrGetType LeafletVisibleChildNamePropertyInfo = T.Text+    type AttrLabel LeafletVisibleChildNamePropertyInfo = "visible-child-name"+    type AttrOrigin LeafletVisibleChildNamePropertyInfo = Leaflet+    attrGet _ = getLeafletVisibleChildName+    attrSet _ = setLeafletVisibleChildName+    attrConstruct _ = constructLeafletVisibleChildName+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList Leaflet+type instance O.AttributeList Leaflet = LeafletAttributeList+type LeafletAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("childTransitionDuration", LeafletChildTransitionDurationPropertyInfo), '("childTransitionRunning", LeafletChildTransitionRunningPropertyInfo), '("childTransitionType", LeafletChildTransitionTypePropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("fold", LeafletFoldPropertyInfo), '("folded", LeafletFoldedPropertyInfo), '("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), '("hhomogeneousFolded", LeafletHhomogeneousFoldedPropertyInfo), '("hhomogeneousUnfolded", LeafletHhomogeneousUnfoldedPropertyInfo), '("interpolateSize", LeafletInterpolateSizePropertyInfo), '("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), '("modeTransitionDuration", LeafletModeTransitionDurationPropertyInfo), '("modeTransitionType", LeafletModeTransitionTypePropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("orientation", Gtk.Orientable.OrientableOrientationPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("vhomogeneousFolded", LeafletVhomogeneousFoldedPropertyInfo), '("vhomogeneousUnfolded", LeafletVhomogeneousUnfoldedPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("visibleChild", LeafletVisibleChildPropertyInfo), '("visibleChildName", LeafletVisibleChildNamePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+leafletChildTransitionDuration :: AttrLabelProxy "childTransitionDuration"+leafletChildTransitionDuration = AttrLabelProxy++leafletChildTransitionRunning :: AttrLabelProxy "childTransitionRunning"+leafletChildTransitionRunning = AttrLabelProxy++leafletChildTransitionType :: AttrLabelProxy "childTransitionType"+leafletChildTransitionType = AttrLabelProxy++leafletFold :: AttrLabelProxy "fold"+leafletFold = AttrLabelProxy++leafletFolded :: AttrLabelProxy "folded"+leafletFolded = AttrLabelProxy++leafletHhomogeneousFolded :: AttrLabelProxy "hhomogeneousFolded"+leafletHhomogeneousFolded = AttrLabelProxy++leafletHhomogeneousUnfolded :: AttrLabelProxy "hhomogeneousUnfolded"+leafletHhomogeneousUnfolded = AttrLabelProxy++leafletInterpolateSize :: AttrLabelProxy "interpolateSize"+leafletInterpolateSize = AttrLabelProxy++leafletModeTransitionDuration :: AttrLabelProxy "modeTransitionDuration"+leafletModeTransitionDuration = AttrLabelProxy++leafletModeTransitionType :: AttrLabelProxy "modeTransitionType"+leafletModeTransitionType = AttrLabelProxy++leafletVhomogeneousFolded :: AttrLabelProxy "vhomogeneousFolded"+leafletVhomogeneousFolded = AttrLabelProxy++leafletVhomogeneousUnfolded :: AttrLabelProxy "vhomogeneousUnfolded"+leafletVhomogeneousUnfolded = AttrLabelProxy++leafletVisibleChild :: AttrLabelProxy "visibleChild"+leafletVisibleChild = AttrLabelProxy++leafletVisibleChildName :: AttrLabelProxy "visibleChildName"+leafletVisibleChildName = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList Leaflet = LeafletSignalList+type LeafletSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("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), '("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), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("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), '("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 Leaflet::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "Leaflet"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_leaflet_new" hdy_leaflet_new :: +    IO (Ptr Leaflet)++{- |+/No description available in the introspection data./+-}+leafletNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Leaflet+leafletNew  = liftIO $ do+    result <- hdy_leaflet_new+    checkUnexpectedReturnNULL "leafletNew" result+    result' <- (newObject Leaflet) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Leaflet::get_child_transition_duration+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Leaflet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyLeaflet", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_leaflet_get_child_transition_duration" hdy_leaflet_get_child_transition_duration :: +    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})+    IO Word32++{- |+Returns the amount of time (in milliseconds) that+transitions between children in /@self@/ will take.+-}+leafletGetChildTransitionDuration ::+    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Leaflet.Leaflet' -}+    -> m Word32+    {- ^ __Returns:__ the mode transition duration -}+leafletGetChildTransitionDuration self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_leaflet_get_child_transition_duration self'+    touchManagedPtr self+    return result++#if ENABLE_OVERLOADING+data LeafletGetChildTransitionDurationMethodInfo+instance (signature ~ (m Word32), MonadIO m, IsLeaflet a) => O.MethodInfo LeafletGetChildTransitionDurationMethodInfo a signature where+    overloadedMethod _ = leafletGetChildTransitionDuration++#endif++-- method Leaflet::get_child_transition_running+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Leaflet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyLeaflet", 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 "hdy_leaflet_get_child_transition_running" hdy_leaflet_get_child_transition_running :: +    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})+    IO CInt++{- |+Returns whether /@self@/ is currently in a transition from one page to+another.+-}+leafletGetChildTransitionRunning ::+    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Leaflet.Leaflet' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if the transition is currently running, 'False' otherwise. -}+leafletGetChildTransitionRunning self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_leaflet_get_child_transition_running self'+    let result' = (/= 0) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data LeafletGetChildTransitionRunningMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsLeaflet a) => O.MethodInfo LeafletGetChildTransitionRunningMethodInfo a signature where+    overloadedMethod _ = leafletGetChildTransitionRunning++#endif++-- method Leaflet::get_child_transition_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Leaflet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyLeaflet", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "LeafletChildTransitionType"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_leaflet_get_child_transition_type" hdy_leaflet_get_child_transition_type :: +    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})+    IO CUInt++{- |+Gets the type of animation that will be used+for transitions between modes in /@self@/.+-}+leafletGetChildTransitionType ::+    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Leaflet.Leaflet' -}+    -> m Handy.Enums.LeafletChildTransitionType+    {- ^ __Returns:__ the current mode transition type of /@self@/ -}+leafletGetChildTransitionType self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_leaflet_get_child_transition_type self'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data LeafletGetChildTransitionTypeMethodInfo+instance (signature ~ (m Handy.Enums.LeafletChildTransitionType), MonadIO m, IsLeaflet a) => O.MethodInfo LeafletGetChildTransitionTypeMethodInfo a signature where+    overloadedMethod _ = leafletGetChildTransitionType++#endif++-- method Leaflet::get_fold+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Leaflet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyLeaflet", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "Fold"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_leaflet_get_fold" hdy_leaflet_get_fold :: +    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})+    IO CUInt++{- |+Gets the fold of /@self@/.+-}+leafletGetFold ::+    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Leaflet.Leaflet' -}+    -> m Handy.Enums.Fold+    {- ^ __Returns:__ the fold of /@self@/. -}+leafletGetFold self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_leaflet_get_fold self'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data LeafletGetFoldMethodInfo+instance (signature ~ (m Handy.Enums.Fold), MonadIO m, IsLeaflet a) => O.MethodInfo LeafletGetFoldMethodInfo a signature where+    overloadedMethod _ = leafletGetFold++#endif++-- method Leaflet::get_homogeneous+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Leaflet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyLeaflet", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fold", argType = TInterface (Name {namespace = "Handy", name = "Fold"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the fold", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "orientation", argType = TInterface (Name {namespace = "Gtk", name = "Orientation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the orientation", 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 "hdy_leaflet_get_homogeneous" hdy_leaflet_get_homogeneous :: +    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})+    CUInt ->                                -- fold : TInterface (Name {namespace = "Handy", name = "Fold"})+    CUInt ->                                -- orientation : TInterface (Name {namespace = "Gtk", name = "Orientation"})+    IO CInt++{- |+Gets whether /@self@/ is homogeneous for the given fold and orientation.+See 'GI.Handy.Objects.Leaflet.leafletSetHomogeneous'.+-}+leafletGetHomogeneous ::+    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Leaflet.Leaflet' -}+    -> Handy.Enums.Fold+    {- ^ /@fold@/: the fold -}+    -> Gtk.Enums.Orientation+    {- ^ /@orientation@/: the orientation -}+    -> m Bool+    {- ^ __Returns:__ whether /@self@/ is homogeneous for the given fold and orientation. -}+leafletGetHomogeneous self fold orientation = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    let fold' = (fromIntegral . fromEnum) fold+    let orientation' = (fromIntegral . fromEnum) orientation+    result <- hdy_leaflet_get_homogeneous self' fold' orientation'+    let result' = (/= 0) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data LeafletGetHomogeneousMethodInfo+instance (signature ~ (Handy.Enums.Fold -> Gtk.Enums.Orientation -> m Bool), MonadIO m, IsLeaflet a) => O.MethodInfo LeafletGetHomogeneousMethodInfo a signature where+    overloadedMethod _ = leafletGetHomogeneous++#endif++-- method Leaflet::get_interpolate_size+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Leaflet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyLeaflet", 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 "hdy_leaflet_get_interpolate_size" hdy_leaflet_get_interpolate_size :: +    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})+    IO CInt++{- |+Returns wether the 'GI.Handy.Objects.Leaflet.Leaflet' is set up to interpolate between+the sizes of children on page switch.+-}+leafletGetInterpolateSize ::+    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Leaflet.Leaflet' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if child sizes are interpolated -}+leafletGetInterpolateSize self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_leaflet_get_interpolate_size self'+    let result' = (/= 0) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data LeafletGetInterpolateSizeMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsLeaflet a) => O.MethodInfo LeafletGetInterpolateSizeMethodInfo a signature where+    overloadedMethod _ = leafletGetInterpolateSize++#endif++-- method Leaflet::get_mode_transition_duration+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Leaflet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyLeaflet", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_leaflet_get_mode_transition_duration" hdy_leaflet_get_mode_transition_duration :: +    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})+    IO Word32++{- |+Returns the amount of time (in milliseconds) that+transitions between modes in /@self@/ will take.+-}+leafletGetModeTransitionDuration ::+    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Leaflet.Leaflet' -}+    -> m Word32+    {- ^ __Returns:__ the mode transition duration -}+leafletGetModeTransitionDuration self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_leaflet_get_mode_transition_duration self'+    touchManagedPtr self+    return result++#if ENABLE_OVERLOADING+data LeafletGetModeTransitionDurationMethodInfo+instance (signature ~ (m Word32), MonadIO m, IsLeaflet a) => O.MethodInfo LeafletGetModeTransitionDurationMethodInfo a signature where+    overloadedMethod _ = leafletGetModeTransitionDuration++#endif++-- method Leaflet::get_mode_transition_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Leaflet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyLeaflet", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "LeafletModeTransitionType"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_leaflet_get_mode_transition_type" hdy_leaflet_get_mode_transition_type :: +    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})+    IO CUInt++{- |+Gets the type of animation that will be used+for transitions between modes in /@self@/.+-}+leafletGetModeTransitionType ::+    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Leaflet.Leaflet' -}+    -> m Handy.Enums.LeafletModeTransitionType+    {- ^ __Returns:__ the current mode transition type of /@self@/ -}+leafletGetModeTransitionType self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_leaflet_get_mode_transition_type self'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data LeafletGetModeTransitionTypeMethodInfo+instance (signature ~ (m Handy.Enums.LeafletModeTransitionType), MonadIO m, IsLeaflet a) => O.MethodInfo LeafletGetModeTransitionTypeMethodInfo a signature where+    overloadedMethod _ = leafletGetModeTransitionType++#endif++-- method Leaflet::get_visible_child+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Leaflet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyLeaflet", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Widget"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_leaflet_get_visible_child" hdy_leaflet_get_visible_child :: +    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})+    IO (Ptr Gtk.Widget.Widget)++{- |+Get the visible child widget.+-}+leafletGetVisibleChild ::+    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Leaflet.Leaflet' -}+    -> m Gtk.Widget.Widget+    {- ^ __Returns:__ the visible child widget -}+leafletGetVisibleChild self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_leaflet_get_visible_child self'+    checkUnexpectedReturnNULL "leafletGetVisibleChild" result+    result' <- (newObject Gtk.Widget.Widget) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data LeafletGetVisibleChildMethodInfo+instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsLeaflet a) => O.MethodInfo LeafletGetVisibleChildMethodInfo a signature where+    overloadedMethod _ = leafletGetVisibleChild++#endif++-- method Leaflet::get_visible_child_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Leaflet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_leaflet_get_visible_child_name" hdy_leaflet_get_visible_child_name :: +    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})+    IO CString++{- |+/No description available in the introspection data./+-}+leafletGetVisibleChildName ::+    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>+    a+    -> m T.Text+leafletGetVisibleChildName self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_leaflet_get_visible_child_name self'+    checkUnexpectedReturnNULL "leafletGetVisibleChildName" result+    result' <- cstringToText result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data LeafletGetVisibleChildNameMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsLeaflet a) => O.MethodInfo LeafletGetVisibleChildNameMethodInfo a signature where+    overloadedMethod _ = leafletGetVisibleChildName++#endif++-- method Leaflet::set_child_transition_duration+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Leaflet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyLeaflet", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new duration, in milliseconds", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_leaflet_set_child_transition_duration" hdy_leaflet_set_child_transition_duration :: +    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})+    Word32 ->                               -- duration : TBasicType TUInt+    IO ()++{- |+Sets the duration that transitions between children in /@self@/+will take.+-}+leafletSetChildTransitionDuration ::+    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Leaflet.Leaflet' -}+    -> Word32+    {- ^ /@duration@/: the new duration, in milliseconds -}+    -> m ()+leafletSetChildTransitionDuration self duration = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    hdy_leaflet_set_child_transition_duration self' duration+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data LeafletSetChildTransitionDurationMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m, IsLeaflet a) => O.MethodInfo LeafletSetChildTransitionDurationMethodInfo a signature where+    overloadedMethod _ = leafletSetChildTransitionDuration++#endif++-- method Leaflet::set_child_transition_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Leaflet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyLeaflet", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "transition", argType = TInterface (Name {namespace = "Handy", name = "LeafletChildTransitionType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new transition type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_leaflet_set_child_transition_type" hdy_leaflet_set_child_transition_type :: +    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})+    CUInt ->                                -- transition : TInterface (Name {namespace = "Handy", name = "LeafletChildTransitionType"})+    IO ()++{- |+Sets the type of animation that will be used for+transitions between children in /@self@/.++The transition type can be changed without problems+at runtime, so it is possible to change the animation+based on the mode that is about to become current.+-}+leafletSetChildTransitionType ::+    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Leaflet.Leaflet' -}+    -> Handy.Enums.LeafletChildTransitionType+    {- ^ /@transition@/: the new transition type -}+    -> m ()+leafletSetChildTransitionType self transition = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    let transition' = (fromIntegral . fromEnum) transition+    hdy_leaflet_set_child_transition_type self' transition'+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data LeafletSetChildTransitionTypeMethodInfo+instance (signature ~ (Handy.Enums.LeafletChildTransitionType -> m ()), MonadIO m, IsLeaflet a) => O.MethodInfo LeafletSetChildTransitionTypeMethodInfo a signature where+    overloadedMethod _ = leafletSetChildTransitionType++#endif++-- method Leaflet::set_homogeneous+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Leaflet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyLeaflet", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fold", argType = TInterface (Name {namespace = "Handy", name = "Fold"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the fold", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "orientation", argType = TInterface (Name {namespace = "Gtk", name = "Orientation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the orientation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "homogeneous", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to make @self homogeneous", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_leaflet_set_homogeneous" hdy_leaflet_set_homogeneous :: +    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})+    CUInt ->                                -- fold : TInterface (Name {namespace = "Handy", name = "Fold"})+    CUInt ->                                -- orientation : TInterface (Name {namespace = "Gtk", name = "Orientation"})+    CInt ->                                 -- homogeneous : TBasicType TBoolean+    IO ()++{- |+Sets the 'GI.Handy.Objects.Leaflet.Leaflet' to be homogeneous or not for the given fold and orientation.+If it is homogeneous, the 'GI.Handy.Objects.Leaflet.Leaflet' will request the same+width or height for all its children depending on the orientation.+If it isn\'t and it is folded, the leaflet may change width or height+when a different child becomes visible.+-}+leafletSetHomogeneous ::+    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Leaflet.Leaflet' -}+    -> Handy.Enums.Fold+    {- ^ /@fold@/: the fold -}+    -> Gtk.Enums.Orientation+    {- ^ /@orientation@/: the orientation -}+    -> Bool+    {- ^ /@homogeneous@/: 'True' to make /@self@/ homogeneous -}+    -> m ()+leafletSetHomogeneous self fold orientation homogeneous = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    let fold' = (fromIntegral . fromEnum) fold+    let orientation' = (fromIntegral . fromEnum) orientation+    let homogeneous' = (fromIntegral . fromEnum) homogeneous+    hdy_leaflet_set_homogeneous self' fold' orientation' homogeneous'+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data LeafletSetHomogeneousMethodInfo+instance (signature ~ (Handy.Enums.Fold -> Gtk.Enums.Orientation -> Bool -> m ()), MonadIO m, IsLeaflet a) => O.MethodInfo LeafletSetHomogeneousMethodInfo a signature where+    overloadedMethod _ = leafletSetHomogeneous++#endif++-- method Leaflet::set_interpolate_size+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Leaflet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyLeaflet", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interpolate_size", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_leaflet_set_interpolate_size" hdy_leaflet_set_interpolate_size :: +    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})+    CInt ->                                 -- interpolate_size : TBasicType TBoolean+    IO ()++{- |+Sets whether or not /@self@/ will interpolate its size when+changing the visible child. If the 'GI.Handy.Objects.Leaflet.Leaflet':@/interpolate-size/@+property is set to 'True', /@stack@/ will interpolate its size between+the current one and the one it\'ll take after changing the+visible child, according to the set transition duration.+-}+leafletSetInterpolateSize ::+    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Leaflet.Leaflet' -}+    -> Bool+    {- ^ /@interpolateSize@/: the new value -}+    -> m ()+leafletSetInterpolateSize self interpolateSize = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    let interpolateSize' = (fromIntegral . fromEnum) interpolateSize+    hdy_leaflet_set_interpolate_size self' interpolateSize'+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data LeafletSetInterpolateSizeMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsLeaflet a) => O.MethodInfo LeafletSetInterpolateSizeMethodInfo a signature where+    overloadedMethod _ = leafletSetInterpolateSize++#endif++-- method Leaflet::set_mode_transition_duration+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Leaflet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyLeaflet", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new duration, in milliseconds", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_leaflet_set_mode_transition_duration" hdy_leaflet_set_mode_transition_duration :: +    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})+    Word32 ->                               -- duration : TBasicType TUInt+    IO ()++{- |+Sets the duration that transitions between modes in /@self@/+will take.+-}+leafletSetModeTransitionDuration ::+    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Leaflet.Leaflet' -}+    -> Word32+    {- ^ /@duration@/: the new duration, in milliseconds -}+    -> m ()+leafletSetModeTransitionDuration self duration = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    hdy_leaflet_set_mode_transition_duration self' duration+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data LeafletSetModeTransitionDurationMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m, IsLeaflet a) => O.MethodInfo LeafletSetModeTransitionDurationMethodInfo a signature where+    overloadedMethod _ = leafletSetModeTransitionDuration++#endif++-- method Leaflet::set_mode_transition_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Leaflet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyLeaflet", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "transition", argType = TInterface (Name {namespace = "Handy", name = "LeafletModeTransitionType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new transition type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_leaflet_set_mode_transition_type" hdy_leaflet_set_mode_transition_type :: +    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})+    CUInt ->                                -- transition : TInterface (Name {namespace = "Handy", name = "LeafletModeTransitionType"})+    IO ()++{- |+Sets the type of animation that will be used for+transitions between modes in /@self@/.++The transition type can be changed without problems+at runtime, so it is possible to change the animation+based on the mode that is about to become current.+-}+leafletSetModeTransitionType ::+    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.Leaflet.Leaflet' -}+    -> Handy.Enums.LeafletModeTransitionType+    {- ^ /@transition@/: the new transition type -}+    -> m ()+leafletSetModeTransitionType self transition = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    let transition' = (fromIntegral . fromEnum) transition+    hdy_leaflet_set_mode_transition_type self' transition'+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data LeafletSetModeTransitionTypeMethodInfo+instance (signature ~ (Handy.Enums.LeafletModeTransitionType -> m ()), MonadIO m, IsLeaflet a) => O.MethodInfo LeafletSetModeTransitionTypeMethodInfo a signature where+    overloadedMethod _ = leafletSetModeTransitionType++#endif++-- method Leaflet::set_visible_child+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Leaflet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "visible_child", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_leaflet_set_visible_child" hdy_leaflet_set_visible_child :: +    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})+    Ptr Gtk.Widget.Widget ->                -- visible_child : TInterface (Name {namespace = "Gtk", name = "Widget"})+    IO ()++{- |+/No description available in the introspection data./+-}+leafletSetVisibleChild ::+    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a, Gtk.Widget.IsWidget b) =>+    a+    -> b+    -> m ()+leafletSetVisibleChild self visibleChild = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    visibleChild' <- unsafeManagedPtrCastPtr visibleChild+    hdy_leaflet_set_visible_child self' visibleChild'+    touchManagedPtr self+    touchManagedPtr visibleChild+    return ()++#if ENABLE_OVERLOADING+data LeafletSetVisibleChildMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, IsLeaflet a, Gtk.Widget.IsWidget b) => O.MethodInfo LeafletSetVisibleChildMethodInfo a signature where+    overloadedMethod _ = leafletSetVisibleChild++#endif++-- method Leaflet::set_visible_child_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "Leaflet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_leaflet_set_visible_child_name" hdy_leaflet_set_visible_child_name :: +    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})+    CString ->                              -- name : TBasicType TUTF8+    IO ()++{- |+/No description available in the introspection data./+-}+leafletSetVisibleChildName ::+    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>+    a+    -> T.Text+    -> m ()+leafletSetVisibleChildName self name = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    name' <- textToCString name+    hdy_leaflet_set_visible_child_name self' name'+    touchManagedPtr self+    freeMem name'+    return ()++#if ENABLE_OVERLOADING+data LeafletSetVisibleChildNameMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m, IsLeaflet a) => O.MethodInfo LeafletSetVisibleChildNameMethodInfo a signature where+    overloadedMethod _ = leafletSetVisibleChildName++#endif++
+ GI/Handy/Objects/Leaflet.hs-boot view
@@ -0,0 +1,125 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Handy.Objects.Leaflet 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 Leaflet = Leaflet (ManagedPtr Leaflet)+instance GObject Leaflet where+class (GObject o, O.IsDescendantOf Leaflet o) => IsLeaflet o+instance (GObject o, O.IsDescendantOf Leaflet o) => IsLeaflet o+instance O.HasParentTypes Leaflet+#if ENABLE_OVERLOADING+data LeafletChildTransitionDurationPropertyInfo+#endif+#if ENABLE_OVERLOADING+data LeafletChildTransitionRunningPropertyInfo+#endif+#if ENABLE_OVERLOADING+data LeafletChildTransitionTypePropertyInfo+#endif+#if ENABLE_OVERLOADING+data LeafletFoldPropertyInfo+#endif+#if ENABLE_OVERLOADING+data LeafletFoldedPropertyInfo+#endif+#if ENABLE_OVERLOADING+data LeafletHhomogeneousFoldedPropertyInfo+#endif+#if ENABLE_OVERLOADING+data LeafletHhomogeneousUnfoldedPropertyInfo+#endif+#if ENABLE_OVERLOADING+data LeafletInterpolateSizePropertyInfo+#endif+#if ENABLE_OVERLOADING+data LeafletModeTransitionDurationPropertyInfo+#endif+#if ENABLE_OVERLOADING+data LeafletModeTransitionTypePropertyInfo+#endif+#if ENABLE_OVERLOADING+data LeafletVhomogeneousFoldedPropertyInfo+#endif+#if ENABLE_OVERLOADING+data LeafletVhomogeneousUnfoldedPropertyInfo+#endif+#if ENABLE_OVERLOADING+data LeafletVisibleChildPropertyInfo+#endif+#if ENABLE_OVERLOADING+data LeafletVisibleChildNamePropertyInfo+#endif+#if ENABLE_OVERLOADING+data LeafletGetChildTransitionDurationMethodInfo+#endif+#if ENABLE_OVERLOADING+data LeafletGetChildTransitionRunningMethodInfo+#endif+#if ENABLE_OVERLOADING+data LeafletGetChildTransitionTypeMethodInfo+#endif+#if ENABLE_OVERLOADING+data LeafletGetFoldMethodInfo+#endif+#if ENABLE_OVERLOADING+data LeafletGetHomogeneousMethodInfo+#endif+#if ENABLE_OVERLOADING+data LeafletGetInterpolateSizeMethodInfo+#endif+#if ENABLE_OVERLOADING+data LeafletGetModeTransitionDurationMethodInfo+#endif+#if ENABLE_OVERLOADING+data LeafletGetModeTransitionTypeMethodInfo+#endif+#if ENABLE_OVERLOADING+data LeafletGetVisibleChildMethodInfo+#endif+#if ENABLE_OVERLOADING+data LeafletGetVisibleChildNameMethodInfo+#endif+#if ENABLE_OVERLOADING+data LeafletSetChildTransitionDurationMethodInfo+#endif+#if ENABLE_OVERLOADING+data LeafletSetChildTransitionTypeMethodInfo+#endif+#if ENABLE_OVERLOADING+data LeafletSetHomogeneousMethodInfo+#endif+#if ENABLE_OVERLOADING+data LeafletSetInterpolateSizeMethodInfo+#endif+#if ENABLE_OVERLOADING+data LeafletSetModeTransitionDurationMethodInfo+#endif+#if ENABLE_OVERLOADING+data LeafletSetModeTransitionTypeMethodInfo+#endif+#if ENABLE_OVERLOADING+data LeafletSetVisibleChildMethodInfo+#endif+#if ENABLE_OVERLOADING+data LeafletSetVisibleChildNameMethodInfo+#endif
+ GI/Handy/Objects/SearchBar.hs view
@@ -0,0 +1,934 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Handy.Objects.SearchBar+    ( ++-- * Exported types+    SearchBar(..)                           ,+    IsSearchBar                             ,+    toSearchBar                             ,+    noSearchBar                             ,+++ -- * Methods+-- ** connectEntry #method:connectEntry#++#if ENABLE_OVERLOADING+    SearchBarConnectEntryMethodInfo         ,+#endif+    searchBarConnectEntry                   ,+++-- ** getSearchMode #method:getSearchMode#++#if ENABLE_OVERLOADING+    SearchBarGetSearchModeMethodInfo        ,+#endif+    searchBarGetSearchMode                  ,+++-- ** getShowCloseButton #method:getShowCloseButton#++#if ENABLE_OVERLOADING+    SearchBarGetShowCloseButtonMethodInfo   ,+#endif+    searchBarGetShowCloseButton             ,+++-- ** handleEvent #method:handleEvent#++#if ENABLE_OVERLOADING+    SearchBarHandleEventMethodInfo          ,+#endif+    searchBarHandleEvent                    ,+++-- ** new #method:new#++    searchBarNew                            ,+++-- ** setSearchMode #method:setSearchMode#++#if ENABLE_OVERLOADING+    SearchBarSetSearchModeMethodInfo        ,+#endif+    searchBarSetSearchMode                  ,+++-- ** setShowCloseButton #method:setShowCloseButton#++#if ENABLE_OVERLOADING+    SearchBarSetShowCloseButtonMethodInfo   ,+#endif+    searchBarSetShowCloseButton             ,+++++ -- * Properties+-- ** searchModeEnabled #attr:searchModeEnabled#+{- | Whether the search mode is on and the search bar shown.++See 'GI.Handy.Objects.SearchBar.searchBarSetSearchMode' for details.+-}+#if ENABLE_OVERLOADING+    SearchBarSearchModeEnabledPropertyInfo  ,+#endif+    constructSearchBarSearchModeEnabled     ,+    getSearchBarSearchModeEnabled           ,+#if ENABLE_OVERLOADING+    searchBarSearchModeEnabled              ,+#endif+    setSearchBarSearchModeEnabled           ,+++-- ** showCloseButton #attr:showCloseButton#+{- | Whether to show the close button in the toolbar.+-}+#if ENABLE_OVERLOADING+    SearchBarShowCloseButtonPropertyInfo    ,+#endif+    constructSearchBarShowCloseButton       ,+    getSearchBarShowCloseButton             ,+#if ENABLE_OVERLOADING+    searchBarShowCloseButton                ,+#endif+    setSearchBarShowCloseButton             ,+++++    ) 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 qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gdk.Unions.Event as Gdk.Event+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable+import qualified GI.Gtk.Objects.Bin as Gtk.Bin+import qualified GI.Gtk.Objects.Container as Gtk.Container+import qualified GI.Gtk.Objects.Entry as Gtk.Entry+import qualified GI.Gtk.Objects.Widget as Gtk.Widget++-- | Memory-managed wrapper type.+newtype SearchBar = SearchBar (ManagedPtr SearchBar)+foreign import ccall "hdy_search_bar_get_type"+    c_hdy_search_bar_get_type :: IO GType++instance GObject SearchBar where+    gobjectType = c_hdy_search_bar_get_type+    ++-- | Type class for types which can be safely cast to `SearchBar`, for instance with `toSearchBar`.+class (GObject o, O.IsDescendantOf SearchBar o) => IsSearchBar o+instance (GObject o, O.IsDescendantOf SearchBar o) => IsSearchBar o++instance O.HasParentTypes SearchBar+type instance O.ParentTypes SearchBar = '[Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable]++-- | Cast to `SearchBar`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toSearchBar :: (MonadIO m, IsSearchBar o) => o -> m SearchBar+toSearchBar = liftIO . unsafeCastTo SearchBar++-- | A convenience alias for `Nothing` :: `Maybe` `SearchBar`.+noSearchBar :: Maybe SearchBar+noSearchBar = Nothing++#if ENABLE_OVERLOADING+type family ResolveSearchBarMethod (t :: Symbol) (o :: *) :: * where+    ResolveSearchBarMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo+    ResolveSearchBarMethod "add" o = Gtk.Container.ContainerAddMethodInfo+    ResolveSearchBarMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo+    ResolveSearchBarMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo+    ResolveSearchBarMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo+    ResolveSearchBarMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo+    ResolveSearchBarMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo+    ResolveSearchBarMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo+    ResolveSearchBarMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveSearchBarMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveSearchBarMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo+    ResolveSearchBarMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo+    ResolveSearchBarMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo+    ResolveSearchBarMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo+    ResolveSearchBarMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo+    ResolveSearchBarMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo+    ResolveSearchBarMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo+    ResolveSearchBarMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo+    ResolveSearchBarMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo+    ResolveSearchBarMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo+    ResolveSearchBarMethod "connectEntry" o = SearchBarConnectEntryMethodInfo+    ResolveSearchBarMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo+    ResolveSearchBarMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo+    ResolveSearchBarMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo+    ResolveSearchBarMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo+    ResolveSearchBarMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo+    ResolveSearchBarMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo+    ResolveSearchBarMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo+    ResolveSearchBarMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo+    ResolveSearchBarMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo+    ResolveSearchBarMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo+    ResolveSearchBarMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo+    ResolveSearchBarMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo+    ResolveSearchBarMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo+    ResolveSearchBarMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo+    ResolveSearchBarMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo+    ResolveSearchBarMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo+    ResolveSearchBarMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo+    ResolveSearchBarMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo+    ResolveSearchBarMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo+    ResolveSearchBarMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo+    ResolveSearchBarMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo+    ResolveSearchBarMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo+    ResolveSearchBarMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo+    ResolveSearchBarMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo+    ResolveSearchBarMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo+    ResolveSearchBarMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo+    ResolveSearchBarMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo+    ResolveSearchBarMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo+    ResolveSearchBarMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo+    ResolveSearchBarMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo+    ResolveSearchBarMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo+    ResolveSearchBarMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo+    ResolveSearchBarMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo+    ResolveSearchBarMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo+    ResolveSearchBarMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo+    ResolveSearchBarMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo+    ResolveSearchBarMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo+    ResolveSearchBarMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo+    ResolveSearchBarMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo+    ResolveSearchBarMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo+    ResolveSearchBarMethod "event" o = Gtk.Widget.WidgetEventMethodInfo+    ResolveSearchBarMethod "forall" o = Gtk.Container.ContainerForallMethodInfo+    ResolveSearchBarMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveSearchBarMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo+    ResolveSearchBarMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo+    ResolveSearchBarMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveSearchBarMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveSearchBarMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo+    ResolveSearchBarMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo+    ResolveSearchBarMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo+    ResolveSearchBarMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo+    ResolveSearchBarMethod "handleEvent" o = SearchBarHandleEventMethodInfo+    ResolveSearchBarMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo+    ResolveSearchBarMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo+    ResolveSearchBarMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo+    ResolveSearchBarMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo+    ResolveSearchBarMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo+    ResolveSearchBarMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo+    ResolveSearchBarMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo+    ResolveSearchBarMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo+    ResolveSearchBarMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo+    ResolveSearchBarMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo+    ResolveSearchBarMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo+    ResolveSearchBarMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo+    ResolveSearchBarMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo+    ResolveSearchBarMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo+    ResolveSearchBarMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo+    ResolveSearchBarMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo+    ResolveSearchBarMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveSearchBarMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo+    ResolveSearchBarMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo+    ResolveSearchBarMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo+    ResolveSearchBarMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo+    ResolveSearchBarMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo+    ResolveSearchBarMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo+    ResolveSearchBarMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo+    ResolveSearchBarMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo+    ResolveSearchBarMethod "map" o = Gtk.Widget.WidgetMapMethodInfo+    ResolveSearchBarMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo+    ResolveSearchBarMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo+    ResolveSearchBarMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo+    ResolveSearchBarMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo+    ResolveSearchBarMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo+    ResolveSearchBarMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo+    ResolveSearchBarMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo+    ResolveSearchBarMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo+    ResolveSearchBarMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveSearchBarMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveSearchBarMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo+    ResolveSearchBarMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo+    ResolveSearchBarMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo+    ResolveSearchBarMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo+    ResolveSearchBarMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo+    ResolveSearchBarMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo+    ResolveSearchBarMethod "path" o = Gtk.Widget.WidgetPathMethodInfo+    ResolveSearchBarMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo+    ResolveSearchBarMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo+    ResolveSearchBarMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo+    ResolveSearchBarMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo+    ResolveSearchBarMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo+    ResolveSearchBarMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo+    ResolveSearchBarMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo+    ResolveSearchBarMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo+    ResolveSearchBarMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo+    ResolveSearchBarMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveSearchBarMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveSearchBarMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo+    ResolveSearchBarMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo+    ResolveSearchBarMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo+    ResolveSearchBarMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo+    ResolveSearchBarMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo+    ResolveSearchBarMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo+    ResolveSearchBarMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo+    ResolveSearchBarMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo+    ResolveSearchBarMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo+    ResolveSearchBarMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo+    ResolveSearchBarMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo+    ResolveSearchBarMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo+    ResolveSearchBarMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveSearchBarMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo+    ResolveSearchBarMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo+    ResolveSearchBarMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo+    ResolveSearchBarMethod "show" o = Gtk.Widget.WidgetShowMethodInfo+    ResolveSearchBarMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo+    ResolveSearchBarMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo+    ResolveSearchBarMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo+    ResolveSearchBarMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo+    ResolveSearchBarMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo+    ResolveSearchBarMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveSearchBarMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveSearchBarMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo+    ResolveSearchBarMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo+    ResolveSearchBarMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo+    ResolveSearchBarMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveSearchBarMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo+    ResolveSearchBarMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo+    ResolveSearchBarMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo+    ResolveSearchBarMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo+    ResolveSearchBarMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo+    ResolveSearchBarMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveSearchBarMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo+    ResolveSearchBarMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo+    ResolveSearchBarMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo+    ResolveSearchBarMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveSearchBarMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo+    ResolveSearchBarMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo+    ResolveSearchBarMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo+    ResolveSearchBarMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo+    ResolveSearchBarMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo+    ResolveSearchBarMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo+    ResolveSearchBarMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo+    ResolveSearchBarMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo+    ResolveSearchBarMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo+    ResolveSearchBarMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo+    ResolveSearchBarMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo+    ResolveSearchBarMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo+    ResolveSearchBarMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo+    ResolveSearchBarMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo+    ResolveSearchBarMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo+    ResolveSearchBarMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo+    ResolveSearchBarMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo+    ResolveSearchBarMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo+    ResolveSearchBarMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo+    ResolveSearchBarMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveSearchBarMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo+    ResolveSearchBarMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo+    ResolveSearchBarMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo+    ResolveSearchBarMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo+    ResolveSearchBarMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo+    ResolveSearchBarMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo+    ResolveSearchBarMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo+    ResolveSearchBarMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo+    ResolveSearchBarMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo+    ResolveSearchBarMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo+    ResolveSearchBarMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo+    ResolveSearchBarMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo+    ResolveSearchBarMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo+    ResolveSearchBarMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo+    ResolveSearchBarMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo+    ResolveSearchBarMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo+    ResolveSearchBarMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo+    ResolveSearchBarMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo+    ResolveSearchBarMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo+    ResolveSearchBarMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo+    ResolveSearchBarMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo+    ResolveSearchBarMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo+    ResolveSearchBarMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo+    ResolveSearchBarMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo+    ResolveSearchBarMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo+    ResolveSearchBarMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo+    ResolveSearchBarMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo+    ResolveSearchBarMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo+    ResolveSearchBarMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo+    ResolveSearchBarMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo+    ResolveSearchBarMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo+    ResolveSearchBarMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo+    ResolveSearchBarMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo+    ResolveSearchBarMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo+    ResolveSearchBarMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo+    ResolveSearchBarMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo+    ResolveSearchBarMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo+    ResolveSearchBarMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo+    ResolveSearchBarMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo+    ResolveSearchBarMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo+    ResolveSearchBarMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo+    ResolveSearchBarMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo+    ResolveSearchBarMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo+    ResolveSearchBarMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo+    ResolveSearchBarMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveSearchBarMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveSearchBarMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo+    ResolveSearchBarMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo+    ResolveSearchBarMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo+    ResolveSearchBarMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo+    ResolveSearchBarMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo+    ResolveSearchBarMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo+    ResolveSearchBarMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo+    ResolveSearchBarMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo+    ResolveSearchBarMethod "getSearchMode" o = SearchBarGetSearchModeMethodInfo+    ResolveSearchBarMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo+    ResolveSearchBarMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo+    ResolveSearchBarMethod "getShowCloseButton" o = SearchBarGetShowCloseButtonMethodInfo+    ResolveSearchBarMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo+    ResolveSearchBarMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo+    ResolveSearchBarMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo+    ResolveSearchBarMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo+    ResolveSearchBarMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo+    ResolveSearchBarMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo+    ResolveSearchBarMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo+    ResolveSearchBarMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo+    ResolveSearchBarMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo+    ResolveSearchBarMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo+    ResolveSearchBarMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo+    ResolveSearchBarMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo+    ResolveSearchBarMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo+    ResolveSearchBarMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo+    ResolveSearchBarMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo+    ResolveSearchBarMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo+    ResolveSearchBarMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo+    ResolveSearchBarMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo+    ResolveSearchBarMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo+    ResolveSearchBarMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo+    ResolveSearchBarMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo+    ResolveSearchBarMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo+    ResolveSearchBarMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo+    ResolveSearchBarMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo+    ResolveSearchBarMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo+    ResolveSearchBarMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo+    ResolveSearchBarMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo+    ResolveSearchBarMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo+    ResolveSearchBarMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveSearchBarMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo+    ResolveSearchBarMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo+    ResolveSearchBarMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo+    ResolveSearchBarMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo+    ResolveSearchBarMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo+    ResolveSearchBarMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo+    ResolveSearchBarMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo+    ResolveSearchBarMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo+    ResolveSearchBarMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo+    ResolveSearchBarMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo+    ResolveSearchBarMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo+    ResolveSearchBarMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo+    ResolveSearchBarMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo+    ResolveSearchBarMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo+    ResolveSearchBarMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo+    ResolveSearchBarMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo+    ResolveSearchBarMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo+    ResolveSearchBarMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo+    ResolveSearchBarMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo+    ResolveSearchBarMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo+    ResolveSearchBarMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo+    ResolveSearchBarMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo+    ResolveSearchBarMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo+    ResolveSearchBarMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo+    ResolveSearchBarMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo+    ResolveSearchBarMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo+    ResolveSearchBarMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo+    ResolveSearchBarMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo+    ResolveSearchBarMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo+    ResolveSearchBarMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveSearchBarMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo+    ResolveSearchBarMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo+    ResolveSearchBarMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo+    ResolveSearchBarMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo+    ResolveSearchBarMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo+    ResolveSearchBarMethod "setSearchMode" o = SearchBarSetSearchModeMethodInfo+    ResolveSearchBarMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo+    ResolveSearchBarMethod "setShowCloseButton" o = SearchBarSetShowCloseButtonMethodInfo+    ResolveSearchBarMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo+    ResolveSearchBarMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo+    ResolveSearchBarMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo+    ResolveSearchBarMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo+    ResolveSearchBarMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo+    ResolveSearchBarMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo+    ResolveSearchBarMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo+    ResolveSearchBarMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo+    ResolveSearchBarMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo+    ResolveSearchBarMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo+    ResolveSearchBarMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo+    ResolveSearchBarMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo+    ResolveSearchBarMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo+    ResolveSearchBarMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo+    ResolveSearchBarMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveSearchBarMethod t SearchBar, O.MethodInfo info SearchBar p) => OL.IsLabel t (SearchBar -> 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 "search-mode-enabled"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@search-mode-enabled@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' searchBar #searchModeEnabled+@+-}+getSearchBarSearchModeEnabled :: (MonadIO m, IsSearchBar o) => o -> m Bool+getSearchBarSearchModeEnabled obj = liftIO $ B.Properties.getObjectPropertyBool obj "search-mode-enabled"++{- |+Set the value of the “@search-mode-enabled@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' searchBar [ #searchModeEnabled 'Data.GI.Base.Attributes.:=' value ]+@+-}+setSearchBarSearchModeEnabled :: (MonadIO m, IsSearchBar o) => o -> Bool -> m ()+setSearchBarSearchModeEnabled obj val = liftIO $ B.Properties.setObjectPropertyBool obj "search-mode-enabled" val++{- |+Construct a `GValueConstruct` with valid value for the “@search-mode-enabled@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructSearchBarSearchModeEnabled :: (IsSearchBar o) => Bool -> IO (GValueConstruct o)+constructSearchBarSearchModeEnabled val = B.Properties.constructObjectPropertyBool "search-mode-enabled" val++#if ENABLE_OVERLOADING+data SearchBarSearchModeEnabledPropertyInfo+instance AttrInfo SearchBarSearchModeEnabledPropertyInfo where+    type AttrAllowedOps SearchBarSearchModeEnabledPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SearchBarSearchModeEnabledPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint SearchBarSearchModeEnabledPropertyInfo = IsSearchBar+    type AttrGetType SearchBarSearchModeEnabledPropertyInfo = Bool+    type AttrLabel SearchBarSearchModeEnabledPropertyInfo = "search-mode-enabled"+    type AttrOrigin SearchBarSearchModeEnabledPropertyInfo = SearchBar+    attrGet _ = getSearchBarSearchModeEnabled+    attrSet _ = setSearchBarSearchModeEnabled+    attrConstruct _ = constructSearchBarSearchModeEnabled+    attrClear _ = undefined+#endif++-- VVV Prop "show-close-button"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@show-close-button@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' searchBar #showCloseButton+@+-}+getSearchBarShowCloseButton :: (MonadIO m, IsSearchBar o) => o -> m Bool+getSearchBarShowCloseButton obj = liftIO $ B.Properties.getObjectPropertyBool obj "show-close-button"++{- |+Set the value of the “@show-close-button@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' searchBar [ #showCloseButton 'Data.GI.Base.Attributes.:=' value ]+@+-}+setSearchBarShowCloseButton :: (MonadIO m, IsSearchBar o) => o -> Bool -> m ()+setSearchBarShowCloseButton obj val = liftIO $ B.Properties.setObjectPropertyBool obj "show-close-button" val++{- |+Construct a `GValueConstruct` with valid value for the “@show-close-button@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructSearchBarShowCloseButton :: (IsSearchBar o) => Bool -> IO (GValueConstruct o)+constructSearchBarShowCloseButton val = B.Properties.constructObjectPropertyBool "show-close-button" val++#if ENABLE_OVERLOADING+data SearchBarShowCloseButtonPropertyInfo+instance AttrInfo SearchBarShowCloseButtonPropertyInfo where+    type AttrAllowedOps SearchBarShowCloseButtonPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SearchBarShowCloseButtonPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint SearchBarShowCloseButtonPropertyInfo = IsSearchBar+    type AttrGetType SearchBarShowCloseButtonPropertyInfo = Bool+    type AttrLabel SearchBarShowCloseButtonPropertyInfo = "show-close-button"+    type AttrOrigin SearchBarShowCloseButtonPropertyInfo = SearchBar+    attrGet _ = getSearchBarShowCloseButton+    attrSet _ = setSearchBarShowCloseButton+    attrConstruct _ = constructSearchBarShowCloseButton+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList SearchBar+type instance O.AttributeList SearchBar = SearchBarAttributeList+type SearchBarAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("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), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("searchModeEnabled", SearchBarSearchModeEnabledPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("showCloseButton", SearchBarShowCloseButtonPropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("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+searchBarSearchModeEnabled :: AttrLabelProxy "searchModeEnabled"+searchBarSearchModeEnabled = AttrLabelProxy++searchBarShowCloseButton :: AttrLabelProxy "showCloseButton"+searchBarShowCloseButton = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList SearchBar = SearchBarSignalList+type SearchBarSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("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), '("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), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("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), '("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 SearchBar::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "SearchBar"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_search_bar_new" hdy_search_bar_new :: +    IO (Ptr SearchBar)++{- |+Creates a 'GI.Handy.Objects.SearchBar.SearchBar'. You will need to tell it about+which widget is going to be your text entry using+'GI.Handy.Objects.SearchBar.searchBarConnectEntry'.++/Since: 0.0.6/+-}+searchBarNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m SearchBar+    {- ^ __Returns:__ a new 'GI.Handy.Objects.SearchBar.SearchBar' -}+searchBarNew  = liftIO $ do+    result <- hdy_search_bar_new+    checkUnexpectedReturnNULL "searchBarNew" result+    result' <- (newObject SearchBar) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method SearchBar::connect_entry+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "SearchBar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdySearchBar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "entry", argType = TInterface (Name {namespace = "Gtk", name = "Entry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEntry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_search_bar_connect_entry" hdy_search_bar_connect_entry :: +    Ptr SearchBar ->                        -- self : TInterface (Name {namespace = "Handy", name = "SearchBar"})+    Ptr Gtk.Entry.Entry ->                  -- entry : TInterface (Name {namespace = "Gtk", name = "Entry"})+    IO ()++{- |+Connects the 'GI.Gtk.Objects.Entry.Entry' widget passed as the one to be used in+this search bar. The entry should be a descendant of the search bar.+This is only required if the entry isn’t the direct child of the+search bar (as in our main example).++/Since: 0.0.6/+-}+searchBarConnectEntry ::+    (B.CallStack.HasCallStack, MonadIO m, IsSearchBar a, Gtk.Entry.IsEntry b) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.SearchBar.SearchBar' -}+    -> b+    {- ^ /@entry@/: a 'GI.Gtk.Objects.Entry.Entry' -}+    -> m ()+searchBarConnectEntry self entry = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    entry' <- unsafeManagedPtrCastPtr entry+    hdy_search_bar_connect_entry self' entry'+    touchManagedPtr self+    touchManagedPtr entry+    return ()++#if ENABLE_OVERLOADING+data SearchBarConnectEntryMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, IsSearchBar a, Gtk.Entry.IsEntry b) => O.MethodInfo SearchBarConnectEntryMethodInfo a signature where+    overloadedMethod _ = searchBarConnectEntry++#endif++-- method SearchBar::get_search_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "SearchBar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdySearchBar", 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 "hdy_search_bar_get_search_mode" hdy_search_bar_get_search_mode :: +    Ptr SearchBar ->                        -- self : TInterface (Name {namespace = "Handy", name = "SearchBar"})+    IO CInt++{- |+Returns whether the search mode is on or off.++/Since: 0.0.6/+-}+searchBarGetSearchMode ::+    (B.CallStack.HasCallStack, MonadIO m, IsSearchBar a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.SearchBar.SearchBar' -}+    -> m Bool+    {- ^ __Returns:__ whether search mode is toggled on -}+searchBarGetSearchMode self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_search_bar_get_search_mode self'+    let result' = (/= 0) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data SearchBarGetSearchModeMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsSearchBar a) => O.MethodInfo SearchBarGetSearchModeMethodInfo a signature where+    overloadedMethod _ = searchBarGetSearchMode++#endif++-- method SearchBar::get_show_close_button+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "SearchBar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdySearchBar", 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 "hdy_search_bar_get_show_close_button" hdy_search_bar_get_show_close_button :: +    Ptr SearchBar ->                        -- self : TInterface (Name {namespace = "Handy", name = "SearchBar"})+    IO CInt++{- |+Returns whether the close button is shown.++/Since: 0.0.6/+-}+searchBarGetShowCloseButton ::+    (B.CallStack.HasCallStack, MonadIO m, IsSearchBar a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.SearchBar.SearchBar' -}+    -> m Bool+    {- ^ __Returns:__ whether the close button is shown -}+searchBarGetShowCloseButton self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_search_bar_get_show_close_button self'+    let result' = (/= 0) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data SearchBarGetShowCloseButtonMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsSearchBar a) => O.MethodInfo SearchBarGetShowCloseButtonMethodInfo a signature where+    overloadedMethod _ = searchBarGetShowCloseButton++#endif++-- method SearchBar::handle_event+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "SearchBar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdySearchBar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gdk", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkEvent containing key press events", 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 "hdy_search_bar_handle_event" hdy_search_bar_handle_event :: +    Ptr SearchBar ->                        -- self : TInterface (Name {namespace = "Handy", name = "SearchBar"})+    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})+    IO CInt++{- |+This function should be called when the top-level+window which contains the search bar received a key event.++If the key event is handled by the search bar, the bar will+be shown, the entry populated with the entered text and 'GI.Gdk.Constants.EVENT_STOP'+will be returned. The caller should ensure that events are+not propagated further.++If no entry has been connected to the search bar, using+'GI.Handy.Objects.SearchBar.searchBarConnectEntry', this function will return+immediately with a warning.++== Showing the search bar on key presses+++=== /C code/+>+>static gboolean+>on_key_press_event (GtkWidget *widget,+>                    GdkEvent  *event,+>                    gpointer   user_data)+>{+>  HdySearchBar *bar = HDY_SEARCH_BAR (user_data);+>  return hdy_search_bar_handle_event (self, event);+>}+>+>static void+>create_toplevel (void)+>{+>  GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);+>  GtkWindow *search_bar = hdy_search_bar_new ();+>+> // Add more widgets to the window...+>+>  g_signal_connect (window,+>                   "key-press-event",+>                    G_CALLBACK (on_key_press_event),+>                    search_bar);+>}+++/Since: 0.0.6/+-}+searchBarHandleEvent ::+    (B.CallStack.HasCallStack, MonadIO m, IsSearchBar a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.SearchBar.SearchBar' -}+    -> Gdk.Event.Event+    {- ^ /@event@/: a 'GI.Gdk.Unions.Event.Event' containing key press events -}+    -> m Bool+    {- ^ __Returns:__ 'GI.Gdk.Constants.EVENT_STOP' if the key press event resulted+    in text being entered in the search entry (and revealing+    the search bar if necessary), 'GI.Gdk.Constants.EVENT_PROPAGATE' otherwise. -}+searchBarHandleEvent self event = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    event' <- unsafeManagedPtrGetPtr event+    result <- hdy_search_bar_handle_event self' event'+    let result' = (/= 0) result+    touchManagedPtr self+    touchManagedPtr event+    return result'++#if ENABLE_OVERLOADING+data SearchBarHandleEventMethodInfo+instance (signature ~ (Gdk.Event.Event -> m Bool), MonadIO m, IsSearchBar a) => O.MethodInfo SearchBarHandleEventMethodInfo a signature where+    overloadedMethod _ = searchBarHandleEvent++#endif++-- method SearchBar::set_search_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "SearchBar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdySearchBar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "search_mode", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new state of the search mode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_search_bar_set_search_mode" hdy_search_bar_set_search_mode :: +    Ptr SearchBar ->                        -- self : TInterface (Name {namespace = "Handy", name = "SearchBar"})+    CInt ->                                 -- search_mode : TBasicType TBoolean+    IO ()++{- |+Switches the search mode on or off.++/Since: 0.0.6/+-}+searchBarSetSearchMode ::+    (B.CallStack.HasCallStack, MonadIO m, IsSearchBar a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.SearchBar.SearchBar' -}+    -> Bool+    {- ^ /@searchMode@/: the new state of the search mode -}+    -> m ()+searchBarSetSearchMode self searchMode = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    let searchMode' = (fromIntegral . fromEnum) searchMode+    hdy_search_bar_set_search_mode self' searchMode'+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data SearchBarSetSearchModeMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsSearchBar a) => O.MethodInfo SearchBarSetSearchModeMethodInfo a signature where+    overloadedMethod _ = searchBarSetSearchMode++#endif++-- method SearchBar::set_show_close_button+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "SearchBar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdySearchBar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "visible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the close button will be shown or not", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_search_bar_set_show_close_button" hdy_search_bar_set_show_close_button :: +    Ptr SearchBar ->                        -- self : TInterface (Name {namespace = "Handy", name = "SearchBar"})+    CInt ->                                 -- visible : TBasicType TBoolean+    IO ()++{- |+Shows or hides the close button. Applications that+already have a “search” toggle button should not show a close+button in their search bar, as it duplicates the role of the+toggle button.++/Since: 0.0.6/+-}+searchBarSetShowCloseButton ::+    (B.CallStack.HasCallStack, MonadIO m, IsSearchBar a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.SearchBar.SearchBar' -}+    -> Bool+    {- ^ /@visible@/: whether the close button will be shown or not -}+    -> m ()+searchBarSetShowCloseButton self visible = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    let visible' = (fromIntegral . fromEnum) visible+    hdy_search_bar_set_show_close_button self' visible'+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data SearchBarSetShowCloseButtonMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsSearchBar a) => O.MethodInfo SearchBarSetShowCloseButtonMethodInfo a signature where+    overloadedMethod _ = searchBarSetShowCloseButton++#endif++
+ GI/Handy/Objects/SearchBar.hs-boot view
@@ -0,0 +1,53 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Handy.Objects.SearchBar 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 SearchBar = SearchBar (ManagedPtr SearchBar)+instance GObject SearchBar where+class (GObject o, O.IsDescendantOf SearchBar o) => IsSearchBar o+instance (GObject o, O.IsDescendantOf SearchBar o) => IsSearchBar o+instance O.HasParentTypes SearchBar+#if ENABLE_OVERLOADING+data SearchBarSearchModeEnabledPropertyInfo+#endif+#if ENABLE_OVERLOADING+data SearchBarShowCloseButtonPropertyInfo+#endif+#if ENABLE_OVERLOADING+data SearchBarConnectEntryMethodInfo+#endif+#if ENABLE_OVERLOADING+data SearchBarGetSearchModeMethodInfo+#endif+#if ENABLE_OVERLOADING+data SearchBarGetShowCloseButtonMethodInfo+#endif+#if ENABLE_OVERLOADING+data SearchBarHandleEventMethodInfo+#endif+#if ENABLE_OVERLOADING+data SearchBarSetSearchModeMethodInfo+#endif+#if ENABLE_OVERLOADING+data SearchBarSetShowCloseButtonMethodInfo+#endif
+ GI/Handy/Objects/TitleBar.hs view
@@ -0,0 +1,616 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Handy.Objects.TitleBar+    ( ++-- * Exported types+    TitleBar(..)                            ,+    IsTitleBar                              ,+    toTitleBar                              ,+    noTitleBar                              ,+++ -- * Methods+-- ** getSelectionMode #method:getSelectionMode#++#if ENABLE_OVERLOADING+    TitleBarGetSelectionModeMethodInfo      ,+#endif+    titleBarGetSelectionMode                ,+++-- ** new #method:new#++    titleBarNew                             ,+++-- ** setSelectionMode #method:setSelectionMode#++#if ENABLE_OVERLOADING+    TitleBarSetSelectionModeMethodInfo      ,+#endif+    titleBarSetSelectionMode                ,+++++ -- * Properties+-- ** selectionMode #attr:selectionMode#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    TitleBarSelectionModePropertyInfo       ,+#endif+    constructTitleBarSelectionMode          ,+    getTitleBarSelectionMode                ,+    setTitleBarSelectionMode                ,+#if ENABLE_OVERLOADING+    titleBarSelectionMode                   ,+#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 qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable+import qualified GI.Gtk.Objects.Bin as Gtk.Bin+import qualified GI.Gtk.Objects.Container as Gtk.Container+import qualified GI.Gtk.Objects.Widget as Gtk.Widget++-- | Memory-managed wrapper type.+newtype TitleBar = TitleBar (ManagedPtr TitleBar)+foreign import ccall "hdy_title_bar_get_type"+    c_hdy_title_bar_get_type :: IO GType++instance GObject TitleBar where+    gobjectType = c_hdy_title_bar_get_type+    ++-- | Type class for types which can be safely cast to `TitleBar`, for instance with `toTitleBar`.+class (GObject o, O.IsDescendantOf TitleBar o) => IsTitleBar o+instance (GObject o, O.IsDescendantOf TitleBar o) => IsTitleBar o++instance O.HasParentTypes TitleBar+type instance O.ParentTypes TitleBar = '[Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable]++-- | Cast to `TitleBar`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toTitleBar :: (MonadIO m, IsTitleBar o) => o -> m TitleBar+toTitleBar = liftIO . unsafeCastTo TitleBar++-- | A convenience alias for `Nothing` :: `Maybe` `TitleBar`.+noTitleBar :: Maybe TitleBar+noTitleBar = Nothing++#if ENABLE_OVERLOADING+type family ResolveTitleBarMethod (t :: Symbol) (o :: *) :: * where+    ResolveTitleBarMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo+    ResolveTitleBarMethod "add" o = Gtk.Container.ContainerAddMethodInfo+    ResolveTitleBarMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo+    ResolveTitleBarMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo+    ResolveTitleBarMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo+    ResolveTitleBarMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo+    ResolveTitleBarMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo+    ResolveTitleBarMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo+    ResolveTitleBarMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveTitleBarMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveTitleBarMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo+    ResolveTitleBarMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo+    ResolveTitleBarMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo+    ResolveTitleBarMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo+    ResolveTitleBarMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo+    ResolveTitleBarMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo+    ResolveTitleBarMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo+    ResolveTitleBarMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo+    ResolveTitleBarMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo+    ResolveTitleBarMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo+    ResolveTitleBarMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo+    ResolveTitleBarMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo+    ResolveTitleBarMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo+    ResolveTitleBarMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo+    ResolveTitleBarMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo+    ResolveTitleBarMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo+    ResolveTitleBarMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo+    ResolveTitleBarMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo+    ResolveTitleBarMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo+    ResolveTitleBarMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo+    ResolveTitleBarMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo+    ResolveTitleBarMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo+    ResolveTitleBarMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo+    ResolveTitleBarMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo+    ResolveTitleBarMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo+    ResolveTitleBarMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo+    ResolveTitleBarMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo+    ResolveTitleBarMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo+    ResolveTitleBarMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo+    ResolveTitleBarMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo+    ResolveTitleBarMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo+    ResolveTitleBarMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo+    ResolveTitleBarMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo+    ResolveTitleBarMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo+    ResolveTitleBarMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo+    ResolveTitleBarMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo+    ResolveTitleBarMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo+    ResolveTitleBarMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo+    ResolveTitleBarMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo+    ResolveTitleBarMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo+    ResolveTitleBarMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo+    ResolveTitleBarMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo+    ResolveTitleBarMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo+    ResolveTitleBarMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo+    ResolveTitleBarMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo+    ResolveTitleBarMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo+    ResolveTitleBarMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo+    ResolveTitleBarMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo+    ResolveTitleBarMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo+    ResolveTitleBarMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo+    ResolveTitleBarMethod "event" o = Gtk.Widget.WidgetEventMethodInfo+    ResolveTitleBarMethod "forall" o = Gtk.Container.ContainerForallMethodInfo+    ResolveTitleBarMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveTitleBarMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo+    ResolveTitleBarMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo+    ResolveTitleBarMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveTitleBarMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveTitleBarMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo+    ResolveTitleBarMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo+    ResolveTitleBarMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo+    ResolveTitleBarMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo+    ResolveTitleBarMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo+    ResolveTitleBarMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo+    ResolveTitleBarMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo+    ResolveTitleBarMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo+    ResolveTitleBarMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo+    ResolveTitleBarMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo+    ResolveTitleBarMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo+    ResolveTitleBarMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo+    ResolveTitleBarMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo+    ResolveTitleBarMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo+    ResolveTitleBarMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo+    ResolveTitleBarMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo+    ResolveTitleBarMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo+    ResolveTitleBarMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo+    ResolveTitleBarMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo+    ResolveTitleBarMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo+    ResolveTitleBarMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveTitleBarMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo+    ResolveTitleBarMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo+    ResolveTitleBarMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo+    ResolveTitleBarMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo+    ResolveTitleBarMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo+    ResolveTitleBarMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo+    ResolveTitleBarMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo+    ResolveTitleBarMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo+    ResolveTitleBarMethod "map" o = Gtk.Widget.WidgetMapMethodInfo+    ResolveTitleBarMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo+    ResolveTitleBarMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo+    ResolveTitleBarMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo+    ResolveTitleBarMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo+    ResolveTitleBarMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo+    ResolveTitleBarMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo+    ResolveTitleBarMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo+    ResolveTitleBarMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo+    ResolveTitleBarMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveTitleBarMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveTitleBarMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo+    ResolveTitleBarMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo+    ResolveTitleBarMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo+    ResolveTitleBarMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo+    ResolveTitleBarMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo+    ResolveTitleBarMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo+    ResolveTitleBarMethod "path" o = Gtk.Widget.WidgetPathMethodInfo+    ResolveTitleBarMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo+    ResolveTitleBarMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo+    ResolveTitleBarMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo+    ResolveTitleBarMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo+    ResolveTitleBarMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo+    ResolveTitleBarMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo+    ResolveTitleBarMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo+    ResolveTitleBarMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo+    ResolveTitleBarMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo+    ResolveTitleBarMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveTitleBarMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveTitleBarMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo+    ResolveTitleBarMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo+    ResolveTitleBarMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo+    ResolveTitleBarMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo+    ResolveTitleBarMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo+    ResolveTitleBarMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo+    ResolveTitleBarMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo+    ResolveTitleBarMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo+    ResolveTitleBarMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo+    ResolveTitleBarMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo+    ResolveTitleBarMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo+    ResolveTitleBarMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo+    ResolveTitleBarMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveTitleBarMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo+    ResolveTitleBarMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo+    ResolveTitleBarMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo+    ResolveTitleBarMethod "show" o = Gtk.Widget.WidgetShowMethodInfo+    ResolveTitleBarMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo+    ResolveTitleBarMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo+    ResolveTitleBarMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo+    ResolveTitleBarMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo+    ResolveTitleBarMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo+    ResolveTitleBarMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveTitleBarMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveTitleBarMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo+    ResolveTitleBarMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo+    ResolveTitleBarMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo+    ResolveTitleBarMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveTitleBarMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo+    ResolveTitleBarMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo+    ResolveTitleBarMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo+    ResolveTitleBarMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo+    ResolveTitleBarMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo+    ResolveTitleBarMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveTitleBarMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo+    ResolveTitleBarMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo+    ResolveTitleBarMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo+    ResolveTitleBarMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveTitleBarMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo+    ResolveTitleBarMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo+    ResolveTitleBarMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo+    ResolveTitleBarMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo+    ResolveTitleBarMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo+    ResolveTitleBarMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo+    ResolveTitleBarMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo+    ResolveTitleBarMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo+    ResolveTitleBarMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo+    ResolveTitleBarMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo+    ResolveTitleBarMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo+    ResolveTitleBarMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo+    ResolveTitleBarMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo+    ResolveTitleBarMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo+    ResolveTitleBarMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo+    ResolveTitleBarMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo+    ResolveTitleBarMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo+    ResolveTitleBarMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo+    ResolveTitleBarMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo+    ResolveTitleBarMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveTitleBarMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo+    ResolveTitleBarMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo+    ResolveTitleBarMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo+    ResolveTitleBarMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo+    ResolveTitleBarMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo+    ResolveTitleBarMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo+    ResolveTitleBarMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo+    ResolveTitleBarMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo+    ResolveTitleBarMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo+    ResolveTitleBarMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo+    ResolveTitleBarMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo+    ResolveTitleBarMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo+    ResolveTitleBarMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo+    ResolveTitleBarMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo+    ResolveTitleBarMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo+    ResolveTitleBarMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo+    ResolveTitleBarMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo+    ResolveTitleBarMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo+    ResolveTitleBarMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo+    ResolveTitleBarMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo+    ResolveTitleBarMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo+    ResolveTitleBarMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo+    ResolveTitleBarMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo+    ResolveTitleBarMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo+    ResolveTitleBarMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo+    ResolveTitleBarMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo+    ResolveTitleBarMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo+    ResolveTitleBarMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo+    ResolveTitleBarMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo+    ResolveTitleBarMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo+    ResolveTitleBarMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo+    ResolveTitleBarMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo+    ResolveTitleBarMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo+    ResolveTitleBarMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo+    ResolveTitleBarMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo+    ResolveTitleBarMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo+    ResolveTitleBarMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo+    ResolveTitleBarMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo+    ResolveTitleBarMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo+    ResolveTitleBarMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo+    ResolveTitleBarMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo+    ResolveTitleBarMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo+    ResolveTitleBarMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo+    ResolveTitleBarMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo+    ResolveTitleBarMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveTitleBarMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveTitleBarMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo+    ResolveTitleBarMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo+    ResolveTitleBarMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo+    ResolveTitleBarMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo+    ResolveTitleBarMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo+    ResolveTitleBarMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo+    ResolveTitleBarMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo+    ResolveTitleBarMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo+    ResolveTitleBarMethod "getSelectionMode" o = TitleBarGetSelectionModeMethodInfo+    ResolveTitleBarMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo+    ResolveTitleBarMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo+    ResolveTitleBarMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo+    ResolveTitleBarMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo+    ResolveTitleBarMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo+    ResolveTitleBarMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo+    ResolveTitleBarMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo+    ResolveTitleBarMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo+    ResolveTitleBarMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo+    ResolveTitleBarMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo+    ResolveTitleBarMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo+    ResolveTitleBarMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo+    ResolveTitleBarMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo+    ResolveTitleBarMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo+    ResolveTitleBarMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo+    ResolveTitleBarMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo+    ResolveTitleBarMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo+    ResolveTitleBarMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo+    ResolveTitleBarMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo+    ResolveTitleBarMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo+    ResolveTitleBarMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo+    ResolveTitleBarMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo+    ResolveTitleBarMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo+    ResolveTitleBarMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo+    ResolveTitleBarMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo+    ResolveTitleBarMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo+    ResolveTitleBarMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo+    ResolveTitleBarMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo+    ResolveTitleBarMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo+    ResolveTitleBarMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo+    ResolveTitleBarMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveTitleBarMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo+    ResolveTitleBarMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo+    ResolveTitleBarMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo+    ResolveTitleBarMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo+    ResolveTitleBarMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo+    ResolveTitleBarMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo+    ResolveTitleBarMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo+    ResolveTitleBarMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo+    ResolveTitleBarMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo+    ResolveTitleBarMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo+    ResolveTitleBarMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo+    ResolveTitleBarMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo+    ResolveTitleBarMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo+    ResolveTitleBarMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo+    ResolveTitleBarMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo+    ResolveTitleBarMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo+    ResolveTitleBarMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo+    ResolveTitleBarMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo+    ResolveTitleBarMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo+    ResolveTitleBarMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo+    ResolveTitleBarMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo+    ResolveTitleBarMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo+    ResolveTitleBarMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo+    ResolveTitleBarMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo+    ResolveTitleBarMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo+    ResolveTitleBarMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo+    ResolveTitleBarMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo+    ResolveTitleBarMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo+    ResolveTitleBarMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo+    ResolveTitleBarMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveTitleBarMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo+    ResolveTitleBarMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo+    ResolveTitleBarMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo+    ResolveTitleBarMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo+    ResolveTitleBarMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo+    ResolveTitleBarMethod "setSelectionMode" o = TitleBarSetSelectionModeMethodInfo+    ResolveTitleBarMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo+    ResolveTitleBarMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo+    ResolveTitleBarMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo+    ResolveTitleBarMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo+    ResolveTitleBarMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo+    ResolveTitleBarMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo+    ResolveTitleBarMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo+    ResolveTitleBarMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo+    ResolveTitleBarMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo+    ResolveTitleBarMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo+    ResolveTitleBarMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo+    ResolveTitleBarMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo+    ResolveTitleBarMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo+    ResolveTitleBarMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo+    ResolveTitleBarMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo+    ResolveTitleBarMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveTitleBarMethod t TitleBar, O.MethodInfo info TitleBar p) => OL.IsLabel t (TitleBar -> 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 "selection-mode"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@selection-mode@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' titleBar #selectionMode+@+-}+getTitleBarSelectionMode :: (MonadIO m, IsTitleBar o) => o -> m Bool+getTitleBarSelectionMode obj = liftIO $ B.Properties.getObjectPropertyBool obj "selection-mode"++{- |+Set the value of the “@selection-mode@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' titleBar [ #selectionMode 'Data.GI.Base.Attributes.:=' value ]+@+-}+setTitleBarSelectionMode :: (MonadIO m, IsTitleBar o) => o -> Bool -> m ()+setTitleBarSelectionMode obj val = liftIO $ B.Properties.setObjectPropertyBool obj "selection-mode" val++{- |+Construct a `GValueConstruct` with valid value for the “@selection-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructTitleBarSelectionMode :: (IsTitleBar o) => Bool -> IO (GValueConstruct o)+constructTitleBarSelectionMode val = B.Properties.constructObjectPropertyBool "selection-mode" val++#if ENABLE_OVERLOADING+data TitleBarSelectionModePropertyInfo+instance AttrInfo TitleBarSelectionModePropertyInfo where+    type AttrAllowedOps TitleBarSelectionModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TitleBarSelectionModePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint TitleBarSelectionModePropertyInfo = IsTitleBar+    type AttrGetType TitleBarSelectionModePropertyInfo = Bool+    type AttrLabel TitleBarSelectionModePropertyInfo = "selection-mode"+    type AttrOrigin TitleBarSelectionModePropertyInfo = TitleBar+    attrGet _ = getTitleBarSelectionMode+    attrSet _ = setTitleBarSelectionMode+    attrConstruct _ = constructTitleBarSelectionMode+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList TitleBar+type instance O.AttributeList TitleBar = TitleBarAttributeList+type TitleBarAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("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), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("selectionMode", TitleBarSelectionModePropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("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+titleBarSelectionMode :: AttrLabelProxy "selectionMode"+titleBarSelectionMode = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList TitleBar = TitleBarSignalList+type TitleBarSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("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), '("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), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("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), '("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 TitleBar::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "TitleBar"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_title_bar_new" hdy_title_bar_new :: +    IO (Ptr TitleBar)++{- |+Creates a new 'GI.Handy.Objects.TitleBar.TitleBar'.+-}+titleBarNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m TitleBar+    {- ^ __Returns:__ a new 'GI.Handy.Objects.TitleBar.TitleBar' -}+titleBarNew  = liftIO $ do+    result <- hdy_title_bar_new+    checkUnexpectedReturnNULL "titleBarNew" result+    result' <- (newObject TitleBar) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method TitleBar::get_selection_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "TitleBar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyTitleBar", 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 "hdy_title_bar_get_selection_mode" hdy_title_bar_get_selection_mode :: +    Ptr TitleBar ->                         -- self : TInterface (Name {namespace = "Handy", name = "TitleBar"})+    IO CInt++{- |+Returns wether whether /@self@/ is in selection mode.+-}+titleBarGetSelectionMode ::+    (B.CallStack.HasCallStack, MonadIO m, IsTitleBar a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.TitleBar.TitleBar' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if the title bar is in selection mode -}+titleBarGetSelectionMode self = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    result <- hdy_title_bar_get_selection_mode self'+    let result' = (/= 0) result+    touchManagedPtr self+    return result'++#if ENABLE_OVERLOADING+data TitleBarGetSelectionModeMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsTitleBar a) => O.MethodInfo TitleBarGetSelectionModeMethodInfo a signature where+    overloadedMethod _ = titleBarGetSelectionMode++#endif++-- method TitleBar::set_selection_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Handy", name = "TitleBar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #HdyTitleBar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "selection_mode", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to enable the selection mode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_title_bar_set_selection_mode" hdy_title_bar_set_selection_mode :: +    Ptr TitleBar ->                         -- self : TInterface (Name {namespace = "Handy", name = "TitleBar"})+    CInt ->                                 -- selection_mode : TBasicType TBoolean+    IO ()++{- |+Sets whether /@self@/ is in selection mode.+-}+titleBarSetSelectionMode ::+    (B.CallStack.HasCallStack, MonadIO m, IsTitleBar a) =>+    a+    {- ^ /@self@/: a 'GI.Handy.Objects.TitleBar.TitleBar' -}+    -> Bool+    {- ^ /@selectionMode@/: 'True' to enable the selection mode -}+    -> m ()+titleBarSetSelectionMode self selectionMode = liftIO $ do+    self' <- unsafeManagedPtrCastPtr self+    let selectionMode' = (fromIntegral . fromEnum) selectionMode+    hdy_title_bar_set_selection_mode self' selectionMode'+    touchManagedPtr self+    return ()++#if ENABLE_OVERLOADING+data TitleBarSetSelectionModeMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsTitleBar a) => O.MethodInfo TitleBarSetSelectionModeMethodInfo a signature where+    overloadedMethod _ = titleBarSetSelectionMode++#endif++
+ GI/Handy/Objects/TitleBar.hs-boot view
@@ -0,0 +1,38 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Handy.Objects.TitleBar 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 TitleBar = TitleBar (ManagedPtr TitleBar)+instance GObject TitleBar where+class (GObject o, O.IsDescendantOf TitleBar o) => IsTitleBar o+instance (GObject o, O.IsDescendantOf TitleBar o) => IsTitleBar o+instance O.HasParentTypes TitleBar+#if ENABLE_OVERLOADING+data TitleBarSelectionModePropertyInfo+#endif+#if ENABLE_OVERLOADING+data TitleBarGetSelectionModeMethodInfo+#endif+#if ENABLE_OVERLOADING+data TitleBarSetSelectionModeMethodInfo+#endif
+ GI/Handy/Objects/ValueObject.hs view
@@ -0,0 +1,411 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Handy.Objects.ValueObject+    ( ++-- * Exported types+    ValueObject(..)                         ,+    IsValueObject                           ,+    toValueObject                           ,+    noValueObject                           ,+++ -- * Methods+-- ** copyValue #method:copyValue#++#if ENABLE_OVERLOADING+    ValueObjectCopyValueMethodInfo          ,+#endif+    valueObjectCopyValue                    ,+++-- ** dupString #method:dupString#++#if ENABLE_OVERLOADING+    ValueObjectDupStringMethodInfo          ,+#endif+    valueObjectDupString                    ,+++-- ** getString #method:getString#++#if ENABLE_OVERLOADING+    ValueObjectGetStringMethodInfo          ,+#endif+    valueObjectGetString                    ,+++-- ** getValue #method:getValue#++#if ENABLE_OVERLOADING+    ValueObjectGetValueMethodInfo           ,+#endif+    valueObjectGetValue                     ,+++-- ** new #method:new#++    valueObjectNew                          ,+++++ -- * Properties+-- ** value #attr:value#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    ValueObjectValuePropertyInfo            ,+#endif+    constructValueObjectValue               ,+    getValueObjectValue                     ,+#if ENABLE_OVERLOADING+    valueObjectValue                        ,+#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.GObject.Objects.Object as GObject.Object++-- | Memory-managed wrapper type.+newtype ValueObject = ValueObject (ManagedPtr ValueObject)+foreign import ccall "hdy_value_object_get_type"+    c_hdy_value_object_get_type :: IO GType++instance GObject ValueObject where+    gobjectType = c_hdy_value_object_get_type+    ++-- | Type class for types which can be safely cast to `ValueObject`, for instance with `toValueObject`.+class (GObject o, O.IsDescendantOf ValueObject o) => IsValueObject o+instance (GObject o, O.IsDescendantOf ValueObject o) => IsValueObject o++instance O.HasParentTypes ValueObject+type instance O.ParentTypes ValueObject = '[GObject.Object.Object]++-- | Cast to `ValueObject`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toValueObject :: (MonadIO m, IsValueObject o) => o -> m ValueObject+toValueObject = liftIO . unsafeCastTo ValueObject++-- | A convenience alias for `Nothing` :: `Maybe` `ValueObject`.+noValueObject :: Maybe ValueObject+noValueObject = Nothing++#if ENABLE_OVERLOADING+type family ResolveValueObjectMethod (t :: Symbol) (o :: *) :: * where+    ResolveValueObjectMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveValueObjectMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveValueObjectMethod "copyValue" o = ValueObjectCopyValueMethodInfo+    ResolveValueObjectMethod "dupString" o = ValueObjectDupStringMethodInfo+    ResolveValueObjectMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveValueObjectMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveValueObjectMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveValueObjectMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveValueObjectMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveValueObjectMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveValueObjectMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveValueObjectMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveValueObjectMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveValueObjectMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveValueObjectMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveValueObjectMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveValueObjectMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveValueObjectMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveValueObjectMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveValueObjectMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveValueObjectMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveValueObjectMethod "getString" o = ValueObjectGetStringMethodInfo+    ResolveValueObjectMethod "getValue" o = ValueObjectGetValueMethodInfo+    ResolveValueObjectMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveValueObjectMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveValueObjectMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveValueObjectMethod t ValueObject, O.MethodInfo info ValueObject p) => OL.IsLabel t (ValueObject -> 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 "value"+   -- Type: TInterface (Name {namespace = "GObject", name = "Value"})+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Just False,Nothing)++{- |+Get the value of the “@value@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' valueObject #value+@+-}+getValueObjectValue :: (MonadIO m, IsValueObject o) => o -> m GValue+getValueObjectValue obj = liftIO $ checkUnexpectedNothing "getValueObjectValue" $ B.Properties.getObjectPropertyBoxed obj "value" GValue++{- |+Construct a `GValueConstruct` with valid value for the “@value@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructValueObjectValue :: (IsValueObject o) => GValue -> IO (GValueConstruct o)+constructValueObjectValue val = B.Properties.constructObjectPropertyBoxed "value" (Just val)++#if ENABLE_OVERLOADING+data ValueObjectValuePropertyInfo+instance AttrInfo ValueObjectValuePropertyInfo where+    type AttrAllowedOps ValueObjectValuePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint ValueObjectValuePropertyInfo = (~) GValue+    type AttrBaseTypeConstraint ValueObjectValuePropertyInfo = IsValueObject+    type AttrGetType ValueObjectValuePropertyInfo = GValue+    type AttrLabel ValueObjectValuePropertyInfo = "value"+    type AttrOrigin ValueObjectValuePropertyInfo = ValueObject+    attrGet _ = getValueObjectValue+    attrSet _ = undefined+    attrConstruct _ = constructValueObjectValue+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList ValueObject+type instance O.AttributeList ValueObject = ValueObjectAttributeList+type ValueObjectAttributeList = ('[ '("value", ValueObjectValuePropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+valueObjectValue :: AttrLabelProxy "value"+valueObjectValue = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList ValueObject = ValueObjectSignalList+type ValueObjectSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++-- method ValueObject::new+-- method type : Constructor+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GValue to store", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Handy", name = "ValueObject"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_value_object_new" hdy_value_object_new :: +    Ptr GValue ->                           -- value : TInterface (Name {namespace = "GObject", name = "Value"})+    IO (Ptr ValueObject)++{- |+Create a new 'GI.Handy.Objects.ValueObject.ValueObject'.++/Since: 0.0.8/+-}+valueObjectNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GValue+    {- ^ /@value@/: the 'GI.GObject.Structs.Value.Value' to store -}+    -> m ValueObject+    {- ^ __Returns:__ a new 'GI.Handy.Objects.ValueObject.ValueObject' -}+valueObjectNew value = liftIO $ do+    value' <- unsafeManagedPtrGetPtr value+    result <- hdy_value_object_new value'+    checkUnexpectedReturnNULL "valueObjectNew" result+    result' <- (wrapObject ValueObject) result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+#endif++-- method ValueObject::copy_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "Handy", name = "ValueObject"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #HdyValueObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GValue with correct type to copy into", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "hdy_value_object_copy_value" hdy_value_object_copy_value :: +    Ptr ValueObject ->                      -- value : TInterface (Name {namespace = "Handy", name = "ValueObject"})+    Ptr GValue ->                           -- dest : TInterface (Name {namespace = "GObject", name = "Value"})+    IO ()++{- |+Copy data from the contained 'GI.GObject.Structs.Value.Value' into /@dest@/.++/Since: 0.0.8/+-}+valueObjectCopyValue ::+    (B.CallStack.HasCallStack, MonadIO m, IsValueObject a) =>+    a+    {- ^ /@value@/: the 'GI.Handy.Objects.ValueObject.ValueObject' -}+    -> GValue+    {- ^ /@dest@/: 'GI.GObject.Structs.Value.Value' with correct type to copy into -}+    -> m ()+valueObjectCopyValue value dest = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    dest' <- unsafeManagedPtrGetPtr dest+    hdy_value_object_copy_value value' dest'+    touchManagedPtr value+    touchManagedPtr dest+    return ()++#if ENABLE_OVERLOADING+data ValueObjectCopyValueMethodInfo+instance (signature ~ (GValue -> m ()), MonadIO m, IsValueObject a) => O.MethodInfo ValueObjectCopyValueMethodInfo a signature where+    overloadedMethod _ = valueObjectCopyValue++#endif++-- method ValueObject::dup_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "Handy", name = "ValueObject"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #HdyValueObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_value_object_dup_string" hdy_value_object_dup_string :: +    Ptr ValueObject ->                      -- value : TInterface (Name {namespace = "Handy", name = "ValueObject"})+    IO CString++{- |+Returns a copy of the contained string if the value is of type+@/G_TYPE_STRING/@.++/Since: 0.0.8/+-}+valueObjectDupString ::+    (B.CallStack.HasCallStack, MonadIO m, IsValueObject a) =>+    a+    {- ^ /@value@/: the 'GI.Handy.Objects.ValueObject.ValueObject' -}+    -> m T.Text+    {- ^ __Returns:__ a copy of the contained string -}+valueObjectDupString value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- hdy_value_object_dup_string value'+    checkUnexpectedReturnNULL "valueObjectDupString" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+data ValueObjectDupStringMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsValueObject a) => O.MethodInfo ValueObjectDupStringMethodInfo a signature where+    overloadedMethod _ = valueObjectDupString++#endif++-- method ValueObject::get_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "Handy", name = "ValueObject"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #HdyValueObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "hdy_value_object_get_string" hdy_value_object_get_string :: +    Ptr ValueObject ->                      -- value : TInterface (Name {namespace = "Handy", name = "ValueObject"})+    IO CString++{- |+Returns the contained string if the value is of type @/G_TYPE_STRING/@.++/Since: 0.0.8/+-}+valueObjectGetString ::+    (B.CallStack.HasCallStack, MonadIO m, IsValueObject a) =>+    a+    {- ^ /@value@/: the 'GI.Handy.Objects.ValueObject.ValueObject' -}+    -> m T.Text+    {- ^ __Returns:__ the contained string -}+valueObjectGetString value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- hdy_value_object_get_string value'+    checkUnexpectedReturnNULL "valueObjectGetString" result+    result' <- cstringToText result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+data ValueObjectGetStringMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsValueObject a) => O.MethodInfo ValueObjectGetStringMethodInfo a signature where+    overloadedMethod _ = valueObjectGetString++#endif++-- method ValueObject::get_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "Handy", name = "ValueObject"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #HdyValueObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GObject", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "hdy_value_object_get_value" hdy_value_object_get_value :: +    Ptr ValueObject ->                      -- value : TInterface (Name {namespace = "Handy", name = "ValueObject"})+    IO (Ptr GValue)++{- |+Return the contained value.++/Since: 0.0.8/+-}+valueObjectGetValue ::+    (B.CallStack.HasCallStack, MonadIO m, IsValueObject a) =>+    a+    {- ^ /@value@/: the 'GI.Handy.Objects.ValueObject.ValueObject' -}+    -> m GValue+    {- ^ __Returns:__ the contained 'GI.GObject.Structs.Value.Value' -}+valueObjectGetValue value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- hdy_value_object_get_value value'+    checkUnexpectedReturnNULL "valueObjectGetValue" result+    result' <- (newBoxed GValue) result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+data ValueObjectGetValueMethodInfo+instance (signature ~ (m GValue), MonadIO m, IsValueObject a) => O.MethodInfo ValueObjectGetValueMethodInfo a signature where+    overloadedMethod _ = valueObjectGetValue++#endif++
+ GI/Handy/Objects/ValueObject.hs-boot view
@@ -0,0 +1,44 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Handy.Objects.ValueObject 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 ValueObject = ValueObject (ManagedPtr ValueObject)+instance GObject ValueObject where+class (GObject o, O.IsDescendantOf ValueObject o) => IsValueObject o+instance (GObject o, O.IsDescendantOf ValueObject o) => IsValueObject o+instance O.HasParentTypes ValueObject+#if ENABLE_OVERLOADING+data ValueObjectValuePropertyInfo+#endif+#if ENABLE_OVERLOADING+data ValueObjectCopyValueMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueObjectDupStringMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueObjectGetStringMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueObjectGetValueMethodInfo+#endif
+ Handy.overrides view
@@ -0,0 +1,3 @@+namespace Handy++set-attr Handy/HeaderGroup/focus nullable 1
+ LICENSE view
@@ -0,0 +1,470 @@+The gi-handy 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-handy 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-handy libraries, or to link their applications against a+user-supplied version of gi-handy. If you link applications to a modified+version of gi-handy, then the changes to gi-handy must be provided under the+terms of the LGPL.++----------------------------------------------------------------------------++                  GNU LESSER GENERAL PUBLIC LICENSE+                       Version 2.1, February 1999++ Copyright (C) 1991, 1999 Free Software Foundation, Inc.+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA+ Everyone is permitted to copy and distribute verbatim copies+ of this license document, but changing it is not allowed.++[This is the first released version of the Lesser GPL.  It also counts+ as the successor of the GNU Library Public License, version 2, hence+ the version number 2.1.]++                            Preamble++  The licenses for most software are designed to take away your+freedom to share and change it.  By contrast, the GNU General Public+Licenses are intended to guarantee your freedom to share and change+free software--to make sure the software is free for all its users.++  This license, the Lesser General Public License, applies to some+specially designated software packages--typically libraries--of the+Free Software Foundation and other authors who decide to use it.  You+can use it too, but we suggest you first think carefully about whether+this license or the ordinary General Public License is the better+strategy to use in any particular case, based on the explanations below.++  When we speak of free software, we are referring to freedom of use,+not price.  Our General Public Licenses are designed to make sure that+you have the freedom to distribute copies of free software (and charge+for this service if you wish); that you receive source code or can get+it if you want it; that you can change the software and use pieces of+it in new free programs; and that you are informed that you can do+these things.++  To protect your rights, we need to make restrictions that forbid+distributors to deny you these rights or to ask you to surrender these+rights.  These restrictions translate to certain responsibilities for+you if you distribute copies of the library or if you modify it.++  For example, if you distribute copies of the library, whether gratis+or for a fee, you must give the recipients all the rights that we gave+you.  You must make sure that they, too, receive or can get the source+code.  If you link other code with the library, you must provide+complete object files to the recipients, so that they can relink them+with the library after making changes to the library and recompiling+it.  And you must show them these terms so they know their rights.++  We protect your rights with a two-step method: (1) we copyright the+library, and (2) we offer you this license, which gives you legal+permission to copy, distribute and/or modify the library.++  To protect each distributor, we want to make it very clear that+there is no warranty for the free library.  Also, if the library is+modified by someone else and passed on, the recipients should know+that what they have is not the original version, so that the original+author's reputation will not be affected by problems that might be+introduced by others.++  Finally, software patents pose a constant threat to the existence of+any free program.  We wish to make sure that a company cannot+effectively restrict the users of a free program by obtaining a+restrictive license from a patent holder.  Therefore, we insist that+any patent license obtained for a version of the library must be+consistent with the full freedom of use specified in this license.++  Most GNU software, including some libraries, is covered by the+ordinary GNU General Public License.  This license, the GNU Lesser+General Public License, applies to certain designated libraries, and+is quite different from the ordinary General Public License.  We use+this license for certain libraries in order to permit linking those+libraries into non-free programs.++  When a program is linked with a library, whether statically or using+a shared library, the combination of the two is legally speaking a+combined work, a derivative of the original library.  The ordinary+General Public License therefore permits such linking only if the+entire combination fits its criteria of freedom.  The Lesser General+Public License permits more lax criteria for linking other code with+the library.++  We call this license the "Lesser" General Public License because it+does Less to protect the user's freedom than the ordinary General+Public License.  It also provides other free software developers Less+of an advantage over competing non-free programs.  These disadvantages+are the reason we use the ordinary General Public License for many+libraries.  However, the Lesser license provides advantages in certain+special circumstances.++  For example, on rare occasions, there may be a special need to+encourage the widest possible use of a certain library, so that it becomes+a de-facto standard.  To achieve this, non-free programs must be+allowed to use the library.  A more frequent case is that a free+library does the same job as widely used non-free libraries.  In this+case, there is little to gain by limiting the free library to free+software only, so we use the Lesser General Public License.++  In other cases, permission to use a particular library in non-free+programs enables a greater number of people to use a large body of+free software.  For example, permission to use the GNU C Library in+non-free programs enables many more people to use the whole GNU+operating system, as well as its variant, the GNU/Linux operating+system.++  Although the Lesser General Public License is Less protective of the+users' freedom, it does ensure that the user of a program that is+linked with the Library has the freedom and the wherewithal to run+that program using a modified version of the Library.++  The precise terms and conditions for copying, distribution and+modification follow.  Pay close attention to the difference between a+"work based on the library" and a "work that uses the library".  The+former contains code derived from the library, whereas the latter must+be combined with the library in order to run.++                  GNU LESSER GENERAL PUBLIC LICENSE+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION++  0. This License Agreement applies to any software library or other+program which contains a notice placed by the copyright holder or+other authorized party saying it may be distributed under the terms of+this Lesser General Public License (also called "this License").+Each licensee is addressed as "you".++  A "library" means a collection of software functions and/or data+prepared so as to be conveniently linked with application programs+(which use some of those functions and data) to form executables.++  The "Library", below, refers to any such software library or work+which has been distributed under these terms.  A "work based on the+Library" means either the Library or any derivative work under+copyright law: that is to say, a work containing the Library or a+portion of it, either verbatim or with modifications and/or translated+straightforwardly into another language.  (Hereinafter, translation is+included without limitation in the term "modification".)++  "Source code" for a work means the preferred form of the work for+making modifications to it.  For a library, complete source code means+all the source code for all modules it contains, plus any associated+interface definition files, plus the scripts used to control compilation+and installation of the library.++  Activities other than copying, distribution and modification are not+covered by this License; they are outside its scope.  The act of+running a program using the Library is not restricted, and output from+such a program is covered only if its contents constitute a work based+on the Library (independent of the use of the Library in a tool for+writing it).  Whether that is true depends on what the Library does+and what the program that uses the Library does.++  1. You may copy and distribute verbatim copies of the Library's+complete source code as you receive it, in any medium, provided that+you conspicuously and appropriately publish on each copy an+appropriate copyright notice and disclaimer of warranty; keep intact+all the notices that refer to this License and to the absence of any+warranty; and distribute a copy of this License along with the+Library.++  You may charge a fee for the physical act of transferring a copy,+and you may at your option offer warranty protection in exchange for a+fee.++  2. You may modify your copy or copies of the Library or any portion+of it, thus forming a work based on the Library, and copy and+distribute such modifications or work under the terms of Section 1+above, provided that you also meet all of these conditions:++    a) The modified work must itself be a software library.++    b) You must cause the files modified to carry prominent notices+    stating that you changed the files and the date of any change.++    c) You must cause the whole of the work to be licensed at no+    charge to all third parties under the terms of this License.++    d) If a facility in the modified Library refers to a function or a+    table of data to be supplied by an application program that uses+    the facility, other than as an argument passed when the facility+    is invoked, then you must make a good faith effort to ensure that,+    in the event an application does not supply such function or+    table, the facility still operates, and performs whatever part of+    its purpose remains meaningful.++    (For example, a function in a library to compute square roots has+    a purpose that is entirely well-defined independent of the+    application.  Therefore, Subsection 2d requires that any+    application-supplied function or table used by this function must+    be optional: if the application does not supply it, the square+    root function must still compute square roots.)++These requirements apply to the modified work as a whole.  If+identifiable sections of that work are not derived from the Library,+and can be reasonably considered independent and separate works in+themselves, then this License, and its terms, do not apply to those+sections when you distribute them as separate works.  But when you+distribute the same sections as part of a whole which is a work based+on the Library, the distribution of the whole must be on the terms of+this License, whose permissions for other licensees extend to the+entire whole, and thus to each and every part regardless of who wrote+it.++Thus, it is not the intent of this section to claim rights or contest+your rights to work written entirely by you; rather, the intent is to+exercise the right to control the distribution of derivative or+collective works based on the Library.++In addition, mere aggregation of another work not based on the Library+with the Library (or with a work based on the Library) on a volume of+a storage or distribution medium does not bring the other work under+the scope of this License.++  3. You may opt to apply the terms of the ordinary GNU General Public+License instead of this License to a given copy of the Library.  To do+this, you must alter all the notices that refer to this License, so+that they refer to the ordinary GNU General Public License, version 2,+instead of to this License.  (If a newer version than version 2 of the+ordinary GNU General Public License has appeared, then you can specify+that version instead if you wish.)  Do not make any other change in+these notices.++  Once this change is made in a given copy, it is irreversible for+that copy, so the ordinary GNU General Public License applies to all+subsequent copies and derivative works made from that copy.++  This option is useful when you wish to copy part of the code of+the Library into a program that is not a library.++  4. You may copy and distribute the Library (or a portion or+derivative of it, under Section 2) in object code or executable form+under the terms of Sections 1 and 2 above provided that you accompany+it with the complete corresponding machine-readable source code, which+must be distributed under the terms of Sections 1 and 2 above on a+medium customarily used for software interchange.++  If distribution of object code is made by offering access to copy+from a designated place, then offering equivalent access to copy the+source code from the same place satisfies the requirement to+distribute the source code, even though third parties are not+compelled to copy the source along with the object code.++  5. A program that contains no derivative of any portion of the+Library, but is designed to work with the Library by being compiled or+linked with it, is called a "work that uses the Library".  Such a+work, in isolation, is not a derivative work of the Library, and+therefore falls outside the scope of this License.++  However, linking a "work that uses the Library" with the Library+creates an executable that is a derivative of the Library (because it+contains portions of the Library), rather than a "work that uses the+library".  The executable is therefore covered by this License.+Section 6 states terms for distribution of such executables.++  When a "work that uses the Library" uses material from a header file+that is part of the Library, the object code for the work may be a+derivative work of the Library even though the source code is not.+Whether this is true is especially significant if the work can be+linked without the Library, or if the work is itself a library.  The+threshold for this to be true is not precisely defined by law.++  If such an object file uses only numerical parameters, data+structure layouts and accessors, and small macros and small inline+functions (ten lines or less in length), then the use of the object+file is unrestricted, regardless of whether it is legally a derivative+work.  (Executables containing this object code plus portions of the+Library will still fall under Section 6.)++  Otherwise, if the work is a derivative of the Library, you may+distribute the object code for the work under the terms of Section 6.+Any executables containing that work also fall under Section 6,+whether or not they are linked directly with the Library itself.++  6. As an exception to the Sections above, you may also combine or+link a "work that uses the Library" with the Library to produce a+work containing portions of the Library, and distribute that work+under terms of your choice, provided that the terms permit+modification of the work for the customer's own use and reverse+engineering for debugging such modifications.++  You must give prominent notice with each copy of the work that the+Library is used in it and that the Library and its use are covered by+this License.  You must supply a copy of this License.  If the work+during execution displays copyright notices, you must include the+copyright notice for the Library among them, as well as a reference+directing the user to the copy of this License.  Also, you must do one+of these things:++    a) Accompany the work with the complete corresponding+    machine-readable source code for the Library including whatever+    changes were used in the work (which must be distributed under+    Sections 1 and 2 above); and, if the work is an executable linked+    with the Library, with the complete machine-readable "work that+    uses the Library", as object code and/or source code, so that the+    user can modify the Library and then relink to produce a modified+    executable containing the modified Library.  (It is understood+    that the user who changes the contents of definitions files in the+    Library will not necessarily be able to recompile the application+    to use the modified definitions.)++    b) Use a suitable shared library mechanism for linking with the+    Library.  A suitable mechanism is one that (1) uses at run time a+    copy of the library already present on the user's computer system,+    rather than copying library functions into the executable, and (2)+    will operate properly with a modified version of the library, if+    the user installs one, as long as the modified version is+    interface-compatible with the version that the work was made with.++    c) Accompany the work with a written offer, valid for at+    least three years, to give the same user the materials+    specified in Subsection 6a, above, for a charge no more+    than the cost of performing this distribution.++    d) If distribution of the work is made by offering access to copy+    from a designated place, offer equivalent access to copy the above+    specified materials from the same place.++    e) Verify that the user has already received a copy of these+    materials or that you have already sent this user a copy.++  For an executable, the required form of the "work that uses the+Library" must include any data and utility programs needed for+reproducing the executable from it.  However, as a special exception,+the materials to be distributed need not include anything that is+normally distributed (in either source or binary form) with the major+components (compiler, kernel, and so on) of the operating system on+which the executable runs, unless that component itself accompanies+the executable.++  It may happen that this requirement contradicts the license+restrictions of other proprietary libraries that do not normally+accompany the operating system.  Such a contradiction means you cannot+use both them and the Library together in an executable that you+distribute.++  7. You may place library facilities that are a work based on the+Library side-by-side in a single library together with other library+facilities not covered by this License, and distribute such a combined+library, provided that the separate distribution of the work based on+the Library and of the other library facilities is otherwise+permitted, and provided that you do these two things:++    a) Accompany the combined library with a copy of the same work+    based on the Library, uncombined with any other library+    facilities.  This must be distributed under the terms of the+    Sections above.++    b) Give prominent notice with the combined library of the fact+    that part of it is a work based on the Library, and explaining+    where to find the accompanying uncombined form of the same work.++  8. You may not copy, modify, sublicense, link with, or distribute+the Library except as expressly provided under this License.  Any+attempt otherwise to copy, modify, sublicense, link with, or+distribute the Library is void, and will automatically terminate your+rights under this License.  However, parties who have received copies,+or rights, from you under this License will not have their licenses+terminated so long as such parties remain in full compliance.++  9. You are not required to accept this License, since you have not+signed it.  However, nothing else grants you permission to modify or+distribute the Library or its derivative works.  These actions are+prohibited by law if you do not accept this License.  Therefore, by+modifying or distributing the Library (or any work based on the+Library), you indicate your acceptance of this License to do so, and+all its terms and conditions for copying, distributing or modifying+the Library or works based on it.++  10. Each time you redistribute the Library (or any work based on the+Library), the recipient automatically receives a license from the+original licensor to copy, distribute, link with or modify the Library+subject to these terms and conditions.  You may not impose any further+restrictions on the recipients' exercise of the rights granted herein.+You are not responsible for enforcing compliance by third parties with+this License.++  11. If, as a consequence of a court judgment or allegation of patent+infringement or for any other reason (not limited to patent issues),+conditions are imposed on you (whether by court order, agreement or+otherwise) that contradict the conditions of this License, they do not+excuse you from the conditions of this License.  If you cannot+distribute so as to satisfy simultaneously your obligations under this+License and any other pertinent obligations, then as a consequence you+may not distribute the Library at all.  For example, if a patent+license would not permit royalty-free redistribution of the Library by+all those who receive copies directly or indirectly through you, then+the only way you could satisfy both it and this License would be to+refrain entirely from distribution of the Library.++If any portion of this section is held invalid or unenforceable under any+particular circumstance, the balance of the section is intended to apply,+and the section as a whole is intended to apply in other circumstances.++It is not the purpose of this section to induce you to infringe any+patents or other property right claims or to contest validity of any+such claims; this section has the sole purpose of protecting the+integrity of the free software distribution system which is+implemented by public license practices.  Many people have made+generous contributions to the wide range of software distributed+through that system in reliance on consistent application of that+system; it is up to the author/donor to decide if he or she is willing+to distribute software through any other system and a licensee cannot+impose that choice.++This section is intended to make thoroughly clear what is believed to+be a consequence of the rest of this License.++  12. If the distribution and/or use of the Library is restricted in+certain countries either by patents or by copyrighted interfaces, the+original copyright holder who places the Library under this License may add+an explicit geographical distribution limitation excluding those countries,+so that distribution is permitted only in or among countries not thus+excluded.  In such case, this License incorporates the limitation as if+written in the body of this License.++  13. The Free Software Foundation may publish revised and/or new+versions of the Lesser General Public License from time to time.+Such new versions will be similar in spirit to the present version,+but may differ in detail to address new problems or concerns.++Each version is given a distinguishing version number.  If the Library+specifies a version number of this License which applies to it and+"any later version", you have the option of following the terms and+conditions either of that version or of any later version published by+the Free Software Foundation.  If the Library does not specify a+license version number, you may choose any version ever published by+the Free Software Foundation.++  14. If you wish to incorporate parts of the Library into other free+programs whose distribution conditions are incompatible with these,+write to the author to ask for permission.  For software which is+copyrighted by the Free Software Foundation, write to the Free+Software Foundation; we sometimes make exceptions for this.  Our+decision will be guided by the two goals of preserving the free status+of all derivatives of our free software and of promoting the sharing+and reuse of software generally.++                            NO WARRANTY++  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.++  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH+DAMAGES.
+ README.md view
@@ -0,0 +1,6 @@+# Documentation+Autogenerated documentation for this package can be found at++[https://hackage.haskell.org/package/gi-handy-0.0.1/docs/GI-Handy.html](https://hackage.haskell.org/package/gi-handy-0.0.1/docs/GI-Handy.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).
+ Setup.hs view
@@ -0,0 +1,11 @@+{-# LANGUAGE OverloadedStrings #-}++import Data.GI.CodeGen.CabalHooks (setupHaskellGIBinding)++main :: IO ()+main = setupHaskellGIBinding name version verbose overridesFile outputDir+  where name = "Handy"+        version = "0.0"+        overridesFile = Just "Handy.overrides"+        verbose = False+        outputDir = Nothing
+ gi-handy.cabal view
@@ -0,0 +1,67 @@+name:                 gi-handy+version:              0.0.1+synopsis:             libhandy bindings+description:          Bindings for libhandy, 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 (inaki@blueleaf.cc)+category:             Bindings+build-type:           Custom+cabal-version:        1.24++extra-source-files: README.md ChangeLog.md stack.yaml Handy.overrides++custom-setup+      setup-depends: base >= 4.9 && < 5,+                     Cabal >= 1.24,+                     haskell-gi >= 0.22.0 && < 0.23++library+      default-language: Haskell2010+      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: libhandy-0.0+      build-depends: base >= 4.7 && <5,+                     haskell-gi-base == 0.22.*,+                     haskell-gi >= 0.22.0 && < 0.23,+                     haskell-gi-overloading < 1.1,+                     gi-gtk == 3.0.*,+                     gi-gdk == 3.0.*,+                     gi-atk == 2.0.*,+                     gi-gobject == 2.0.*,+                     gi-glib == 2.0.*,+                     gi-gio == 2.0.*,+                     bytestring >= 0.10 && < 1,+                     containers >= 0.5 && < 1,+                     text >= 1.0 && < 2,+                     transformers >= 0.4 && < 1++      -- Disable overloading when compiling under GHC 8.2.x+      -- see https://ghc.haskell.org/trac/ghc/ticket/14382+      if impl(ghc == 8.2.*)+              build-depends: haskell-gi-overloading == 0.0++      exposed-modules: GI.Handy,+                       GI.Handy.Callbacks,+                       GI.Handy.Enums,+                       GI.Handy.Functions,+                       GI.Handy.Objects,+                       GI.Handy.Objects.ActionRow,+                       GI.Handy.Objects.Arrows,+                       GI.Handy.Objects.Column,+                       GI.Handy.Objects.ComboRow,+                       GI.Handy.Objects.Dialer,+                       GI.Handy.Objects.DialerButton,+                       GI.Handy.Objects.DialerCycleButton,+                       GI.Handy.Objects.Dialog,+                       GI.Handy.Objects.EnumValueObject,+                       GI.Handy.Objects.ExpanderRow,+                       GI.Handy.Objects.HeaderGroup,+                       GI.Handy.Objects.Leaflet,+                       GI.Handy.Objects.SearchBar,+                       GI.Handy.Objects.TitleBar,+                       GI.Handy.Objects.ValueObject
+ stack.yaml view
@@ -0,0 +1,3 @@+packages:+- '.'+resolver: lts-13.7