{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Handy.Objects.HeaderGroup
(
HeaderGroup(..) ,
IsHeaderGroup ,
toHeaderGroup ,
#if defined(ENABLE_OVERLOADING)
ResolveHeaderGroupMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
HeaderGroupAddHeaderBarMethodInfo ,
#endif
headerGroupAddHeaderBar ,
#if defined(ENABLE_OVERLOADING)
HeaderGroupGetFocusMethodInfo ,
#endif
headerGroupGetFocus ,
#if defined(ENABLE_OVERLOADING)
HeaderGroupGetHeaderBarsMethodInfo ,
#endif
headerGroupGetHeaderBars ,
headerGroupNew ,
#if defined(ENABLE_OVERLOADING)
HeaderGroupRemoveHeaderBarMethodInfo ,
#endif
headerGroupRemoveHeaderBar ,
#if defined(ENABLE_OVERLOADING)
HeaderGroupSetFocusMethodInfo ,
#endif
headerGroupSetFocus ,
#if defined(ENABLE_OVERLOADING)
HeaderGroupFocusPropertyInfo ,
#endif
clearHeaderGroupFocus ,
constructHeaderGroupFocus ,
getHeaderGroupFocus ,
#if defined(ENABLE_OVERLOADING)
headerGroupFocus ,
#endif
setHeaderGroupFocus ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.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 qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Objects.HeaderBar as Gtk.HeaderBar
newtype = (SP.ManagedPtr HeaderGroup)
deriving (HeaderGroup -> HeaderGroup -> Bool
(HeaderGroup -> HeaderGroup -> Bool)
-> (HeaderGroup -> HeaderGroup -> Bool) -> Eq HeaderGroup
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HeaderGroup -> HeaderGroup -> Bool
$c/= :: HeaderGroup -> HeaderGroup -> Bool
== :: HeaderGroup -> HeaderGroup -> Bool
$c== :: HeaderGroup -> HeaderGroup -> Bool
Eq)
instance SP.ManagedPtrNewtype HeaderGroup where
toManagedPtr :: HeaderGroup -> ManagedPtr HeaderGroup
toManagedPtr (HeaderGroup ManagedPtr HeaderGroup
p) = ManagedPtr HeaderGroup
p
foreign import ccall "hdy_header_group_get_type"
:: IO B.Types.GType
instance B.Types.TypedObject HeaderGroup where
glibType :: IO GType
glibType = IO GType
c_hdy_header_group_get_type
instance B.Types.GObject HeaderGroup
instance B.GValue.IsGValue HeaderGroup where
toGValue :: HeaderGroup -> IO GValue
toGValue HeaderGroup
o = do
GType
gtype <- IO GType
c_hdy_header_group_get_type
HeaderGroup -> (Ptr HeaderGroup -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr HeaderGroup
o (GType
-> (GValue -> Ptr HeaderGroup -> IO ())
-> Ptr HeaderGroup
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr HeaderGroup -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO HeaderGroup
fromGValue GValue
gv = do
Ptr HeaderGroup
ptr <- GValue -> IO (Ptr HeaderGroup)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr HeaderGroup)
(ManagedPtr HeaderGroup -> HeaderGroup)
-> Ptr HeaderGroup -> IO HeaderGroup
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr HeaderGroup -> HeaderGroup
HeaderGroup Ptr HeaderGroup
ptr
class (SP.GObject o, O.IsDescendantOf HeaderGroup o) => o
instance (SP.GObject o, O.IsDescendantOf HeaderGroup o) => IsHeaderGroup o
instance O.HasParentTypes HeaderGroup
type instance O.ParentTypes HeaderGroup = '[GObject.Object.Object, Gtk.Buildable.Buildable]
toHeaderGroup :: (MonadIO m, IsHeaderGroup o) => o -> m HeaderGroup
= IO HeaderGroup -> m HeaderGroup
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO HeaderGroup -> m HeaderGroup)
-> (o -> IO HeaderGroup) -> o -> m HeaderGroup
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr HeaderGroup -> HeaderGroup) -> o -> IO HeaderGroup
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr HeaderGroup -> HeaderGroup
HeaderGroup
#if defined(ENABLE_OVERLOADING)
type family ResolveHeaderGroupMethod (t :: Symbol) (o :: *) :: * where
ResolveHeaderGroupMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
ResolveHeaderGroupMethod "addHeaderBar" o = HeaderGroupAddHeaderBarMethodInfo
ResolveHeaderGroupMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveHeaderGroupMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveHeaderGroupMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
ResolveHeaderGroupMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
ResolveHeaderGroupMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
ResolveHeaderGroupMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
ResolveHeaderGroupMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveHeaderGroupMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveHeaderGroupMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveHeaderGroupMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveHeaderGroupMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveHeaderGroupMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveHeaderGroupMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
ResolveHeaderGroupMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveHeaderGroupMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveHeaderGroupMethod "removeHeaderBar" o = HeaderGroupRemoveHeaderBarMethodInfo
ResolveHeaderGroupMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveHeaderGroupMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveHeaderGroupMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveHeaderGroupMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveHeaderGroupMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveHeaderGroupMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveHeaderGroupMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveHeaderGroupMethod "getFocus" o = HeaderGroupGetFocusMethodInfo
ResolveHeaderGroupMethod "getHeaderBars" o = HeaderGroupGetHeaderBarsMethodInfo
ResolveHeaderGroupMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
ResolveHeaderGroupMethod "getName" o = Gtk.Buildable.BuildableGetNameMethodInfo
ResolveHeaderGroupMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveHeaderGroupMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveHeaderGroupMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
ResolveHeaderGroupMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveHeaderGroupMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveHeaderGroupMethod "setFocus" o = HeaderGroupSetFocusMethodInfo
ResolveHeaderGroupMethod "setName" o = Gtk.Buildable.BuildableSetNameMethodInfo
ResolveHeaderGroupMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveHeaderGroupMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveHeaderGroupMethod t HeaderGroup, O.MethodInfo info HeaderGroup p) => OL.IsLabel t (HeaderGroup -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
getHeaderGroupFocus :: (MonadIO m, IsHeaderGroup o) => o -> m (Maybe Gtk.HeaderBar.HeaderBar)
o
obj = IO (Maybe HeaderBar) -> m (Maybe HeaderBar)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe HeaderBar) -> m (Maybe HeaderBar))
-> IO (Maybe HeaderBar) -> m (Maybe HeaderBar)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr HeaderBar -> HeaderBar)
-> IO (Maybe HeaderBar)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"focus" ManagedPtr HeaderBar -> HeaderBar
Gtk.HeaderBar.HeaderBar
setHeaderGroupFocus :: (MonadIO m, IsHeaderGroup o, Gtk.HeaderBar.IsHeaderBar a) => o -> a -> m ()
o
obj a
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 a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"focus" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)
constructHeaderGroupFocus :: (IsHeaderGroup o, MIO.MonadIO m, Gtk.HeaderBar.IsHeaderBar a) => a -> m (GValueConstruct o)
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
"focus" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)
clearHeaderGroupFocus :: (MonadIO m, IsHeaderGroup o) => o -> m ()
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 HeaderBar -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"focus" (Maybe HeaderBar
forall a. Maybe a
Nothing :: Maybe Gtk.HeaderBar.HeaderBar)
#if defined(ENABLE_OVERLOADING)
data HeaderGroupFocusPropertyInfo
instance AttrInfo HeaderGroupFocusPropertyInfo where
type AttrAllowedOps HeaderGroupFocusPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint HeaderGroupFocusPropertyInfo = IsHeaderGroup
type AttrSetTypeConstraint HeaderGroupFocusPropertyInfo = Gtk.HeaderBar.IsHeaderBar
type AttrTransferTypeConstraint HeaderGroupFocusPropertyInfo = Gtk.HeaderBar.IsHeaderBar
type AttrTransferType HeaderGroupFocusPropertyInfo = Gtk.HeaderBar.HeaderBar
type AttrGetType HeaderGroupFocusPropertyInfo = (Maybe Gtk.HeaderBar.HeaderBar)
type AttrLabel HeaderGroupFocusPropertyInfo = "focus"
type AttrOrigin HeaderGroupFocusPropertyInfo = HeaderGroup
attrGet = getHeaderGroupFocus
attrSet = setHeaderGroupFocus
attrTransfer _ v = do
unsafeCastTo Gtk.HeaderBar.HeaderBar v
attrConstruct = constructHeaderGroupFocus
attrClear = clearHeaderGroupFocus
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList HeaderGroup
type instance O.AttributeList HeaderGroup = HeaderGroupAttributeList
type HeaderGroupAttributeList = ('[ '("focus", HeaderGroupFocusPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
headerGroupFocus :: AttrLabelProxy "focus"
headerGroupFocus = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList HeaderGroup = HeaderGroupSignalList
type HeaderGroupSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "hdy_header_group_new" ::
IO (Ptr HeaderGroup)
headerGroupNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m HeaderGroup
= IO HeaderGroup -> m HeaderGroup
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO HeaderGroup -> m HeaderGroup)
-> IO HeaderGroup -> m HeaderGroup
forall a b. (a -> b) -> a -> b
$ do
Ptr HeaderGroup
result <- IO (Ptr HeaderGroup)
hdy_header_group_new
Text -> Ptr HeaderGroup -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"headerGroupNew" Ptr HeaderGroup
result
HeaderGroup
result' <- ((ManagedPtr HeaderGroup -> HeaderGroup)
-> Ptr HeaderGroup -> IO HeaderGroup
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr HeaderGroup -> HeaderGroup
HeaderGroup) Ptr HeaderGroup
result
HeaderGroup -> IO HeaderGroup
forall (m :: * -> *) a. Monad m => a -> m a
return HeaderGroup
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "hdy_header_group_add_header_bar" ::
Ptr HeaderGroup ->
Ptr Gtk.HeaderBar.HeaderBar ->
IO ()
headerGroupAddHeaderBar ::
(B.CallStack.HasCallStack, MonadIO m, IsHeaderGroup a, Gtk.HeaderBar.IsHeaderBar b) =>
a
-> b
-> m ()
a
self b
headerBar = 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 HeaderGroup
self' <- a -> IO (Ptr HeaderGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr HeaderBar
headerBar' <- b -> IO (Ptr HeaderBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
headerBar
Ptr HeaderGroup -> Ptr HeaderBar -> IO ()
hdy_header_group_add_header_bar Ptr HeaderGroup
self' Ptr HeaderBar
headerBar'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
headerBar
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data HeaderGroupAddHeaderBarMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsHeaderGroup a, Gtk.HeaderBar.IsHeaderBar b) => O.MethodInfo HeaderGroupAddHeaderBarMethodInfo a signature where
overloadedMethod = headerGroupAddHeaderBar
#endif
foreign import ccall "hdy_header_group_get_focus" ::
Ptr HeaderGroup ->
IO (Ptr Gtk.HeaderBar.HeaderBar)
headerGroupGetFocus ::
(B.CallStack.HasCallStack, MonadIO m, IsHeaderGroup a) =>
a
-> m (Maybe Gtk.HeaderBar.HeaderBar)
a
self = IO (Maybe HeaderBar) -> m (Maybe HeaderBar)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe HeaderBar) -> m (Maybe HeaderBar))
-> IO (Maybe HeaderBar) -> m (Maybe HeaderBar)
forall a b. (a -> b) -> a -> b
$ do
Ptr HeaderGroup
self' <- a -> IO (Ptr HeaderGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr HeaderBar
result <- Ptr HeaderGroup -> IO (Ptr HeaderBar)
hdy_header_group_get_focus Ptr HeaderGroup
self'
Maybe HeaderBar
maybeResult <- Ptr HeaderBar
-> (Ptr HeaderBar -> IO HeaderBar) -> IO (Maybe HeaderBar)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr HeaderBar
result ((Ptr HeaderBar -> IO HeaderBar) -> IO (Maybe HeaderBar))
-> (Ptr HeaderBar -> IO HeaderBar) -> IO (Maybe HeaderBar)
forall a b. (a -> b) -> a -> b
$ \Ptr HeaderBar
result' -> do
HeaderBar
result'' <- ((ManagedPtr HeaderBar -> HeaderBar)
-> Ptr HeaderBar -> IO HeaderBar
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr HeaderBar -> HeaderBar
Gtk.HeaderBar.HeaderBar) Ptr HeaderBar
result'
HeaderBar -> IO HeaderBar
forall (m :: * -> *) a. Monad m => a -> m a
return HeaderBar
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Maybe HeaderBar -> IO (Maybe HeaderBar)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe HeaderBar
maybeResult
#if defined(ENABLE_OVERLOADING)
data HeaderGroupGetFocusMethodInfo
instance (signature ~ (m (Maybe Gtk.HeaderBar.HeaderBar)), MonadIO m, IsHeaderGroup a) => O.MethodInfo HeaderGroupGetFocusMethodInfo a signature where
overloadedMethod = headerGroupGetFocus
#endif
foreign import ccall "hdy_header_group_get_header_bars" ::
Ptr HeaderGroup ->
IO (Ptr (GSList (Ptr Gtk.HeaderBar.HeaderBar)))
headerGroupGetHeaderBars ::
(B.CallStack.HasCallStack, MonadIO m, IsHeaderGroup a) =>
a
-> m [Gtk.HeaderBar.HeaderBar]
a
self = IO [HeaderBar] -> m [HeaderBar]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [HeaderBar] -> m [HeaderBar])
-> IO [HeaderBar] -> m [HeaderBar]
forall a b. (a -> b) -> a -> b
$ do
Ptr HeaderGroup
self' <- a -> IO (Ptr HeaderGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr (GSList (Ptr HeaderBar))
result <- Ptr HeaderGroup -> IO (Ptr (GSList (Ptr HeaderBar)))
hdy_header_group_get_header_bars Ptr HeaderGroup
self'
[Ptr HeaderBar]
result' <- Ptr (GSList (Ptr HeaderBar)) -> IO [Ptr HeaderBar]
forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList (Ptr HeaderBar))
result
[HeaderBar]
result'' <- (Ptr HeaderBar -> IO HeaderBar)
-> [Ptr HeaderBar] -> IO [HeaderBar]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr HeaderBar -> HeaderBar)
-> Ptr HeaderBar -> IO HeaderBar
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr HeaderBar -> HeaderBar
Gtk.HeaderBar.HeaderBar) [Ptr HeaderBar]
result'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
[HeaderBar] -> IO [HeaderBar]
forall (m :: * -> *) a. Monad m => a -> m a
return [HeaderBar]
result''
#if defined(ENABLE_OVERLOADING)
data HeaderGroupGetHeaderBarsMethodInfo
instance (signature ~ (m [Gtk.HeaderBar.HeaderBar]), MonadIO m, IsHeaderGroup a) => O.MethodInfo HeaderGroupGetHeaderBarsMethodInfo a signature where
overloadedMethod = headerGroupGetHeaderBars
#endif
foreign import ccall "hdy_header_group_remove_header_bar" ::
Ptr HeaderGroup ->
Ptr Gtk.HeaderBar.HeaderBar ->
IO ()
headerGroupRemoveHeaderBar ::
(B.CallStack.HasCallStack, MonadIO m, IsHeaderGroup a, Gtk.HeaderBar.IsHeaderBar b) =>
a
-> b
-> m ()
a
self b
headerBar = 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 HeaderGroup
self' <- a -> IO (Ptr HeaderGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr HeaderBar
headerBar' <- b -> IO (Ptr HeaderBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
headerBar
Ptr HeaderGroup -> Ptr HeaderBar -> IO ()
hdy_header_group_remove_header_bar Ptr HeaderGroup
self' Ptr HeaderBar
headerBar'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
headerBar
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data HeaderGroupRemoveHeaderBarMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsHeaderGroup a, Gtk.HeaderBar.IsHeaderBar b) => O.MethodInfo HeaderGroupRemoveHeaderBarMethodInfo a signature where
overloadedMethod = headerGroupRemoveHeaderBar
#endif
foreign import ccall "hdy_header_group_set_focus" ::
Ptr HeaderGroup ->
Ptr Gtk.HeaderBar.HeaderBar ->
IO ()
headerGroupSetFocus ::
(B.CallStack.HasCallStack, MonadIO m, IsHeaderGroup a, Gtk.HeaderBar.IsHeaderBar b) =>
a
-> Maybe (b)
-> m ()
a
self Maybe b
headerBar = 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 HeaderGroup
self' <- a -> IO (Ptr HeaderGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr HeaderBar
maybeHeaderBar <- case Maybe b
headerBar of
Maybe b
Nothing -> Ptr HeaderBar -> IO (Ptr HeaderBar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr HeaderBar
forall a. Ptr a
nullPtr
Just b
jHeaderBar -> do
Ptr HeaderBar
jHeaderBar' <- b -> IO (Ptr HeaderBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jHeaderBar
Ptr HeaderBar -> IO (Ptr HeaderBar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr HeaderBar
jHeaderBar'
Ptr HeaderGroup -> Ptr HeaderBar -> IO ()
hdy_header_group_set_focus Ptr HeaderGroup
self' Ptr HeaderBar
maybeHeaderBar
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
headerBar b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data HeaderGroupSetFocusMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsHeaderGroup a, Gtk.HeaderBar.IsHeaderBar b) => O.MethodInfo HeaderGroupSetFocusMethodInfo a signature where
overloadedMethod = headerGroupSetFocus
#endif