{-# 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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import qualified GI.Cairo.Enums as Cairo.Enums
import qualified GI.Cairo.Structs.Context as Cairo.Context
import qualified GI.Cairo.Structs.Region as Cairo.Region
import qualified GI.Cairo.Structs.Surface as Cairo.Surface
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.String as GLib.String
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gdk.Enums as Gdk.Enums
import {-# SOURCE #-} qualified GI.Gdk.Flags as Gdk.Flags
import {-# SOURCE #-} qualified GI.Gdk.Interfaces.Paintable as Gdk.Paintable
import {-# SOURCE #-} qualified GI.Gdk.Objects.AppLaunchContext as Gdk.AppLaunchContext
import {-# SOURCE #-} qualified GI.Gdk.Objects.CairoContext as Gdk.CairoContext
import {-# SOURCE #-} qualified GI.Gdk.Objects.Clipboard as Gdk.Clipboard
import {-# SOURCE #-} qualified GI.Gdk.Objects.ContentProvider as Gdk.ContentProvider
import {-# SOURCE #-} qualified GI.Gdk.Objects.Cursor as Gdk.Cursor
import {-# SOURCE #-} qualified GI.Gdk.Objects.Device as Gdk.Device
import {-# SOURCE #-} qualified GI.Gdk.Objects.DeviceTool as Gdk.DeviceTool
import {-# SOURCE #-} qualified GI.Gdk.Objects.Display as Gdk.Display
import {-# SOURCE #-} qualified GI.Gdk.Objects.DrawContext as Gdk.DrawContext
import {-# SOURCE #-} qualified GI.Gdk.Objects.Event as Gdk.Event
import {-# SOURCE #-} qualified GI.Gdk.Objects.FrameClock as Gdk.FrameClock
import {-# SOURCE #-} qualified GI.Gdk.Objects.GLContext as Gdk.GLContext
import {-# SOURCE #-} qualified GI.Gdk.Objects.Monitor as Gdk.Monitor
import {-# SOURCE #-} qualified GI.Gdk.Objects.Seat as Gdk.Seat
import {-# SOURCE #-} qualified GI.Gdk.Objects.Snapshot as Gdk.Snapshot
import {-# SOURCE #-} qualified GI.Gdk.Objects.Surface as Gdk.Surface
import {-# SOURCE #-} qualified GI.Gdk.Objects.Texture as Gdk.Texture
import {-# SOURCE #-} qualified GI.Gdk.Objects.VulkanContext as Gdk.VulkanContext
import {-# SOURCE #-} qualified GI.Gdk.Structs.ContentFormats as Gdk.ContentFormats
import {-# SOURCE #-} qualified GI.Gdk.Structs.DmabufFormats as Gdk.DmabufFormats
import {-# SOURCE #-} qualified GI.Gdk.Structs.EventSequence as Gdk.EventSequence
import {-# SOURCE #-} qualified GI.Gdk.Structs.FrameTimings as Gdk.FrameTimings
import {-# SOURCE #-} qualified GI.Gdk.Structs.KeymapKey as Gdk.KeymapKey
import {-# SOURCE #-} qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import {-# SOURCE #-} qualified GI.Gdk.Structs.TimeCoord as Gdk.TimeCoord
import qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Interfaces.File as Gio.File
import qualified GI.Gio.Interfaces.Icon as Gio.Icon
import qualified GI.Gio.Interfaces.Initable as Gio.Initable
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
import qualified GI.Gio.Interfaces.LoadableIcon as Gio.LoadableIcon
import qualified GI.Gio.Objects.AppLaunchContext as Gio.AppLaunchContext
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.InputStream as Gio.InputStream
import qualified GI.Gio.Objects.OutputStream as Gio.OutputStream
import qualified GI.Pango.Enums as Pango.Enums
#else
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gdk.Objects.Display as Gdk.Display
#endif
newtype DisplayManager = DisplayManager (SP.ManagedPtr DisplayManager)
deriving (DisplayManager -> DisplayManager -> Bool
(DisplayManager -> DisplayManager -> Bool)
-> (DisplayManager -> DisplayManager -> Bool) -> Eq DisplayManager
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DisplayManager -> DisplayManager -> Bool
== :: DisplayManager -> DisplayManager -> Bool
$c/= :: DisplayManager -> DisplayManager -> Bool
/= :: 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 = IO DisplayManager -> m DisplayManager
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO DisplayManager -> m DisplayManager)
-> (o -> IO DisplayManager) -> o -> m DisplayManager
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr DisplayManager -> DisplayManager)
-> o -> IO DisplayManager
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 = Ptr GValue -> Ptr DisplayManager -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr DisplayManager
forall a. Ptr a
FP.nullPtr :: FP.Ptr DisplayManager)
gvalueSet_ Ptr GValue
gv (P.Just DisplayManager
obj) = DisplayManager -> (Ptr DisplayManager -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DisplayManager
obj (Ptr GValue -> Ptr DisplayManager -> IO ()
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 <- Ptr GValue -> IO (Ptr DisplayManager)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr DisplayManager)
if ptr /= FP.nullPtr
then P.Just <$> B.ManagedPtr.newObject DisplayManager ptr
else return 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' <- ((ManagedPtr Display -> Display) -> Ptr Display -> IO 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
B.ManagedPtr.withNewObject gi'selfPtr $ \DisplayManager
gi'self -> a -> DisplayManagerDisplayOpenedCallback
gi'cb (DisplayManager -> a
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 = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> DisplayManagerDisplayOpenedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DisplayManagerDisplayOpenedCallback
DisplayManagerDisplayOpenedCallback
cb
let wrapped' :: C_DisplayManagerDisplayOpenedCallback
wrapped' = (a -> DisplayManagerDisplayOpenedCallback)
-> C_DisplayManagerDisplayOpenedCallback
forall a.
GObject a =>
(a -> DisplayManagerDisplayOpenedCallback)
-> C_DisplayManagerDisplayOpenedCallback
wrap_DisplayManagerDisplayOpenedCallback a -> DisplayManagerDisplayOpenedCallback
wrapped
wrapped'' <- C_DisplayManagerDisplayOpenedCallback
-> IO (FunPtr C_DisplayManagerDisplayOpenedCallback)
mk_DisplayManagerDisplayOpenedCallback C_DisplayManagerDisplayOpenedCallback
wrapped'
connectSignalFunPtr obj "display-opened" wrapped'' SignalConnectBefore 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 = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> DisplayManagerDisplayOpenedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DisplayManagerDisplayOpenedCallback
DisplayManagerDisplayOpenedCallback
cb
let wrapped' :: C_DisplayManagerDisplayOpenedCallback
wrapped' = (a -> DisplayManagerDisplayOpenedCallback)
-> C_DisplayManagerDisplayOpenedCallback
forall a.
GObject a =>
(a -> DisplayManagerDisplayOpenedCallback)
-> C_DisplayManagerDisplayOpenedCallback
wrap_DisplayManagerDisplayOpenedCallback a -> DisplayManagerDisplayOpenedCallback
wrapped
wrapped'' <- C_DisplayManagerDisplayOpenedCallback
-> IO (FunPtr C_DisplayManagerDisplayOpenedCallback)
mk_DisplayManagerDisplayOpenedCallback C_DisplayManagerDisplayOpenedCallback
wrapped'
connectSignalFunPtr obj "display-opened" wrapped'' SignalConnectAfter 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-4.0.9/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 = IO (Maybe Display) -> m (Maybe Display)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Display) -> m (Maybe Display))
-> IO (Maybe Display) -> m (Maybe Display)
forall a b. (a -> b) -> a -> b
$ o
-> String -> (ManagedPtr Display -> Display) -> IO (Maybe Display)
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 = IO () -> m ()
forall a. IO a -> m a
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
"default-display" (a -> Maybe a
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 = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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 a. IO a -> IO a
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
"default-display" (a -> Maybe a
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-4.0.9/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 = IO (Maybe Display) -> m (Maybe Display)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Display) -> m (Maybe Display))
-> IO (Maybe Display) -> m (Maybe Display)
forall a b. (a -> b) -> a -> b
$ do
manager' <- a -> IO (Ptr DisplayManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
result <- gdk_display_manager_get_default_display manager'
maybeResult <- convertIfNonNull result $ \Ptr Display
result' -> do
result'' <- ((ManagedPtr Display -> Display) -> Ptr Display -> IO 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
result'
return result''
touchManagedPtr manager
return 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-4.0.9/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 = IO [Display] -> m [Display]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Display] -> m [Display]) -> IO [Display] -> m [Display]
forall a b. (a -> b) -> a -> b
$ do
manager' <- a -> IO (Ptr DisplayManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
result <- gdk_display_manager_list_displays manager'
result' <- unpackGSList result
result'' <- mapM (newObject Gdk.Display.Display) result'
g_slist_free result
touchManagedPtr manager
return 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-4.0.9/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
-> Maybe (T.Text)
-> m (Maybe Gdk.Display.Display)
displayManagerOpenDisplay :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDisplayManager a) =>
a -> Maybe Text -> m (Maybe Display)
displayManagerOpenDisplay a
manager Maybe Text
name = IO (Maybe Display) -> m (Maybe Display)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Display) -> m (Maybe Display))
-> IO (Maybe Display) -> m (Maybe Display)
forall a b. (a -> b) -> a -> b
$ do
manager' <- a -> IO (Ptr DisplayManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
maybeName <- case name of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
FP.nullPtr
Just Text
jName -> do
jName' <- Text -> IO (Ptr CChar)
textToCString Text
jName
return jName'
result <- gdk_display_manager_open_display manager' maybeName
maybeResult <- convertIfNonNull result $ \Ptr Display
result' -> do
result'' <- ((ManagedPtr Display -> Display) -> Ptr Display -> IO 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
result'
return result''
touchManagedPtr manager
freeMem maybeName
return maybeResult
#if defined(ENABLE_OVERLOADING)
data DisplayManagerOpenDisplayMethodInfo
instance (signature ~ (Maybe (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-4.0.9/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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
manager' <- a -> IO (Ptr DisplayManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
display' <- unsafeManagedPtrCastPtr display
gdk_display_manager_set_default_display manager' display'
touchManagedPtr manager
touchManagedPtr display
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-4.0.9/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 = IO DisplayManager -> m DisplayManager
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DisplayManager -> m DisplayManager)
-> IO DisplayManager -> m DisplayManager
forall a b. (a -> b) -> a -> b
$ do
result <- IO (Ptr DisplayManager)
gdk_display_manager_get
checkUnexpectedReturnNULL "displayManagerGet" result
result' <- (newObject DisplayManager) result
return result'
#if defined(ENABLE_OVERLOADING)
#endif