{-# LANGUAGE LambdaCase #-}
----------------------------------------------------------------------------
-- |
-- Module      :  XMonad.Hooks.WorkspaceByPos
-- Description :  Move new window to non-focused screen based on its requested geometry.
-- Copyright   :  (c) Jan Vornberger 2009
-- License     :  BSD3-style (see LICENSE)
--
-- Maintainer  :  jan.vornberger@informatik.uni-oldenburg.de
-- Stability   :  unstable
-- Portability :  not portable
--
-- Useful in a dual-head setup: Looks at the requested geometry of
-- new windows and moves them to the workspace of the non-focused
-- screen if necessary.
--
-----------------------------------------------------------------------------

module XMonad.Hooks.WorkspaceByPos (
    -- * Usage
    -- $usage
    workspaceByPos
    ) where

import XMonad
import XMonad.Prelude
import qualified XMonad.StackSet as W

import Control.Monad.Except (runExceptT, throwError)
import Control.Monad.Trans (lift)

-- $usage
-- You can use this module with the following in your @xmonad.hs@:
--
-- > import XMonad.Hooks.WorkspaceByPos
-- >
-- > myManageHook = workspaceByPos <> manageHook def
-- >
-- > main = xmonad def { manageHook = myManageHook }

workspaceByPos :: ManageHook
workspaceByPos :: Query (Endo WindowSet)
workspaceByPos = (Query (Endo WindowSet)
-> ([Char] -> Query (Endo WindowSet))
-> Maybe [Char]
-> Query (Endo WindowSet)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Query (Endo WindowSet)
forall m. Monoid m => m
idHook [Char] -> Query (Endo WindowSet)
doShift (Maybe [Char] -> Query (Endo WindowSet))
-> (Word64 -> Query (Maybe [Char]))
-> Word64
-> Query (Endo WindowSet)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< X (Maybe [Char]) -> Query (Maybe [Char])
forall a. X a -> Query a
liftX (X (Maybe [Char]) -> Query (Maybe [Char]))
-> (Word64 -> X (Maybe [Char])) -> Word64 -> Query (Maybe [Char])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> X (Maybe [Char])
needsMoving) (Word64 -> Query (Endo WindowSet))
-> Query Word64 -> Query (Endo WindowSet)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Query Word64
forall r (m :: * -> *). MonadReader r m => m r
ask

needsMoving :: Window -> X (Maybe WorkspaceId)
needsMoving :: Word64 -> X (Maybe [Char])
needsMoving Word64
w = Word64 -> X (Maybe WindowAttributes)
safeGetWindowAttributes Word64
w X (Maybe WindowAttributes)
-> (Maybe WindowAttributes -> X (Maybe [Char])) -> X (Maybe [Char])
forall a b. X a -> (a -> X b) -> X b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Maybe WindowAttributes
Nothing -> Maybe [Char] -> X (Maybe [Char])
forall a. a -> X a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe [Char]
forall a. Maybe a
Nothing
    Just WindowAttributes
wa -> (Either [Char] [Char] -> Maybe [Char])
-> X (Either [Char] [Char]) -> X (Maybe [Char])
forall a b. (a -> b) -> X a -> X b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (([Char] -> Maybe [Char])
-> ([Char] -> Maybe [Char]) -> Either [Char] [Char] -> Maybe [Char]
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Maybe [Char] -> [Char] -> Maybe [Char]
forall a b. a -> b -> a
const Maybe [Char]
forall a. Maybe a
Nothing) [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just) (X (Either [Char] [Char]) -> X (Maybe [Char]))
-> (ExceptT [Char] X [Char] -> X (Either [Char] [Char]))
-> ExceptT [Char] X [Char]
-> X (Maybe [Char])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExceptT [Char] X [Char] -> X (Either [Char] [Char])
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT [Char] X [Char] -> X (Maybe [Char]))
-> ExceptT [Char] X [Char] -> X (Maybe [Char])
forall a b. (a -> b) -> a -> b
$ do
        -- only relocate windows with non-zero position
        Bool -> ExceptT [Char] X ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> ExceptT [Char] X ()) -> Bool -> ExceptT [Char] X ()
forall a b. (a -> b) -> a -> b
$ WindowAttributes -> CInt
wa_x WindowAttributes
wa CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0 Bool -> Bool -> Bool
|| WindowAttributes -> CInt
wa_y WindowAttributes
wa CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0
        ws <- (XState -> WindowSet) -> ExceptT [Char] X WindowSet
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets XState -> WindowSet
windowset
        sc <- lift $ fromMaybe (W.current ws)
                <$> pointScreen (fi $ wa_x wa) (fi $ wa_y wa)
        Just wkspc <- lift $ screenWorkspace (W.screen sc)
        guard $ W.currentTag ws /= wkspc
        return wkspc `asTypeOf` throwError ""