{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- An auxiliary class used by t'GI.Adw.Objects.Squeezer.Squeezer'.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Adw.Objects.SqueezerPage
    ( 

-- * Exported types
    SqueezerPage(..)                        ,
    IsSqueezerPage                          ,
    toSqueezerPage                          ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getChild]("GI.Adw.Objects.SqueezerPage#g:method:getChild"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getEnabled]("GI.Adw.Objects.SqueezerPage#g:method:getEnabled"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setEnabled]("GI.Adw.Objects.SqueezerPage#g:method:setEnabled"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveSqueezerPageMethod               ,
#endif

-- ** getChild #method:getChild#

#if defined(ENABLE_OVERLOADING)
    SqueezerPageGetChildMethodInfo          ,
#endif
    squeezerPageGetChild                    ,


-- ** getEnabled #method:getEnabled#

#if defined(ENABLE_OVERLOADING)
    SqueezerPageGetEnabledMethodInfo        ,
#endif
    squeezerPageGetEnabled                  ,


-- ** setEnabled #method:setEnabled#

#if defined(ENABLE_OVERLOADING)
    SqueezerPageSetEnabledMethodInfo        ,
#endif
    squeezerPageSetEnabled                  ,




 -- * Properties


-- ** child #attr:child#
-- | The child of the page.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SqueezerPageChildPropertyInfo           ,
#endif
    constructSqueezerPageChild              ,
    getSqueezerPageChild                    ,
#if defined(ENABLE_OVERLOADING)
    squeezerPageChild                       ,
#endif


-- ** enabled #attr:enabled#
-- | Whether the child is enabled.
-- 
-- If a child is disabled, it will be ignored when looking for the child
-- fitting the available size best.
-- 
-- This allows to programmatically and prematurely hide a child even if it
-- fits in the available space.
-- 
-- This can be used e.g. to ensure a certain child is hidden below a certain
-- window width, or any other constraint you find suitable.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SqueezerPageEnabledPropertyInfo         ,
#endif
    constructSqueezerPageEnabled            ,
    getSqueezerPageEnabled                  ,
    setSqueezerPageEnabled                  ,
#if defined(ENABLE_OVERLOADING)
    squeezerPageEnabled                     ,
#endif




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
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 GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

-- | Memory-managed wrapper type.
newtype SqueezerPage = SqueezerPage (SP.ManagedPtr SqueezerPage)
    deriving (SqueezerPage -> SqueezerPage -> Bool
(SqueezerPage -> SqueezerPage -> Bool)
-> (SqueezerPage -> SqueezerPage -> Bool) -> Eq SqueezerPage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SqueezerPage -> SqueezerPage -> Bool
$c/= :: SqueezerPage -> SqueezerPage -> Bool
== :: SqueezerPage -> SqueezerPage -> Bool
$c== :: SqueezerPage -> SqueezerPage -> Bool
Eq)

instance SP.ManagedPtrNewtype SqueezerPage where
    toManagedPtr :: SqueezerPage -> ManagedPtr SqueezerPage
toManagedPtr (SqueezerPage ManagedPtr SqueezerPage
p) = ManagedPtr SqueezerPage
p

foreign import ccall "adw_squeezer_page_get_type"
    c_adw_squeezer_page_get_type :: IO B.Types.GType

instance B.Types.TypedObject SqueezerPage where
    glibType :: IO GType
glibType = IO GType
c_adw_squeezer_page_get_type

instance B.Types.GObject SqueezerPage

-- | Type class for types which can be safely cast to `SqueezerPage`, for instance with `toSqueezerPage`.
class (SP.GObject o, O.IsDescendantOf SqueezerPage o) => IsSqueezerPage o
instance (SP.GObject o, O.IsDescendantOf SqueezerPage o) => IsSqueezerPage o

instance O.HasParentTypes SqueezerPage
type instance O.ParentTypes SqueezerPage = '[GObject.Object.Object]

-- | Cast to `SqueezerPage`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toSqueezerPage :: (MIO.MonadIO m, IsSqueezerPage o) => o -> m SqueezerPage
toSqueezerPage :: forall (m :: * -> *) o.
(MonadIO m, IsSqueezerPage o) =>
o -> m SqueezerPage
toSqueezerPage = IO SqueezerPage -> m SqueezerPage
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO SqueezerPage -> m SqueezerPage)
-> (o -> IO SqueezerPage) -> o -> m SqueezerPage
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr SqueezerPage -> SqueezerPage) -> o -> IO SqueezerPage
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr SqueezerPage -> SqueezerPage
SqueezerPage

-- | Convert 'SqueezerPage' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe SqueezerPage) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_adw_squeezer_page_get_type
    gvalueSet_ :: Ptr GValue -> Maybe SqueezerPage -> IO ()
gvalueSet_ Ptr GValue
gv Maybe SqueezerPage
P.Nothing = Ptr GValue -> Ptr SqueezerPage -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr SqueezerPage
forall a. Ptr a
FP.nullPtr :: FP.Ptr SqueezerPage)
    gvalueSet_ Ptr GValue
gv (P.Just SqueezerPage
obj) = SqueezerPage -> (Ptr SqueezerPage -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr SqueezerPage
obj (Ptr GValue -> Ptr SqueezerPage -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe SqueezerPage)
gvalueGet_ Ptr GValue
gv = do
        Ptr SqueezerPage
ptr <- Ptr GValue -> IO (Ptr SqueezerPage)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr SqueezerPage)
        if Ptr SqueezerPage
ptr Ptr SqueezerPage -> Ptr SqueezerPage -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr SqueezerPage
forall a. Ptr a
FP.nullPtr
        then SqueezerPage -> Maybe SqueezerPage
forall a. a -> Maybe a
P.Just (SqueezerPage -> Maybe SqueezerPage)
-> IO SqueezerPage -> IO (Maybe SqueezerPage)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr SqueezerPage -> SqueezerPage)
-> Ptr SqueezerPage -> IO SqueezerPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr SqueezerPage -> SqueezerPage
SqueezerPage Ptr SqueezerPage
ptr
        else Maybe SqueezerPage -> IO (Maybe SqueezerPage)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SqueezerPage
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveSqueezerPageMethod (t :: Symbol) (o :: *) :: * where
    ResolveSqueezerPageMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveSqueezerPageMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveSqueezerPageMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveSqueezerPageMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveSqueezerPageMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveSqueezerPageMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveSqueezerPageMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveSqueezerPageMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveSqueezerPageMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveSqueezerPageMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveSqueezerPageMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveSqueezerPageMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveSqueezerPageMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveSqueezerPageMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveSqueezerPageMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveSqueezerPageMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveSqueezerPageMethod "getChild" o = SqueezerPageGetChildMethodInfo
    ResolveSqueezerPageMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveSqueezerPageMethod "getEnabled" o = SqueezerPageGetEnabledMethodInfo
    ResolveSqueezerPageMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveSqueezerPageMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveSqueezerPageMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveSqueezerPageMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveSqueezerPageMethod "setEnabled" o = SqueezerPageSetEnabledMethodInfo
    ResolveSqueezerPageMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveSqueezerPageMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveSqueezerPageMethod t SqueezerPage, O.OverloadedMethod info SqueezerPage p) => OL.IsLabel t (SqueezerPage -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveSqueezerPageMethod t SqueezerPage, O.OverloadedMethod info SqueezerPage p, R.HasField t SqueezerPage p) => R.HasField t SqueezerPage p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveSqueezerPageMethod t SqueezerPage, O.OverloadedMethodInfo info SqueezerPage) => OL.IsLabel t (O.MethodProxy info SqueezerPage) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- VVV Prop "child"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Widget"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@child@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' squeezerPage #child
-- @
getSqueezerPageChild :: (MonadIO m, IsSqueezerPage o) => o -> m Gtk.Widget.Widget
getSqueezerPageChild :: forall (m :: * -> *) o.
(MonadIO m, IsSqueezerPage o) =>
o -> m Widget
getSqueezerPageChild o
obj = IO Widget -> m Widget
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Widget -> m Widget) -> IO Widget -> m Widget
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Widget) -> IO Widget
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getSqueezerPageChild" (IO (Maybe Widget) -> IO Widget) -> IO (Maybe Widget) -> IO Widget
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Widget -> Widget) -> IO (Maybe Widget)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"child" ManagedPtr Widget -> Widget
Gtk.Widget.Widget

-- | Construct a `GValueConstruct` with valid value for the “@child@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSqueezerPageChild :: (IsSqueezerPage o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
constructSqueezerPageChild :: forall o (m :: * -> *) a.
(IsSqueezerPage o, MonadIO m, IsWidget a) =>
a -> m (GValueConstruct o)
constructSqueezerPageChild a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"child" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

#if defined(ENABLE_OVERLOADING)
data SqueezerPageChildPropertyInfo
instance AttrInfo SqueezerPageChildPropertyInfo where
    type AttrAllowedOps SqueezerPageChildPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SqueezerPageChildPropertyInfo = IsSqueezerPage
    type AttrSetTypeConstraint SqueezerPageChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint SqueezerPageChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType SqueezerPageChildPropertyInfo = Gtk.Widget.Widget
    type AttrGetType SqueezerPageChildPropertyInfo = Gtk.Widget.Widget
    type AttrLabel SqueezerPageChildPropertyInfo = "child"
    type AttrOrigin SqueezerPageChildPropertyInfo = SqueezerPage
    attrGet = getSqueezerPageChild
    attrSet = undefined
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructSqueezerPageChild
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SqueezerPage.child"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SqueezerPage.html#g:attr:child"
        })
#endif

-- VVV Prop "enabled"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@enabled@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' squeezerPage #enabled
-- @
getSqueezerPageEnabled :: (MonadIO m, IsSqueezerPage o) => o -> m Bool
getSqueezerPageEnabled :: forall (m :: * -> *) o.
(MonadIO m, IsSqueezerPage o) =>
o -> m Bool
getSqueezerPageEnabled o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"enabled"

-- | Set the value of the “@enabled@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' squeezerPage [ #enabled 'Data.GI.Base.Attributes.:=' value ]
-- @
setSqueezerPageEnabled :: (MonadIO m, IsSqueezerPage o) => o -> Bool -> m ()
setSqueezerPageEnabled :: forall (m :: * -> *) o.
(MonadIO m, IsSqueezerPage o) =>
o -> Bool -> m ()
setSqueezerPageEnabled o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"enabled" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@enabled@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSqueezerPageEnabled :: (IsSqueezerPage o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSqueezerPageEnabled :: forall o (m :: * -> *).
(IsSqueezerPage o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSqueezerPageEnabled Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"enabled" Bool
val

#if defined(ENABLE_OVERLOADING)
data SqueezerPageEnabledPropertyInfo
instance AttrInfo SqueezerPageEnabledPropertyInfo where
    type AttrAllowedOps SqueezerPageEnabledPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SqueezerPageEnabledPropertyInfo = IsSqueezerPage
    type AttrSetTypeConstraint SqueezerPageEnabledPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SqueezerPageEnabledPropertyInfo = (~) Bool
    type AttrTransferType SqueezerPageEnabledPropertyInfo = Bool
    type AttrGetType SqueezerPageEnabledPropertyInfo = Bool
    type AttrLabel SqueezerPageEnabledPropertyInfo = "enabled"
    type AttrOrigin SqueezerPageEnabledPropertyInfo = SqueezerPage
    attrGet = getSqueezerPageEnabled
    attrSet = setSqueezerPageEnabled
    attrTransfer _ v = do
        return v
    attrConstruct = constructSqueezerPageEnabled
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SqueezerPage.enabled"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SqueezerPage.html#g:attr:enabled"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList SqueezerPage
type instance O.AttributeList SqueezerPage = SqueezerPageAttributeList
type SqueezerPageAttributeList = ('[ '("child", SqueezerPageChildPropertyInfo), '("enabled", SqueezerPageEnabledPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
squeezerPageChild :: AttrLabelProxy "child"
squeezerPageChild = AttrLabelProxy

squeezerPageEnabled :: AttrLabelProxy "enabled"
squeezerPageEnabled = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList SqueezerPage = SqueezerPageSignalList
type SqueezerPageSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method SqueezerPage::get_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SqueezerPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezerPage`"
--                 , 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 "adw_squeezer_page_get_child" adw_squeezer_page_get_child :: 
    Ptr SqueezerPage ->                     -- self : TInterface (Name {namespace = "Adw", name = "SqueezerPage"})
    IO (Ptr Gtk.Widget.Widget)

-- | Returns the squeezer child to which /@self@/ belongs.
-- 
-- /Since: 1.0/
squeezerPageGetChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezerPage a) =>
    a
    -- ^ /@self@/: a @AdwSqueezerPage@
    -> m Gtk.Widget.Widget
    -- ^ __Returns:__ the child to which /@self@/ belongs
squeezerPageGetChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezerPage a) =>
a -> m Widget
squeezerPageGetChild a
self = IO Widget -> m Widget
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Widget -> m Widget) -> IO Widget -> m Widget
forall a b. (a -> b) -> a -> b
$ do
    Ptr SqueezerPage
self' <- a -> IO (Ptr SqueezerPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr SqueezerPage -> IO (Ptr Widget)
adw_squeezer_page_get_child Ptr SqueezerPage
self'
    Text -> Ptr Widget -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"squeezerPageGetChild" Ptr Widget
result
    Widget
result' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerPageGetChildMethodInfo
instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsSqueezerPage a) => O.OverloadedMethod SqueezerPageGetChildMethodInfo a signature where
    overloadedMethod = squeezerPageGetChild

instance O.OverloadedMethodInfo SqueezerPageGetChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SqueezerPage.squeezerPageGetChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SqueezerPage.html#v:squeezerPageGetChild"
        })


#endif

-- method SqueezerPage::get_enabled
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SqueezerPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezerPage`"
--                 , 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 "adw_squeezer_page_get_enabled" adw_squeezer_page_get_enabled :: 
    Ptr SqueezerPage ->                     -- self : TInterface (Name {namespace = "Adw", name = "SqueezerPage"})
    IO CInt

-- | Gets whether /@self@/ is enabled.
-- 
-- /Since: 1.0/
squeezerPageGetEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezerPage a) =>
    a
    -- ^ /@self@/: a @AdwSqueezerPage@
    -> m Bool
    -- ^ __Returns:__ whether /@self@/ is enabled
squeezerPageGetEnabled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezerPage a) =>
a -> m Bool
squeezerPageGetEnabled a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SqueezerPage
self' <- a -> IO (Ptr SqueezerPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr SqueezerPage -> IO CInt
adw_squeezer_page_get_enabled Ptr SqueezerPage
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerPageGetEnabledMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSqueezerPage a) => O.OverloadedMethod SqueezerPageGetEnabledMethodInfo a signature where
    overloadedMethod = squeezerPageGetEnabled

instance O.OverloadedMethodInfo SqueezerPageGetEnabledMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SqueezerPage.squeezerPageGetEnabled",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SqueezerPage.html#v:squeezerPageGetEnabled"
        })


#endif

-- method SqueezerPage::set_enabled
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SqueezerPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezerPage`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enabled"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether @self is enabled"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_squeezer_page_set_enabled" adw_squeezer_page_set_enabled :: 
    Ptr SqueezerPage ->                     -- self : TInterface (Name {namespace = "Adw", name = "SqueezerPage"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

-- | Sets whether /@self@/ is enabled.
-- 
-- /Since: 1.0/
squeezerPageSetEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezerPage a) =>
    a
    -- ^ /@self@/: a @AdwSqueezerPage@
    -> Bool
    -- ^ /@enabled@/: whether /@self@/ is enabled
    -> m ()
squeezerPageSetEnabled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezerPage a) =>
a -> Bool -> m ()
squeezerPageSetEnabled a
self Bool
enabled = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SqueezerPage
self' <- a -> IO (Ptr SqueezerPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let enabled' :: CInt
enabled' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
enabled
    Ptr SqueezerPage -> CInt -> IO ()
adw_squeezer_page_set_enabled Ptr SqueezerPage
self' CInt
enabled'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SqueezerPageSetEnabledMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSqueezerPage a) => O.OverloadedMethod SqueezerPageSetEnabledMethodInfo a signature where
    overloadedMethod = squeezerPageSetEnabled

instance O.OverloadedMethodInfo SqueezerPageSetEnabledMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SqueezerPage.squeezerPageSetEnabled",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SqueezerPage.html#v:squeezerPageSetEnabled"
        })


#endif