{- |
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