{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gdk.Objects.DisplayManager
(
DisplayManager(..) ,
IsDisplayManager ,
toDisplayManager ,
#if defined(ENABLE_OVERLOADING)
ResolveDisplayManagerMethod ,
#endif
displayManagerGet ,
#if defined(ENABLE_OVERLOADING)
DisplayManagerGetDefaultDisplayMethodInfo,
#endif
displayManagerGetDefaultDisplay ,
#if defined(ENABLE_OVERLOADING)
DisplayManagerListDisplaysMethodInfo ,
#endif
displayManagerListDisplays ,
#if defined(ENABLE_OVERLOADING)
DisplayManagerOpenDisplayMethodInfo ,
#endif
displayManagerOpenDisplay ,
#if defined(ENABLE_OVERLOADING)
DisplayManagerSetDefaultDisplayMethodInfo,
#endif
displayManagerSetDefaultDisplay ,
#if defined(ENABLE_OVERLOADING)
DisplayManagerDefaultDisplayPropertyInfo,
#endif
constructDisplayManagerDefaultDisplay ,
#if defined(ENABLE_OVERLOADING)
displayManagerDefaultDisplay ,
#endif
getDisplayManagerDefaultDisplay ,
setDisplayManagerDefaultDisplay ,
DisplayManagerDisplayOpenedCallback ,
#if defined(ENABLE_OVERLOADING)
DisplayManagerDisplayOpenedSignalInfo ,
#endif
afterDisplayManagerDisplayOpened ,
onDisplayManagerDisplayOpened ,
) 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.GHashTable as B.GHT
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.Kind as DK
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 {-# SOURCE #-} qualified GI.Gdk.Objects.Display as Gdk.Display
newtype DisplayManager = DisplayManager (SP.ManagedPtr DisplayManager)
deriving (DisplayManager -> DisplayManager -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DisplayManager -> DisplayManager -> Bool
$c/= :: DisplayManager -> DisplayManager -> Bool
== :: DisplayManager -> DisplayManager -> Bool
$c== :: DisplayManager -> DisplayManager -> Bool
Eq)
instance SP.ManagedPtrNewtype DisplayManager where
toManagedPtr :: DisplayManager -> ManagedPtr DisplayManager
toManagedPtr (DisplayManager ManagedPtr DisplayManager
p) = ManagedPtr DisplayManager
p
foreign import ccall "gdk_display_manager_get_type"
c_gdk_display_manager_get_type :: IO B.Types.GType
instance B.Types.TypedObject DisplayManager where
glibType :: IO GType
glibType = IO GType
c_gdk_display_manager_get_type
instance B.Types.GObject DisplayManager
class (SP.GObject o, O.IsDescendantOf DisplayManager o) => IsDisplayManager o
instance (SP.GObject o, O.IsDescendantOf DisplayManager o) => IsDisplayManager o
instance O.HasParentTypes DisplayManager
type instance O.ParentTypes DisplayManager = '[GObject.Object.Object]
toDisplayManager :: (MIO.MonadIO m, IsDisplayManager o) => o -> m DisplayManager
toDisplayManager :: forall (m :: * -> *) o.
(MonadIO m, IsDisplayManager o) =>
o -> m DisplayManager
toDisplayManager = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr DisplayManager -> DisplayManager
DisplayManager
instance B.GValue.IsGValue (Maybe DisplayManager) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gdk_display_manager_get_type
gvalueSet_ :: Ptr GValue -> Maybe DisplayManager -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DisplayManager
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr DisplayManager)
gvalueSet_ Ptr GValue
gv (P.Just DisplayManager
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DisplayManager
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe DisplayManager)
gvalueGet_ Ptr GValue
gv = do
Ptr DisplayManager
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr DisplayManager)
if Ptr DisplayManager
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr DisplayManager -> DisplayManager
DisplayManager Ptr DisplayManager
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveDisplayManagerMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveDisplayManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveDisplayManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveDisplayManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveDisplayManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveDisplayManagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveDisplayManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveDisplayManagerMethod "listDisplays" o = DisplayManagerListDisplaysMethodInfo
ResolveDisplayManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveDisplayManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveDisplayManagerMethod "openDisplay" o = DisplayManagerOpenDisplayMethodInfo
ResolveDisplayManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveDisplayManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveDisplayManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveDisplayManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveDisplayManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveDisplayManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveDisplayManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveDisplayManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveDisplayManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveDisplayManagerMethod "getDefaultDisplay" o = DisplayManagerGetDefaultDisplayMethodInfo
ResolveDisplayManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveDisplayManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveDisplayManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveDisplayManagerMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveDisplayManagerMethod "setDefaultDisplay" o = DisplayManagerSetDefaultDisplayMethodInfo
ResolveDisplayManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveDisplayManagerMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDisplayManagerMethod t DisplayManager, O.OverloadedMethod info DisplayManager p) => OL.IsLabel t (DisplayManager -> 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 ~ ResolveDisplayManagerMethod t DisplayManager, O.OverloadedMethod info DisplayManager p, R.HasField t DisplayManager p) => R.HasField t DisplayManager p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveDisplayManagerMethod t DisplayManager, O.OverloadedMethodInfo info DisplayManager) => OL.IsLabel t (O.MethodProxy info DisplayManager) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
type DisplayManagerDisplayOpenedCallback =
Gdk.Display.Display
-> IO ()
type C_DisplayManagerDisplayOpenedCallback =
Ptr DisplayManager ->
Ptr Gdk.Display.Display ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DisplayManagerDisplayOpenedCallback :: C_DisplayManagerDisplayOpenedCallback -> IO (FunPtr C_DisplayManagerDisplayOpenedCallback)
wrap_DisplayManagerDisplayOpenedCallback ::
GObject a => (a -> DisplayManagerDisplayOpenedCallback) ->
C_DisplayManagerDisplayOpenedCallback
wrap_DisplayManagerDisplayOpenedCallback :: forall a.
GObject a =>
(a -> DisplayManagerDisplayOpenedCallback)
-> C_DisplayManagerDisplayOpenedCallback
wrap_DisplayManagerDisplayOpenedCallback a -> DisplayManagerDisplayOpenedCallback
gi'cb Ptr DisplayManager
gi'selfPtr Ptr Display
display Ptr ()
_ = do
Display
display' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Display -> Display
Gdk.Display.Display) Ptr Display
display
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr DisplayManager
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \DisplayManager
gi'self -> a -> DisplayManagerDisplayOpenedCallback
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce DisplayManager
gi'self) Display
display'
onDisplayManagerDisplayOpened :: (IsDisplayManager a, MonadIO m) => a -> ((?self :: a) => DisplayManagerDisplayOpenedCallback) -> m SignalHandlerId
onDisplayManagerDisplayOpened :: forall a (m :: * -> *).
(IsDisplayManager a, MonadIO m) =>
a
-> ((?self::a) => DisplayManagerDisplayOpenedCallback)
-> m SignalHandlerId
onDisplayManagerDisplayOpened a
obj (?self::a) => DisplayManagerDisplayOpenedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> DisplayManagerDisplayOpenedCallback
wrapped a
self = let ?self = a
self in (?self::a) => DisplayManagerDisplayOpenedCallback
cb
let wrapped' :: C_DisplayManagerDisplayOpenedCallback
wrapped' = forall a.
GObject a =>
(a -> DisplayManagerDisplayOpenedCallback)
-> C_DisplayManagerDisplayOpenedCallback
wrap_DisplayManagerDisplayOpenedCallback a -> DisplayManagerDisplayOpenedCallback
wrapped
FunPtr C_DisplayManagerDisplayOpenedCallback
wrapped'' <- C_DisplayManagerDisplayOpenedCallback
-> IO (FunPtr C_DisplayManagerDisplayOpenedCallback)
mk_DisplayManagerDisplayOpenedCallback C_DisplayManagerDisplayOpenedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"display-opened" FunPtr C_DisplayManagerDisplayOpenedCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing
afterDisplayManagerDisplayOpened :: (IsDisplayManager a, MonadIO m) => a -> ((?self :: a) => DisplayManagerDisplayOpenedCallback) -> m SignalHandlerId
afterDisplayManagerDisplayOpened :: forall a (m :: * -> *).
(IsDisplayManager a, MonadIO m) =>
a
-> ((?self::a) => DisplayManagerDisplayOpenedCallback)
-> m SignalHandlerId
afterDisplayManagerDisplayOpened a
obj (?self::a) => DisplayManagerDisplayOpenedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> DisplayManagerDisplayOpenedCallback
wrapped a
self = let ?self = a
self in (?self::a) => DisplayManagerDisplayOpenedCallback
cb
let wrapped' :: C_DisplayManagerDisplayOpenedCallback
wrapped' = forall a.
GObject a =>
(a -> DisplayManagerDisplayOpenedCallback)
-> C_DisplayManagerDisplayOpenedCallback
wrap_DisplayManagerDisplayOpenedCallback a -> DisplayManagerDisplayOpenedCallback
wrapped
FunPtr C_DisplayManagerDisplayOpenedCallback
wrapped'' <- C_DisplayManagerDisplayOpenedCallback
-> IO (FunPtr C_DisplayManagerDisplayOpenedCallback)
mk_DisplayManagerDisplayOpenedCallback C_DisplayManagerDisplayOpenedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"display-opened" FunPtr C_DisplayManagerDisplayOpenedCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data DisplayManagerDisplayOpenedSignalInfo
instance SignalInfo DisplayManagerDisplayOpenedSignalInfo where
type HaskellCallbackType DisplayManagerDisplayOpenedSignalInfo = DisplayManagerDisplayOpenedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_DisplayManagerDisplayOpenedCallback cb
cb'' <- mk_DisplayManagerDisplayOpenedCallback cb'
connectSignalFunPtr obj "display-opened" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Objects.DisplayManager::display-opened"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Objects-DisplayManager.html#g:signal:displayOpened"})
#endif
getDisplayManagerDefaultDisplay :: (MonadIO m, IsDisplayManager o) => o -> m (Maybe Gdk.Display.Display)
getDisplayManagerDefaultDisplay :: forall (m :: * -> *) o.
(MonadIO m, IsDisplayManager o) =>
o -> m (Maybe Display)
getDisplayManagerDefaultDisplay o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"default-display" ManagedPtr Display -> Display
Gdk.Display.Display
setDisplayManagerDefaultDisplay :: (MonadIO m, IsDisplayManager o, Gdk.Display.IsDisplay a) => o -> a -> m ()
setDisplayManagerDefaultDisplay :: forall (m :: * -> *) o a.
(MonadIO m, IsDisplayManager o, IsDisplay a) =>
o -> a -> m ()
setDisplayManagerDefaultDisplay o
obj a
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"default-display" (forall a. a -> Maybe a
Just a
val)
constructDisplayManagerDefaultDisplay :: (IsDisplayManager o, MIO.MonadIO m, Gdk.Display.IsDisplay a) => a -> m (GValueConstruct o)
constructDisplayManagerDefaultDisplay :: forall o (m :: * -> *) a.
(IsDisplayManager o, MonadIO m, IsDisplay a) =>
a -> m (GValueConstruct o)
constructDisplayManagerDefaultDisplay a
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"default-display" (forall a. a -> Maybe a
P.Just a
val)
#if defined(ENABLE_OVERLOADING)
data DisplayManagerDefaultDisplayPropertyInfo
instance AttrInfo DisplayManagerDefaultDisplayPropertyInfo where
type AttrAllowedOps DisplayManagerDefaultDisplayPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint DisplayManagerDefaultDisplayPropertyInfo = IsDisplayManager
type AttrSetTypeConstraint DisplayManagerDefaultDisplayPropertyInfo = Gdk.Display.IsDisplay
type AttrTransferTypeConstraint DisplayManagerDefaultDisplayPropertyInfo = Gdk.Display.IsDisplay
type AttrTransferType DisplayManagerDefaultDisplayPropertyInfo = Gdk.Display.Display
type AttrGetType DisplayManagerDefaultDisplayPropertyInfo = (Maybe Gdk.Display.Display)
type AttrLabel DisplayManagerDefaultDisplayPropertyInfo = "default-display"
type AttrOrigin DisplayManagerDefaultDisplayPropertyInfo = DisplayManager
attrGet = getDisplayManagerDefaultDisplay
attrSet = setDisplayManagerDefaultDisplay
attrTransfer _ v = do
unsafeCastTo Gdk.Display.Display v
attrConstruct = constructDisplayManagerDefaultDisplay
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Objects.DisplayManager.defaultDisplay"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Objects-DisplayManager.html#g:attr:defaultDisplay"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DisplayManager
type instance O.AttributeList DisplayManager = DisplayManagerAttributeList
type DisplayManagerAttributeList = ('[ '("defaultDisplay", DisplayManagerDefaultDisplayPropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
displayManagerDefaultDisplay :: AttrLabelProxy "defaultDisplay"
displayManagerDefaultDisplay = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList DisplayManager = DisplayManagerSignalList
type DisplayManagerSignalList = ('[ '("displayOpened", DisplayManagerDisplayOpenedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "gdk_display_manager_get_default_display" gdk_display_manager_get_default_display ::
Ptr DisplayManager ->
IO (Ptr Gdk.Display.Display)
displayManagerGetDefaultDisplay ::
(B.CallStack.HasCallStack, MonadIO m, IsDisplayManager a) =>
a
-> m (Maybe Gdk.Display.Display)
displayManagerGetDefaultDisplay :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDisplayManager a) =>
a -> m (Maybe Display)
displayManagerGetDefaultDisplay a
manager = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DisplayManager
manager' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
Ptr Display
result <- Ptr DisplayManager -> IO (Ptr Display)
gdk_display_manager_get_default_display Ptr DisplayManager
manager'
Maybe Display
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Display
result forall a b. (a -> b) -> a -> b
$ \Ptr Display
result' -> do
Display
result'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Display -> Display
Gdk.Display.Display) Ptr Display
result'
forall (m :: * -> *) a. Monad m => a -> m a
return Display
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Display
maybeResult
#if defined(ENABLE_OVERLOADING)
data DisplayManagerGetDefaultDisplayMethodInfo
instance (signature ~ (m (Maybe Gdk.Display.Display)), MonadIO m, IsDisplayManager a) => O.OverloadedMethod DisplayManagerGetDefaultDisplayMethodInfo a signature where
overloadedMethod = displayManagerGetDefaultDisplay
instance O.OverloadedMethodInfo DisplayManagerGetDefaultDisplayMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Objects.DisplayManager.displayManagerGetDefaultDisplay",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Objects-DisplayManager.html#v:displayManagerGetDefaultDisplay"
})
#endif
foreign import ccall "gdk_display_manager_list_displays" gdk_display_manager_list_displays ::
Ptr DisplayManager ->
IO (Ptr (GSList (Ptr Gdk.Display.Display)))
displayManagerListDisplays ::
(B.CallStack.HasCallStack, MonadIO m, IsDisplayManager a) =>
a
-> m [Gdk.Display.Display]
displayManagerListDisplays :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDisplayManager a) =>
a -> m [Display]
displayManagerListDisplays a
manager = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DisplayManager
manager' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
Ptr (GSList (Ptr Display))
result <- Ptr DisplayManager -> IO (Ptr (GSList (Ptr Display)))
gdk_display_manager_list_displays Ptr DisplayManager
manager'
[Ptr Display]
result' <- forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList (Ptr Display))
result
[Display]
result'' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Display -> Display
Gdk.Display.Display) [Ptr Display]
result'
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr Display))
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
forall (m :: * -> *) a. Monad m => a -> m a
return [Display]
result''
#if defined(ENABLE_OVERLOADING)
data DisplayManagerListDisplaysMethodInfo
instance (signature ~ (m [Gdk.Display.Display]), MonadIO m, IsDisplayManager a) => O.OverloadedMethod DisplayManagerListDisplaysMethodInfo a signature where
overloadedMethod = displayManagerListDisplays
instance O.OverloadedMethodInfo DisplayManagerListDisplaysMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Objects.DisplayManager.displayManagerListDisplays",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Objects-DisplayManager.html#v:displayManagerListDisplays"
})
#endif
foreign import ccall "gdk_display_manager_open_display" gdk_display_manager_open_display ::
Ptr DisplayManager ->
CString ->
IO (Ptr Gdk.Display.Display)
displayManagerOpenDisplay ::
(B.CallStack.HasCallStack, MonadIO m, IsDisplayManager a) =>
a
-> T.Text
-> m (Maybe Gdk.Display.Display)
displayManagerOpenDisplay :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDisplayManager a) =>
a -> Text -> m (Maybe Display)
displayManagerOpenDisplay a
manager Text
name = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DisplayManager
manager' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr Display
result <- Ptr DisplayManager -> CString -> IO (Ptr Display)
gdk_display_manager_open_display Ptr DisplayManager
manager' CString
name'
Maybe Display
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Display
result forall a b. (a -> b) -> a -> b
$ \Ptr Display
result' -> do
Display
result'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Display -> Display
Gdk.Display.Display) Ptr Display
result'
forall (m :: * -> *) a. Monad m => a -> m a
return Display
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
forall a. Ptr a -> IO ()
freeMem CString
name'
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Display
maybeResult
#if defined(ENABLE_OVERLOADING)
data DisplayManagerOpenDisplayMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gdk.Display.Display)), MonadIO m, IsDisplayManager a) => O.OverloadedMethod DisplayManagerOpenDisplayMethodInfo a signature where
overloadedMethod = displayManagerOpenDisplay
instance O.OverloadedMethodInfo DisplayManagerOpenDisplayMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Objects.DisplayManager.displayManagerOpenDisplay",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Objects-DisplayManager.html#v:displayManagerOpenDisplay"
})
#endif
foreign import ccall "gdk_display_manager_set_default_display" gdk_display_manager_set_default_display ::
Ptr DisplayManager ->
Ptr Gdk.Display.Display ->
IO ()
displayManagerSetDefaultDisplay ::
(B.CallStack.HasCallStack, MonadIO m, IsDisplayManager a, Gdk.Display.IsDisplay b) =>
a
-> b
-> m ()
displayManagerSetDefaultDisplay :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDisplayManager a, IsDisplay b) =>
a -> b -> m ()
displayManagerSetDefaultDisplay a
manager b
display = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DisplayManager
manager' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
Ptr Display
display' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
display
Ptr DisplayManager -> Ptr Display -> IO ()
gdk_display_manager_set_default_display Ptr DisplayManager
manager' Ptr Display
display'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
display
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DisplayManagerSetDefaultDisplayMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDisplayManager a, Gdk.Display.IsDisplay b) => O.OverloadedMethod DisplayManagerSetDefaultDisplayMethodInfo a signature where
overloadedMethod = displayManagerSetDefaultDisplay
instance O.OverloadedMethodInfo DisplayManagerSetDefaultDisplayMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Objects.DisplayManager.displayManagerSetDefaultDisplay",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Objects-DisplayManager.html#v:displayManagerSetDefaultDisplay"
})
#endif
foreign import ccall "gdk_display_manager_get" gdk_display_manager_get ::
IO (Ptr DisplayManager)
displayManagerGet ::
(B.CallStack.HasCallStack, MonadIO m) =>
m DisplayManager
displayManagerGet :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m DisplayManager
displayManagerGet = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DisplayManager
result <- IO (Ptr DisplayManager)
gdk_display_manager_get
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"displayManagerGet" Ptr DisplayManager
result
DisplayManager
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DisplayManager -> DisplayManager
DisplayManager) Ptr DisplayManager
result
forall (m :: * -> *) a. Monad m => a -> m a
return DisplayManager
result'
#if defined(ENABLE_OVERLOADING)
#endif