{-# LANGUAGE 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 ,
noDisplayManager ,
#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 ,
C_DisplayManagerDisplayOpenedCallback ,
DisplayManagerDisplayOpenedCallback ,
#if defined(ENABLE_OVERLOADING)
DisplayManagerDisplayOpenedSignalInfo ,
#endif
afterDisplayManagerDisplayOpened ,
genClosure_DisplayManagerDisplayOpened ,
mk_DisplayManagerDisplayOpenedCallback ,
noDisplayManagerDisplayOpenedCallback ,
onDisplayManagerDisplayOpened ,
wrap_DisplayManagerDisplayOpenedCallback,
) 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.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 Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gdk.Objects.Display as Gdk.Display
newtype DisplayManager = DisplayManager (ManagedPtr DisplayManager)
deriving (Eq)
foreign import ccall "gdk_display_manager_get_type"
c_gdk_display_manager_get_type :: IO GType
instance GObject DisplayManager where
gobjectType = c_gdk_display_manager_get_type
instance B.GValue.IsGValue DisplayManager where
toGValue o = do
gtype <- c_gdk_display_manager_get_type
B.ManagedPtr.withManagedPtr o (B.GValue.buildGValue gtype B.GValue.set_object)
fromGValue gv = do
ptr <- B.GValue.get_object gv :: IO (Ptr DisplayManager)
B.ManagedPtr.newObject DisplayManager ptr
class (GObject o, O.IsDescendantOf DisplayManager o) => IsDisplayManager o
instance (GObject o, O.IsDescendantOf DisplayManager o) => IsDisplayManager o
instance O.HasParentTypes DisplayManager
type instance O.ParentTypes DisplayManager = '[GObject.Object.Object]
toDisplayManager :: (MonadIO m, IsDisplayManager o) => o -> m DisplayManager
toDisplayManager = liftIO . unsafeCastTo DisplayManager
noDisplayManager :: Maybe DisplayManager
noDisplayManager = Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveDisplayManagerMethod (t :: Symbol) (o :: *) :: * 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.MethodInfo 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
#endif
type DisplayManagerDisplayOpenedCallback =
Gdk.Display.Display
-> IO ()
noDisplayManagerDisplayOpenedCallback :: Maybe DisplayManagerDisplayOpenedCallback
noDisplayManagerDisplayOpenedCallback = Nothing
type C_DisplayManagerDisplayOpenedCallback =
Ptr () ->
Ptr Gdk.Display.Display ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DisplayManagerDisplayOpenedCallback :: C_DisplayManagerDisplayOpenedCallback -> IO (FunPtr C_DisplayManagerDisplayOpenedCallback)
genClosure_DisplayManagerDisplayOpened :: MonadIO m => DisplayManagerDisplayOpenedCallback -> m (GClosure C_DisplayManagerDisplayOpenedCallback)
genClosure_DisplayManagerDisplayOpened cb = liftIO $ do
let cb' = wrap_DisplayManagerDisplayOpenedCallback cb
mk_DisplayManagerDisplayOpenedCallback cb' >>= B.GClosure.newGClosure
wrap_DisplayManagerDisplayOpenedCallback ::
DisplayManagerDisplayOpenedCallback ->
C_DisplayManagerDisplayOpenedCallback
wrap_DisplayManagerDisplayOpenedCallback _cb _ display _ = do
display' <- (newObject Gdk.Display.Display) display
_cb display'
onDisplayManagerDisplayOpened :: (IsDisplayManager a, MonadIO m) => a -> DisplayManagerDisplayOpenedCallback -> m SignalHandlerId
onDisplayManagerDisplayOpened obj cb = liftIO $ do
let cb' = wrap_DisplayManagerDisplayOpenedCallback cb
cb'' <- mk_DisplayManagerDisplayOpenedCallback cb'
connectSignalFunPtr obj "display-opened" cb'' SignalConnectBefore Nothing
afterDisplayManagerDisplayOpened :: (IsDisplayManager a, MonadIO m) => a -> DisplayManagerDisplayOpenedCallback -> m SignalHandlerId
afterDisplayManagerDisplayOpened obj cb = liftIO $ do
let cb' = wrap_DisplayManagerDisplayOpenedCallback cb
cb'' <- mk_DisplayManagerDisplayOpenedCallback cb'
connectSignalFunPtr obj "display-opened" cb'' 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
#endif
getDisplayManagerDefaultDisplay :: (MonadIO m, IsDisplayManager o) => o -> m (Maybe Gdk.Display.Display)
getDisplayManagerDefaultDisplay obj = liftIO $ B.Properties.getObjectPropertyObject obj "default-display" Gdk.Display.Display
setDisplayManagerDefaultDisplay :: (MonadIO m, IsDisplayManager o, Gdk.Display.IsDisplay a) => o -> a -> m ()
setDisplayManagerDefaultDisplay obj val = liftIO $ B.Properties.setObjectPropertyObject obj "default-display" (Just val)
constructDisplayManagerDefaultDisplay :: (IsDisplayManager o, Gdk.Display.IsDisplay a) => a -> IO (GValueConstruct o)
constructDisplayManagerDefaultDisplay val = B.Properties.constructObjectPropertyObject "default-display" (Just 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
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DisplayManager
type instance O.AttributeList DisplayManager = DisplayManagerAttributeList
type DisplayManagerAttributeList = ('[ '("defaultDisplay", DisplayManagerDefaultDisplayPropertyInfo)] :: [(Symbol, *)])
#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, *)])
#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 manager = liftIO $ do
manager' <- unsafeManagedPtrCastPtr manager
result <- gdk_display_manager_get_default_display manager'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (newObject Gdk.Display.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.MethodInfo DisplayManagerGetDefaultDisplayMethodInfo a signature where
overloadedMethod = 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 manager = liftIO $ do
manager' <- unsafeManagedPtrCastPtr 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.MethodInfo DisplayManagerListDisplaysMethodInfo a signature where
overloadedMethod = 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 manager name = liftIO $ do
manager' <- unsafeManagedPtrCastPtr manager
name' <- textToCString name
result <- gdk_display_manager_open_display manager' name'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (newObject Gdk.Display.Display) result'
return result''
touchManagedPtr manager
freeMem name'
return maybeResult
#if defined(ENABLE_OVERLOADING)
data DisplayManagerOpenDisplayMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gdk.Display.Display)), MonadIO m, IsDisplayManager a) => O.MethodInfo DisplayManagerOpenDisplayMethodInfo a signature where
overloadedMethod = 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 manager display = liftIO $ do
manager' <- unsafeManagedPtrCastPtr 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.MethodInfo DisplayManagerSetDefaultDisplayMethodInfo a signature where
overloadedMethod = 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 = liftIO $ do
result <- gdk_display_manager_get
checkUnexpectedReturnNULL "displayManagerGet" result
result' <- (newObject DisplayManager) result
return result'
#if defined(ENABLE_OVERLOADING)
#endif