{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GdkX11.Objects.X11Screen
(
X11Screen(..) ,
IsX11Screen ,
toX11Screen ,
#if defined(ENABLE_OVERLOADING)
ResolveX11ScreenMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
X11ScreenGetCurrentDesktopMethodInfo ,
#endif
x11ScreenGetCurrentDesktop ,
#if defined(ENABLE_OVERLOADING)
X11ScreenGetMonitorOutputMethodInfo ,
#endif
x11ScreenGetMonitorOutput ,
#if defined(ENABLE_OVERLOADING)
X11ScreenGetNumberOfDesktopsMethodInfo ,
#endif
x11ScreenGetNumberOfDesktops ,
#if defined(ENABLE_OVERLOADING)
X11ScreenGetScreenNumberMethodInfo ,
#endif
x11ScreenGetScreenNumber ,
#if defined(ENABLE_OVERLOADING)
X11ScreenGetWindowManagerNameMethodInfo ,
#endif
x11ScreenGetWindowManagerName ,
#if defined(ENABLE_OVERLOADING)
X11ScreenGetXscreenMethodInfo ,
#endif
x11ScreenGetXscreen ,
#if defined(ENABLE_OVERLOADING)
X11ScreenLookupVisualMethodInfo ,
#endif
x11ScreenLookupVisual ,
#if defined(ENABLE_OVERLOADING)
X11ScreenSupportsNetWmHintMethodInfo ,
#endif
x11ScreenSupportsNetWmHint ,
X11ScreenWindowManagerChangedCallback ,
#if defined(ENABLE_OVERLOADING)
X11ScreenWindowManagerChangedSignalInfo ,
#endif
afterX11ScreenWindowManagerChanged ,
onX11ScreenWindowManagerChanged ,
) 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.Coerce as Coerce
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.Gdk.Objects.Screen as Gdk.Screen
import qualified GI.Gdk.Structs.Atom as Gdk.Atom
import {-# SOURCE #-} qualified GI.GdkX11.Objects.X11Visual as GdkX11.X11Visual
import qualified GI.Xlib.Structs.Screen as Xlib.Screen
newtype X11Screen = X11Screen (SP.ManagedPtr X11Screen)
deriving (X11Screen -> X11Screen -> Bool
(X11Screen -> X11Screen -> Bool)
-> (X11Screen -> X11Screen -> Bool) -> Eq X11Screen
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: X11Screen -> X11Screen -> Bool
$c/= :: X11Screen -> X11Screen -> Bool
== :: X11Screen -> X11Screen -> Bool
$c== :: X11Screen -> X11Screen -> Bool
Eq)
instance SP.ManagedPtrNewtype X11Screen where
toManagedPtr :: X11Screen -> ManagedPtr X11Screen
toManagedPtr (X11Screen ManagedPtr X11Screen
p) = ManagedPtr X11Screen
p
foreign import ccall "gdk_x11_screen_get_type"
c_gdk_x11_screen_get_type :: IO B.Types.GType
instance B.Types.TypedObject X11Screen where
glibType :: IO GType
glibType = IO GType
c_gdk_x11_screen_get_type
instance B.Types.GObject X11Screen
class (SP.GObject o, O.IsDescendantOf X11Screen o) => IsX11Screen o
instance (SP.GObject o, O.IsDescendantOf X11Screen o) => IsX11Screen o
instance O.HasParentTypes X11Screen
type instance O.ParentTypes X11Screen = '[Gdk.Screen.Screen, GObject.Object.Object]
toX11Screen :: (MIO.MonadIO m, IsX11Screen o) => o -> m X11Screen
toX11Screen :: forall (m :: * -> *) o.
(MonadIO m, IsX11Screen o) =>
o -> m X11Screen
toX11Screen = IO X11Screen -> m X11Screen
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO X11Screen -> m X11Screen)
-> (o -> IO X11Screen) -> o -> m X11Screen
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr X11Screen -> X11Screen) -> o -> IO X11Screen
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr X11Screen -> X11Screen
X11Screen
instance B.GValue.IsGValue (Maybe X11Screen) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gdk_x11_screen_get_type
gvalueSet_ :: Ptr GValue -> Maybe X11Screen -> IO ()
gvalueSet_ Ptr GValue
gv Maybe X11Screen
P.Nothing = Ptr GValue -> Ptr X11Screen -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr X11Screen
forall a. Ptr a
FP.nullPtr :: FP.Ptr X11Screen)
gvalueSet_ Ptr GValue
gv (P.Just X11Screen
obj) = X11Screen -> (Ptr X11Screen -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr X11Screen
obj (Ptr GValue -> Ptr X11Screen -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe X11Screen)
gvalueGet_ Ptr GValue
gv = do
Ptr X11Screen
ptr <- Ptr GValue -> IO (Ptr X11Screen)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr X11Screen)
if Ptr X11Screen
ptr Ptr X11Screen -> Ptr X11Screen -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr X11Screen
forall a. Ptr a
FP.nullPtr
then X11Screen -> Maybe X11Screen
forall a. a -> Maybe a
P.Just (X11Screen -> Maybe X11Screen)
-> IO X11Screen -> IO (Maybe X11Screen)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr X11Screen -> X11Screen)
-> Ptr X11Screen -> IO X11Screen
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr X11Screen -> X11Screen
X11Screen Ptr X11Screen
ptr
else Maybe X11Screen -> IO (Maybe X11Screen)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe X11Screen
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveX11ScreenMethod (t :: Symbol) (o :: *) :: * where
ResolveX11ScreenMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveX11ScreenMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveX11ScreenMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveX11ScreenMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveX11ScreenMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveX11ScreenMethod "isComposited" o = Gdk.Screen.ScreenIsCompositedMethodInfo
ResolveX11ScreenMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveX11ScreenMethod "listVisuals" o = Gdk.Screen.ScreenListVisualsMethodInfo
ResolveX11ScreenMethod "lookupVisual" o = X11ScreenLookupVisualMethodInfo
ResolveX11ScreenMethod "makeDisplayName" o = Gdk.Screen.ScreenMakeDisplayNameMethodInfo
ResolveX11ScreenMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveX11ScreenMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveX11ScreenMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveX11ScreenMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveX11ScreenMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveX11ScreenMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveX11ScreenMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveX11ScreenMethod "supportsNetWmHint" o = X11ScreenSupportsNetWmHintMethodInfo
ResolveX11ScreenMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveX11ScreenMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveX11ScreenMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveX11ScreenMethod "getActiveWindow" o = Gdk.Screen.ScreenGetActiveWindowMethodInfo
ResolveX11ScreenMethod "getCurrentDesktop" o = X11ScreenGetCurrentDesktopMethodInfo
ResolveX11ScreenMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveX11ScreenMethod "getDisplay" o = Gdk.Screen.ScreenGetDisplayMethodInfo
ResolveX11ScreenMethod "getFontOptions" o = Gdk.Screen.ScreenGetFontOptionsMethodInfo
ResolveX11ScreenMethod "getHeight" o = Gdk.Screen.ScreenGetHeightMethodInfo
ResolveX11ScreenMethod "getHeightMm" o = Gdk.Screen.ScreenGetHeightMmMethodInfo
ResolveX11ScreenMethod "getMonitorAtPoint" o = Gdk.Screen.ScreenGetMonitorAtPointMethodInfo
ResolveX11ScreenMethod "getMonitorAtWindow" o = Gdk.Screen.ScreenGetMonitorAtWindowMethodInfo
ResolveX11ScreenMethod "getMonitorGeometry" o = Gdk.Screen.ScreenGetMonitorGeometryMethodInfo
ResolveX11ScreenMethod "getMonitorHeightMm" o = Gdk.Screen.ScreenGetMonitorHeightMmMethodInfo
ResolveX11ScreenMethod "getMonitorOutput" o = X11ScreenGetMonitorOutputMethodInfo
ResolveX11ScreenMethod "getMonitorPlugName" o = Gdk.Screen.ScreenGetMonitorPlugNameMethodInfo
ResolveX11ScreenMethod "getMonitorScaleFactor" o = Gdk.Screen.ScreenGetMonitorScaleFactorMethodInfo
ResolveX11ScreenMethod "getMonitorWidthMm" o = Gdk.Screen.ScreenGetMonitorWidthMmMethodInfo
ResolveX11ScreenMethod "getMonitorWorkarea" o = Gdk.Screen.ScreenGetMonitorWorkareaMethodInfo
ResolveX11ScreenMethod "getNMonitors" o = Gdk.Screen.ScreenGetNMonitorsMethodInfo
ResolveX11ScreenMethod "getNumber" o = Gdk.Screen.ScreenGetNumberMethodInfo
ResolveX11ScreenMethod "getNumberOfDesktops" o = X11ScreenGetNumberOfDesktopsMethodInfo
ResolveX11ScreenMethod "getPrimaryMonitor" o = Gdk.Screen.ScreenGetPrimaryMonitorMethodInfo
ResolveX11ScreenMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveX11ScreenMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveX11ScreenMethod "getResolution" o = Gdk.Screen.ScreenGetResolutionMethodInfo
ResolveX11ScreenMethod "getRgbaVisual" o = Gdk.Screen.ScreenGetRgbaVisualMethodInfo
ResolveX11ScreenMethod "getRootWindow" o = Gdk.Screen.ScreenGetRootWindowMethodInfo
ResolveX11ScreenMethod "getScreenNumber" o = X11ScreenGetScreenNumberMethodInfo
ResolveX11ScreenMethod "getSetting" o = Gdk.Screen.ScreenGetSettingMethodInfo
ResolveX11ScreenMethod "getSystemVisual" o = Gdk.Screen.ScreenGetSystemVisualMethodInfo
ResolveX11ScreenMethod "getToplevelWindows" o = Gdk.Screen.ScreenGetToplevelWindowsMethodInfo
ResolveX11ScreenMethod "getWidth" o = Gdk.Screen.ScreenGetWidthMethodInfo
ResolveX11ScreenMethod "getWidthMm" o = Gdk.Screen.ScreenGetWidthMmMethodInfo
ResolveX11ScreenMethod "getWindowManagerName" o = X11ScreenGetWindowManagerNameMethodInfo
ResolveX11ScreenMethod "getWindowStack" o = Gdk.Screen.ScreenGetWindowStackMethodInfo
ResolveX11ScreenMethod "getXscreen" o = X11ScreenGetXscreenMethodInfo
ResolveX11ScreenMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveX11ScreenMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveX11ScreenMethod "setFontOptions" o = Gdk.Screen.ScreenSetFontOptionsMethodInfo
ResolveX11ScreenMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveX11ScreenMethod "setResolution" o = Gdk.Screen.ScreenSetResolutionMethodInfo
ResolveX11ScreenMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveX11ScreenMethod t X11Screen, O.OverloadedMethod info X11Screen p) => OL.IsLabel t (X11Screen -> 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 ~ ResolveX11ScreenMethod t X11Screen, O.OverloadedMethod info X11Screen p, R.HasField t X11Screen p) => R.HasField t X11Screen p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveX11ScreenMethod t X11Screen, O.OverloadedMethodInfo info X11Screen) => OL.IsLabel t (O.MethodProxy info X11Screen) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
type X11ScreenWindowManagerChangedCallback =
IO ()
type C_X11ScreenWindowManagerChangedCallback =
Ptr X11Screen ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_X11ScreenWindowManagerChangedCallback :: C_X11ScreenWindowManagerChangedCallback -> IO (FunPtr C_X11ScreenWindowManagerChangedCallback)
wrap_X11ScreenWindowManagerChangedCallback ::
GObject a => (a -> X11ScreenWindowManagerChangedCallback) ->
C_X11ScreenWindowManagerChangedCallback
wrap_X11ScreenWindowManagerChangedCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_X11ScreenWindowManagerChangedCallback
wrap_X11ScreenWindowManagerChangedCallback a -> IO ()
gi'cb Ptr X11Screen
gi'selfPtr Ptr ()
_ = do
Ptr X11Screen -> (X11Screen -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr X11Screen
gi'selfPtr ((X11Screen -> IO ()) -> IO ()) -> (X11Screen -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \X11Screen
gi'self -> a -> IO ()
gi'cb (X11Screen -> a
Coerce.coerce X11Screen
gi'self)
onX11ScreenWindowManagerChanged :: (IsX11Screen a, MonadIO m) => a -> ((?self :: a) => X11ScreenWindowManagerChangedCallback) -> m SignalHandlerId
onX11ScreenWindowManagerChanged :: forall a (m :: * -> *).
(IsX11Screen a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onX11ScreenWindowManagerChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
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 -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_X11ScreenWindowManagerChangedCallback
wrapped' = (a -> IO ()) -> C_X11ScreenWindowManagerChangedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_X11ScreenWindowManagerChangedCallback
wrap_X11ScreenWindowManagerChangedCallback a -> IO ()
wrapped
FunPtr C_X11ScreenWindowManagerChangedCallback
wrapped'' <- C_X11ScreenWindowManagerChangedCallback
-> IO (FunPtr C_X11ScreenWindowManagerChangedCallback)
mk_X11ScreenWindowManagerChangedCallback C_X11ScreenWindowManagerChangedCallback
wrapped'
a
-> Text
-> FunPtr C_X11ScreenWindowManagerChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"window-manager-changed" FunPtr C_X11ScreenWindowManagerChangedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterX11ScreenWindowManagerChanged :: (IsX11Screen a, MonadIO m) => a -> ((?self :: a) => X11ScreenWindowManagerChangedCallback) -> m SignalHandlerId
afterX11ScreenWindowManagerChanged :: forall a (m :: * -> *).
(IsX11Screen a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterX11ScreenWindowManagerChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
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 -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_X11ScreenWindowManagerChangedCallback
wrapped' = (a -> IO ()) -> C_X11ScreenWindowManagerChangedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_X11ScreenWindowManagerChangedCallback
wrap_X11ScreenWindowManagerChangedCallback a -> IO ()
wrapped
FunPtr C_X11ScreenWindowManagerChangedCallback
wrapped'' <- C_X11ScreenWindowManagerChangedCallback
-> IO (FunPtr C_X11ScreenWindowManagerChangedCallback)
mk_X11ScreenWindowManagerChangedCallback C_X11ScreenWindowManagerChangedCallback
wrapped'
a
-> Text
-> FunPtr C_X11ScreenWindowManagerChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"window-manager-changed" FunPtr C_X11ScreenWindowManagerChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data X11ScreenWindowManagerChangedSignalInfo
instance SignalInfo X11ScreenWindowManagerChangedSignalInfo where
type HaskellCallbackType X11ScreenWindowManagerChangedSignalInfo = X11ScreenWindowManagerChangedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_X11ScreenWindowManagerChangedCallback cb
cb'' <- mk_X11ScreenWindowManagerChangedCallback cb'
connectSignalFunPtr obj "window-manager-changed" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GdkX11.Objects.X11Screen::window-manager-changed"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkx11-3.0.12/docs/GI-GdkX11-Objects-X11Screen.html#g:signal:windowManagerChanged"})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList X11Screen
type instance O.AttributeList X11Screen = X11ScreenAttributeList
type X11ScreenAttributeList = ('[ '("fontOptions", Gdk.Screen.ScreenFontOptionsPropertyInfo), '("resolution", Gdk.Screen.ScreenResolutionPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList X11Screen = X11ScreenSignalList
type X11ScreenSignalList = ('[ '("compositedChanged", Gdk.Screen.ScreenCompositedChangedSignalInfo), '("monitorsChanged", Gdk.Screen.ScreenMonitorsChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("sizeChanged", Gdk.Screen.ScreenSizeChangedSignalInfo), '("windowManagerChanged", X11ScreenWindowManagerChangedSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gdk_x11_screen_get_current_desktop" gdk_x11_screen_get_current_desktop ::
Ptr X11Screen ->
IO Word32
x11ScreenGetCurrentDesktop ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Screen a) =>
a
-> m Word32
x11ScreenGetCurrentDesktop :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Screen a) =>
a -> m Word32
x11ScreenGetCurrentDesktop a
screen = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Screen
screen' <- a -> IO (Ptr X11Screen)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
screen
Word32
result <- Ptr X11Screen -> IO Word32
gdk_x11_screen_get_current_desktop Ptr X11Screen
screen'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
screen
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data X11ScreenGetCurrentDesktopMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsX11Screen a) => O.OverloadedMethod X11ScreenGetCurrentDesktopMethodInfo a signature where
overloadedMethod = x11ScreenGetCurrentDesktop
instance O.OverloadedMethodInfo X11ScreenGetCurrentDesktopMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GdkX11.Objects.X11Screen.x11ScreenGetCurrentDesktop",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkx11-3.0.12/docs/GI-GdkX11-Objects-X11Screen.html#v:x11ScreenGetCurrentDesktop"
})
#endif
foreign import ccall "gdk_x11_screen_get_monitor_output" gdk_x11_screen_get_monitor_output ::
Ptr X11Screen ->
Int32 ->
IO CULong
x11ScreenGetMonitorOutput ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Screen a) =>
a
-> Int32
-> m CULong
x11ScreenGetMonitorOutput :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Screen a) =>
a -> Int32 -> m SignalHandlerId
x11ScreenGetMonitorOutput a
screen Int32
monitorNum = IO SignalHandlerId -> m SignalHandlerId
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
Ptr X11Screen
screen' <- a -> IO (Ptr X11Screen)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
screen
SignalHandlerId
result <- Ptr X11Screen -> Int32 -> IO SignalHandlerId
gdk_x11_screen_get_monitor_output Ptr X11Screen
screen' Int32
monitorNum
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
screen
SignalHandlerId -> IO SignalHandlerId
forall (m :: * -> *) a. Monad m => a -> m a
return SignalHandlerId
result
#if defined(ENABLE_OVERLOADING)
data X11ScreenGetMonitorOutputMethodInfo
instance (signature ~ (Int32 -> m CULong), MonadIO m, IsX11Screen a) => O.OverloadedMethod X11ScreenGetMonitorOutputMethodInfo a signature where
overloadedMethod = x11ScreenGetMonitorOutput
instance O.OverloadedMethodInfo X11ScreenGetMonitorOutputMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GdkX11.Objects.X11Screen.x11ScreenGetMonitorOutput",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkx11-3.0.12/docs/GI-GdkX11-Objects-X11Screen.html#v:x11ScreenGetMonitorOutput"
})
#endif
foreign import ccall "gdk_x11_screen_get_number_of_desktops" gdk_x11_screen_get_number_of_desktops ::
Ptr X11Screen ->
IO Word32
x11ScreenGetNumberOfDesktops ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Screen a) =>
a
-> m Word32
x11ScreenGetNumberOfDesktops :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Screen a) =>
a -> m Word32
x11ScreenGetNumberOfDesktops a
screen = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Screen
screen' <- a -> IO (Ptr X11Screen)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
screen
Word32
result <- Ptr X11Screen -> IO Word32
gdk_x11_screen_get_number_of_desktops Ptr X11Screen
screen'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
screen
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data X11ScreenGetNumberOfDesktopsMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsX11Screen a) => O.OverloadedMethod X11ScreenGetNumberOfDesktopsMethodInfo a signature where
overloadedMethod = x11ScreenGetNumberOfDesktops
instance O.OverloadedMethodInfo X11ScreenGetNumberOfDesktopsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GdkX11.Objects.X11Screen.x11ScreenGetNumberOfDesktops",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkx11-3.0.12/docs/GI-GdkX11-Objects-X11Screen.html#v:x11ScreenGetNumberOfDesktops"
})
#endif
foreign import ccall "gdk_x11_screen_get_screen_number" gdk_x11_screen_get_screen_number ::
Ptr X11Screen ->
IO Int32
x11ScreenGetScreenNumber ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Screen a) =>
a
-> m Int32
x11ScreenGetScreenNumber :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Screen a) =>
a -> m Int32
x11ScreenGetScreenNumber a
screen = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Screen
screen' <- a -> IO (Ptr X11Screen)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
screen
Int32
result <- Ptr X11Screen -> IO Int32
gdk_x11_screen_get_screen_number Ptr X11Screen
screen'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
screen
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data X11ScreenGetScreenNumberMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsX11Screen a) => O.OverloadedMethod X11ScreenGetScreenNumberMethodInfo a signature where
overloadedMethod = x11ScreenGetScreenNumber
instance O.OverloadedMethodInfo X11ScreenGetScreenNumberMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GdkX11.Objects.X11Screen.x11ScreenGetScreenNumber",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkx11-3.0.12/docs/GI-GdkX11-Objects-X11Screen.html#v:x11ScreenGetScreenNumber"
})
#endif
foreign import ccall "gdk_x11_screen_get_window_manager_name" gdk_x11_screen_get_window_manager_name ::
Ptr X11Screen ->
IO CString
x11ScreenGetWindowManagerName ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Screen a) =>
a
-> m T.Text
x11ScreenGetWindowManagerName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Screen a) =>
a -> m Text
x11ScreenGetWindowManagerName a
screen = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Screen
screen' <- a -> IO (Ptr X11Screen)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
screen
CString
result <- Ptr X11Screen -> IO CString
gdk_x11_screen_get_window_manager_name Ptr X11Screen
screen'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"x11ScreenGetWindowManagerName" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
screen
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data X11ScreenGetWindowManagerNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsX11Screen a) => O.OverloadedMethod X11ScreenGetWindowManagerNameMethodInfo a signature where
overloadedMethod = x11ScreenGetWindowManagerName
instance O.OverloadedMethodInfo X11ScreenGetWindowManagerNameMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GdkX11.Objects.X11Screen.x11ScreenGetWindowManagerName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkx11-3.0.12/docs/GI-GdkX11-Objects-X11Screen.html#v:x11ScreenGetWindowManagerName"
})
#endif
foreign import ccall "gdk_x11_screen_get_xscreen" gdk_x11_screen_get_xscreen ::
Ptr X11Screen ->
IO (Ptr Xlib.Screen.Screen)
x11ScreenGetXscreen ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Screen a) =>
a
-> m Xlib.Screen.Screen
x11ScreenGetXscreen :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Screen a) =>
a -> m Screen
x11ScreenGetXscreen a
screen = IO Screen -> m Screen
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Screen -> m Screen) -> IO Screen -> m Screen
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Screen
screen' <- a -> IO (Ptr X11Screen)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
screen
Ptr Screen
result <- Ptr X11Screen -> IO (Ptr Screen)
gdk_x11_screen_get_xscreen Ptr X11Screen
screen'
Text -> Ptr Screen -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"x11ScreenGetXscreen" Ptr Screen
result
Screen
result' <- ((ManagedPtr Screen -> Screen) -> Ptr Screen -> IO Screen
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Screen -> Screen
Xlib.Screen.Screen) Ptr Screen
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
screen
Screen -> IO Screen
forall (m :: * -> *) a. Monad m => a -> m a
return Screen
result'
#if defined(ENABLE_OVERLOADING)
data X11ScreenGetXscreenMethodInfo
instance (signature ~ (m Xlib.Screen.Screen), MonadIO m, IsX11Screen a) => O.OverloadedMethod X11ScreenGetXscreenMethodInfo a signature where
overloadedMethod = x11ScreenGetXscreen
instance O.OverloadedMethodInfo X11ScreenGetXscreenMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GdkX11.Objects.X11Screen.x11ScreenGetXscreen",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkx11-3.0.12/docs/GI-GdkX11-Objects-X11Screen.html#v:x11ScreenGetXscreen"
})
#endif
foreign import ccall "gdk_x11_screen_lookup_visual" gdk_x11_screen_lookup_visual ::
Ptr X11Screen ->
CULong ->
IO (Ptr GdkX11.X11Visual.X11Visual)
x11ScreenLookupVisual ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Screen a) =>
a
-> CULong
-> m GdkX11.X11Visual.X11Visual
x11ScreenLookupVisual :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Screen a) =>
a -> SignalHandlerId -> m X11Visual
x11ScreenLookupVisual a
screen SignalHandlerId
xvisualid = IO X11Visual -> m X11Visual
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO X11Visual -> m X11Visual) -> IO X11Visual -> m X11Visual
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Screen
screen' <- a -> IO (Ptr X11Screen)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
screen
Ptr X11Visual
result <- Ptr X11Screen -> SignalHandlerId -> IO (Ptr X11Visual)
gdk_x11_screen_lookup_visual Ptr X11Screen
screen' SignalHandlerId
xvisualid
Text -> Ptr X11Visual -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"x11ScreenLookupVisual" Ptr X11Visual
result
X11Visual
result' <- ((ManagedPtr X11Visual -> X11Visual)
-> Ptr X11Visual -> IO X11Visual
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr X11Visual -> X11Visual
GdkX11.X11Visual.X11Visual) Ptr X11Visual
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
screen
X11Visual -> IO X11Visual
forall (m :: * -> *) a. Monad m => a -> m a
return X11Visual
result'
#if defined(ENABLE_OVERLOADING)
data X11ScreenLookupVisualMethodInfo
instance (signature ~ (CULong -> m GdkX11.X11Visual.X11Visual), MonadIO m, IsX11Screen a) => O.OverloadedMethod X11ScreenLookupVisualMethodInfo a signature where
overloadedMethod = x11ScreenLookupVisual
instance O.OverloadedMethodInfo X11ScreenLookupVisualMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GdkX11.Objects.X11Screen.x11ScreenLookupVisual",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkx11-3.0.12/docs/GI-GdkX11-Objects-X11Screen.html#v:x11ScreenLookupVisual"
})
#endif
foreign import ccall "gdk_x11_screen_supports_net_wm_hint" gdk_x11_screen_supports_net_wm_hint ::
Ptr X11Screen ->
Ptr Gdk.Atom.Atom ->
IO CInt
x11ScreenSupportsNetWmHint ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Screen a) =>
a
-> Gdk.Atom.Atom
-> m Bool
x11ScreenSupportsNetWmHint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Screen a) =>
a -> Atom -> m Bool
x11ScreenSupportsNetWmHint a
screen Atom
property = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Screen
screen' <- a -> IO (Ptr X11Screen)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
screen
Ptr Atom
property' <- Atom -> IO (Ptr Atom)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Atom
property
CInt
result <- Ptr X11Screen -> Ptr Atom -> IO CInt
gdk_x11_screen_supports_net_wm_hint Ptr X11Screen
screen' Ptr Atom
property'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
screen
Atom -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Atom
property
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data X11ScreenSupportsNetWmHintMethodInfo
instance (signature ~ (Gdk.Atom.Atom -> m Bool), MonadIO m, IsX11Screen a) => O.OverloadedMethod X11ScreenSupportsNetWmHintMethodInfo a signature where
overloadedMethod = x11ScreenSupportsNetWmHint
instance O.OverloadedMethodInfo X11ScreenSupportsNetWmHintMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GdkX11.Objects.X11Screen.x11ScreenSupportsNetWmHint",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkx11-3.0.12/docs/GI-GdkX11-Objects-X11Screen.html#v:x11ScreenSupportsNetWmHint"
})
#endif