path: root/XMonad/Hooks/DebugEvents.hs

{-# LANGUAGE CPP, GeneralizedNewtypeDeriving #-}
-----------------------------------------------------------------------------
-- |
-- Module      :  XMonad.Hooks.DebugEvents
-- Copyright   :  (c) Brandon S Allbery KF8NH, 2012
-- License     :  BSD3-style (see LICENSE)
--
-- Maintainer  :  allbery.b@gmail.com
-- Stability   :  unstable
-- Portability :  not portable
--
-- Module to dump diagnostic information about X11 events received by
-- @xmonad@.  This is incomplete due to 'Event' being incomplete and not
-- providing information about a number of events, and enforcing artificial
-- constraints on others (for example 'ClientMessage'); the @X11@ package
-- will require a number of changes to fix these problems.
--
-----------------------------------------------------------------------------

module XMonad.Hooks.DebugEvents (debugEventsHook) where

import           Prelude

import           XMonad                               hiding (windowEvent
                                                             ,(-->)
                                                             )

import           XMonad.Hooks.DebugKeyEvents                 (debugKeyEvents)
import           XMonad.Util.DebugWindow                     (debugWindow)

-- import           Graphics.X11.Xlib.Extras.GetAtomName        (getAtomName)

import           Control.Exception.Extensible         as E
import           Control.Monad.State
import           Control.Monad.Reader
import           Data.Char                                   (isDigit)
import           Data.List                                   (genericIndex
                                                             ,genericLength
                                                             ,unfoldr
                                                             )
import           Codec.Binary.UTF8.String
import           Data.Maybe                                  (fromMaybe)
import           Data.Monoid
import           Foreign
import           Foreign.C.Types
import           Numeric                                     (showHex)
import           System.Exit
import           System.IO
import           System.Process
import           Control.Applicative

-- | Event hook to dump all received events.  You should probably not use this
--   unconditionally; it will produce massive amounts of output.
debugEventsHook   :: Event -> X All
debugEventsHook e =  debugEventsHook' e >> return (All True)

-- | Dump an X11 event.  Can't be used directly as a 'handleEventHook'.
debugEventsHook' :: Event -> X ()

debugEventsHook' (ConfigureRequestEvent {ev_window       = w
                                        ,ev_parent       = p
                                        ,ev_x            = x
                                        ,ev_y            = y
                                        ,ev_width        = wid
                                        ,ev_height       = ht
                                        ,ev_border_width = bw
                                        ,ev_above        = above
                                        ,ev_detail       = place
                                        ,ev_value_mask   = msk
                                        }) = do
  windowEvent "ConfigureRequest" w
  windowEvent "  parent"         p
--  mask <- quickFormat msk $ dumpBits wmCRMask
--  say "  requested parameters" $ concat ['(':show wid
--                                        ,'x':show ht
--                                        ,')':if bw == 0 then "" else '+':show bw
--                                        ,'@':'(':show x
--                                        ,',':show y
--                                        ,") mask "
--                                        ,mask
--                                        ]
  s <- quickFormat [x,y,wid,ht,bw,fromIntegral above,place] $
       dumpListByMask' msk [("x"           ,dump32              ,cARDINAL)
                           ,("y"           ,dump32              ,cARDINAL)
                           ,("width"       ,dump32              ,cARDINAL)
                           ,("height"      ,dump32              ,cARDINAL)
                           ,("border_width",dump32              ,cARDINAL)
                           ,("sibling"     ,dumpWindow          ,wINDOW  )
                           ,("detail"      ,dumpEnum wmPlacement,cARDINAL)
                           ]
  say "  requested" s

debugEventsHook' (ConfigureEvent        {ev_window = w
                                        ,ev_above  = above
                                        }) = do
  windowEvent "Configure" w
  -- most of the content is covered by debugWindow
  when (above /= none) $ debugWindow above >>= say "  above"

debugEventsHook' (MapRequestEvent       {ev_window     = w
                                        ,ev_parent     = p
                                        }) =
  windowEvent "MapRequest" w >>
  windowEvent "  parent"   p

debugEventsHook' e@(KeyEvent {ev_event_type = t})
    | t == keyPress =
  io (hPutStr stderr "KeyPress ") >>
  debugKeyEvents e >>
  return ()

debugEventsHook' (ButtonEvent           {ev_window = w
                                        ,ev_state  = s
                                        ,ev_button = b
                                        }) = do
  windowEvent "Button" w
  nl <- gets numberlockMask
  let msk | s == 0    = ""
          | otherwise = "modifiers " ++ vmask nl s
  say "  button" $ show b ++ msk

debugEventsHook' (DestroyWindowEvent    {ev_window = w
                                        }) =
  windowEvent "DestroyWindow" w

debugEventsHook' (UnmapEvent            {ev_window = w
                                        }) =
  windowEvent "Unmap" w

debugEventsHook' (MapNotifyEvent        {ev_window = w
                                        }) =
  windowEvent "MapNotify" w

{- way too much output; suppressed.

debugEventsHook' (CrossingEvent         {ev_window    = w
                                        ,ev_subwindow = s
                                        }) =
  windowEvent "Crossing"    w >>
  windowEvent "  subwindow" s
-}
debugEventsHook' (CrossingEvent         {}) =
  return ()

debugEventsHook' (SelectionRequest      {ev_requestor = rw
                                        ,ev_owner     = ow
                                        ,ev_selection = a
                                        }) =
  windowEvent "SelectionRequest" rw >>
  windowEvent "  owner"          ow >>
  atomEvent   "  atom"           a

debugEventsHook' (PropertyEvent         {ev_window    = w
                                        ,ev_atom      = a
                                        ,ev_propstate = s
                                        }) = do
  a' <- atomName a
  -- too many of these, and they're not real useful
  if a' `elem` ["_NET_WM_USER_TIME"
--               ,"_NET_WM_WINDOW_OPACITY"
               ] then return () else do
  windowEvent "Property on" w
  s' <- case s of
          1 -> return "deleted"
          0 -> dumpProperty a a' w (7 + length a')
          _ -> error "Illegal propState; Xlib corrupted?"
  say "  atom" $ a' ++ s'

debugEventsHook' (ExposeEvent           {ev_window = w
                                        }) =
  windowEvent "Expose" w

debugEventsHook' (ClientMessageEvent    {ev_window       = w
                                        ,ev_message_type = a
                                        -- @@@ they did it again!  no ev_format,
                                        --     and ev_data is [CInt]
                                        -- @@@ and get a load of the trainwreck
                                        --     that is setClientMessageEvent!
--                                        ,ev_format       = b
                                        ,ev_data         = vs'
                                        }) = do
  windowEvent "ClientMessage on" w
  n <- atomName a
  -- this is a sort of custom property
  -- @@@ this likely won't work as is; type information varies, I think
  (ta,b,l) <- case lookup n clientMessages of
                Nothing        -> return (a,32,length vs')
                Just (ta',b,l) -> do
                  ta <- getAtom ta'
                  return (ta,b,l)
  let wl = bytes b
  vs <- io $ take (l * wl) `fmap` splitCInt vs'
  s <- dumpProperty' w a n ta b vs 0 (10 + length n)
  say "  message" $ n ++ s

debugEventsHook' _                      = return ()

-- | Emit information about an atom.
atomName   :: Atom -> X String
atomName a =  withDisplay $ \d ->
  io $ fromMaybe ("(unknown atom " ++ show a ++ ")") `fmap` getAtomName d a

-- | Emit an atom with respect to the current event.
atomEvent     :: String -> Atom -> X ()
atomEvent l a =  atomName a >>= say l

-- | Emit a window with respect to the current event.
windowEvent     :: String -> Window -> X ()
windowEvent l w =  debugWindow w >>= say l

-- | Helper to emit tagged event information.
say     :: String -> String -> X ()
say l s =  trace $ l ++ ' ':s

-- | Deconstuct a list of 'CInt's into raw bytes
splitCInt    :: [CInt] -> IO Raw
splitCInt vs =  io $ withArray vs $ \p ->
                peekArray (4 * length vs) (castPtr p :: Ptr CUChar)

-- | Specify how to decode some common client messages.
clientMessages :: [(String,(String,Int,Int))]
clientMessages =  [("_NET_ACTIVE_WINDOW",("_NET_ACTIVE_WINDOW",32,1))
                  ,("WM_CHANGE_STATE"   ,("WM_STATE"          ,32,2))
                  ,("WM_COMMAND"        ,("STRING"            , 8,0))
                  ,("WM_SAVE_YOURSELF"  ,("STRING"            , 8,0))
                  ]

#if __GLASGOW_HASKELL__ < 707
finiteBitSize :: Bits a => a -> Int
finiteBitSize x = bitSize x
#endif


-- | Convert a modifier mask into a useful string
vmask                 :: KeyMask -> KeyMask -> String
vmask numLockMask msk =  unwords $
                         reverse $
                         fst     $
                         foldr vmask' ([],msk) masks
    where
      masks = map (\m -> (m,show m)) [0..toEnum (finiteBitSize msk - 1)] ++
              [(numLockMask,"num"  )
              ,(   lockMask,"lock" )
              ,(controlMask,"ctrl" )
              ,(  shiftMask,"shift")
              ,(   mod5Mask,"mod5" )
              ,(   mod4Mask,"mod4" )
              ,(   mod3Mask,"mod3" )
              ,(   mod2Mask,"mod2" )
              ,(   mod1Mask,"mod1" )
              ]
      vmask'   _   a@( _,0)                = a
      vmask' (m,s)   (ss,v) | v .&. m == m = (s : ss,v .&. complement m)
      vmask'   _        r                  = r

-- formatting properties.  ick. --

-- @@@ Document the parser.  Someday.

type Raw     = [CUChar]

data Decode = Decode {property :: Atom          -- original property atom
                     ,pName    :: String        -- its name
                     ,pType    :: Atom          -- base property type atom
                     ,width    :: Int           -- declared data width
                     ,window   :: Window        -- source window
                     ,indent   :: Int           -- current indent (via local)
                     ,limit    :: Int           -- line length
                     }

-- the result accumulates here mainly for the benefit of the indenter
data DecodeState = DecS {value :: Raw           -- unconsumed raw property value
                        ,accum :: String        -- output accumulator
                        ,joint :: String        -- separator when adding to accumulator
                        }

newtype Decoder a = Decoder (ReaderT Decode (StateT DecodeState X) a)
#ifndef __HADDOCK__
    deriving (Functor
             ,Applicative
             ,Monad
             ,MonadIO
             ,MonadState  DecodeState
             ,MonadReader Decode
             )
#endif

-- | Retrive, parse, and dump a window property.  As all the high-level property
--   interfaces lose information necessary to decode properties correctly, we 
--   work at the lowest level available.
dumpProperty          :: Atom -> String -> Window -> Int -> X String
dumpProperty a n w i  =  do
  prop <- withDisplay $ \d ->
    io     $
    alloca $ \fmtp ->
    alloca $ \szp  ->
    alloca $ \lenp ->
    alloca $ \ackp ->
    alloca $ \vsp  -> do
    rc   <- xGetWindowProperty
              d
              w
              a
              0
              maxBound
              False
              anyPropertyType
              fmtp
              szp
              lenp
              ackp
              vsp
    case rc of
      0 -> do
        fmt <- fromIntegral `fmap` peek fmtp
        vs' <-                     peek vsp
        sz  <- fromIntegral `fmap` peek szp
        case () of
          () | fmt == none     -> xFree vs' >> return (Left   "(property deleted)"   )
             | sz < 0          -> xFree vs' >> return (Left $ "(illegal bit size " ++
                                                              show sz              ++
                                                              ")"                    )
             | sz `mod` 8 /= 0 -> xFree vs' >> return (Left $ "(illegal bit size " ++
                                                              show sz              ++
                                                              ")"                    )
             | otherwise       -> do
                 len <- fromIntegral `fmap` peek lenp
                 -- that's as in "ack! it's fugged!"
                 ack <- fromIntegral `fmap` peek ackp
                 vs <- peekArray (len * bytes sz) vs'
                 _ <- xFree vs'
                 return $ Right (fmt,sz,ack,vs)
      e -> return $ Left $ "getWindowProperty failed: " ++ show e
  case prop of
    Left  _               -> return ""
    Right (fmt,sz,ack,vs) -> dumpProperty' w a n fmt sz vs ack i

-- @@@ am I better off passing in the Decode and DecodeState?
-- | Parse and dump a property (or a 'ClientMessage').
dumpProperty'                             :: Window -- source window
                                          -> Atom   -- property id
                                          -> String -- property name
                                          -> Atom   -- property type
                                          -> Int    -- bit width
                                          -> Raw    -- raw value
                                          -> CULong -- size of un-dumped content
                                          -> Int    -- indent for output formatting
                                          -> X String
dumpProperty' w a n fmt sz vs ack i =  do
  ptn <- atomName fmt
  let dec  = Decode {property = a
                    ,pName    = n
                    ,pType    = fmt
                    ,width    = sz
                    ,indent   = i + length ptn + 6
                    ,window   = w
                    ,limit    = 96
                    }
      dec' = dec    {pType    = cARDINAL
                    ,width    = 8
                    }
      ds   = DecS   {value    = vs
                    -- @@@ probably should push this outside, since it doesn't
                    --     make sense for ClientMessage
                    ,accum    = " (" ++ ptn ++ ") "
                    ,joint    = "= "
                    }
  (_,ds') <- runDecode dec ds $ dumpProp a n
  let fin = length (value ds')
      len = length vs
      lost = if ack == 0 then "" else "and " ++ show ack ++ " lost bytes"
      unk = case () of
              () | fin == len -> "undecodeable "
                 | fin == 0   -> "."
                 | otherwise  -> "and remainder (" ++ show (len - fin) ++ '/':show len ++ ")"
  (_,ds'') <- if fin == 0
              then return (True,ds')
              else runDecode dec' (withJoint' unk ds' ) $ dumpArray dump8
  (_,ds''') <- if ack == 0
               then return (True,ds'')
               else runDecode dec' (withJoint' " " ds'') $ propSimple lost -- @@@
  return $ accum ds'''

-- | A simplified version of 'dumpProperty\'', to format random values from
--   events.
quickFormat     :: (Storable i, Integral i) => [i] -> Decoder Bool -> X String
quickFormat v f =  do
  let vl = length v
  vs <- io $
        allocaArray vl $
        \p -> pokeArray p (map fromIntegral v :: [CULong]) >>
              peekArray (4 * vl) (castPtr p :: Ptr CUChar)
  let dec = Decode {property = none
                   ,pName    = ""
                   ,pType    = cARDINAL
                   ,width    = 32
                   ,indent   = 0
                   ,window   = none
                   ,limit    = maxBound
                   }
      ds  = DecS   {value    = vs
                   ,accum    = ""
                   ,joint    = ""
                   }
  (r,ds') <- runDecode dec ds f
  return $ accum ds' ++ if r then "" else "?"

-- | Launch a decoding parser, returning success and final state.
runDecode                 :: Decode -> DecodeState -> Decoder Bool -> X (Bool,DecodeState)
runDecode c s (Decoder p) =  runStateT (runReaderT p c) s

-- Coerce bit size to bytes.
bytes   :: Int -> Int
bytes w =  w `div` 8

-- | The top level property decoder, for a wide variety of standard ICCCM and 
--   EWMH window properties.  We pass part of the 'ReaderT' as arguments for 
--   pattern matching.
dumpProp                                              :: Atom -> String -> Decoder Bool

dumpProp _ "CLIPBOARD"                                =  dumpSelection
dumpProp _ "_NET_SUPPORTED"                           =  dumpArray dumpAtom
dumpProp _ "_NET_CLIENT_LIST"                         =  dumpArray dumpWindow
dumpProp _ "_NET_CLIENT_LIST_STACKING"                =  dumpArray dumpWindow
dumpProp _ "_NET_NUMBER_OF_DESKTOPS"                  =  dump32
dumpProp _ "_NET_VIRTUAL_ROOTS"                       =  dumpArray dumpWindow
dumpProp _ "_NET_DESKTOP_GEOMETRY"                    =  dumpArray dump32
dumpProp _ "_NET_DESKTOP_VIEWPORT"                    =  dumpList [("w",dump32)
                                                                  ,("h",dump32)
                                                                  ]
dumpProp _ "_NET_CURRENT_DESKTOP"                     =  dump32
dumpProp _ "_NET_DESKTOP_NAMES"                       =  dumpArray dumpUTF
dumpProp _ "_NET_ACTIVE_WINDOW"                       =  dumpActiveWindow
dumpProp _ "_NET_WORKAREA"                            =  dumpList [("start"
                                                                   ,dumpList [("x",dump32)
                                                                             ,("y",dump32)
                                                                             ]
                                                                   )
                                                                  ,("size"
                                                                   ,dumpList [("w",dump32)
                                                                             ,("h",dump32)
                                                                             ]
                                                                   )
                                                                  ]
dumpProp _ "_NET_SUPPORTING_WM_CHECK"                 =  dumpWindow
dumpProp _ "_NET_DESKTOP_LAYOUT"                      =  dumpList [("orientation"
                                                                   ,dumpEnum nwmOrientation
                                                                   )
                                                                  ,("size"
                                                                   ,dumpList [("cols",dump32)
                                                                             ,("rows",dump32)
                                                                             ]
                                                                   )
                                                                  ,("origin"
                                                                   ,dumpEnum nwmOrigin
                                                                   )
                                                                  ]
dumpProp _ "_NET_SHOWING_DESKTOP"                     =  dump32
dumpProp _ "_NET_WM_NAME"                             =  dumpUTF
dumpProp _ "_NET_WM_VISIBLE_NAME"                     =  dumpUTF
dumpProp _ "_NET_WM_ICON_NAME"                        =  dumpUTF
dumpProp _ "_NET_WM_VISIBLE_ICON_NAME"                =  dumpUTF
dumpProp _ "_NET_WM_DESKTOP"                          =  dumpExcept [(0xFFFFFFFF,"all")]
                                                                    dump32
dumpProp _ "_NET_WM_WINDOW_TYPE"                      =  dumpArray dumpAtom
dumpProp _ "_NET_WM_STATE"                            =  dumpArray dumpAtom
dumpProp _ "_NET_WM_ALLOWED_ACTIONS"                  =  dumpArray dumpAtom
dumpProp _ "_NET_WM_STRUT"                            =  dumpList [("left gap"  ,dump32)
                                                                  ,("right gap" ,dump32)
                                                                  ,("top gap"   ,dump32)
                                                                  ,("bottom gap",dump32)
                                                                  ]
dumpProp _ "_NET_WM_STRUT_PARTIAL"                    =  dumpList [("left gap"    ,dump32)
                                                                  ,("right gap"   ,dump32)
                                                                  ,("top gap"     ,dump32)
                                                                  ,("bottom gap"  ,dump32)
                                                                  ,("left start"  ,dump32)
                                                                  ,("left end"    ,dump32)
                                                                  ,("right start" ,dump32)
                                                                  ,("right end"   ,dump32)
                                                                  ,("top start"   ,dump32)
                                                                  ,("top end"     ,dump32)
                                                                  ,("bottom start",dump32)
                                                                  ,("bottom end"  ,dump32)
                                                                  ]
dumpProp _ "_NET_WM_ICON_GEOMETRY"                    =  dumpList [("x",dump32)
                                                                  ,("y",dump32)
                                                                  ,("w",dump32)
                                                                  ,("h",dump32)
                                                                  ]
-- no, I'm not going to duplicate xprop *completely*!
dumpProp _ "_NET_WM_ICON"                             =  propSimple "(icon)"
dumpProp _ "_NET_WM_PID"                              =  dumpPid
dumpProp _ "_NET_WM_HANDLED_ICONS"                    =  propSimple "(defined)"
dumpProp _ "_NET_WM_USER_TIME"                        =  dumpExcept [(0,"do not map initially")]
                                                                    dumpTime
dumpProp _ "_NET_FRAME_EXTENTS"                       =  dumpList [("left"  ,dump32)
                                                                  ,("right" ,dump32)
                                                                  ,("top"   ,dump32)
                                                                  ,("bottom",dump32)
                                                                  ]
dumpProp _ "_NET_WM_SYNC_REQUEST_COUNTER"             =  dumpExcept [(0,"illegal value 0")]
                                                                    dump64
dumpProp _ "_NET_STARTUP_ID"                          =  dumpUTF
dumpProp _ "WM_PROTOCOLS"                             =  dumpArray dumpAtom
dumpProp _ "WM_COLORMAP_WINDOWS"                      =  dumpArray dumpWindow
dumpProp _ "WM_STATE"                                 =  dumpState
dumpProp _ "WM_LOCALE_NAME"                           =  dumpString
dumpProp _ "WM_CLIENT_LEADER"                         =  dumpWindow
dumpProp _ "_NET_WM_WINDOW_OPACITY"                   =  dumpPercent
dumpProp _ "XdndAware"                                =  dumpArray dumpAtom
dumpProp _ "_XKLAVIER_TRANSPARENT"                    =  dumpInteger 32
dumpProp _ "_XKLAVIER_STATE"                          =  dumpList [("state"     ,dumpInteger 32)
                                                                  ,("indicators",dumpXKlInds)
                                                                  ]
dumpProp _ "_MOTIF_DRAG_RECEIVER_INFO"                =  dumpMotifDragReceiver
dumpProp _ "_OL_WIN_ATTR"                             =  dumpOLAttrs
dumpProp _ "_OL_DECOR_ADD"                            =  dumpArray dumpAtom
dumpProp _ "_OL_DECOR_DEL"                            =  dumpArray dumpAtom
dumpProp _ "_MOTIF_WM_HINTS"                          =  dumpMwmHints
dumpProp _ "_MOTIF_WM_INFO"                           =  dumpMwmInfo
dumpProp _ "_XMONAD_DECORATED_BY"                     =  dumpWindow
dumpProp _ "_XMONAD_DECORATION_FOR"                   =  dumpWindow
dumpProp a _ | a == wM_NAME                           =  dumpString
             | a == pRIMARY                           =  dumpSelection
             | a == sECONDARY                         =  dumpSelection
               -- this is gross
             | a == wM_TRANSIENT_FOR                  =  do
                 root <- fromIntegral `fmap` inX (asks theRoot)
                 w <- asks window
                 WMHints {wmh_window_group = group} <-
                   inX $ asks display >>= io . flip getWMHints w
                 dumpExcept [(0   ,"window group " ++ show group)
                            ,(root,"window group " ++ show group)
                            ]
                            dumpWindow
             | a == rESOURCE_MANAGER                  =  dumpString
             | a == wM_COMMAND                        =  dumpString
             | a == wM_HINTS                          =  dumpWmHints
             | a == wM_CLIENT_MACHINE                 =  dumpString
             | a == wM_ICON_NAME                      =  dumpString
             | a == wM_ICON_SIZE                      =  dumpList [("min size"
                                                                   ,dumpList [("w",dump32)
                                                                             ,("h",dump32)
                                                                             ]
                                                                   )
                                                                  ,("max size"
                                                                   ,dumpList [("w",dump32)
                                                                             ,("h",dump32)
                                                                             ]
                                                                   )
                                                                  ,("increment"
                                                                   ,dumpList [("w",dump32)
                                                                             ,("h",dump32)
                                                                             ]
                                                                   )
                                                                  ]
             | a == wM_NORMAL_HINTS                   =  (...)
             | a == wM_ZOOM_HINTS                     =  (...) -- same as previous
             | a == rGB_DEFAULT_MAP                   =  (...) -- XStandardColormap
             | a == rGB_BEST_MAP                      =  (...) -- "
             | a == rGB_RED_MAP                       =  (...) -- "
             | a == rGB_GREEN_MAP                     =  (...) -- "
             | a == rGB_BLUE_MAP                      =  (...) -- "
             | a == rGB_GRAY_MAP                      =  (...) -- "
             | a == wM_CLASS                          =  dumpList [("name" ,dumpString)
                                                                  ,("class",dumpString)
                                                                  ]
dumpProp _ s | s `isCountOf` "WM_S"                   =  dumpSelection
             | s `isCountOf` "_NET_WM_CM_S"           =  dumpSelection
             | s `isCountOf` "_NET_DESKTOP_LAYOUT_S"  =  dumpSelection
             | s `isCountOf` "CUT_BUFFER"             =  dumpString
             -- and dumpProperties does the rest
             | otherwise                              =  return False

-- lower level decoders --

-- alter the current joint
withJoint   :: String -> Decoder a -> Decoder a
withJoint j =  ((modify $ withJoint' j) >>)

withJoint'     :: String -> DecodeState -> DecodeState
withJoint' j s =  s {joint = j}

-- lift an X into a Decoder
inX :: X a -> Decoder a
inX =  Decoder . lift . lift

-- flip isPrefixOf, but the remainder must be all digits
isCountOf         :: String -> String -> Bool
-- note that \NUL is safe because atom names have to be C strings
s `isCountOf` pfx =  null                     $
                     dropWhile isDigit        $
                     map fst                  $
                     dropWhile (uncurry (==)) $
                     zip s                    $
                     pfx ++ repeat '\NUL'

-- localize an increased indent
withIndent   :: Int -> Decoder a -> Decoder a
withIndent w =  local (\r -> r {indent = indent r + w})

-- dump an array of items.  this dumps the entire property
dumpArray      :: Decoder Bool -> Decoder Bool
dumpArray item =  do
  withIndent 1 $ append "[" >> withJoint "" (dumpArray' item "")

-- step through values as an array, ending on parse error or end of list
dumpArray'          :: Decoder Bool -> String -> Decoder Bool
dumpArray' item pfx =  do
  vs <- gets value
  if vs == []
    then append "]"
    else append pfx >> whenD item (dumpArray' item ",")

-- keep parsing until a parse step fails
-- @@@ which points out that all my uses of @whenX (return ...)@ are actually 'when',
--     which suggests that 'whenX' is *also* the same function... yep.  ISAGN
whenD     :: Monad m => m Bool -> m Bool -> m Bool
whenD p f =  p >>= \b -> if b then f else return False

-- verify a decoder parameter, else call error reporter
-- once again, it's more general than I originally wrote
guardR                  :: (MonadReader r m, Eq v)
                        => (r -> v)                -- value selector
                        -> v                       -- expected value
                        -> (v -> v -> m a)         -- error reporter
                        -> m a                     -- continuation (hush)
                        -> m a
guardR sel val err good =  do
  v <- asks sel
  if v == val then good else err v val

-- this is kinda dumb
fi       :: Bool -> a -> a -> a
fi p n y =  if p then y else n -- flip (if' p), if that existed

-- verify we have the expected word size
guardSize      :: Int -> Decoder Bool -> Decoder Bool
-- see XSync documentation for this insanity
guardSize 64 =  guardR width 32 propSizeErr . guardSize' 8         propShortErr
guardSize  w =  guardR width  w propSizeErr . guardSize' (bytes w) propShortErr

guardSize'       :: Int -> Decoder a -> Decoder a -> Decoder a
guardSize' l n y =  gets value >>= \vs -> fi (length vs >= l) n y

-- verify we have the expected property type
guardType    :: Atom -> Decoder Bool -> Decoder Bool
guardType  t =  guardR pType t propTypeErr

-- dump a structure as a named tuple
dumpList       :: [(String,Decoder Bool)] -> Decoder Bool
dumpList proto =  do
  a <- asks pType
  dumpList'' (maxBound :: CULong) (map (\(s,d) -> (s,d,a)) proto) "("

-- same but elements have their own distinct types
dumpList'       :: [(String,Decoder Bool,Atom)] -> Decoder Bool
dumpList' proto =  dumpList'' (maxBound :: CULong) proto "("

-- same but only dump elements identified by provided mask
dumpListByMask     :: CULong -> [(String,Decoder Bool)] -> Decoder Bool
dumpListByMask m p =  do
  a <- asks pType
  dumpList'' m (map (\(s,d) -> (s,d,a)) p) "("

-- and the previous two combined
dumpListByMask'     :: CULong -> [(String,Decoder Bool,Atom)] -> Decoder Bool
dumpListByMask' m p =  dumpList'' m p "("

dumpList''                    :: CULong -> [(String,Decoder Bool,Atom)] -> String -> Decoder Bool
dumpList'' _ []           _   =  append ")" >> return True
dumpList'' 0 _            _   =  append ")" >> return True
dumpList'' m ((l,p,t):ps) sep = do
  (e,sep') <- if m .&. 1 == 0
              then do
                -- @@@ ew
                st <- get
                e <- local (\r -> r {pType = t}) p
                v' <- gets value
                put $ st {value = v'}
                return (e,sep)
              else do
                let label = sep ++ l ++ " = "
                append label
                e <- withJoint "" $ do
                       local (\r -> r {pType  = t
                                      ,indent = indent r + length label
                                      })
                             p
                return (e,",")
  if e then dumpList'' (m `shiftR` 1) ps sep' else return e

-- do the getTextProperty dance, the hard way.
-- @@@ @COMPOUND_TEXT@ not supported yet.
dumpString :: Decoder Bool
dumpString =  do
  fmt <- asks pType
  [cOMPOUND_TEXT,uTF8_STRING] <- inX $ mapM getAtom ["COMPOUND_TEXT","UTF8_STRING"]
  case () of
    () | fmt == cOMPOUND_TEXT -> guardSize 16 (...)
       | fmt == sTRING        -> guardSize  8 $ do
                                   vs <- gets value
                                   modify (\r -> r {value = []})
                                   let ss = flip unfoldr (map twiddle vs) $
                                            \s -> if null s
                                                  then Nothing
                                                  else let (w,s'') = break (== '\NUL') s
                                                           s'      = if null s''
                                                                     then s''
                                                                     else tail s''
                                                        in Just (w,s')
                                   case ss of
                                     [s] -> append $ show s
                                     ss' -> let go (s:ss'') c = append c        >>
                                                                append (show s) >>
                                                                go ss'' ","
                                                go []       _ = append "]"
                                             in append "[" >> go ss' ""
       | fmt == uTF8_STRING   -> dumpUTF -- duplicate type test instead of code :)
       | otherwise            -> (inX $ atomName fmt) >>=
                                 failure . ("unrecognized string type " ++)

-- show who owns a selection
dumpSelection :: Decoder Bool
dumpSelection =  do
  -- system selections contain a window ID; others are random
  -- note that the window ID will be the same as the owner, so
  -- we don't really care anyway.  we *do* want the selection owner
  a <- asks property
  owner <- inX $ withDisplay $ \d -> io $ xGetSelectionOwner d a
  if owner == none
    then append "unowned"
    else do
      w <- inX $ debugWindow owner
      append $ "owned by " ++ w

-- for now, not querying Xkb
dumpXKlInds :: Decoder Bool
dumpXKlInds =  guardType iNTEGER $ do
                 n <- fmap fromIntegral `fmap` getInt' 32
                 case n of
                   Nothing -> propShortErr
                   Just is -> append $ "indicators " ++ unwords (dumpInds is 1 1 [])
  where
    dumpInds                               :: Word32 -> Word32 -> Int -> [String] -> [String]
    dumpInds n bt c bs | n == 0 && c == 1 =  ["none"]
                       | n == 0           =  bs
                       | n .&. bt /= 0    =  dumpInds (n .&. complement bt)
                                                      (bt `shiftL` 1)
                                                      (c + 1)
                                                      ((show c):bs)
                       | otherwise        =  dumpInds n
                                                      (bt `shiftL` 1)
                                                      (c + 1)
                                                      bs

-- decode an Atom
dumpAtom :: Decoder Bool
dumpAtom =
  guardType aTOM $ do
  a <- getInt' 32
  case a of
    Nothing -> return False
    Just a' -> do
           an <- inX $ atomName $ fromIntegral a'
           append an

dumpWindow :: Decoder Bool
dumpWindow =  guardSize 32 $ guardType wINDOW $ do
                w <- getInt' 32
                case w of
                  Nothing -> return False
                  Just w' -> inX (debugWindow (fromIntegral w')) >>= append

-- a bit of a hack; as a Property it's a wINDOW, as a ClientMessage it's a list
dumpActiveWindow :: Decoder Bool
dumpActiveWindow =  guardSize 32 $ do
                      t <- asks pType
                      nAW <- inX $ getAtom "_NET_ACTIVE_WINDOW"
                      case () of
                        () | t == wINDOW -> dumpWindow
                           | t == nAW    -> dumpList' [("source"       ,dumpEnum awSource,cARDINAL)
                                                      ,("timestamp"    ,dumpTime         ,cARDINAL)
                                                      ,("active window",dumpWindow       ,wINDOW  )
                                                      ]
                        _                -> do
                                     t' <- inX $ atomName t
                                     failure $ concat ["(bad type "
                                                      ,t'
                                                      ,"; expected WINDOW or _NET_ACTIVE_WINDOW"
                                                      ]
-- dump a generic CARDINAL value
dumpInt   :: Int -> Decoder Bool
dumpInt w =  guardSize w $ guardType cARDINAL $ getInt w show

-- INTEGER is the signed version of CARDINAL
dumpInteger   :: Int -> Decoder Bool
dumpInteger w =  guardSize w $ guardType iNTEGER $ getInt w (show . signed w)

-- reinterpret an unsigned as a signed
signed     :: Int -> Integer -> Integer
signed w i =  bit (w + 1) - i

-- and wrappers to keep the parse list in bounds
dump64 :: Decoder Bool
dump64 =  dumpInt 64

dump32 :: Decoder Bool
dump32 =  dumpInt 32

{- not used in standard properties
dump16 :: Decoder Bool
dump16 =  dumpInt 16
-}

dump8 :: Decoder Bool
dump8 =  dumpInt 8

-- I am assuming for the moment that this is a single string.
-- This might be false; consider the way the STRING properties
-- handle lists.
dumpUTF :: Decoder Bool
dumpUTF =  do
  uTF8_STRING <- inX $ getAtom "UTF8_STRING"
  guardType uTF8_STRING $ guardSize 8 $ do
  s <- gets value
  modify (\r -> r {value = []})
  append . show . decode . map fromIntegral $ s
  return True

-- dump an enumerated value using a translation table
dumpEnum'        :: [String] -> Atom -> Decoder Bool
dumpEnum' ss fmt =  guardType fmt $
                    getInt 32     $
                    \r -> case () of
                            () | r < 0                 -> "undefined value " ++ show r
                               | r >= genericLength ss -> "undefined value " ++ show r
                               | otherwise             -> genericIndex ss r

-- we do not, unlike @xev@, try to ascii-art pixmaps.
dumpPixmap :: Decoder Bool
dumpPixmap =  guardType pIXMAP $ do
                p' <- getInt' 32
                case p' of
                  Nothing -> return False
                  Just p  -> do
                    append $ "pixmap " ++ showHex p ""
                    g' <- inX $ withDisplay $ \d -> io $
                            Just `fmap` getGeometry d (fromIntegral p)
                            `E.catch`
                            \e -> case fromException e of
                                    Just x -> throw e `const` (x `asTypeOf` ExitSuccess)
                                    _      -> return Nothing
                    case g' of
                      Nothing                   -> append " (deleted)"
                      Just (_,x,y,wid,ht,bw,dp) ->
                          append $ concat
                                     [" ("
                                     ,show wid
                                     ,'x':show ht
                                     ,'x':show dp
                                     ,')':if bw == 0 then "" else '+':show bw
                                     ,"@("
                                     ,show x
                                     ,',':show y
                                     ,")"
                                     ]

dumpOLAttrs :: Decoder Bool
dumpOLAttrs = do
  pt <- inX $ getAtom "_OL_WIN_ATTR"
  guardType pt $ do
    msk <- getInt' 32
    case msk of
      Nothing   -> propShortErr
      Just msk' -> dumpListByMask (fromIntegral msk') [("window type" ,dumpAtom     )
                                                      ,("menu"        ,dump32       ) -- @@@ unk
                                                      ,("pushpin"     ,dumpEnum bool)
                                                      ,("limited menu",dump32       ) -- @@@ unk
                                                      ]

dumpMwmHints :: Decoder Bool
dumpMwmHints =  do
  ta <- asks property
  guardType ta $ do
    msk <- getInt' 32
    case msk of
      Nothing   -> propShortErr
      Just msk' -> dumpListByMask (fromIntegral msk') [("functions"  ,dumpBits mwmFuncs    )
                                                      ,("decorations",dumpBits mwmDecos    )
                                                      ,("input mode" ,dumpEnum mwmInputMode)
                                                      ,("status"     ,dumpBits mwmState    )
                                                      ]

dumpMwmInfo :: Decoder Bool
dumpMwmInfo =  do
  ta <- asks property
  guardType ta $ dumpList' [("flags" ,dumpBits mwmHints,cARDINAL)
                           ,("window",dumpWindow       ,wINDOW  )
                           ]
             
-- the most common case
dumpEnum    :: [String] -> Decoder Bool
dumpEnum ss =  dumpEnum' ss cARDINAL

-- implement exceptional cases atop a normal dumper
-- @@@ there's gotta be a better way
dumpExcept           :: [(Integer,String)] -> Decoder Bool -> Decoder Bool
dumpExcept xs item = do
  -- this horror brought to you by reparsing to get the right value for our use
  sp <- get
  rc <- item
  if not rc then return False else do
    that <- get -- if none match then we just restore the value parse
    vs <- gets value
    let w = (length (value sp) - length vs) * 8
    -- now we get to reparse again so we get our copy of it
    put sp
    Just v <- getInt' w
    -- and after all that, we can process the exception list
    dumpExcept' xs that v

dumpExcept'                                      :: [(Integer,String)]
                                                 -> DecodeState
                                                 -> Integer
                                                 -> Decoder Bool
dumpExcept' []             that _                =  put that >> return True
dumpExcept' ((exc,str):xs) that val | exc == val =  append str
                                    | otherwise  =  dumpExcept' xs that val

-- use @ps@ to get process information.
-- @@@@ assumes a POSIX @ps@, not a BSDish one.
dumpPid :: Decoder Bool
dumpPid =  guardType cARDINAL $ do
             n <- getInt' 32
             case n of
               Nothing   -> return False
               Just pid' -> do
                      let pid = show pid'
                          ps  = (proc "/bin/ps" ["-fp" ++ pid]) {std_out = CreatePipe}
                      (_,o,_,_) <- io $ createProcess ps
                      case o of
                        Nothing -> append $ "pid " ++ pid
                        Just p' -> do
                                  prc <- io $ lines `fmap` hGetContents p'
                                  -- deliberately forcing it
                                  append $ if length prc < 2
                                           then "pid " ++ pid
                                           else prc !! 1

dumpTime :: Decoder Bool
dumpTime =  append "server event # " >> dump32

dumpState :: Decoder Bool
dumpState =  do
  wM_STATE <- inX $ getAtom "WM_STATE"
  guardType wM_STATE $ dumpList' [("state"      ,dumpEnum wmState,cARDINAL)
                                 ,("icon window",dumpWindow      ,wINDOW  )
                                 ]

dumpMotifDragReceiver :: Decoder Bool
dumpMotifDragReceiver =  do
  ta <- inX $ getAtom "_MOTIF_DRAG_RECEIVER_INFO"
  guardType ta $ dumpList' [("endian"    ,dumpMotifEndian,cARDINAL)
                           ,("version"   ,dump8          ,cARDINAL)
                           ,("style"     ,dumpMDropStyle ,cARDINAL) -- @@@ dummy
                           ]

dumpMDropStyle :: Decoder Bool
dumpMDropStyle =  do
  d <- getInt' 8
  pad 1 $ case d of
            Nothing             -> propShortErr
            Just ps | ps == 0   -> pad 12 $ append "none"
                    | ps == 1   -> pad 12 $ append "drop only"
                    | ps == 2   ->          append "prefer preregister " >> dumpMDPrereg
                    | ps == 3   ->          append "preregister "        >> dumpMDPrereg
                    | ps == 4   -> pad 12 $ append "prefer dynamic"
                    | ps == 5   -> pad 12 $ append "dynamic"
                    | ps == 6   -> pad 12 $ append "prefer receiver"
                    | otherwise -> failure $ "unknown drop style " ++ show ps

dumpMDPrereg :: Decoder Bool
dumpMDPrereg =  do
  -- this is a bit ugly; we pretend to be extending the above dumpList'
  append ","
  append "proxy window = "
  withIndent 15 dumpWindow
  append ","
  append "drop sites = "
  dsc' <- getInt' 16
  case dsc' of
    Nothing  -> propShortErr
    Just dsc -> do
      withIndent 13 $ append (show dsc)
      pad 2 $ do
        append ","
        append "total size = "
        withIndent 13 dump32
        dumpMDBlocks $ fromIntegral dsc
    
dumpMDBlocks   :: Int -> Decoder Bool
dumpMDBlocks _ =  propSimple "(drop site info)" -- @@@ maybe later if needed

dumpMotifEndian :: Decoder Bool
dumpMotifEndian =  guardType cARDINAL $ guardSize 8 $ do
  c <- map twiddle `fmap` eat 1
  case c of
    ['l'] -> append "little"
    ['B'] -> append "big"
    _     -> failure "bad endian flag"

pad     :: Int -> Decoder Bool -> Decoder Bool
pad n p =  do
  vs <- gets value
  if length vs < n
    then propShortErr
    else modify (\r -> r {value = drop n vs}) >> p

dumpPercent :: Decoder Bool
dumpPercent =  guardType cARDINAL $ do
                 n <- getInt' 32
                 case n of
                   Nothing -> return False
                   Just n' -> 
                       let pct = 100 * fromIntegral n' / fromIntegral (maxBound :: Word32)
                           pct :: Double
                        in append $ show (round pct :: Integer) ++ "%"

dumpWmHints :: Decoder Bool
dumpWmHints =
  guardType wM_HINTS $ do
  msk <- getInt' 32
  case msk of
    Nothing   -> return False
    Just msk' -> dumpListByMask' (fromIntegral msk')
                                 [("input"        ,dumpEnum bool   ,cARDINAL)
                                 ,("initial_state",dumpEnum wmState,cARDINAL)
                                 ,("icon_pixmap"  ,dumpPixmap      ,pIXMAP  )
                                 ,("icon_window"  ,dumpWindow      ,wINDOW  )
                                 ,("icon_x"       ,dump32          ,cARDINAL)
                                 ,("icon_y"       ,dump32          ,cARDINAL)
                                 ,("icon_mask"    ,dumpPixmap      ,pIXMAP  )
                                 ,("window_group" ,dumpWindow      ,wINDOW  )
                                 ]

dumpBits    :: [String] -> Decoder Bool
dumpBits bs =  guardType cARDINAL $ do
                 n <- getInt' 32
                 case n of
                   Nothing -> return False
                   Just n' -> dumpBits' bs 1 (fromIntegral n') ""

dumpBits' :: [String] -> Int -> Int -> String -> Decoder Bool
dumpBits' []     _ n p = if n == 0 then return True else append (p ++ show n)
dumpBits' (s:ss) b n p = do
  p' <- if n .&. b /= 0
        then append (p ++ s) >> return "|"
        else return p
  dumpBits' ss (b `shiftL` 1) (n .&. complement b) p'

-- enum definitions --

mwmFuncs :: [String]
mwmFuncs =  ["all except"
            ,"resize"
            ,"move"
            ,"minimize"
            ,"maximize"
            ,"close"
            ]

mwmDecos :: [String]
mwmDecos =  ["all except"
            ,"border"
            ,"resize handle"
            ,"title"
            ,"menu button"
            ,"maximize button"
            ,"minimize button"
            ]

mwmInputMode :: [String]
mwmInputMode =  ["modeless"
                ,"application modal"
                ,"system model"
                ,"full application modal"
                ]

mwmState :: [String]
mwmState =  ["tearoff window"
            ]

mwmHints :: [String]
mwmHints =  ["standard startup"
            ,"custom startup"
            ]

awSource :: [String]
awSource =  ["unspecified"
            ,"application"
            ,"pager/task list"
            ]

{- eventually...
wmHintsFlags :: [String]
wmHintsFlags =  ["Input"
                ,"State"
                ,"IconPixmap"
                ,"IconWindow"
                ,"IconX"
                ,"IconY"
                ,"IconMask"
                ,"WindowGroup"
                ]

wmCRMask :: [String]
wmCRMask =  ["X"
            ,"Y"
            ,"Width"
            ,"Height"
            ,"BorderWidth"
            ,"Sibling"
            ,"StackMode"
            ]
-}

wmPlacement :: [String]
wmPlacement =  ["Above"
               ,"Below"
               ,"TopIf"
               ,"BottomIf"
               ,"Opposite"
               ]

bool :: [String]
bool =  ["False","True"]

nwmOrientation :: [String]
nwmOrientation =  nwmEnum (Just "ORIENTATION") ["HORZ","VERT"]

nwmOrigin :: [String]
nwmOrigin =  nwmEnum Nothing ["TOPLEFT","TOPRIGHT","BOTTOMRIGHT","BOTTOMLEFT"]

wmState :: [String]
wmState =  ["Withdrawn","Normal","Zoomed (obsolete)","Iconified","Inactive"]

nwmEnum                  :: Maybe String
                         -> [String]
                         -> [String]
nwmEnum Nothing       vs =  map ( "_NET_WM_"                   ++) vs
nwmEnum (Just prefix) vs =  map (("_NET_WM_" ++ prefix ++ "_") ++) vs

-- and the lowest level coercions --

-- parse and return an integral value
getInt'    :: Int -> Decoder (Maybe Integer)
-- see XSync documentation for this insanity
getInt' 64 =  guardR width 32 (\a e -> propSizeErr a e >> return Nothing) $
              guardSize' 8 (propShortErr >> return Nothing) $ do
                lo <- inhale 32
                hi <- inhale 32
                return $ Just $ lo + hi * (fromIntegral (maxBound :: Word32) + 1)
getInt' w  =  guardR width w  (\a e -> propSizeErr a e >> return Nothing) $
              guardSize' (bytes w) (propShortErr >> return Nothing)       $
              Just `fmap` inhale w

-- parse an integral value and feed it to a show-er of some kind
getInt     :: Int -> (Integer -> String) -> Decoder Bool
getInt w f =  getInt' w >>= maybe (return False) (append . f)

-- bottommost level:  parse an integral value out of the stream.
-- Not much in the way of error checking; it is assumed you used
-- the appropriate guards.
-- @@@@@@@@@ evil beyond evil.  there *has* to be a better way
inhale    :: Int -> Decoder Integer
inhale  8 =  do
               [b] <- eat 1
               return $ fromIntegral b
inhale 16 =  do
               [b0,b1] <- eat 2
               io $ allocaArray 2 $ \p -> do
                 pokeArray p [b0,b1]
                 [v] <- peekArray 1 (castPtr p :: Ptr Word16)
                 return $ fromIntegral v
inhale 32 =  do
               [b0,b1,b2,b3] <- eat 4
               io $ allocaArray 4 $ \p -> do
                 pokeArray p [b0,b1,b2,b3]
                 [v] <- peekArray 1 (castPtr p :: Ptr Word32)
                 return $ fromIntegral v
inhale  b =  error $ "inhale " ++ show b

eat   :: Int -> Decoder Raw
eat n =  do
  (bs,rest) <- splitAt n `fmap` gets value
  modify (\r -> r {value = rest})
  return bs

-- actually do formatting type stuffs
-- sorta stubbed for the moment
-- eventually we should do indentation foo here
append :: String -> Decoder Bool
append =  append' True

-- and the same but for errors
failure :: String -> Decoder Bool
failure =  append' False

-- common appender
append'     :: Bool -> String -> Decoder Bool
append' b s =  do
  j <- gets joint
  modify (\r -> r {accum = accum r ++ j ++ s})
  return b

-- consume all and output a constant string
propSimple   :: String -> Decoder Bool
propSimple s =  modify (\r -> r {value = []}) >> append s

-- report various errors
propShortErr :: Decoder Bool
propShortErr =  failure "(property ended prematurely)"

propSizeErr     :: Int -> Int -> Decoder Bool
propSizeErr e a =  failure $ "(bad bit width " ++
                             show a            ++
                             "; expected "     ++
                             show e            ++
                             ")"

propTypeErr     :: Atom -> Atom -> Decoder Bool
propTypeErr a e =  do
  e' <- inX $ atomName e
  a' <- inX $ atomName a
  failure $ "(bad type " ++ a' ++"; expected " ++ e' ++ ")"

-- for stubs
(...) :: Decoder Bool
(...) =  do
  fmt <- asks pType >>= inX . atomName
  propSimple $ "(unimplemented type " ++ fmt ++ ")"

-- you like fi, I like this
twiddle :: (Enum a, Enum b) => a -> b
twiddle =  toEnum . fromEnum