{-# LANGUAGE CPP             #-}
{-# LANGUAGE LambdaCase      #-}
{-# LANGUAGE TupleSections   #-}
{-# LANGUAGE RecordWildCards #-}
-----------------------------------------------------------------------------
-- |
-- Module      :  XMonad.Util.XUtils
-- Description :  A module for painting on the screen.
-- Copyright   :  (c) 2007 Andrea Rossato
--                    2010 Alejandro Serrano
-- License     :  BSD-style (see xmonad/LICENSE)
--
-- Maintainer  :  andrea.rossato@unibz.it
-- Stability   :  unstable
-- Portability :  unportable
--
-- A module for painting on the screen
--
-----------------------------------------------------------------------------

module XMonad.Util.XUtils
    ( -- * Usage:
      -- $usage
      withSimpleWindow
    , showSimpleWindow
    , WindowConfig(..)
    , WindowRect(..)
    , averagePixels
    , createNewWindow
    , showWindow
    , showWindows
    , hideWindow
    , hideWindows
    , deleteWindow
    , deleteWindows
    , paintWindow
    , paintAndWrite
    , paintTextAndIcons
    , stringToPixel
    , pixelToString
    , fi
    ) where

import XMonad.Prelude
import XMonad
import XMonad.Util.Font
import XMonad.Util.Image
import qualified XMonad.StackSet as W
import Data.Bits ((.&.))

-- $usage
-- See "XMonad.Layout.Tabbed" or "XMonad.Layout.DragPane" or
-- "XMonad.Layout.Decoration" for usage examples

-- | Compute the weighted average the colors of two given 'Pixel' values.
--
-- This function masks out any alpha channel in the passed pixels, and the
-- result has no alpha channel. X11 mishandles @Pixel@ values with alpha
-- channels and throws errors while producing black pixels.
averagePixels :: Pixel -> Pixel -> Double -> X Pixel
averagePixels :: Word64 -> Word64 -> Double -> X Word64
averagePixels Word64
p1' Word64
p2' Double
f =
    do d <- (XConf -> Display) -> X Display
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks XConf -> Display
display
       let cm = Display -> Word32 -> Word64
defaultColormap Display
d (Display -> Word32
defaultScreen Display
d)
           mask a
p = a
p a -> a -> a
forall a. Bits a => a -> a -> a
.&. a
0x00FFFFFF
           p1 = Word64 -> Word64
forall {a}. (Bits a, Num a) => a -> a
mask Word64
p1'
           p2 = Word64 -> Word64
forall {a}. (Bits a, Num a) => a -> a
mask Word64
p2'
       [Color _ r1 g1 b1 _,Color _ r2 g2 b2 _] <- io $ queryColors d cm [Color p1 0 0 0 0,Color p2 0 0 0 0]
       let mn a
x1 a
x2 = Double -> b
forall b. Integral b => Double -> b
forall a b. (RealFrac a, Integral b) => a -> b
round (a -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
x1 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
f Double -> Double -> Double
forall a. Num a => a -> a -> a
+ a -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
x2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* (Double
1Double -> Double -> Double
forall a. Num a => a -> a -> a
-Double
f))
       Color p _ _ _ _ <- io $ allocColor d cm (Color 0 (mn r1 r2) (mn g1 g2) (mn b1 b2) 0)
       return p

-- | Create a simple window given a rectangle. If Nothing is given
-- only the exposureMask will be set, otherwise the Just value.
-- Use 'showWindow' to map and hideWindow to unmap.
createNewWindow :: Rectangle -> Maybe EventMask -> String -> Bool -> X Window
createNewWindow :: Rectangle -> Maybe Word64 -> String -> Bool -> X Word64
createNewWindow (Rectangle Int32
x Int32
y Word32
w Word32
h) Maybe Word64
m String
col Bool
o = do
  d   <- (XConf -> Display) -> X Display
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks XConf -> Display
display
  rw  <- asks theRoot
  c   <- stringToPixel d col
  win <- io $ mkWindow d (defaultScreenOfDisplay d) rw x y w h c o
  case m of
    Just Word64
em -> IO () -> X ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
io (IO () -> X ()) -> IO () -> X ()
forall a b. (a -> b) -> a -> b
$ Display -> Word64 -> Word64 -> IO ()
selectInput Display
d Word64
win Word64
em
    Maybe Word64
Nothing -> IO () -> X ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
io (IO () -> X ()) -> IO () -> X ()
forall a b. (a -> b) -> a -> b
$ Display -> Word64 -> Word64 -> IO ()
selectInput Display
d Word64
win Word64
exposureMask
  -- @@@ ugly hack to prevent compositing
  whenX (return $ isJust m) $ flip catchX (return ()) $ do
    wINDOW_TYPE <- getAtom "_NET_WM_WINDOW_TYPE"
    dESKTOP <- getAtom "_NET_WM_WINDOW_TYPE_DESKTOP"
    io $ changeProperty32 d win wINDOW_TYPE aTOM propModeReplace [fi dESKTOP]
  return win

-- | Map a window
showWindow :: Window -> X ()
showWindow :: Word64 -> X ()
showWindow Word64
w = do
  d <- (XConf -> Display) -> X Display
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks XConf -> Display
display
  io $ mapWindow d w

-- | the list version
showWindows :: [Window] -> X ()
showWindows :: [Word64] -> X ()
showWindows = (Word64 -> X ()) -> [Word64] -> X ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Word64 -> X ()
showWindow

-- | unmap a window
hideWindow :: Window -> X ()
hideWindow :: Word64 -> X ()
hideWindow Word64
w = do
  d <- (XConf -> Display) -> X Display
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks XConf -> Display
display
  io $ unmapWindow d w

-- | the list version
hideWindows :: [Window] -> X ()
hideWindows :: [Word64] -> X ()
hideWindows = (Word64 -> X ()) -> [Word64] -> X ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Word64 -> X ()
hideWindow

-- | destroy a window
deleteWindow :: Window -> X ()
deleteWindow :: Word64 -> X ()
deleteWindow Word64
w = do
  d <- (XConf -> Display) -> X Display
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks XConf -> Display
display
  io $ destroyWindow d w

-- | the list version
deleteWindows :: [Window] -> X ()
deleteWindows :: [Word64] -> X ()
deleteWindows = (Word64 -> X ()) -> [Word64] -> X ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Word64 -> X ()
deleteWindow

-- | Fill a window with a rectangle and a border
paintWindow :: Window     -- ^ The window where to draw
            -> Dimension  -- ^ Window width
            -> Dimension  -- ^ Window height
            -> Dimension  -- ^ Border width
            -> String     -- ^ Window background color
            -> String     -- ^ Border color
            -> X ()
paintWindow :: Word64 -> Word32 -> Word32 -> Word32 -> String -> String -> X ()
paintWindow Word64
w Word32
wh Word32
ht Word32
bw String
c String
bc =
    Word64
-> Rectangle
-> Word32
-> String
-> String
-> Maybe (XMonadFont, String, String, [(String, (Int32, Int32))])
-> Maybe (String, String, [((Int32, Int32), [[Bool]])])
-> X ()
paintWindow' Word64
w (Int32 -> Int32 -> Word32 -> Word32 -> Rectangle
Rectangle Int32
0 Int32
0 Word32
wh Word32
ht) Word32
bw String
c String
bc Maybe (XMonadFont, String, String, [(String, (Int32, Int32))])
forall a. Maybe a
Nothing Maybe (String, String, [((Int32, Int32), [[Bool]])])
forall a. Maybe a
Nothing

-- | Fill a window with a rectangle and a border, and write
-- | a number of strings to given positions
paintAndWrite :: Window     -- ^ The window where to draw
              -> XMonadFont -- ^ XMonad Font for drawing
              -> Dimension  -- ^ Window width
              -> Dimension  -- ^ Window height
              -> Dimension  -- ^ Border width
              -> String     -- ^ Window background color
              -> String     -- ^ Border color
              -> String     -- ^ String color
              -> String     -- ^ String background color
              -> [Align]    -- ^ String 'Align'ments
              -> [String]   -- ^ Strings to be printed
              -> X ()
paintAndWrite :: Word64
-> XMonadFont
-> Word32
-> Word32
-> Word32
-> String
-> String
-> String
-> String
-> [Align]
-> [String]
-> X ()
paintAndWrite Word64
w XMonadFont
fs Word32
wh Word32
ht Word32
bw String
bc String
borc String
ffc String
fbc [Align]
als [String]
strs = do
    d <- (XConf -> Display) -> X Display
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks XConf -> Display
display
    strPositions <- forM (zip als strs) $
        uncurry (stringPosition d fs (Rectangle 0 0 wh ht))
    let ms = (XMonadFont, String, String, [(String, (Int32, Int32))])
-> Maybe (XMonadFont, String, String, [(String, (Int32, Int32))])
forall a. a -> Maybe a
Just (XMonadFont
fs,String
ffc,String
fbc, [String] -> [(Int32, Int32)] -> [(String, (Int32, Int32))]
forall a b. [a] -> [b] -> [(a, b)]
zip [String]
strs [(Int32, Int32)]
strPositions)
    paintWindow' w (Rectangle 0 0 wh ht) bw bc borc ms Nothing

-- | Fill a window with a rectangle and a border, and write
-- | a number of strings and a number of icons to given positions
paintTextAndIcons :: Window      -- ^ The window where to draw
                  -> XMonadFont  -- ^ XMonad Font for drawing
                  -> Dimension   -- ^ Window width
                  -> Dimension   -- ^ Window height
                  -> Dimension   -- ^ Border width
                  -> String      -- ^ Window background color
                  -> String      -- ^ Border color
                  -> String      -- ^ String color
                  -> String      -- ^ String background color
                  -> [Align]     -- ^ String 'Align'ments
                  -> [String]    -- ^ Strings to be printed
                  -> [Placement] -- ^ Icon 'Placements'
                  -> [[[Bool]]]  -- ^ Icons to be printed
                  -> X ()
paintTextAndIcons :: Word64
-> XMonadFont
-> Word32
-> Word32
-> Word32
-> String
-> String
-> String
-> String
-> [Align]
-> [String]
-> [Placement]
-> [[[Bool]]]
-> X ()
paintTextAndIcons Word64
w XMonadFont
fs Word32
wh Word32
ht Word32
bw String
bc String
borc String
ffc String
fbc [Align]
als [String]
strs [Placement]
i_als [[[Bool]]]
icons = do
    d <- (XConf -> Display) -> X Display
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks XConf -> Display
display
    strPositions <- forM (zip als strs) $ uncurry (stringPosition d fs (Rectangle 0 0 wh ht))
    let iconPositions = (Placement -> [[Bool]] -> (Int32, Int32))
-> [Placement] -> [[[Bool]]] -> [(Int32, Int32)]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (Rectangle -> Placement -> [[Bool]] -> (Int32, Int32)
iconPosition (Int32 -> Int32 -> Word32 -> Word32 -> Rectangle
Rectangle Int32
0 Int32
0 Word32
wh Word32
ht)) [Placement]
i_als [[[Bool]]]
icons
        ms = (XMonadFont, String, String, [(String, (Int32, Int32))])
-> Maybe (XMonadFont, String, String, [(String, (Int32, Int32))])
forall a. a -> Maybe a
Just (XMonadFont
fs,String
ffc,String
fbc, [String] -> [(Int32, Int32)] -> [(String, (Int32, Int32))]
forall a b. [a] -> [b] -> [(a, b)]
zip [String]
strs [(Int32, Int32)]
strPositions)
        is = (String, String, [((Int32, Int32), [[Bool]])])
-> Maybe (String, String, [((Int32, Int32), [[Bool]])])
forall a. a -> Maybe a
Just (String
ffc, String
fbc, [(Int32, Int32)] -> [[[Bool]]] -> [((Int32, Int32), [[Bool]])]
forall a b. [a] -> [b] -> [(a, b)]
zip [(Int32, Int32)]
iconPositions [[[Bool]]]
icons)
    paintWindow' w (Rectangle 0 0 wh ht) bw bc borc ms is

-- | The config for a window, as interpreted by 'showSimpleWindow'.
--
-- The font @winFont@ can either be specified in the TODO format or as an
-- xft font.  For example:
--
-- > winFont = "xft:monospace-20"
--
-- or
--
-- > winFont = "-misc-fixed-*-*-*-*-20-*-*-*-*-*-*-*"
data WindowConfig = WindowConfig
  { WindowConfig -> String
winFont :: !String      -- ^ Font to use.
  , WindowConfig -> String
winBg   :: !String      -- ^ Background color.
  , WindowConfig -> String
winFg   :: !String      -- ^ Foreground color.
  , WindowConfig -> WindowRect
winRect :: !WindowRect  -- ^ Position and size of the rectangle.
  }

instance Default WindowConfig where
  def :: WindowConfig
def = WindowConfig
    {
#ifdef XFT
      winFont = "xft:monospace-20"
#else
      winFont :: String
winFont = String
"-misc-fixed-*-*-*-*-20-*-*-*-*-*-*-*"
#endif
    , winBg :: String
winBg   = String
"black"
    , winFg :: String
winFg   = String
"white"
    , winRect :: WindowRect
winRect = WindowRect
CenterWindow
    }

-- | What kind of window we should be.
data WindowRect
  = CenterWindow         -- ^ Centered, big enough to fit all the text.
  | CustomRect Rectangle -- ^ Completely custom dimensions.

-- | Create a window, then fill and show it with the given text.  If you
-- are looking for a version of this function that also takes care of
-- destroying the window, refer to 'withSimpleWindow'.
showSimpleWindow :: WindowConfig -- ^ Window config.
                 -> [String]     -- ^ Lines of text to show.
                 -> X Window
showSimpleWindow :: WindowConfig -> [String] -> X Word64
showSimpleWindow WindowConfig{String
WindowRect
winFont :: WindowConfig -> String
winBg :: WindowConfig -> String
winFg :: WindowConfig -> String
winRect :: WindowConfig -> WindowRect
winFont :: String
winBg :: String
winFg :: String
winRect :: WindowRect
..} [String]
strs = do
  let pad :: Int32
pad = Int32
20
  font <- String -> X XMonadFont
initXMF String
winFont
  dpy  <- asks display
  Rectangle sx sy sw sh <- getRectangle winRect

  -- Text extents for centering all fonts
  extends <- maximum . map (uncurry (+)) <$> traverse (textExtentsXMF font) strs
  -- Height and width of entire window
  height <- pure . fi $ (1 + length strs) * fi extends
  width  <- (+ pad) . fi . maximum <$> traverse (textWidthXMF dpy font) strs

  let -- x and y coordinates that specify the upper left corner of the window
      x = Int32
sx Int32 -> Int32 -> Int32
forall a. Num a => a -> a -> a
+ (Word32 -> Int32
forall a b. (Integral a, Num b) => a -> b
fi Word32
sw Int32 -> Int32 -> Int32
forall a. Num a => a -> a -> a
- Int32
width  Int32 -> Int32 -> Int32
forall a. Num a => a -> a -> a
+ Int32
2) Int32 -> Int32 -> Int32
forall a. Integral a => a -> a -> a
`div` Int32
2
      y = Int32
sy Int32 -> Int32 -> Int32
forall a. Num a => a -> a -> a
+ (Word32 -> Int32
forall a b. (Integral a, Num b) => a -> b
fi Word32
sh Int32 -> Int32 -> Int32
forall a. Num a => a -> a -> a
- Int32
height Int32 -> Int32 -> Int32
forall a. Num a => a -> a -> a
+ Int32
2) Int32 -> Int32 -> Int32
forall a. Integral a => a -> a -> a
`div` Int32
2
      -- y position of first string
      yFirst = (Int32
height Int32 -> Int32 -> Int32
forall a. Num a => a -> a -> a
+ Int32
2 Int32 -> Int32 -> Int32
forall a. Num a => a -> a -> a
* Int32
extends) Int32 -> Int32 -> Int32
forall a. Integral a => a -> a -> a
`div` Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fi (Int
2 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ [String] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
strs)
      -- (x starting, y starting) for all strings
      strPositions = (Int32 -> (Int32, Int32)) -> [Int32] -> [(Int32, Int32)]
forall a b. (a -> b) -> [a] -> [b]
map (Int32
pad Int32 -> Int32 -> Int32
forall a. Integral a => a -> a -> a
`div` Int32
2, ) [Int32
yFirst, Int32
yFirst Int32 -> Int32 -> Int32
forall a. Num a => a -> a -> a
+ Int32
extends ..]

  w <- createNewWindow (Rectangle x y (fi width) (fi height)) Nothing "" True
  let ms = (XMonadFont, String, String, [(String, (Int32, Int32))])
-> Maybe (XMonadFont, String, String, [(String, (Int32, Int32))])
forall a. a -> Maybe a
Just (XMonadFont
font, String
winFg, String
winBg, [String] -> [(Int32, Int32)] -> [(String, (Int32, Int32))]
forall a b. [a] -> [b] -> [(a, b)]
zip [String]
strs [(Int32, Int32)]
strPositions)
  showWindow w
  paintWindow' w (Rectangle 0 0 (fi width) (fi height)) 0 winBg "" ms Nothing
  releaseXMF font
  pure w
 where
  getRectangle :: WindowRect -> X Rectangle
  getRectangle :: WindowRect -> X Rectangle
getRectangle = \case
    WindowRect
CenterWindow -> (XState -> Rectangle) -> X Rectangle
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ((XState -> Rectangle) -> X Rectangle)
-> (XState -> Rectangle) -> X Rectangle
forall a b. (a -> b) -> a -> b
$ ScreenDetail -> Rectangle
screenRect (ScreenDetail -> Rectangle)
-> (XState -> ScreenDetail) -> XState -> Rectangle
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Screen String (Layout Word64) Word64 ScreenId ScreenDetail
-> ScreenDetail
forall i l a sid sd. Screen i l a sid sd -> sd
W.screenDetail (Screen String (Layout Word64) Word64 ScreenId ScreenDetail
 -> ScreenDetail)
-> (XState
    -> Screen String (Layout Word64) Word64 ScreenId ScreenDetail)
-> XState
-> ScreenDetail
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StackSet String (Layout Word64) Word64 ScreenId ScreenDetail
-> Screen String (Layout Word64) Word64 ScreenId ScreenDetail
forall i l a sid sd. StackSet i l a sid sd -> Screen i l a sid sd
W.current (StackSet String (Layout Word64) Word64 ScreenId ScreenDetail
 -> Screen String (Layout Word64) Word64 ScreenId ScreenDetail)
-> (XState
    -> StackSet String (Layout Word64) Word64 ScreenId ScreenDetail)
-> XState
-> Screen String (Layout Word64) Word64 ScreenId ScreenDetail
forall b c a. (b -> c) -> (a -> b) -> a -> c
. XState
-> StackSet String (Layout Word64) Word64 ScreenId ScreenDetail
windowset
    CustomRect Rectangle
r -> Rectangle -> X Rectangle
forall a. a -> X a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Rectangle
r

-- | Like 'showSimpleWindow', but fully manage the window; i.e., destroy
-- it after the given function finishes its execution.
withSimpleWindow :: WindowConfig -> [String] -> X a -> X a
withSimpleWindow :: forall a. WindowConfig -> [String] -> X a -> X a
withSimpleWindow WindowConfig
wc [String]
strs X a
doStuff = do
  w <- WindowConfig -> [String] -> X Word64
showSimpleWindow WindowConfig
wc [String]
strs
  doStuff <* withDisplay (io . (`destroyWindow` w))

-- This stuff is not exported

-- | Paints a titlebar with some strings and icons
-- drawn inside it.
-- Not exported.
paintWindow' :: Window -> Rectangle -> Dimension -> String -> String
                -> Maybe (XMonadFont,String,String,[(String, (Position, Position))])
                -> Maybe (String, String, [((Position, Position), [[Bool]])]) -> X ()
paintWindow' :: Word64
-> Rectangle
-> Word32
-> String
-> String
-> Maybe (XMonadFont, String, String, [(String, (Int32, Int32))])
-> Maybe (String, String, [((Int32, Int32), [[Bool]])])
-> X ()
paintWindow' Word64
win (Rectangle Int32
_ Int32
_ Word32
wh Word32
ht) Word32
bw String
color String
b_color Maybe (XMonadFont, String, String, [(String, (Int32, Int32))])
strStuff Maybe (String, String, [((Int32, Int32), [[Bool]])])
iconStuff = do
  d  <- (XConf -> Display) -> X Display
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks XConf -> Display
display
  p  <- io $ createPixmap d win wh ht (defaultDepthOfScreen $ defaultScreenOfDisplay d)
  gc <- io $ createGC d p
  -- draw
  io $ setGraphicsExposures d gc False
  [color',b_color'] <- mapM (stringToPixel d) [color,b_color]
  -- we start with the border
  io $ setForeground d gc b_color'
  io $ fillRectangle d p gc 0 0 wh ht
  -- and now again
  io $ setForeground d gc color'
  io $ fillRectangle d p gc (fi bw) (fi bw) (wh - (bw * 2)) (ht - (bw * 2))
  -- paint strings
  when (isJust strStuff) $ do
    let (xmf,fc,bc,strAndPos) = fromJust strStuff
    forM_ strAndPos $ \(String
s, (Int32
x, Int32
y)) ->
        Display
-> Word64
-> XMonadFont
-> GC
-> String
-> String
-> Int32
-> Int32
-> String
-> X ()
forall (m :: * -> *).
(Functor m, MonadIO m) =>
Display
-> Word64
-> XMonadFont
-> GC
-> String
-> String
-> Int32
-> Int32
-> String
-> m ()
printStringXMF Display
d Word64
p XMonadFont
xmf GC
gc String
fc String
bc Int32
x Int32
y String
s
  -- paint icons
  when (isJust iconStuff) $ do
    let (fc, bc, iconAndPos) = fromJust iconStuff
    forM_ iconAndPos $ \((Int32
x, Int32
y), [[Bool]]
icon) ->
      Display
-> Word64
-> GC
-> String
-> String
-> Int32
-> Int32
-> [[Bool]]
-> X ()
forall (m :: * -> *).
(Functor m, MonadIO m) =>
Display
-> Word64
-> GC
-> String
-> String
-> Int32
-> Int32
-> [[Bool]]
-> m ()
drawIcon Display
d Word64
p GC
gc String
fc String
bc Int32
x Int32
y [[Bool]]
icon
  -- copy the pixmap over the window
  io $ copyArea      d p win gc 0 0 wh ht 0 0
  -- free the pixmap and GC
  io $ freePixmap    d p
  io $ freeGC        d gc

-- | Creates a window with the possibility of setting some attributes.
-- Not exported.
mkWindow :: Display -> Screen -> Window -> Position
         -> Position -> Dimension -> Dimension -> Pixel -> Bool -> IO Window
mkWindow :: Display
-> Screen
-> Word64
-> Int32
-> Int32
-> Word32
-> Word32
-> Word64
-> Bool
-> IO Word64
mkWindow Display
d Screen
s Word64
rw Int32
x Int32
y Word32
w Word32
h Word64
p Bool
o = do
  let visual :: Visual
visual = Screen -> Visual
defaultVisualOfScreen Screen
s
      attrmask :: Word64
attrmask = Word64
cWOverrideRedirect Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.|. Word64
cWBackPixel Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.|. Word64
cWBorderPixel
  (Ptr SetWindowAttributes -> IO Word64) -> IO Word64
forall a. (Ptr SetWindowAttributes -> IO a) -> IO a
allocaSetWindowAttributes ((Ptr SetWindowAttributes -> IO Word64) -> IO Word64)
-> (Ptr SetWindowAttributes -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$
         \Ptr SetWindowAttributes
attributes -> do
           Ptr SetWindowAttributes -> Bool -> IO ()
set_override_redirect Ptr SetWindowAttributes
attributes Bool
o
           Ptr SetWindowAttributes -> Word64 -> IO ()
set_border_pixel      Ptr SetWindowAttributes
attributes Word64
p
           Ptr SetWindowAttributes -> Word64 -> IO ()
set_background_pixel  Ptr SetWindowAttributes
attributes Word64
p
           Display
-> Word64
-> Int32
-> Int32
-> Word32
-> Word32
-> CInt
-> CInt
-> CInt
-> Visual
-> Word64
-> Ptr SetWindowAttributes
-> IO Word64
createWindow Display
d Word64
rw Int32
x Int32
y Word32
w Word32
h CInt
0 (Screen -> CInt
defaultDepthOfScreen Screen
s)
                        CInt
inputOutput Visual
visual Word64
attrmask Ptr SetWindowAttributes
attributes