{-# 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.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.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.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
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 :: (MIO.MonadIO m, IsHeaderGroup o) => o -> m HeaderGroup
= IO HeaderGroup -> m HeaderGroup
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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'
B.ManagedPtr.unsafeCastTo ManagedPtr HeaderGroup -> HeaderGroup
HeaderGroup
instance B.GValue.IsGValue (Maybe HeaderGroup) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_hdy_header_group_get_type
gvalueSet_ :: Ptr GValue -> Maybe HeaderGroup -> IO ()
gvalueSet_ Ptr GValue
gv Maybe HeaderGroup
P.Nothing = Ptr GValue -> Ptr HeaderGroup -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr HeaderGroup
forall a. Ptr a
FP.nullPtr :: FP.Ptr HeaderGroup)
gvalueSet_ Ptr GValue
gv (P.Just HeaderGroup
obj) = HeaderGroup -> (Ptr HeaderGroup -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr HeaderGroup
obj (Ptr GValue -> Ptr HeaderGroup -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe HeaderGroup)
gvalueGet_ Ptr GValue
gv = do
Ptr HeaderGroup
ptr <- Ptr GValue -> IO (Ptr HeaderGroup)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr HeaderGroup)
if Ptr HeaderGroup
ptr Ptr HeaderGroup -> Ptr HeaderGroup -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr HeaderGroup
forall a. Ptr a
FP.nullPtr
then HeaderGroup -> Maybe HeaderGroup
forall a. a -> Maybe a
P.Just (HeaderGroup -> Maybe HeaderGroup)
-> IO HeaderGroup -> IO (Maybe HeaderGroup)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (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
else Maybe HeaderGroup -> IO (Maybe HeaderGroup)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe HeaderGroup
forall a. Maybe a
P.Nothing
#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.OverloadedMethod 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
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveHeaderGroupMethod t HeaderGroup, O.OverloadedMethod info HeaderGroup p, R.HasField t HeaderGroup p) => R.HasField t HeaderGroup p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveHeaderGroupMethod t HeaderGroup, O.OverloadedMethodInfo info HeaderGroup) => OL.IsLabel t (O.MethodProxy info HeaderGroup) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#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
MIO.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
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
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
$ 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
"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.OverloadedMethod HeaderGroupAddHeaderBarMethodInfo a signature where
overloadedMethod = headerGroupAddHeaderBar
instance O.OverloadedMethodInfo HeaderGroupAddHeaderBarMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Handy.Objects.HeaderGroup.headerGroupAddHeaderBar",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-handy-0.0.8/docs/GI-Handy-Objects-HeaderGroup.html#v: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.OverloadedMethod HeaderGroupGetFocusMethodInfo a signature where
overloadedMethod = headerGroupGetFocus
instance O.OverloadedMethodInfo HeaderGroupGetFocusMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Handy.Objects.HeaderGroup.headerGroupGetFocus",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-handy-0.0.8/docs/GI-Handy-Objects-HeaderGroup.html#v: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.OverloadedMethod HeaderGroupGetHeaderBarsMethodInfo a signature where
overloadedMethod = headerGroupGetHeaderBars
instance O.OverloadedMethodInfo HeaderGroupGetHeaderBarsMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Handy.Objects.HeaderGroup.headerGroupGetHeaderBars",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-handy-0.0.8/docs/GI-Handy-Objects-HeaderGroup.html#v: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.OverloadedMethod HeaderGroupRemoveHeaderBarMethodInfo a signature where
overloadedMethod = headerGroupRemoveHeaderBar
instance O.OverloadedMethodInfo HeaderGroupRemoveHeaderBarMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Handy.Objects.HeaderGroup.headerGroupRemoveHeaderBar",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-handy-0.0.8/docs/GI-Handy-Objects-HeaderGroup.html#v: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.OverloadedMethod HeaderGroupSetFocusMethodInfo a signature where
overloadedMethod = headerGroupSetFocus
instance O.OverloadedMethodInfo HeaderGroupSetFocusMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Handy.Objects.HeaderGroup.headerGroupSetFocus",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-handy-0.0.8/docs/GI-Handy-Objects-HeaderGroup.html#v:headerGroupSetFocus"
}
#endif