{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Gtk.Objects.StackPage
    ( 

-- * Exported types
    StackPage(..)                           ,
    IsStackPage                             ,
    toStackPage                             ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveStackPageMethod                  ,
#endif


-- ** getChild #method:getChild#

#if defined(ENABLE_OVERLOADING)
    StackPageGetChildMethodInfo             ,
#endif
    stackPageGetChild                       ,


-- ** getVisible #method:getVisible#

#if defined(ENABLE_OVERLOADING)
    StackPageGetVisibleMethodInfo           ,
#endif
    stackPageGetVisible                     ,


-- ** setVisible #method:setVisible#

#if defined(ENABLE_OVERLOADING)
    StackPageSetVisibleMethodInfo           ,
#endif
    stackPageSetVisible                     ,




 -- * Properties
-- ** child #attr:child#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StackPageChildPropertyInfo              ,
#endif
    constructStackPageChild                 ,
    getStackPageChild                       ,
#if defined(ENABLE_OVERLOADING)
    stackPageChild                          ,
#endif


-- ** iconName #attr:iconName#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StackPageIconNamePropertyInfo           ,
#endif
    clearStackPageIconName                  ,
    constructStackPageIconName              ,
    getStackPageIconName                    ,
    setStackPageIconName                    ,
#if defined(ENABLE_OVERLOADING)
    stackPageIconName                       ,
#endif


-- ** name #attr:name#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StackPageNamePropertyInfo               ,
#endif
    constructStackPageName                  ,
    getStackPageName                        ,
#if defined(ENABLE_OVERLOADING)
    stackPageName                           ,
#endif


-- ** needsAttention #attr:needsAttention#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StackPageNeedsAttentionPropertyInfo     ,
#endif
    constructStackPageNeedsAttention        ,
    getStackPageNeedsAttention              ,
    setStackPageNeedsAttention              ,
#if defined(ENABLE_OVERLOADING)
    stackPageNeedsAttention                 ,
#endif


-- ** title #attr:title#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StackPageTitlePropertyInfo              ,
#endif
    clearStackPageTitle                     ,
    constructStackPageTitle                 ,
    getStackPageTitle                       ,
    setStackPageTitle                       ,
#if defined(ENABLE_OVERLOADING)
    stackPageTitle                          ,
#endif


-- ** useUnderline #attr:useUnderline#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StackPageUseUnderlinePropertyInfo       ,
#endif
    constructStackPageUseUnderline          ,
    getStackPageUseUnderline                ,
    setStackPageUseUnderline                ,
#if defined(ENABLE_OVERLOADING)
    stackPageUseUnderline                   ,
#endif


-- ** visible #attr:visible#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    StackPageVisiblePropertyInfo            ,
#endif
    constructStackPageVisible               ,
    getStackPageVisible                     ,
    setStackPageVisible                     ,
#if defined(ENABLE_OVERLOADING)
    stackPageVisible                        ,
#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.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.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget

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

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

foreign import ccall "gtk_stack_page_get_type"
    c_gtk_stack_page_get_type :: IO B.Types.GType

instance B.Types.TypedObject StackPage where
    glibType :: IO GType
glibType = IO GType
c_gtk_stack_page_get_type

instance B.Types.GObject StackPage

-- | Convert 'StackPage' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue StackPage where
    toGValue :: StackPage -> IO GValue
toGValue StackPage
o = do
        GType
gtype <- IO GType
c_gtk_stack_page_get_type
        StackPage -> (Ptr StackPage -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr StackPage
o (GType
-> (GValue -> Ptr StackPage -> IO ()) -> Ptr StackPage -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr StackPage -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO StackPage
fromGValue GValue
gv = do
        Ptr StackPage
ptr <- GValue -> IO (Ptr StackPage)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr StackPage)
        (ManagedPtr StackPage -> StackPage)
-> Ptr StackPage -> IO StackPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr StackPage -> StackPage
StackPage Ptr StackPage
ptr
        
    

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

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

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

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

instance (info ~ ResolveStackPageMethod t StackPage, O.MethodInfo info StackPage p) => OL.IsLabel t (StackPage -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#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' stackPage #child
-- @
getStackPageChild :: (MonadIO m, IsStackPage o) => o -> m Gtk.Widget.Widget
getStackPageChild :: o -> m Widget
getStackPageChild o
obj = 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
$ Text -> IO (Maybe Widget) -> IO Widget
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getStackPageChild" (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`.
constructStackPageChild :: (IsStackPage o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
constructStackPageChild :: a -> m (GValueConstruct o)
constructStackPageChild 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
$ 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 StackPageChildPropertyInfo
instance AttrInfo StackPageChildPropertyInfo where
    type AttrAllowedOps StackPageChildPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint StackPageChildPropertyInfo = IsStackPage
    type AttrSetTypeConstraint StackPageChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint StackPageChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType StackPageChildPropertyInfo = Gtk.Widget.Widget
    type AttrGetType StackPageChildPropertyInfo = Gtk.Widget.Widget
    type AttrLabel StackPageChildPropertyInfo = "child"
    type AttrOrigin StackPageChildPropertyInfo = StackPage
    attrGet = getStackPageChild
    attrSet = undefined
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructStackPageChild
    attrClear = undefined
#endif

-- VVV Prop "icon-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@icon-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' stackPage #iconName
-- @
getStackPageIconName :: (MonadIO m, IsStackPage o) => o -> m (Maybe T.Text)
getStackPageIconName :: o -> m (Maybe Text)
getStackPageIconName o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"icon-name"

-- | Set the value of the “@icon-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' stackPage [ #iconName 'Data.GI.Base.Attributes.:=' value ]
-- @
setStackPageIconName :: (MonadIO m, IsStackPage o) => o -> T.Text -> m ()
setStackPageIconName :: o -> Text -> m ()
setStackPageIconName o
obj Text
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"icon-name" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@icon-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStackPageIconName :: (IsStackPage o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructStackPageIconName :: Text -> m (GValueConstruct o)
constructStackPageIconName Text
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
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"icon-name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@icon-name@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #iconName
-- @
clearStackPageIconName :: (MonadIO m, IsStackPage o) => o -> m ()
clearStackPageIconName :: o -> m ()
clearStackPageIconName o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"icon-name" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data StackPageIconNamePropertyInfo
instance AttrInfo StackPageIconNamePropertyInfo where
    type AttrAllowedOps StackPageIconNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint StackPageIconNamePropertyInfo = IsStackPage
    type AttrSetTypeConstraint StackPageIconNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint StackPageIconNamePropertyInfo = (~) T.Text
    type AttrTransferType StackPageIconNamePropertyInfo = T.Text
    type AttrGetType StackPageIconNamePropertyInfo = (Maybe T.Text)
    type AttrLabel StackPageIconNamePropertyInfo = "icon-name"
    type AttrOrigin StackPageIconNamePropertyInfo = StackPage
    attrGet = getStackPageIconName
    attrSet = setStackPageIconName
    attrTransfer _ v = do
        return v
    attrConstruct = constructStackPageIconName
    attrClear = clearStackPageIconName
#endif

-- VVV Prop "name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

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

-- | Construct a `GValueConstruct` with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStackPageName :: (IsStackPage o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructStackPageName :: Text -> m (GValueConstruct o)
constructStackPageName Text
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
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data StackPageNamePropertyInfo
instance AttrInfo StackPageNamePropertyInfo where
    type AttrAllowedOps StackPageNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint StackPageNamePropertyInfo = IsStackPage
    type AttrSetTypeConstraint StackPageNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint StackPageNamePropertyInfo = (~) T.Text
    type AttrTransferType StackPageNamePropertyInfo = T.Text
    type AttrGetType StackPageNamePropertyInfo = (Maybe T.Text)
    type AttrLabel StackPageNamePropertyInfo = "name"
    type AttrOrigin StackPageNamePropertyInfo = StackPage
    attrGet = getStackPageName
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructStackPageName
    attrClear = undefined
#endif

-- VVV Prop "needs-attention"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@needs-attention@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' stackPage #needsAttention
-- @
getStackPageNeedsAttention :: (MonadIO m, IsStackPage o) => o -> m Bool
getStackPageNeedsAttention :: o -> m Bool
getStackPageNeedsAttention o
obj = 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
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"needs-attention"

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

-- | Construct a `GValueConstruct` with valid value for the “@needs-attention@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStackPageNeedsAttention :: (IsStackPage o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructStackPageNeedsAttention :: Bool -> m (GValueConstruct o)
constructStackPageNeedsAttention 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
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"needs-attention" Bool
val

#if defined(ENABLE_OVERLOADING)
data StackPageNeedsAttentionPropertyInfo
instance AttrInfo StackPageNeedsAttentionPropertyInfo where
    type AttrAllowedOps StackPageNeedsAttentionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StackPageNeedsAttentionPropertyInfo = IsStackPage
    type AttrSetTypeConstraint StackPageNeedsAttentionPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StackPageNeedsAttentionPropertyInfo = (~) Bool
    type AttrTransferType StackPageNeedsAttentionPropertyInfo = Bool
    type AttrGetType StackPageNeedsAttentionPropertyInfo = Bool
    type AttrLabel StackPageNeedsAttentionPropertyInfo = "needs-attention"
    type AttrOrigin StackPageNeedsAttentionPropertyInfo = StackPage
    attrGet = getStackPageNeedsAttention
    attrSet = setStackPageNeedsAttention
    attrTransfer _ v = do
        return v
    attrConstruct = constructStackPageNeedsAttention
    attrClear = undefined
#endif

-- VVV Prop "title"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

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

-- | Set the value of the “@title@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' stackPage [ #title 'Data.GI.Base.Attributes.:=' value ]
-- @
setStackPageTitle :: (MonadIO m, IsStackPage o) => o -> T.Text -> m ()
setStackPageTitle :: o -> Text -> m ()
setStackPageTitle o
obj Text
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"title" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@title@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStackPageTitle :: (IsStackPage o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructStackPageTitle :: Text -> m (GValueConstruct o)
constructStackPageTitle Text
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
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"title" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@title@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #title
-- @
clearStackPageTitle :: (MonadIO m, IsStackPage o) => o -> m ()
clearStackPageTitle :: o -> m ()
clearStackPageTitle o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"title" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data StackPageTitlePropertyInfo
instance AttrInfo StackPageTitlePropertyInfo where
    type AttrAllowedOps StackPageTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint StackPageTitlePropertyInfo = IsStackPage
    type AttrSetTypeConstraint StackPageTitlePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint StackPageTitlePropertyInfo = (~) T.Text
    type AttrTransferType StackPageTitlePropertyInfo = T.Text
    type AttrGetType StackPageTitlePropertyInfo = (Maybe T.Text)
    type AttrLabel StackPageTitlePropertyInfo = "title"
    type AttrOrigin StackPageTitlePropertyInfo = StackPage
    attrGet = getStackPageTitle
    attrSet = setStackPageTitle
    attrTransfer _ v = do
        return v
    attrConstruct = constructStackPageTitle
    attrClear = clearStackPageTitle
#endif

-- VVV Prop "use-underline"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@use-underline@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' stackPage #useUnderline
-- @
getStackPageUseUnderline :: (MonadIO m, IsStackPage o) => o -> m Bool
getStackPageUseUnderline :: o -> m Bool
getStackPageUseUnderline o
obj = 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
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"use-underline"

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

-- | Construct a `GValueConstruct` with valid value for the “@use-underline@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStackPageUseUnderline :: (IsStackPage o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructStackPageUseUnderline :: Bool -> m (GValueConstruct o)
constructStackPageUseUnderline 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
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"use-underline" Bool
val

#if defined(ENABLE_OVERLOADING)
data StackPageUseUnderlinePropertyInfo
instance AttrInfo StackPageUseUnderlinePropertyInfo where
    type AttrAllowedOps StackPageUseUnderlinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StackPageUseUnderlinePropertyInfo = IsStackPage
    type AttrSetTypeConstraint StackPageUseUnderlinePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StackPageUseUnderlinePropertyInfo = (~) Bool
    type AttrTransferType StackPageUseUnderlinePropertyInfo = Bool
    type AttrGetType StackPageUseUnderlinePropertyInfo = Bool
    type AttrLabel StackPageUseUnderlinePropertyInfo = "use-underline"
    type AttrOrigin StackPageUseUnderlinePropertyInfo = StackPage
    attrGet = getStackPageUseUnderline
    attrSet = setStackPageUseUnderline
    attrTransfer _ v = do
        return v
    attrConstruct = constructStackPageUseUnderline
    attrClear = undefined
#endif

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

-- | Get the value of the “@visible@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' stackPage #visible
-- @
getStackPageVisible :: (MonadIO m, IsStackPage o) => o -> m Bool
getStackPageVisible :: o -> m Bool
getStackPageVisible o
obj = 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
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"visible"

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

-- | Construct a `GValueConstruct` with valid value for the “@visible@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStackPageVisible :: (IsStackPage o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructStackPageVisible :: Bool -> m (GValueConstruct o)
constructStackPageVisible 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
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"visible" Bool
val

#if defined(ENABLE_OVERLOADING)
data StackPageVisiblePropertyInfo
instance AttrInfo StackPageVisiblePropertyInfo where
    type AttrAllowedOps StackPageVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StackPageVisiblePropertyInfo = IsStackPage
    type AttrSetTypeConstraint StackPageVisiblePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StackPageVisiblePropertyInfo = (~) Bool
    type AttrTransferType StackPageVisiblePropertyInfo = Bool
    type AttrGetType StackPageVisiblePropertyInfo = Bool
    type AttrLabel StackPageVisiblePropertyInfo = "visible"
    type AttrOrigin StackPageVisiblePropertyInfo = StackPage
    attrGet = getStackPageVisible
    attrSet = setStackPageVisible
    attrTransfer _ v = do
        return v
    attrConstruct = constructStackPageVisible
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList StackPage
type instance O.AttributeList StackPage = StackPageAttributeList
type StackPageAttributeList = ('[ '("child", StackPageChildPropertyInfo), '("iconName", StackPageIconNamePropertyInfo), '("name", StackPageNamePropertyInfo), '("needsAttention", StackPageNeedsAttentionPropertyInfo), '("title", StackPageTitlePropertyInfo), '("useUnderline", StackPageUseUnderlinePropertyInfo), '("visible", StackPageVisiblePropertyInfo)] :: [(Symbol, *)])
#endif

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

stackPageIconName :: AttrLabelProxy "iconName"
stackPageIconName = AttrLabelProxy

stackPageName :: AttrLabelProxy "name"
stackPageName = AttrLabelProxy

stackPageNeedsAttention :: AttrLabelProxy "needsAttention"
stackPageNeedsAttention = AttrLabelProxy

stackPageTitle :: AttrLabelProxy "title"
stackPageTitle = AttrLabelProxy

stackPageUseUnderline :: AttrLabelProxy "useUnderline"
stackPageUseUnderline = AttrLabelProxy

stackPageVisible :: AttrLabelProxy "visible"
stackPageVisible = AttrLabelProxy

#endif

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

#endif

-- method StackPage::get_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "StackPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkStackPage" , 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 "gtk_stack_page_get_child" gtk_stack_page_get_child :: 
    Ptr StackPage ->                        -- page : TInterface (Name {namespace = "Gtk", name = "StackPage"})
    IO (Ptr Gtk.Widget.Widget)

-- | Returns the stack child to which /@page@/ belongs.
stackPageGetChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsStackPage a) =>
    a
    -- ^ /@page@/: a t'GI.Gtk.Objects.StackPage.StackPage'
    -> m Gtk.Widget.Widget
    -- ^ __Returns:__ the child to which /@page@/ belongs
stackPageGetChild :: a -> m Widget
stackPageGetChild a
page = 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 StackPage
page' <- a -> IO (Ptr StackPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
page
    Ptr Widget
result <- Ptr StackPage -> IO (Ptr Widget)
gtk_stack_page_get_child Ptr StackPage
page'
    Text -> Ptr Widget -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stackPageGetChild" 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
page
    Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result'

#if defined(ENABLE_OVERLOADING)
data StackPageGetChildMethodInfo
instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsStackPage a) => O.MethodInfo StackPageGetChildMethodInfo a signature where
    overloadedMethod = stackPageGetChild

#endif

-- method StackPage::get_visible
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "StackPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkStackPage" , 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 "gtk_stack_page_get_visible" gtk_stack_page_get_visible :: 
    Ptr StackPage ->                        -- page : TInterface (Name {namespace = "Gtk", name = "StackPage"})
    IO CInt

-- | Returns whether /@page@/ is visible in its t'GI.Gtk.Objects.Stack.Stack'.
-- This is independent from the t'GI.Gtk.Objects.Widget.Widget':@/visible/@ value of its
-- t'GI.Gtk.Objects.Widget.Widget'.
stackPageGetVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsStackPage a) =>
    a
    -- ^ /@page@/: a t'GI.Gtk.Objects.StackPage.StackPage'
    -> m Bool
stackPageGetVisible :: a -> m Bool
stackPageGetVisible a
page = 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 StackPage
page' <- a -> IO (Ptr StackPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
page
    CInt
result <- Ptr StackPage -> IO CInt
gtk_stack_page_get_visible Ptr StackPage
page'
    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
page
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data StackPageGetVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsStackPage a) => O.MethodInfo StackPageGetVisibleMethodInfo a signature where
    overloadedMethod = stackPageGetVisible

#endif

-- method StackPage::set_visible
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "StackPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkStackPage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "visible"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The new property value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_stack_page_set_visible" gtk_stack_page_set_visible :: 
    Ptr StackPage ->                        -- page : TInterface (Name {namespace = "Gtk", name = "StackPage"})
    CInt ->                                 -- visible : TBasicType TBoolean
    IO ()

-- | Sets the new value of the t'GI.Gtk.Objects.StackPage.StackPage':@/visible/@ property
-- to /@visible@/.
stackPageSetVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsStackPage a) =>
    a
    -- ^ /@page@/: a t'GI.Gtk.Objects.StackPage.StackPage'
    -> Bool
    -- ^ /@visible@/: The new property value
    -> m ()
stackPageSetVisible :: a -> Bool -> m ()
stackPageSetVisible a
page Bool
visible = 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 StackPage
page' <- a -> IO (Ptr StackPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
page
    let visible' :: CInt
visible' = (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
visible
    Ptr StackPage -> CInt -> IO ()
gtk_stack_page_set_visible Ptr StackPage
page' CInt
visible'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
page
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StackPageSetVisibleMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsStackPage a) => O.MethodInfo StackPageSetVisibleMethodInfo a signature where
    overloadedMethod = stackPageSetVisible

#endif