{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GdkX11.Objects.X11Display
(
X11Display(..) ,
IsX11Display ,
toX11Display ,
#if defined(ENABLE_OVERLOADING)
ResolveX11DisplayMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
X11DisplayErrorTrapPopMethodInfo ,
#endif
x11DisplayErrorTrapPop ,
#if defined(ENABLE_OVERLOADING)
X11DisplayErrorTrapPopIgnoredMethodInfo ,
#endif
x11DisplayErrorTrapPopIgnored ,
#if defined(ENABLE_OVERLOADING)
X11DisplayErrorTrapPushMethodInfo ,
#endif
x11DisplayErrorTrapPush ,
#if defined(ENABLE_OVERLOADING)
X11DisplayGetDefaultGroupMethodInfo ,
#endif
x11DisplayGetDefaultGroup ,
#if defined(ENABLE_OVERLOADING)
X11DisplayGetGlxVersionMethodInfo ,
#endif
x11DisplayGetGlxVersion ,
#if defined(ENABLE_OVERLOADING)
X11DisplayGetPrimaryMonitorMethodInfo ,
#endif
x11DisplayGetPrimaryMonitor ,
#if defined(ENABLE_OVERLOADING)
X11DisplayGetScreenMethodInfo ,
#endif
x11DisplayGetScreen ,
#if defined(ENABLE_OVERLOADING)
X11DisplayGetStartupNotificationIdMethodInfo,
#endif
x11DisplayGetStartupNotificationId ,
#if defined(ENABLE_OVERLOADING)
X11DisplayGetUserTimeMethodInfo ,
#endif
x11DisplayGetUserTime ,
#if defined(ENABLE_OVERLOADING)
X11DisplayGetXcursorMethodInfo ,
#endif
x11DisplayGetXcursor ,
#if defined(ENABLE_OVERLOADING)
X11DisplayGetXdisplayMethodInfo ,
#endif
x11DisplayGetXdisplay ,
#if defined(ENABLE_OVERLOADING)
X11DisplayGetXrootwindowMethodInfo ,
#endif
x11DisplayGetXrootwindow ,
#if defined(ENABLE_OVERLOADING)
X11DisplayGetXscreenMethodInfo ,
#endif
x11DisplayGetXscreen ,
#if defined(ENABLE_OVERLOADING)
X11DisplayGrabMethodInfo ,
#endif
x11DisplayGrab ,
x11DisplayOpen ,
#if defined(ENABLE_OVERLOADING)
X11DisplaySetCursorThemeMethodInfo ,
#endif
x11DisplaySetCursorTheme ,
x11DisplaySetProgramClass ,
#if defined(ENABLE_OVERLOADING)
X11DisplaySetStartupNotificationIdMethodInfo,
#endif
x11DisplaySetStartupNotificationId ,
#if defined(ENABLE_OVERLOADING)
X11DisplaySetSurfaceScaleMethodInfo ,
#endif
x11DisplaySetSurfaceScale ,
#if defined(ENABLE_OVERLOADING)
X11DisplayStringToCompoundTextMethodInfo,
#endif
x11DisplayStringToCompoundText ,
#if defined(ENABLE_OVERLOADING)
X11DisplayTextPropertyToTextListMethodInfo,
#endif
x11DisplayTextPropertyToTextList ,
#if defined(ENABLE_OVERLOADING)
X11DisplayUngrabMethodInfo ,
#endif
x11DisplayUngrab ,
#if defined(ENABLE_OVERLOADING)
X11DisplayUtf8ToCompoundTextMethodInfo ,
#endif
x11DisplayUtf8ToCompoundText ,
C_X11DisplayXeventCallback ,
X11DisplayXeventCallback ,
#if defined(ENABLE_OVERLOADING)
X11DisplayXeventSignalInfo ,
#endif
afterX11DisplayXevent ,
genClosure_X11DisplayXevent ,
mk_X11DisplayXeventCallback ,
noX11DisplayXeventCallback ,
onX11DisplayXevent ,
wrap_X11DisplayXeventCallback ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Objects.Cursor as Gdk.Cursor
import qualified GI.Gdk.Objects.Display as Gdk.Display
import qualified GI.Gdk.Objects.Monitor as Gdk.Monitor
import qualified GI.Gdk.Objects.Surface as Gdk.Surface
import {-# SOURCE #-} qualified GI.GdkX11.Objects.X11Screen as GdkX11.X11Screen
import qualified GI.Xlib.Structs.Display as Xlib.Display
import qualified GI.Xlib.Structs.Screen as Xlib.Screen
newtype X11Display = X11Display (SP.ManagedPtr X11Display)
deriving (X11Display -> X11Display -> Bool
(X11Display -> X11Display -> Bool)
-> (X11Display -> X11Display -> Bool) -> Eq X11Display
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: X11Display -> X11Display -> Bool
$c/= :: X11Display -> X11Display -> Bool
== :: X11Display -> X11Display -> Bool
$c== :: X11Display -> X11Display -> Bool
Eq)
instance SP.ManagedPtrNewtype X11Display where
toManagedPtr :: X11Display -> ManagedPtr X11Display
toManagedPtr (X11Display ManagedPtr X11Display
p) = ManagedPtr X11Display
p
foreign import ccall "gdk_x11_display_get_type"
c_gdk_x11_display_get_type :: IO B.Types.GType
instance B.Types.TypedObject X11Display where
glibType :: IO GType
glibType = IO GType
c_gdk_x11_display_get_type
instance B.Types.GObject X11Display
class (SP.GObject o, O.IsDescendantOf X11Display o) => IsX11Display o
instance (SP.GObject o, O.IsDescendantOf X11Display o) => IsX11Display o
instance O.HasParentTypes X11Display
type instance O.ParentTypes X11Display = '[Gdk.Display.Display, GObject.Object.Object]
toX11Display :: (MIO.MonadIO m, IsX11Display o) => o -> m X11Display
toX11Display :: forall (m :: * -> *) o.
(MonadIO m, IsX11Display o) =>
o -> m X11Display
toX11Display = IO X11Display -> m X11Display
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO X11Display -> m X11Display)
-> (o -> IO X11Display) -> o -> m X11Display
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr X11Display -> X11Display) -> o -> IO X11Display
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr X11Display -> X11Display
X11Display
instance B.GValue.IsGValue (Maybe X11Display) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gdk_x11_display_get_type
gvalueSet_ :: Ptr GValue -> Maybe X11Display -> IO ()
gvalueSet_ Ptr GValue
gv Maybe X11Display
P.Nothing = Ptr GValue -> Ptr X11Display -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr X11Display
forall a. Ptr a
FP.nullPtr :: FP.Ptr X11Display)
gvalueSet_ Ptr GValue
gv (P.Just X11Display
obj) = X11Display -> (Ptr X11Display -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr X11Display
obj (Ptr GValue -> Ptr X11Display -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe X11Display)
gvalueGet_ Ptr GValue
gv = do
Ptr X11Display
ptr <- Ptr GValue -> IO (Ptr X11Display)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr X11Display)
if Ptr X11Display
ptr Ptr X11Display -> Ptr X11Display -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr X11Display
forall a. Ptr a
FP.nullPtr
then X11Display -> Maybe X11Display
forall a. a -> Maybe a
P.Just (X11Display -> Maybe X11Display)
-> IO X11Display -> IO (Maybe X11Display)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr X11Display -> X11Display)
-> Ptr X11Display -> IO X11Display
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr X11Display -> X11Display
X11Display Ptr X11Display
ptr
else Maybe X11Display -> IO (Maybe X11Display)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe X11Display
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveX11DisplayMethod (t :: Symbol) (o :: *) :: * where
ResolveX11DisplayMethod "beep" o = Gdk.Display.DisplayBeepMethodInfo
ResolveX11DisplayMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveX11DisplayMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveX11DisplayMethod "close" o = Gdk.Display.DisplayCloseMethodInfo
ResolveX11DisplayMethod "deviceIsGrabbed" o = Gdk.Display.DisplayDeviceIsGrabbedMethodInfo
ResolveX11DisplayMethod "errorTrapPop" o = X11DisplayErrorTrapPopMethodInfo
ResolveX11DisplayMethod "errorTrapPopIgnored" o = X11DisplayErrorTrapPopIgnoredMethodInfo
ResolveX11DisplayMethod "errorTrapPush" o = X11DisplayErrorTrapPushMethodInfo
ResolveX11DisplayMethod "flush" o = Gdk.Display.DisplayFlushMethodInfo
ResolveX11DisplayMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveX11DisplayMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveX11DisplayMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveX11DisplayMethod "grab" o = X11DisplayGrabMethodInfo
ResolveX11DisplayMethod "isClosed" o = Gdk.Display.DisplayIsClosedMethodInfo
ResolveX11DisplayMethod "isComposited" o = Gdk.Display.DisplayIsCompositedMethodInfo
ResolveX11DisplayMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveX11DisplayMethod "isRgba" o = Gdk.Display.DisplayIsRgbaMethodInfo
ResolveX11DisplayMethod "listSeats" o = Gdk.Display.DisplayListSeatsMethodInfo
ResolveX11DisplayMethod "mapKeycode" o = Gdk.Display.DisplayMapKeycodeMethodInfo
ResolveX11DisplayMethod "mapKeyval" o = Gdk.Display.DisplayMapKeyvalMethodInfo
ResolveX11DisplayMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveX11DisplayMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveX11DisplayMethod "notifyStartupComplete" o = Gdk.Display.DisplayNotifyStartupCompleteMethodInfo
ResolveX11DisplayMethod "putEvent" o = Gdk.Display.DisplayPutEventMethodInfo
ResolveX11DisplayMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveX11DisplayMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveX11DisplayMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveX11DisplayMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveX11DisplayMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveX11DisplayMethod "stringToCompoundText" o = X11DisplayStringToCompoundTextMethodInfo
ResolveX11DisplayMethod "supportsInputShapes" o = Gdk.Display.DisplaySupportsInputShapesMethodInfo
ResolveX11DisplayMethod "sync" o = Gdk.Display.DisplaySyncMethodInfo
ResolveX11DisplayMethod "textPropertyToTextList" o = X11DisplayTextPropertyToTextListMethodInfo
ResolveX11DisplayMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveX11DisplayMethod "translateKey" o = Gdk.Display.DisplayTranslateKeyMethodInfo
ResolveX11DisplayMethod "ungrab" o = X11DisplayUngrabMethodInfo
ResolveX11DisplayMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveX11DisplayMethod "utf8ToCompoundText" o = X11DisplayUtf8ToCompoundTextMethodInfo
ResolveX11DisplayMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveX11DisplayMethod "getAppLaunchContext" o = Gdk.Display.DisplayGetAppLaunchContextMethodInfo
ResolveX11DisplayMethod "getClipboard" o = Gdk.Display.DisplayGetClipboardMethodInfo
ResolveX11DisplayMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveX11DisplayMethod "getDefaultGroup" o = X11DisplayGetDefaultGroupMethodInfo
ResolveX11DisplayMethod "getDefaultSeat" o = Gdk.Display.DisplayGetDefaultSeatMethodInfo
ResolveX11DisplayMethod "getGlxVersion" o = X11DisplayGetGlxVersionMethodInfo
ResolveX11DisplayMethod "getMonitorAtSurface" o = Gdk.Display.DisplayGetMonitorAtSurfaceMethodInfo
ResolveX11DisplayMethod "getMonitors" o = Gdk.Display.DisplayGetMonitorsMethodInfo
ResolveX11DisplayMethod "getName" o = Gdk.Display.DisplayGetNameMethodInfo
ResolveX11DisplayMethod "getPrimaryClipboard" o = Gdk.Display.DisplayGetPrimaryClipboardMethodInfo
ResolveX11DisplayMethod "getPrimaryMonitor" o = X11DisplayGetPrimaryMonitorMethodInfo
ResolveX11DisplayMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveX11DisplayMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveX11DisplayMethod "getScreen" o = X11DisplayGetScreenMethodInfo
ResolveX11DisplayMethod "getSetting" o = Gdk.Display.DisplayGetSettingMethodInfo
ResolveX11DisplayMethod "getStartupNotificationId" o = X11DisplayGetStartupNotificationIdMethodInfo
ResolveX11DisplayMethod "getUserTime" o = X11DisplayGetUserTimeMethodInfo
ResolveX11DisplayMethod "getXcursor" o = X11DisplayGetXcursorMethodInfo
ResolveX11DisplayMethod "getXdisplay" o = X11DisplayGetXdisplayMethodInfo
ResolveX11DisplayMethod "getXrootwindow" o = X11DisplayGetXrootwindowMethodInfo
ResolveX11DisplayMethod "getXscreen" o = X11DisplayGetXscreenMethodInfo
ResolveX11DisplayMethod "setCursorTheme" o = X11DisplaySetCursorThemeMethodInfo
ResolveX11DisplayMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveX11DisplayMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveX11DisplayMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveX11DisplayMethod "setStartupNotificationId" o = X11DisplaySetStartupNotificationIdMethodInfo
ResolveX11DisplayMethod "setSurfaceScale" o = X11DisplaySetSurfaceScaleMethodInfo
ResolveX11DisplayMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveX11DisplayMethod t X11Display, O.OverloadedMethod info X11Display p) => OL.IsLabel t (X11Display -> 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 ~ ResolveX11DisplayMethod t X11Display, O.OverloadedMethod info X11Display p, R.HasField t X11Display p) => R.HasField t X11Display p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveX11DisplayMethod t X11Display, O.OverloadedMethodInfo info X11Display) => OL.IsLabel t (O.MethodProxy info X11Display) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
type X11DisplayXeventCallback =
Ptr ()
-> IO Bool
noX11DisplayXeventCallback :: Maybe X11DisplayXeventCallback
noX11DisplayXeventCallback :: Maybe X11DisplayXeventCallback
noX11DisplayXeventCallback = Maybe X11DisplayXeventCallback
forall a. Maybe a
Nothing
type C_X11DisplayXeventCallback =
Ptr () ->
Ptr () ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mk_X11DisplayXeventCallback :: C_X11DisplayXeventCallback -> IO (FunPtr C_X11DisplayXeventCallback)
genClosure_X11DisplayXevent :: MonadIO m => X11DisplayXeventCallback -> m (GClosure C_X11DisplayXeventCallback)
genClosure_X11DisplayXevent :: forall (m :: * -> *).
MonadIO m =>
X11DisplayXeventCallback -> m (GClosure C_X11DisplayXeventCallback)
genClosure_X11DisplayXevent X11DisplayXeventCallback
cb = IO (GClosure C_X11DisplayXeventCallback)
-> m (GClosure C_X11DisplayXeventCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_X11DisplayXeventCallback)
-> m (GClosure C_X11DisplayXeventCallback))
-> IO (GClosure C_X11DisplayXeventCallback)
-> m (GClosure C_X11DisplayXeventCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_X11DisplayXeventCallback
cb' = X11DisplayXeventCallback -> C_X11DisplayXeventCallback
wrap_X11DisplayXeventCallback X11DisplayXeventCallback
cb
C_X11DisplayXeventCallback
-> IO (FunPtr C_X11DisplayXeventCallback)
mk_X11DisplayXeventCallback C_X11DisplayXeventCallback
cb' IO (FunPtr C_X11DisplayXeventCallback)
-> (FunPtr C_X11DisplayXeventCallback
-> IO (GClosure C_X11DisplayXeventCallback))
-> IO (GClosure C_X11DisplayXeventCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_X11DisplayXeventCallback
-> IO (GClosure C_X11DisplayXeventCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_X11DisplayXeventCallback ::
X11DisplayXeventCallback ->
C_X11DisplayXeventCallback
wrap_X11DisplayXeventCallback :: X11DisplayXeventCallback -> C_X11DisplayXeventCallback
wrap_X11DisplayXeventCallback X11DisplayXeventCallback
_cb Ptr ()
_ Ptr ()
xevent Ptr ()
_ = do
Bool
result <- X11DisplayXeventCallback
_cb Ptr ()
xevent
let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
onX11DisplayXevent :: (IsX11Display a, MonadIO m) => a -> X11DisplayXeventCallback -> m SignalHandlerId
onX11DisplayXevent :: forall a (m :: * -> *).
(IsX11Display a, MonadIO m) =>
a -> X11DisplayXeventCallback -> m SignalHandlerId
onX11DisplayXevent a
obj X11DisplayXeventCallback
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 cb' :: C_X11DisplayXeventCallback
cb' = X11DisplayXeventCallback -> C_X11DisplayXeventCallback
wrap_X11DisplayXeventCallback X11DisplayXeventCallback
cb
FunPtr C_X11DisplayXeventCallback
cb'' <- C_X11DisplayXeventCallback
-> IO (FunPtr C_X11DisplayXeventCallback)
mk_X11DisplayXeventCallback C_X11DisplayXeventCallback
cb'
a
-> Text
-> FunPtr C_X11DisplayXeventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"xevent" FunPtr C_X11DisplayXeventCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterX11DisplayXevent :: (IsX11Display a, MonadIO m) => a -> X11DisplayXeventCallback -> m SignalHandlerId
afterX11DisplayXevent :: forall a (m :: * -> *).
(IsX11Display a, MonadIO m) =>
a -> X11DisplayXeventCallback -> m SignalHandlerId
afterX11DisplayXevent a
obj X11DisplayXeventCallback
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 cb' :: C_X11DisplayXeventCallback
cb' = X11DisplayXeventCallback -> C_X11DisplayXeventCallback
wrap_X11DisplayXeventCallback X11DisplayXeventCallback
cb
FunPtr C_X11DisplayXeventCallback
cb'' <- C_X11DisplayXeventCallback
-> IO (FunPtr C_X11DisplayXeventCallback)
mk_X11DisplayXeventCallback C_X11DisplayXeventCallback
cb'
a
-> Text
-> FunPtr C_X11DisplayXeventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"xevent" FunPtr C_X11DisplayXeventCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data X11DisplayXeventSignalInfo
instance SignalInfo X11DisplayXeventSignalInfo where
type HaskellCallbackType X11DisplayXeventSignalInfo = X11DisplayXeventCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_X11DisplayXeventCallback cb
cb'' <- mk_X11DisplayXeventCallback cb'
connectSignalFunPtr obj "xevent" cb'' connectMode detail
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList X11Display
type instance O.AttributeList X11Display = X11DisplayAttributeList
type X11DisplayAttributeList = ('[ '("composited", Gdk.Display.DisplayCompositedPropertyInfo), '("inputShapes", Gdk.Display.DisplayInputShapesPropertyInfo), '("rgba", Gdk.Display.DisplayRgbaPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList X11Display = X11DisplaySignalList
type X11DisplaySignalList = ('[ '("closed", Gdk.Display.DisplayClosedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("opened", Gdk.Display.DisplayOpenedSignalInfo), '("seatAdded", Gdk.Display.DisplaySeatAddedSignalInfo), '("seatRemoved", Gdk.Display.DisplaySeatRemovedSignalInfo), '("settingChanged", Gdk.Display.DisplaySettingChangedSignalInfo), '("xevent", X11DisplayXeventSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gdk_x11_display_error_trap_pop" gdk_x11_display_error_trap_pop ::
Ptr X11Display ->
IO Int32
x11DisplayErrorTrapPop ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> m Int32
x11DisplayErrorTrapPop :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> m Int32
x11DisplayErrorTrapPop a
display = 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 X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
Int32
result <- Ptr X11Display -> IO Int32
gdk_x11_display_error_trap_pop Ptr X11Display
display'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data X11DisplayErrorTrapPopMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplayErrorTrapPopMethodInfo a signature where
overloadedMethod = x11DisplayErrorTrapPop
instance O.OverloadedMethodInfo X11DisplayErrorTrapPopMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplayErrorTrapPop",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplayErrorTrapPop"
}
#endif
foreign import ccall "gdk_x11_display_error_trap_pop_ignored" gdk_x11_display_error_trap_pop_ignored ::
Ptr X11Display ->
IO ()
x11DisplayErrorTrapPopIgnored ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> m ()
x11DisplayErrorTrapPopIgnored :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> m ()
x11DisplayErrorTrapPopIgnored a
display = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
Ptr X11Display -> IO ()
gdk_x11_display_error_trap_pop_ignored Ptr X11Display
display'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data X11DisplayErrorTrapPopIgnoredMethodInfo
instance (signature ~ (m ()), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplayErrorTrapPopIgnoredMethodInfo a signature where
overloadedMethod = x11DisplayErrorTrapPopIgnored
instance O.OverloadedMethodInfo X11DisplayErrorTrapPopIgnoredMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplayErrorTrapPopIgnored",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplayErrorTrapPopIgnored"
}
#endif
foreign import ccall "gdk_x11_display_error_trap_push" gdk_x11_display_error_trap_push ::
Ptr X11Display ->
IO ()
x11DisplayErrorTrapPush ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> m ()
x11DisplayErrorTrapPush :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> m ()
x11DisplayErrorTrapPush a
display = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
Ptr X11Display -> IO ()
gdk_x11_display_error_trap_push Ptr X11Display
display'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data X11DisplayErrorTrapPushMethodInfo
instance (signature ~ (m ()), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplayErrorTrapPushMethodInfo a signature where
overloadedMethod = x11DisplayErrorTrapPush
instance O.OverloadedMethodInfo X11DisplayErrorTrapPushMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplayErrorTrapPush",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplayErrorTrapPush"
}
#endif
foreign import ccall "gdk_x11_display_get_default_group" gdk_x11_display_get_default_group ::
Ptr X11Display ->
IO (Ptr Gdk.Surface.Surface)
x11DisplayGetDefaultGroup ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> m Gdk.Surface.Surface
x11DisplayGetDefaultGroup :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> m Surface
x11DisplayGetDefaultGroup a
display = IO Surface -> m Surface
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Surface -> m Surface) -> IO Surface -> m Surface
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
Ptr Surface
result <- Ptr X11Display -> IO (Ptr Surface)
gdk_x11_display_get_default_group Ptr X11Display
display'
Text -> Ptr Surface -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"x11DisplayGetDefaultGroup" Ptr Surface
result
Surface
result' <- ((ManagedPtr Surface -> Surface) -> Ptr Surface -> IO Surface
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Surface -> Surface
Gdk.Surface.Surface) Ptr Surface
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
Surface -> IO Surface
forall (m :: * -> *) a. Monad m => a -> m a
return Surface
result'
#if defined(ENABLE_OVERLOADING)
data X11DisplayGetDefaultGroupMethodInfo
instance (signature ~ (m Gdk.Surface.Surface), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplayGetDefaultGroupMethodInfo a signature where
overloadedMethod = x11DisplayGetDefaultGroup
instance O.OverloadedMethodInfo X11DisplayGetDefaultGroupMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplayGetDefaultGroup",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplayGetDefaultGroup"
}
#endif
foreign import ccall "gdk_x11_display_get_glx_version" gdk_x11_display_get_glx_version ::
Ptr X11Display ->
Ptr Int32 ->
Ptr Int32 ->
IO CInt
x11DisplayGetGlxVersion ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> m ((Bool, Int32, Int32))
x11DisplayGetGlxVersion :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> m (Bool, Int32, Int32)
x11DisplayGetGlxVersion a
display = IO (Bool, Int32, Int32) -> m (Bool, Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int32, Int32) -> m (Bool, Int32, Int32))
-> IO (Bool, Int32, Int32) -> m (Bool, Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
Ptr Int32
major <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
minor <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
CInt
result <- Ptr X11Display -> Ptr Int32 -> Ptr Int32 -> IO CInt
gdk_x11_display_get_glx_version Ptr X11Display
display' Ptr Int32
major Ptr Int32
minor
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int32
major' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
major
Int32
minor' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
minor
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
major
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
minor
(Bool, Int32, Int32) -> IO (Bool, Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int32
major', Int32
minor')
#if defined(ENABLE_OVERLOADING)
data X11DisplayGetGlxVersionMethodInfo
instance (signature ~ (m ((Bool, Int32, Int32))), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplayGetGlxVersionMethodInfo a signature where
overloadedMethod = x11DisplayGetGlxVersion
instance O.OverloadedMethodInfo X11DisplayGetGlxVersionMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplayGetGlxVersion",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplayGetGlxVersion"
}
#endif
foreign import ccall "gdk_x11_display_get_primary_monitor" gdk_x11_display_get_primary_monitor ::
Ptr X11Display ->
IO (Ptr Gdk.Monitor.Monitor)
x11DisplayGetPrimaryMonitor ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> m Gdk.Monitor.Monitor
x11DisplayGetPrimaryMonitor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> m Monitor
x11DisplayGetPrimaryMonitor a
display = IO Monitor -> m Monitor
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Monitor -> m Monitor) -> IO Monitor -> m Monitor
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
Ptr Monitor
result <- Ptr X11Display -> IO (Ptr Monitor)
gdk_x11_display_get_primary_monitor Ptr X11Display
display'
Text -> Ptr Monitor -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"x11DisplayGetPrimaryMonitor" Ptr Monitor
result
Monitor
result' <- ((ManagedPtr Monitor -> Monitor) -> Ptr Monitor -> IO Monitor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Monitor -> Monitor
Gdk.Monitor.Monitor) Ptr Monitor
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
Monitor -> IO Monitor
forall (m :: * -> *) a. Monad m => a -> m a
return Monitor
result'
#if defined(ENABLE_OVERLOADING)
data X11DisplayGetPrimaryMonitorMethodInfo
instance (signature ~ (m Gdk.Monitor.Monitor), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplayGetPrimaryMonitorMethodInfo a signature where
overloadedMethod = x11DisplayGetPrimaryMonitor
instance O.OverloadedMethodInfo X11DisplayGetPrimaryMonitorMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplayGetPrimaryMonitor",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplayGetPrimaryMonitor"
}
#endif
foreign import ccall "gdk_x11_display_get_screen" gdk_x11_display_get_screen ::
Ptr X11Display ->
IO (Ptr GdkX11.X11Screen.X11Screen)
x11DisplayGetScreen ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> m GdkX11.X11Screen.X11Screen
x11DisplayGetScreen :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> m X11Screen
x11DisplayGetScreen a
display = IO X11Screen -> m X11Screen
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO X11Screen -> m X11Screen) -> IO X11Screen -> m X11Screen
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
Ptr X11Screen
result <- Ptr X11Display -> IO (Ptr X11Screen)
gdk_x11_display_get_screen Ptr X11Display
display'
Text -> Ptr X11Screen -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"x11DisplayGetScreen" Ptr X11Screen
result
X11Screen
result' <- ((ManagedPtr X11Screen -> X11Screen)
-> Ptr X11Screen -> IO X11Screen
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr X11Screen -> X11Screen
GdkX11.X11Screen.X11Screen) Ptr X11Screen
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
X11Screen -> IO X11Screen
forall (m :: * -> *) a. Monad m => a -> m a
return X11Screen
result'
#if defined(ENABLE_OVERLOADING)
data X11DisplayGetScreenMethodInfo
instance (signature ~ (m GdkX11.X11Screen.X11Screen), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplayGetScreenMethodInfo a signature where
overloadedMethod = x11DisplayGetScreen
instance O.OverloadedMethodInfo X11DisplayGetScreenMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplayGetScreen",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplayGetScreen"
}
#endif
foreign import ccall "gdk_x11_display_get_startup_notification_id" gdk_x11_display_get_startup_notification_id ::
Ptr X11Display ->
IO CString
x11DisplayGetStartupNotificationId ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> m T.Text
x11DisplayGetStartupNotificationId :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> m Text
x11DisplayGetStartupNotificationId a
display = 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 X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
CString
result <- Ptr X11Display -> IO CString
gdk_x11_display_get_startup_notification_id Ptr X11Display
display'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"x11DisplayGetStartupNotificationId" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data X11DisplayGetStartupNotificationIdMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplayGetStartupNotificationIdMethodInfo a signature where
overloadedMethod = x11DisplayGetStartupNotificationId
instance O.OverloadedMethodInfo X11DisplayGetStartupNotificationIdMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplayGetStartupNotificationId",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplayGetStartupNotificationId"
}
#endif
foreign import ccall "gdk_x11_display_get_user_time" gdk_x11_display_get_user_time ::
Ptr X11Display ->
IO Word32
x11DisplayGetUserTime ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> m Word32
x11DisplayGetUserTime :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> m Word32
x11DisplayGetUserTime a
display = 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 X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
Word32
result <- Ptr X11Display -> IO Word32
gdk_x11_display_get_user_time Ptr X11Display
display'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data X11DisplayGetUserTimeMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplayGetUserTimeMethodInfo a signature where
overloadedMethod = x11DisplayGetUserTime
instance O.OverloadedMethodInfo X11DisplayGetUserTimeMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplayGetUserTime",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplayGetUserTime"
}
#endif
foreign import ccall "gdk_x11_display_get_xcursor" gdk_x11_display_get_xcursor ::
Ptr X11Display ->
Ptr Gdk.Cursor.Cursor ->
IO CULong
x11DisplayGetXcursor ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a, Gdk.Cursor.IsCursor b) =>
a
-> b
-> m CULong
x11DisplayGetXcursor :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsX11Display a, IsCursor b) =>
a -> b -> m SignalHandlerId
x11DisplayGetXcursor a
display b
cursor = 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 X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
Ptr Cursor
cursor' <- b -> IO (Ptr Cursor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
cursor
SignalHandlerId
result <- Ptr X11Display -> Ptr Cursor -> IO SignalHandlerId
gdk_x11_display_get_xcursor Ptr X11Display
display' Ptr Cursor
cursor'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
cursor
SignalHandlerId -> IO SignalHandlerId
forall (m :: * -> *) a. Monad m => a -> m a
return SignalHandlerId
result
#if defined(ENABLE_OVERLOADING)
data X11DisplayGetXcursorMethodInfo
instance (signature ~ (b -> m CULong), MonadIO m, IsX11Display a, Gdk.Cursor.IsCursor b) => O.OverloadedMethod X11DisplayGetXcursorMethodInfo a signature where
overloadedMethod = x11DisplayGetXcursor
instance O.OverloadedMethodInfo X11DisplayGetXcursorMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplayGetXcursor",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplayGetXcursor"
}
#endif
foreign import ccall "gdk_x11_display_get_xdisplay" gdk_x11_display_get_xdisplay ::
Ptr X11Display ->
IO (Ptr Xlib.Display.Display)
x11DisplayGetXdisplay ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> m Xlib.Display.Display
x11DisplayGetXdisplay :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> m Display
x11DisplayGetXdisplay a
display = IO Display -> m Display
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
Ptr X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
Ptr Display
result <- Ptr X11Display -> IO (Ptr Display)
gdk_x11_display_get_xdisplay Ptr X11Display
display'
Text -> Ptr Display -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"x11DisplayGetXdisplay" Ptr Display
result
Display
result' <- ((ManagedPtr Display -> Display) -> Ptr Display -> IO Display
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Display -> Display
Xlib.Display.Display) Ptr Display
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
Display -> IO Display
forall (m :: * -> *) a. Monad m => a -> m a
return Display
result'
#if defined(ENABLE_OVERLOADING)
data X11DisplayGetXdisplayMethodInfo
instance (signature ~ (m Xlib.Display.Display), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplayGetXdisplayMethodInfo a signature where
overloadedMethod = x11DisplayGetXdisplay
instance O.OverloadedMethodInfo X11DisplayGetXdisplayMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplayGetXdisplay",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplayGetXdisplay"
}
#endif
foreign import ccall "gdk_x11_display_get_xrootwindow" gdk_x11_display_get_xrootwindow ::
Ptr X11Display ->
IO CULong
x11DisplayGetXrootwindow ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> m CULong
x11DisplayGetXrootwindow :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> m SignalHandlerId
x11DisplayGetXrootwindow a
display = 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 X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
SignalHandlerId
result <- Ptr X11Display -> IO SignalHandlerId
gdk_x11_display_get_xrootwindow Ptr X11Display
display'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
SignalHandlerId -> IO SignalHandlerId
forall (m :: * -> *) a. Monad m => a -> m a
return SignalHandlerId
result
#if defined(ENABLE_OVERLOADING)
data X11DisplayGetXrootwindowMethodInfo
instance (signature ~ (m CULong), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplayGetXrootwindowMethodInfo a signature where
overloadedMethod = x11DisplayGetXrootwindow
instance O.OverloadedMethodInfo X11DisplayGetXrootwindowMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplayGetXrootwindow",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplayGetXrootwindow"
}
#endif
foreign import ccall "gdk_x11_display_get_xscreen" gdk_x11_display_get_xscreen ::
Ptr X11Display ->
IO (Ptr Xlib.Screen.Screen)
x11DisplayGetXscreen ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> m Xlib.Screen.Screen
x11DisplayGetXscreen :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> m Screen
x11DisplayGetXscreen a
display = 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 X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
Ptr Screen
result <- Ptr X11Display -> IO (Ptr Screen)
gdk_x11_display_get_xscreen Ptr X11Display
display'
Text -> Ptr Screen -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"x11DisplayGetXscreen" 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
display
Screen -> IO Screen
forall (m :: * -> *) a. Monad m => a -> m a
return Screen
result'
#if defined(ENABLE_OVERLOADING)
data X11DisplayGetXscreenMethodInfo
instance (signature ~ (m Xlib.Screen.Screen), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplayGetXscreenMethodInfo a signature where
overloadedMethod = x11DisplayGetXscreen
instance O.OverloadedMethodInfo X11DisplayGetXscreenMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplayGetXscreen",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplayGetXscreen"
}
#endif
foreign import ccall "gdk_x11_display_grab" gdk_x11_display_grab ::
Ptr X11Display ->
IO ()
x11DisplayGrab ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> m ()
x11DisplayGrab :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> m ()
x11DisplayGrab a
display = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
Ptr X11Display -> IO ()
gdk_x11_display_grab Ptr X11Display
display'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data X11DisplayGrabMethodInfo
instance (signature ~ (m ()), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplayGrabMethodInfo a signature where
overloadedMethod = x11DisplayGrab
instance O.OverloadedMethodInfo X11DisplayGrabMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplayGrab",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplayGrab"
}
#endif
foreign import ccall "gdk_x11_display_set_cursor_theme" gdk_x11_display_set_cursor_theme ::
Ptr X11Display ->
CString ->
Int32 ->
IO ()
x11DisplaySetCursorTheme ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> Maybe (T.Text)
-> Int32
-> m ()
x11DisplaySetCursorTheme :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> Maybe Text -> Int32 -> m ()
x11DisplaySetCursorTheme a
display Maybe Text
theme Int32
size = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
CString
maybeTheme <- case Maybe Text
theme of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jTheme -> do
CString
jTheme' <- Text -> IO CString
textToCString Text
jTheme
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jTheme'
Ptr X11Display -> CString -> Int32 -> IO ()
gdk_x11_display_set_cursor_theme Ptr X11Display
display' CString
maybeTheme Int32
size
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeTheme
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data X11DisplaySetCursorThemeMethodInfo
instance (signature ~ (Maybe (T.Text) -> Int32 -> m ()), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplaySetCursorThemeMethodInfo a signature where
overloadedMethod = x11DisplaySetCursorTheme
instance O.OverloadedMethodInfo X11DisplaySetCursorThemeMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplaySetCursorTheme",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplaySetCursorTheme"
}
#endif
foreign import ccall "gdk_x11_display_set_startup_notification_id" gdk_x11_display_set_startup_notification_id ::
Ptr X11Display ->
CString ->
IO ()
x11DisplaySetStartupNotificationId ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> T.Text
-> m ()
x11DisplaySetStartupNotificationId :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> Text -> m ()
x11DisplaySetStartupNotificationId a
display Text
startupId = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
CString
startupId' <- Text -> IO CString
textToCString Text
startupId
Ptr X11Display -> CString -> IO ()
gdk_x11_display_set_startup_notification_id Ptr X11Display
display' CString
startupId'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
startupId'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data X11DisplaySetStartupNotificationIdMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplaySetStartupNotificationIdMethodInfo a signature where
overloadedMethod = x11DisplaySetStartupNotificationId
instance O.OverloadedMethodInfo X11DisplaySetStartupNotificationIdMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplaySetStartupNotificationId",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplaySetStartupNotificationId"
}
#endif
foreign import ccall "gdk_x11_display_set_surface_scale" gdk_x11_display_set_surface_scale ::
Ptr X11Display ->
Int32 ->
IO ()
x11DisplaySetSurfaceScale ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> Int32
-> m ()
x11DisplaySetSurfaceScale :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> Int32 -> m ()
x11DisplaySetSurfaceScale a
display Int32
scale = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
Ptr X11Display -> Int32 -> IO ()
gdk_x11_display_set_surface_scale Ptr X11Display
display' Int32
scale
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data X11DisplaySetSurfaceScaleMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplaySetSurfaceScaleMethodInfo a signature where
overloadedMethod = x11DisplaySetSurfaceScale
instance O.OverloadedMethodInfo X11DisplaySetSurfaceScaleMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplaySetSurfaceScale",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplaySetSurfaceScale"
}
#endif
foreign import ccall "gdk_x11_display_string_to_compound_text" gdk_x11_display_string_to_compound_text ::
Ptr X11Display ->
CString ->
Ptr CString ->
Ptr Int32 ->
Ptr (Ptr Word8) ->
Ptr Int32 ->
IO Int32
x11DisplayStringToCompoundText ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> T.Text
-> m ((Int32, T.Text, Int32, ByteString))
x11DisplayStringToCompoundText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> Text -> m (Int32, Text, Int32, ByteString)
x11DisplayStringToCompoundText a
display Text
str = IO (Int32, Text, Int32, ByteString)
-> m (Int32, Text, Int32, ByteString)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Text, Int32, ByteString)
-> m (Int32, Text, Int32, ByteString))
-> IO (Int32, Text, Int32, ByteString)
-> m (Int32, Text, Int32, ByteString)
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
CString
str' <- Text -> IO CString
textToCString Text
str
Ptr CString
encoding <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr Int32
format <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr (Ptr Word8)
ctext <- IO (Ptr (Ptr Word8))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Word8))
Ptr Int32
length_ <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Int32
result <- Ptr X11Display
-> CString
-> Ptr CString
-> Ptr Int32
-> Ptr (Ptr Word8)
-> Ptr Int32
-> IO Int32
gdk_x11_display_string_to_compound_text Ptr X11Display
display' CString
str' Ptr CString
encoding Ptr Int32
format Ptr (Ptr Word8)
ctext Ptr Int32
length_
Int32
length_' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
length_
CString
encoding' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
encoding
Text
encoding'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
encoding'
Int32
format' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
format
Ptr Word8
ctext' <- Ptr (Ptr Word8) -> IO (Ptr Word8)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Word8)
ctext
ByteString
ctext'' <- (Int32 -> Ptr Word8 -> IO ByteString
forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Int32
length_') Ptr Word8
ctext'
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
ctext'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
encoding
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
format
Ptr (Ptr Word8) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Word8)
ctext
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
length_
(Int32, Text, Int32, ByteString)
-> IO (Int32, Text, Int32, ByteString)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
result, Text
encoding'', Int32
format', ByteString
ctext'')
#if defined(ENABLE_OVERLOADING)
data X11DisplayStringToCompoundTextMethodInfo
instance (signature ~ (T.Text -> m ((Int32, T.Text, Int32, ByteString))), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplayStringToCompoundTextMethodInfo a signature where
overloadedMethod = x11DisplayStringToCompoundText
instance O.OverloadedMethodInfo X11DisplayStringToCompoundTextMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplayStringToCompoundText",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplayStringToCompoundText"
}
#endif
foreign import ccall "gdk_x11_display_text_property_to_text_list" gdk_x11_display_text_property_to_text_list ::
Ptr X11Display ->
CString ->
Int32 ->
Word8 ->
Int32 ->
CString ->
IO Int32
x11DisplayTextPropertyToTextList ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> T.Text
-> Int32
-> Word8
-> Int32
-> T.Text
-> m Int32
x11DisplayTextPropertyToTextList :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> Text -> Int32 -> Word8 -> Int32 -> Text -> m Int32
x11DisplayTextPropertyToTextList a
display Text
encoding Int32
format Word8
text Int32
length_ Text
list = 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 X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
CString
encoding' <- Text -> IO CString
textToCString Text
encoding
CString
list' <- Text -> IO CString
textToCString Text
list
Int32
result <- Ptr X11Display
-> CString -> Int32 -> Word8 -> Int32 -> CString -> IO Int32
gdk_x11_display_text_property_to_text_list Ptr X11Display
display' CString
encoding' Int32
format Word8
text Int32
length_ CString
list'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
encoding'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
list'
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data X11DisplayTextPropertyToTextListMethodInfo
instance (signature ~ (T.Text -> Int32 -> Word8 -> Int32 -> T.Text -> m Int32), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplayTextPropertyToTextListMethodInfo a signature where
overloadedMethod = x11DisplayTextPropertyToTextList
instance O.OverloadedMethodInfo X11DisplayTextPropertyToTextListMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplayTextPropertyToTextList",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplayTextPropertyToTextList"
}
#endif
foreign import ccall "gdk_x11_display_ungrab" gdk_x11_display_ungrab ::
Ptr X11Display ->
IO ()
x11DisplayUngrab ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> m ()
x11DisplayUngrab :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> m ()
x11DisplayUngrab a
display = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
Ptr X11Display -> IO ()
gdk_x11_display_ungrab Ptr X11Display
display'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data X11DisplayUngrabMethodInfo
instance (signature ~ (m ()), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplayUngrabMethodInfo a signature where
overloadedMethod = x11DisplayUngrab
instance O.OverloadedMethodInfo X11DisplayUngrabMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplayUngrab",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplayUngrab"
}
#endif
foreign import ccall "gdk_x11_display_utf8_to_compound_text" gdk_x11_display_utf8_to_compound_text ::
Ptr X11Display ->
CString ->
Ptr CString ->
Ptr Int32 ->
Ptr (Ptr Word8) ->
Ptr Int32 ->
IO CInt
x11DisplayUtf8ToCompoundText ::
(B.CallStack.HasCallStack, MonadIO m, IsX11Display a) =>
a
-> T.Text
-> m ((Bool, T.Text, Int32, ByteString))
x11DisplayUtf8ToCompoundText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsX11Display a) =>
a -> Text -> m (Bool, Text, Int32, ByteString)
x11DisplayUtf8ToCompoundText a
display Text
str = IO (Bool, Text, Int32, ByteString)
-> m (Bool, Text, Int32, ByteString)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Text, Int32, ByteString)
-> m (Bool, Text, Int32, ByteString))
-> IO (Bool, Text, Int32, ByteString)
-> m (Bool, Text, Int32, ByteString)
forall a b. (a -> b) -> a -> b
$ do
Ptr X11Display
display' <- a -> IO (Ptr X11Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
CString
str' <- Text -> IO CString
textToCString Text
str
Ptr CString
encoding <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr Int32
format <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr (Ptr Word8)
ctext <- IO (Ptr (Ptr Word8))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Word8))
Ptr Int32
length_ <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
CInt
result <- Ptr X11Display
-> CString
-> Ptr CString
-> Ptr Int32
-> Ptr (Ptr Word8)
-> Ptr Int32
-> IO CInt
gdk_x11_display_utf8_to_compound_text Ptr X11Display
display' CString
str' Ptr CString
encoding Ptr Int32
format Ptr (Ptr Word8)
ctext Ptr Int32
length_
Int32
length_' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
length_
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString
encoding' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
encoding
Text
encoding'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
encoding'
Int32
format' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
format
Ptr Word8
ctext' <- Ptr (Ptr Word8) -> IO (Ptr Word8)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Word8)
ctext
ByteString
ctext'' <- (Int32 -> Ptr Word8 -> IO ByteString
forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Int32
length_') Ptr Word8
ctext'
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
ctext'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
encoding
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
format
Ptr (Ptr Word8) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Word8)
ctext
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
length_
(Bool, Text, Int32, ByteString)
-> IO (Bool, Text, Int32, ByteString)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Text
encoding'', Int32
format', ByteString
ctext'')
#if defined(ENABLE_OVERLOADING)
data X11DisplayUtf8ToCompoundTextMethodInfo
instance (signature ~ (T.Text -> m ((Bool, T.Text, Int32, ByteString))), MonadIO m, IsX11Display a) => O.OverloadedMethod X11DisplayUtf8ToCompoundTextMethodInfo a signature where
overloadedMethod = x11DisplayUtf8ToCompoundText
instance O.OverloadedMethodInfo X11DisplayUtf8ToCompoundTextMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GdkX11.Objects.X11Display.x11DisplayUtf8ToCompoundText",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdkx11-4.0.3/docs/GI-GdkX11-Objects-X11Display.html#v:x11DisplayUtf8ToCompoundText"
}
#endif
foreign import ccall "gdk_x11_display_open" gdk_x11_display_open ::
CString ->
IO (Ptr Gdk.Display.Display)
x11DisplayOpen ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> m (Maybe Gdk.Display.Display)
x11DisplayOpen :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> m (Maybe Display)
x11DisplayOpen Maybe Text
displayName = IO (Maybe Display) -> m (Maybe Display)
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
CString
maybeDisplayName <- case Maybe Text
displayName of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jDisplayName -> do
CString
jDisplayName' <- Text -> IO CString
textToCString Text
jDisplayName
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jDisplayName'
Ptr Display
result <- CString -> IO (Ptr Display)
gdk_x11_display_open CString
maybeDisplayName
Maybe Display
maybeResult <- Ptr Display -> (Ptr Display -> IO Display) -> IO (Maybe Display)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Display
result ((Ptr Display -> IO Display) -> IO (Maybe Display))
-> (Ptr Display -> IO Display) -> IO (Maybe Display)
forall a b. (a -> b) -> a -> b
$ \Ptr Display
result' -> do
Display
result'' <- ((ManagedPtr Display -> Display) -> Ptr Display -> IO Display
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Display -> Display
Gdk.Display.Display) Ptr Display
result'
Display -> IO Display
forall (m :: * -> *) a. Monad m => a -> m a
return Display
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeDisplayName
Maybe Display -> IO (Maybe Display)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Display
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gdk_x11_display_set_program_class" gdk_x11_display_set_program_class ::
Ptr Gdk.Display.Display ->
CString ->
IO ()
x11DisplaySetProgramClass ::
(B.CallStack.HasCallStack, MonadIO m, Gdk.Display.IsDisplay a) =>
a
-> T.Text
-> m ()
x11DisplaySetProgramClass :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDisplay a) =>
a -> Text -> m ()
x11DisplaySetProgramClass a
display Text
programClass = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Display
display' <- a -> IO (Ptr Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
display
CString
programClass' <- Text -> IO CString
textToCString Text
programClass
Ptr Display -> CString -> IO ()
gdk_x11_display_set_program_class Ptr Display
display' CString
programClass'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
display
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
programClass'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif