module Graphics.X11.Xrandr (
XRRScreenSize(..),
XRRModeInfo(..),
XRRScreenResources(..),
XRROutputInfo(..),
XRRCrtcInfo(..),
compiledWithXrandr,
Rotation,
Reflection,
SizeID,
XRRScreenConfiguration,
xrrQueryExtension,
xrrQueryVersion,
xrrGetScreenInfo,
xrrFreeScreenConfigInfo,
xrrSetScreenConfig,
xrrSetScreenConfigAndRate,
xrrConfigRotations,
xrrConfigTimes,
xrrConfigSizes,
xrrConfigRates,
xrrConfigCurrentConfiguration,
xrrConfigCurrentRate,
xrrRootToScreen,
xrrSelectInput,
xrrUpdateConfiguration,
xrrRotations,
xrrSizes,
xrrRates,
xrrTimes,
xrrGetScreenResources,
xrrGetOutputInfo,
xrrGetCrtcInfo,
xrrGetScreenResourcesCurrent,
xrrSetOutputPrimary,
xrrGetOutputPrimary,
xrrListOutputProperties
) where
import Foreign
import Foreign.C.Types
import Foreign.C.String
import Control.Monad
import Graphics.X11.Xlib.Event
import Graphics.X11.Xlib.Internal
import Graphics.X11.Xlib.Types
import Graphics.X11.Types
import Data.Data
data XRRScreenSize = XRRScreenSize
{ xrr_ss_width :: !CInt,
xrr_ss_height :: !CInt,
xrr_ss_mwidth :: !CInt,
xrr_ss_mheight :: !CInt }
deriving (Show)
data XRRModeInfo = XRRModeInfo
{ xrr_mi_id :: !RRMode
, xrr_mi_width :: !CUInt
, xrr_mi_height :: !CUInt
, xrr_mi_dotClock :: !CUInt
, xrr_mi_hSyncStart :: !CUInt
, xrr_mi_hSyncEnd :: !CUInt
, xrr_mi_hTotal :: !CUInt
, xrr_mi_hSkew :: !CUInt
, xrr_mi_vSyncStart :: !CUInt
, xrr_mi_vSyncEnd :: !CUInt
, xrr_mi_vTotal :: !CUInt
, xrr_mi_name :: !String
, xrr_mi_modeFlags :: !XRRModeFlags
} deriving (Eq, Show)
data XRRScreenResources = XRRScreenResources
{ xrr_sr_timestamp :: !Time
, xrr_sr_configTimestamp :: !Time
, xrr_sr_crtcs :: [RRCrtc]
, xrr_sr_outputs :: [RROutput]
, xrr_sr_modes :: [XRRModeInfo]
} deriving (Eq, Show)
data XRROutputInfo = XRROutputInfo
{ xrr_oi_timestamp :: !Time
, xrr_oi_crtc :: !RRCrtc
, xrr_oi_name :: !String
, xrr_oi_mm_width :: !CULong
, xrr_oi_mm_height :: !CULong
, xrr_oi_connection :: !Connection
, xrr_oi_subpixel_order :: !SubpixelOrder
, xrr_oi_crtcs :: [RRCrtc]
, xrr_oi_clones :: [RROutput]
, xrr_oi_npreferred :: !CInt
, xrr_oi_modes :: [RRMode]
} deriving (Eq, Show)
data XRRCrtcInfo = XRRCrtcInfo
{ xrr_ci_timestamp :: !Time
, xrr_ci_x :: !CInt
, xrr_ci_y :: !CInt
, xrr_ci_width :: !CUInt
, xrr_ci_height :: !CUInt
, xrr_ci_mode :: !RRMode
, xrr_ci_rotation :: !Rotation
, xrr_ci_outputs :: [RROutput]
, xrr_ci_rotations :: !Rotation
, xrr_ci_possible :: [RROutput]
} deriving (Eq, Show)
compiledWithXrandr :: Bool
compiledWithXrandr = True
newtype XRRScreenConfiguration = XRRScreenConfiguration (Ptr XRRScreenConfiguration)
deriving (Eq, Ord, Show, Typeable, Data)
instance Storable XRRScreenSize where
sizeOf _ = (16)
alignment _ = alignment (undefined :: CInt)
poke p xrr_ss = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p $ xrr_ss_width xrr_ss
(\hsc_ptr -> pokeByteOff hsc_ptr 4) p $ xrr_ss_height xrr_ss
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p $ xrr_ss_mwidth xrr_ss
(\hsc_ptr -> pokeByteOff hsc_ptr 12) p $ xrr_ss_mheight xrr_ss
peek p = return XRRScreenSize
`ap` ((\hsc_ptr -> peekByteOff hsc_ptr 0) p)
`ap` ((\hsc_ptr -> peekByteOff hsc_ptr 4) p)
`ap` ((\hsc_ptr -> peekByteOff hsc_ptr 8) p)
`ap` ((\hsc_ptr -> peekByteOff hsc_ptr 12) p)
instance Storable XRRModeInfo where
sizeOf _ = (80)
alignment _ = alignment (undefined :: CInt)
poke p xrr_mi = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p $ xrr_mi_id xrr_mi
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p $ xrr_mi_width xrr_mi
(\hsc_ptr -> pokeByteOff hsc_ptr 12) p $ xrr_mi_height xrr_mi
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p $ xrr_mi_dotClock xrr_mi
(\hsc_ptr -> pokeByteOff hsc_ptr 24) p $ xrr_mi_hSyncStart xrr_mi
(\hsc_ptr -> pokeByteOff hsc_ptr 28) p $ xrr_mi_hSyncEnd xrr_mi
(\hsc_ptr -> pokeByteOff hsc_ptr 32) p $ xrr_mi_hTotal xrr_mi
(\hsc_ptr -> pokeByteOff hsc_ptr 36) p $ xrr_mi_hSkew xrr_mi
(\hsc_ptr -> pokeByteOff hsc_ptr 40) p $ xrr_mi_vSyncStart xrr_mi
(\hsc_ptr -> pokeByteOff hsc_ptr 44) p $ xrr_mi_vSyncEnd xrr_mi
(\hsc_ptr -> pokeByteOff hsc_ptr 48) p $ xrr_mi_vTotal xrr_mi
(\hsc_ptr -> pokeByteOff hsc_ptr 72) p $ xrr_mi_modeFlags xrr_mi
(\hsc_ptr -> pokeByteOff hsc_ptr 64) p ( 0 :: CInt )
(\hsc_ptr -> pokeByteOff hsc_ptr 56) p ( nullPtr :: Ptr CChar )
peek p = return XRRModeInfo
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 0) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 8) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 12) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 16) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 24) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 28) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 32) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 36) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 40) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 44) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 48) p )
`ap` peekCStringLenIO ((\hsc_ptr -> peekByteOff hsc_ptr 64) p)
((\hsc_ptr -> peekByteOff hsc_ptr 56) p)
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 72) p )
instance Storable XRRScreenResources where
sizeOf _ = (64)
alignment _ = alignment (undefined :: CInt)
poke p xrr_sr = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p $ xrr_sr_timestamp xrr_sr
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p $ xrr_sr_configTimestamp xrr_sr
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p ( 0 :: CInt )
(\hsc_ptr -> pokeByteOff hsc_ptr 32) p ( 0 :: CInt )
(\hsc_ptr -> pokeByteOff hsc_ptr 48) p ( 0 :: CInt )
(\hsc_ptr -> pokeByteOff hsc_ptr 24) p ( nullPtr :: Ptr RRCrtc )
(\hsc_ptr -> pokeByteOff hsc_ptr 40) p ( nullPtr :: Ptr RROutput )
(\hsc_ptr -> pokeByteOff hsc_ptr 56) p ( nullPtr :: Ptr XRRModeInfo )
peek p = return XRRScreenResources
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 0) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 8) p )
`ap` peekCArrayIO ((\hsc_ptr -> peekByteOff hsc_ptr 16) p)
((\hsc_ptr -> peekByteOff hsc_ptr 24) p)
`ap` peekCArrayIO ((\hsc_ptr -> peekByteOff hsc_ptr 32) p)
((\hsc_ptr -> peekByteOff hsc_ptr 40) p)
`ap` peekCArrayIO ((\hsc_ptr -> peekByteOff hsc_ptr 48) p)
((\hsc_ptr -> peekByteOff hsc_ptr 56) p)
instance Storable XRROutputInfo where
sizeOf _ = (96)
alignment _ = alignment (undefined :: CInt)
poke p xrr_oi = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p $ xrr_oi_timestamp xrr_oi
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p $ xrr_oi_crtc xrr_oi
(\hsc_ptr -> pokeByteOff hsc_ptr 32) p $ xrr_oi_mm_width xrr_oi
(\hsc_ptr -> pokeByteOff hsc_ptr 40) p $ xrr_oi_mm_height xrr_oi
(\hsc_ptr -> pokeByteOff hsc_ptr 48) p $ xrr_oi_connection xrr_oi
(\hsc_ptr -> pokeByteOff hsc_ptr 50) p $ xrr_oi_subpixel_order xrr_oi
(\hsc_ptr -> pokeByteOff hsc_ptr 84) p $ xrr_oi_npreferred xrr_oi
(\hsc_ptr -> pokeByteOff hsc_ptr 24) p ( 0 :: CInt )
(\hsc_ptr -> pokeByteOff hsc_ptr 52) p ( 0 :: CInt )
(\hsc_ptr -> pokeByteOff hsc_ptr 64) p ( 0 :: CInt )
(\hsc_ptr -> pokeByteOff hsc_ptr 80) p ( 0 :: CInt )
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p ( nullPtr :: Ptr CChar )
(\hsc_ptr -> pokeByteOff hsc_ptr 56) p ( nullPtr :: Ptr RRCrtc )
(\hsc_ptr -> pokeByteOff hsc_ptr 72) p ( nullPtr :: Ptr RROutput )
(\hsc_ptr -> pokeByteOff hsc_ptr 88) p ( nullPtr :: Ptr RRMode )
peek p = return XRROutputInfo
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 0) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 8) p )
`ap` peekCStringLenIO ((\hsc_ptr -> peekByteOff hsc_ptr 24) p)
((\hsc_ptr -> peekByteOff hsc_ptr 16) p)
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 32) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 40) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 48) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 50) p )
`ap` peekCArrayIO ((\hsc_ptr -> peekByteOff hsc_ptr 52) p)
((\hsc_ptr -> peekByteOff hsc_ptr 56) p)
`ap` peekCArrayIO ((\hsc_ptr -> peekByteOff hsc_ptr 64) p)
((\hsc_ptr -> peekByteOff hsc_ptr 72) p)
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 84) p )
`ap` peekCArrayIO ((\hsc_ptr -> peekByteOff hsc_ptr 80) p)
((\hsc_ptr -> peekByteOff hsc_ptr 88) p)
instance Storable XRRCrtcInfo where
sizeOf _ = (64)
alignment _ = alignment (undefined :: CInt)
poke p xrr_ci = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p $ xrr_ci_timestamp xrr_ci
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p $ xrr_ci_x xrr_ci
(\hsc_ptr -> pokeByteOff hsc_ptr 12) p $ xrr_ci_y xrr_ci
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p $ xrr_ci_width xrr_ci
(\hsc_ptr -> pokeByteOff hsc_ptr 20) p $ xrr_ci_height xrr_ci
(\hsc_ptr -> pokeByteOff hsc_ptr 24) p $ xrr_ci_mode xrr_ci
(\hsc_ptr -> pokeByteOff hsc_ptr 32) p $ xrr_ci_rotation xrr_ci
(\hsc_ptr -> pokeByteOff hsc_ptr 48) p $ xrr_ci_rotations xrr_ci
(\hsc_ptr -> pokeByteOff hsc_ptr 36) p ( 0 :: CInt )
(\hsc_ptr -> pokeByteOff hsc_ptr 52) p ( 0 :: CInt )
(\hsc_ptr -> pokeByteOff hsc_ptr 40) p ( nullPtr :: Ptr RROutput )
(\hsc_ptr -> pokeByteOff hsc_ptr 56) p ( nullPtr :: Ptr RROutput )
peek p = return XRRCrtcInfo
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 0) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 8) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 12) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 16) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 20) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 24) p )
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 32) p )
`ap` peekCArrayIO ((\hsc_ptr -> peekByteOff hsc_ptr 36) p)
((\hsc_ptr -> peekByteOff hsc_ptr 40) p)
`ap` ( (\hsc_ptr -> peekByteOff hsc_ptr 48) p )
`ap` peekCArrayIO ((\hsc_ptr -> peekByteOff hsc_ptr 52) p)
((\hsc_ptr -> peekByteOff hsc_ptr 56) p)
xrrQueryExtension :: Display -> IO (Maybe (CInt, CInt))
xrrQueryExtension dpy = wrapPtr2 (cXRRQueryExtension dpy) go
where go False _ _ = Nothing
go True eventbase errorbase = Just (fromIntegral eventbase, fromIntegral errorbase)
foreign import ccall "XRRQueryExtension"
cXRRQueryExtension :: Display -> Ptr CInt -> Ptr CInt -> IO Bool
xrrQueryVersion :: Display -> IO (Maybe (CInt, CInt))
xrrQueryVersion dpy = wrapPtr2 (cXRRQueryVersion dpy) go
where go False _ _ = Nothing
go True major minor = Just (fromIntegral major, fromIntegral minor)
foreign import ccall "XRRQueryVersion"
cXRRQueryVersion :: Display -> Ptr CInt -> Ptr CInt -> IO Bool
xrrGetScreenInfo :: Display -> Drawable -> IO (Maybe XRRScreenConfiguration)
xrrGetScreenInfo dpy draw = do
p <- cXRRGetScreenInfo dpy draw
if p == nullPtr
then return Nothing
else return (Just (XRRScreenConfiguration p))
foreign import ccall "XRRGetScreenInfo"
cXRRGetScreenInfo :: Display -> Drawable -> IO (Ptr XRRScreenConfiguration)
xrrFreeScreenConfigInfo :: XRRScreenConfiguration -> IO ()
xrrFreeScreenConfigInfo = cXRRFreeScreenConfigInfo
foreign import ccall "XRRFreeScreenConfigInfo"
cXRRFreeScreenConfigInfo :: XRRScreenConfiguration -> IO ()
xrrSetScreenConfig :: Display -> XRRScreenConfiguration -> Drawable -> CInt -> Rotation -> Time -> IO Status
xrrSetScreenConfig = cXRRSetScreenConfig
foreign import ccall "XRRSetScreenConfig"
cXRRSetScreenConfig :: Display -> XRRScreenConfiguration -> Drawable -> CInt -> Rotation -> Time -> IO Status
xrrSetScreenConfigAndRate :: Display -> XRRScreenConfiguration -> Drawable -> CInt -> Rotation -> CShort -> Time -> IO Status
xrrSetScreenConfigAndRate = cXRRSetScreenConfigAndRate
foreign import ccall "XRRSetScreenConfigAndRate"
cXRRSetScreenConfigAndRate :: Display -> XRRScreenConfiguration -> Drawable -> CInt -> Rotation -> CShort -> Time -> IO Status
xrrConfigRotations :: XRRScreenConfiguration -> IO (Rotation, Rotation)
xrrConfigRotations config =
withPool $ \pool -> do rptr <- pooledMalloc pool
rotations <- cXRRConfigRotations config rptr
cur_rotation <- peek rptr
return (rotations, cur_rotation)
foreign import ccall "XRRConfigRotations"
cXRRConfigRotations :: XRRScreenConfiguration -> Ptr Rotation -> IO Rotation
xrrConfigTimes :: XRRScreenConfiguration -> IO (Time, Time)
xrrConfigTimes config =
withPool $ \pool -> do tptr <- pooledMalloc pool
time <- cXRRConfigTimes config tptr
cur_time <- peek tptr
return (time, cur_time)
foreign import ccall "XRRConfigTimes"
cXRRConfigTimes :: XRRScreenConfiguration -> Ptr Time -> IO Time
xrrConfigSizes :: XRRScreenConfiguration -> IO (Maybe [XRRScreenSize])
xrrConfigSizes config =
withPool $ \pool -> do intp <- pooledMalloc pool
p <- cXRRConfigSizes config intp
if p == nullPtr
then return Nothing
else do nsizes <- peek intp
sizes <- if nsizes == 0
then return Nothing
else peekArray (fromIntegral nsizes) p >>= return . Just
_ <- xFree p
return sizes
foreign import ccall "XRRConfigSizes"
cXRRConfigSizes :: XRRScreenConfiguration -> Ptr CInt -> IO (Ptr XRRScreenSize)
xrrConfigRates :: XRRScreenConfiguration -> CInt -> IO (Maybe [CShort])
xrrConfigRates config size_index =
withPool $ \pool -> do intp <- pooledMalloc pool
p <- cXRRConfigRates config size_index intp
if p == nullPtr
then return Nothing
else do nrates <- peek intp
rates <- if nrates == 0
then return Nothing
else peekArray (fromIntegral nrates) p >>= return . Just
_ <- xFree p
return rates
foreign import ccall "XRRConfigRates"
cXRRConfigRates :: XRRScreenConfiguration -> CInt -> Ptr CInt -> IO (Ptr CShort)
xrrConfigCurrentConfiguration :: XRRScreenConfiguration -> IO (Rotation, SizeID)
xrrConfigCurrentConfiguration config =
withPool $ \pool -> do rptr <- pooledMalloc pool
sizeid <- cXRRConfigCurrentConfiguration config rptr
rotation <- peek rptr
return (rotation, sizeid)
foreign import ccall "XRRConfigCurrentConfiguration"
cXRRConfigCurrentConfiguration :: XRRScreenConfiguration -> Ptr Rotation -> IO SizeID
xrrConfigCurrentRate :: XRRScreenConfiguration -> IO CShort
xrrConfigCurrentRate = cXRRConfigCurrentRate
foreign import ccall "XRRConfigCurrentRate"
cXRRConfigCurrentRate :: XRRScreenConfiguration -> IO CShort
xrrRootToScreen :: Display -> Window -> IO CInt
xrrRootToScreen = cXRRRootToScreen
foreign import ccall "XRRRootToScreen"
cXRRRootToScreen :: Display -> Window -> IO CInt
xrrSelectInput :: Display -> Window -> EventMask -> IO ()
xrrSelectInput dpy window mask = cXRRSelectInput dpy window (fromIntegral mask)
foreign import ccall "XRRSelectInput"
cXRRSelectInput :: Display -> Window -> CInt -> IO ()
xrrUpdateConfiguration :: XEvent -> IO CInt
xrrUpdateConfiguration = cXRRUpdateConfiguration
foreign import ccall "XRRUpdateConfiguration"
cXRRUpdateConfiguration :: XEvent -> IO CInt
xrrRotations :: Display -> CInt -> IO (Rotation, Rotation)
xrrRotations dpy screen =
withPool $ \pool -> do rptr <- pooledMalloc pool
rotations <- cXRRRotations dpy screen rptr
cur_rotation <- peek rptr
return (rotations, cur_rotation)
foreign import ccall "XRRRotations"
cXRRRotations :: Display -> CInt -> Ptr Rotation -> IO Rotation
xrrSizes :: Display -> CInt -> IO (Maybe [XRRScreenSize])
xrrSizes dpy screen =
withPool $ \pool -> do intp <- pooledMalloc pool
p <- cXRRSizes dpy screen intp
if p == nullPtr
then return Nothing
else do nsizes <- peek intp
sizes <- if nsizes == 0
then return Nothing
else peekArray (fromIntegral nsizes) p >>= return . Just
_ <- xFree p
return sizes
foreign import ccall "XRRSizes"
cXRRSizes :: Display -> CInt -> Ptr CInt -> IO (Ptr XRRScreenSize)
xrrRates :: Display -> CInt -> CInt -> IO (Maybe [CShort])
xrrRates dpy screen size_index =
withPool $ \pool -> do intp <- pooledMalloc pool
p <- cXRRRates dpy screen size_index intp
if p == nullPtr
then return Nothing
else do nrates <- peek intp
rates <- if nrates == 0
then return Nothing
else peekArray (fromIntegral nrates) p >>= return . Just
_ <- xFree p
return rates
foreign import ccall "XRRRates"
cXRRRates :: Display -> CInt -> CInt -> Ptr CInt -> IO (Ptr CShort)
xrrTimes :: Display -> CInt -> IO (Time, Time)
xrrTimes dpy screen =
withPool $ \pool -> do tptr <- pooledMalloc pool
time <- cXRRTimes dpy screen tptr
config_time <- peek tptr
return (time, config_time)
foreign import ccall "XRRTimes"
cXRRTimes :: Display -> CInt -> Ptr Time -> IO Time
xrrGetScreenResources :: Display -> Window -> IO (Maybe XRRScreenResources)
xrrGetScreenResources dpy win = do
srp <- cXRRGetScreenResources dpy win
if srp == nullPtr
then return Nothing
else do
res <- peek srp
cXRRFreeScreenResources srp
return $ Just res
foreign import ccall "XRRGetScreenResources"
cXRRGetScreenResources :: Display -> Window -> IO (Ptr XRRScreenResources)
foreign import ccall "XRRFreeScreenResources"
cXRRFreeScreenResources :: Ptr XRRScreenResources -> IO ()
xrrGetOutputInfo :: Display -> XRRScreenResources -> RROutput -> IO (Maybe XRROutputInfo)
xrrGetOutputInfo dpy xrr_sr rro = withPool $ \pool -> do
oip <- pooledMalloc pool >>= \srp -> do
poke srp xrr_sr
cXRRGetOutputInfo dpy srp rro
if oip == nullPtr
then return Nothing
else do
oi <- peek oip
_ <- cXRRFreeOutputInfo oip
return $ Just oi
foreign import ccall "XRRGetOutputInfo"
cXRRGetOutputInfo :: Display -> Ptr XRRScreenResources -> RROutput -> IO (Ptr XRROutputInfo)
foreign import ccall "XRRFreeOutputInfo"
cXRRFreeOutputInfo :: Ptr XRROutputInfo -> IO ()
xrrGetCrtcInfo :: Display -> XRRScreenResources -> RRCrtc -> IO (Maybe XRRCrtcInfo)
xrrGetCrtcInfo dpy xrr_sr crtc = withPool $ \pool -> do
cip <- pooledMalloc pool >>= \srp -> do
poke srp xrr_sr
cXRRGetCrtcInfo dpy srp crtc
if cip == nullPtr
then return Nothing
else do
ci <- peek cip
cXRRFreeCrtcInfo cip
return $ Just ci
foreign import ccall "XRRGetCrtcInfo"
cXRRGetCrtcInfo :: Display -> Ptr XRRScreenResources -> RRCrtc -> IO (Ptr XRRCrtcInfo)
foreign import ccall "XRRFreeCrtcInfo"
cXRRFreeCrtcInfo :: Ptr XRRCrtcInfo -> IO ()
foreign import ccall "XRRSetOutputPrimary"
xrrSetOutputPrimary :: Display -> Window -> RROutput -> IO ()
foreign import ccall "XRRGetOutputPrimary"
xrrGetOutputPrimary :: Display -> Window -> IO RROutput
xrrGetScreenResourcesCurrent :: Display -> Window -> IO (Maybe XRRScreenResources)
xrrGetScreenResourcesCurrent dpy win = do
srcp <- cXRRGetScreenResourcesCurrent dpy win
if srcp == nullPtr
then return Nothing
else do
res <- peek srcp
cXRRFreeScreenResources srcp
return $ Just res
foreign import ccall "XRRGetScreenResourcesCurrent"
cXRRGetScreenResourcesCurrent :: Display -> Window -> IO (Ptr XRRScreenResources)
xrrListOutputProperties :: Display -> RROutput -> IO (Maybe [Atom])
xrrListOutputProperties dpy rro = withPool $ \pool -> do
intp <- pooledMalloc pool
p <- cXRRListOutputProperties dpy rro intp
if p == nullPtr
then return Nothing
else do
nprop <- peek intp
res <- fmap Just $ peekCArray nprop p
_ <- xFree p
return res
foreign import ccall "XRRListOutputProperties"
cXRRListOutputProperties :: Display -> RROutput -> Ptr CInt -> IO (Ptr Atom)
wrapPtr2 :: (Storable a, Storable b) => (Ptr a -> Ptr b -> IO c) -> (c -> a -> b -> d) -> IO d
wrapPtr2 cfun f =
withPool $ \pool -> do aptr <- pooledMalloc pool
bptr <- pooledMalloc pool
ret <- cfun aptr bptr
a <- peek aptr
b <- peek bptr
return (f ret a b)
peekCArray :: Storable a => CInt -> Ptr a -> IO [a]
peekCArray n = peekArray (fromIntegral n)
peekCArrayIO :: Storable a => IO CInt -> IO (Ptr a) -> IO [a]
peekCArrayIO n = join . liftM2 peekCArray n
peekCStringLenIO :: IO CInt -> IO (Ptr CChar) -> IO String
peekCStringLenIO n p = liftM2 (,) p (fmap fromIntegral n) >>= peekCStringLen