-----------------------------------------------------------------------------
-- |
-- Module      :  XMonad.Prompt.Window
-- Copyright   :  Devin Mullins <me@twifkak.com>
--                Andrea Rossato <andrea.rossato@unibz.it>
-- License     :  BSD-style (see LICENSE)
--
-- Maintainer  :  Devin  Mullins <me@twifkak.com>
--                Andrea Rossato <andrea.rossato@unibz.it>
-- Stability   :  unstable
-- Portability :  unportable
--
-- xprompt operations to bring windows to you, and bring you to windows.
--
-----------------------------------------------------------------------------

module XMonad.Prompt.Window
    (
    -- * Usage
    -- $usage
    WindowPrompt(..),
    windowPrompt,
    windowMultiPrompt,
    allWindows,
    wsWindows,
    XWindowMap,

    -- * Deprecated
    windowPromptGoto,
    windowPromptBring,
    windowPromptBringCopy,
    ) where

import Control.Monad (forM)
import qualified Data.Map as M

import qualified XMonad.StackSet as W
import XMonad
import XMonad.Prompt
import XMonad.Actions.CopyWindow
import XMonad.Actions.WindowBringer
import XMonad.Util.NamedWindows

-- $usage
-- WindowPrompt brings windows to you and you to windows. That is to
-- say, it pops up a prompt with window names, in case you forgot
-- where you left your XChat. It also offers helpers to build the
-- subset of windows which is used for the prompt completion.
--
-- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:
--
-- > import XMonad.Prompt
-- > import XMonad.Prompt.Window
--
-- and in the keys definition:
--
-- > , ((modm .|. shiftMask, xK_g     ), windowPrompt def Goto wsWindows)
-- > , ((modm .|. shiftMask, xK_b     ), windowPrompt def Bring allWindows)
--
-- The autoComplete option is a handy complement here:
--
-- > , ((modm .|. shiftMask, xK_g     ), windowPrompt
-- >                                        def { autoComplete = Just 500000 }
-- >                                        Goto allWindows)
--
-- The \'500000\' is the number of microseconds to pause before sending you to
-- your new window. This is useful so that you don't accidentally send some
-- keystrokes to the selected client.
--
-- For detailed instruction on editing the key binding see
-- "XMonad.Doc.Extending#Editing_key_bindings".

-- Describe actions that can applied  on the selected window
data WindowPrompt = Goto | Bring | BringCopy | BringToMaster
instance XPrompt WindowPrompt where
    showXPrompt :: WindowPrompt -> String
showXPrompt Goto      = "Go to window: "
    showXPrompt Bring     = "Bring window: "
    showXPrompt BringToMaster
                          = "Bring window to master: "
    showXPrompt BringCopy = "Bring a copy: "
    commandToComplete :: WindowPrompt -> String -> String
commandToComplete _ c :: String
c = String
c
    nextCompletion :: WindowPrompt -> String -> [String] -> String
nextCompletion      _ = String -> [String] -> String
getNextCompletion

-- | Internal type used for the multiple mode prompt.
data WindowModePrompt =
  WindowModePrompt WindowPrompt (M.Map String Window) (String -> String -> Bool)

instance XPrompt WindowModePrompt where
    showXPrompt :: WindowModePrompt -> String
showXPrompt (WindowModePrompt action :: WindowPrompt
action _ _) =
        WindowPrompt -> String
forall t. XPrompt t => t -> String
showXPrompt WindowPrompt
action

    completionFunction :: WindowModePrompt -> ComplFunction
completionFunction (WindowModePrompt _ winmap :: Map String Window
winmap predicate :: String -> String -> Bool
predicate) =
        \s :: String
s -> [String] -> IO [String]
forall (m :: * -> *) a. Monad m => a -> m a
return ([String] -> IO [String])
-> (Map String Window -> [String])
-> Map String Window
-> IO [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Bool) -> [String] -> [String]
forall a. (a -> Bool) -> [a] -> [a]
filter (String -> String -> Bool
predicate String
s) ([String] -> [String])
-> (Map String Window -> [String]) -> Map String Window -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((String, Window) -> String) -> [(String, Window)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String, Window) -> String
forall a b. (a, b) -> a
fst ([(String, Window)] -> [String])
-> (Map String Window -> [(String, Window)])
-> Map String Window
-> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map String Window -> [(String, Window)]
forall k a. Map k a -> [(k, a)]
M.toList (Map String Window -> IO [String])
-> Map String Window -> IO [String]
forall a b. (a -> b) -> a -> b
$ Map String Window
winmap

    modeAction :: WindowModePrompt -> String -> String -> X ()
modeAction (WindowModePrompt action :: WindowPrompt
action winmap :: Map String Window
winmap _) buf :: String
buf auto :: String
auto = do
        let name :: String
name = if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
auto then String
buf else String
auto
            a :: String -> X ()
a = case WindowPrompt
action of
                  Goto          -> Map String Window -> String -> X ()
gotoAction  Map String Window
winmap
                  Bring         -> Map String Window -> String -> X ()
bringAction Map String Window
winmap
                  BringCopy     -> Map String Window -> String -> X ()
bringCopyAction Map String Window
winmap
                  BringToMaster -> Map String Window -> String -> X ()
bringToMaster Map String Window
winmap
        String -> X ()
a String
name
      where
        winAction :: (a -> WindowSet -> WindowSet) -> Map k a -> k -> X ()
winAction a :: a -> WindowSet -> WindowSet
a m :: Map k a
m    = (Maybe a -> (a -> X ()) -> X ()) -> (a -> X ()) -> Maybe a -> X ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip Maybe a -> (a -> X ()) -> X ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust ((WindowSet -> WindowSet) -> X ()
windows ((WindowSet -> WindowSet) -> X ())
-> (a -> WindowSet -> WindowSet) -> a -> X ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> WindowSet -> WindowSet
a) (Maybe a -> X ()) -> (k -> Maybe a) -> k -> X ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k -> Map k a -> Maybe a) -> Map k a -> k -> Maybe a
forall a b c. (a -> b -> c) -> b -> a -> c
flip k -> Map k a -> Maybe a
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Map k a
m
        gotoAction :: Map String Window -> String -> X ()
gotoAction       = (Window -> WindowSet -> WindowSet)
-> Map String Window -> String -> X ()
forall k a.
Ord k =>
(a -> WindowSet -> WindowSet) -> Map k a -> k -> X ()
winAction Window -> WindowSet -> WindowSet
forall s a i l sd.
(Eq s, Eq a, Eq i) =>
a -> StackSet i l a s sd -> StackSet i l a s sd
W.focusWindow
        bringAction :: Map String Window -> String -> X ()
bringAction      = (Window -> WindowSet -> WindowSet)
-> Map String Window -> String -> X ()
forall k a.
Ord k =>
(a -> WindowSet -> WindowSet) -> Map k a -> k -> X ()
winAction Window -> WindowSet -> WindowSet
bringWindow
        bringCopyAction :: Map String Window -> String -> X ()
bringCopyAction  = (Window -> WindowSet -> WindowSet)
-> Map String Window -> String -> X ()
forall k a.
Ord k =>
(a -> WindowSet -> WindowSet) -> Map k a -> k -> X ()
winAction Window -> WindowSet -> WindowSet
bringCopyWindow
        bringToMaster :: Map String Window -> String -> X ()
bringToMaster    = (Window -> WindowSet -> WindowSet)
-> Map String Window -> String -> X ()
forall k a.
Ord k =>
(a -> WindowSet -> WindowSet) -> Map k a -> k -> X ()
winAction (\w :: Window
w s :: WindowSet
s -> WindowSet -> WindowSet
forall i l a s sd. StackSet i l a s sd -> StackSet i l a s sd
W.shiftMaster (WindowSet -> WindowSet)
-> (WindowSet -> WindowSet) -> WindowSet -> WindowSet
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Window -> WindowSet -> WindowSet
forall s a i l sd.
(Eq s, Eq a, Eq i) =>
a -> StackSet i l a s sd -> StackSet i l a s sd
W.focusWindow Window
w (WindowSet -> WindowSet) -> WindowSet -> WindowSet
forall a b. (a -> b) -> a -> b
$ Window -> WindowSet -> WindowSet
bringWindow Window
w WindowSet
s)

-- | Deprecated. Use windowPrompt instead.
{-# DEPRECATED windowPromptGoto      "Use windowPrompt instead." #-}
{-# DEPRECATED windowPromptBring     "Use windowPrompt instead." #-}
{-# DEPRECATED windowPromptBringCopy "Use windowPrompt instead." #-}
windowPromptGoto, windowPromptBring, windowPromptBringCopy :: XPConfig -> X ()
windowPromptGoto :: XPConfig -> X ()
windowPromptGoto c :: XPConfig
c = XPConfig -> WindowPrompt -> XWindowMap -> X ()
windowPrompt XPConfig
c WindowPrompt
Goto XWindowMap
windowMap
windowPromptBring :: XPConfig -> X ()
windowPromptBring c :: XPConfig
c = XPConfig -> WindowPrompt -> XWindowMap -> X ()
windowPrompt XPConfig
c WindowPrompt
Bring XWindowMap
windowMap
windowPromptBringCopy :: XPConfig -> X ()
windowPromptBringCopy c :: XPConfig
c = XPConfig -> WindowPrompt -> XWindowMap -> X ()
windowPrompt XPConfig
c WindowPrompt
BringCopy XWindowMap
windowMap

-- | A helper to get the map of all windows.
allWindows :: XWindowMap
allWindows :: XWindowMap
allWindows = XWindowMap
windowMap

-- | A helper to get the map of windows of the current workspace.
wsWindows :: XWindowMap
wsWindows :: XWindowMap
wsWindows = (WindowSet -> X [Window]) -> X [Window]
forall a. (WindowSet -> X a) -> X a
withWindowSet ([Window] -> X [Window]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Window] -> X [Window])
-> (WindowSet -> [Window]) -> WindowSet -> X [Window]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WindowSet -> [Window]
forall i l a s sd. StackSet i l a s sd -> [a]
W.index) X [Window] -> ([Window] -> XWindowMap) -> XWindowMap
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [Window] -> XWindowMap
winmap
    where
      winmap :: [Window] -> XWindowMap
winmap = ([(String, Window)] -> Map String Window)
-> X [(String, Window)] -> XWindowMap
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [(String, Window)] -> Map String Window
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList (X [(String, Window)] -> XWindowMap)
-> ([Window] -> X [(String, Window)]) -> [Window] -> XWindowMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Window -> X (String, Window)) -> [Window] -> X [(String, Window)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Window -> X (String, Window)
pair
      pair :: Window -> X (String, Window)
pair w :: Window
w = do String
name <- (NamedWindow -> String) -> X NamedWindow -> X String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap NamedWindow -> String
forall a. Show a => a -> String
show (X NamedWindow -> X String) -> X NamedWindow -> X String
forall a b. (a -> b) -> a -> b
$ Window -> X NamedWindow
getName Window
w
                  (String, Window) -> X (String, Window)
forall (m :: * -> *) a. Monad m => a -> m a
return (String
name, Window
w)

-- | A Map where keys are pretty printable window names and values are
-- Xmonad windows identifier.
type XWindowMap = X (M.Map String Window)

-- | Pops open a prompt with window titles belonging to
-- winmap. Choose one, and an action is applied on the
-- selected window, according to WindowPrompt.
windowPrompt :: XPConfig -> WindowPrompt -> XWindowMap -> X ()
windowPrompt :: XPConfig -> WindowPrompt -> XWindowMap -> X ()
windowPrompt c :: XPConfig
c t :: WindowPrompt
t winmap :: XWindowMap
winmap = do
  Map String Window
wm <- XWindowMap
winmap
  let mode :: WindowModePrompt
mode     = WindowPrompt
-> Map String Window
-> (String -> String -> Bool)
-> WindowModePrompt
WindowModePrompt WindowPrompt
t Map String Window
wm (XPConfig -> String -> String -> Bool
searchPredicate XPConfig
c)
      action :: String -> String -> X ()
action   = WindowModePrompt -> String -> String -> X ()
forall t. XPrompt t => t -> String -> String -> X ()
modeAction WindowModePrompt
mode
      compList :: ComplFunction
compList = WindowModePrompt -> ComplFunction
forall t. XPrompt t => t -> ComplFunction
completionFunction WindowModePrompt
mode
  WindowPrompt
-> XPConfig -> ComplFunction -> (String -> X ()) -> X ()
forall p.
XPrompt p =>
p -> XPConfig -> ComplFunction -> (String -> X ()) -> X ()
mkXPrompt WindowPrompt
t XPConfig
c ComplFunction
compList (\s :: String
s -> String -> String -> X ()
action String
s String
s)

-- | Like 'windowPrompt', but uses the multiple modes feature of
-- @Prompt@ (via 'mkXPromptWithModes').
--
-- Given a list of actions along with the windows they should work
-- with, display the appropriate prompt with the ability to switch
-- between them using the @changeModeKey@.
--
-- For example, to have a prompt that first shows you all windows, but
-- allows you to narrow the list down to just the windows on the
-- current workspace:
--
-- > windowMultiPrompt config [(Goto, allWindows), (Goto, wsWindows)]
windowMultiPrompt :: XPConfig -> [(WindowPrompt, XWindowMap)] -> X ()
windowMultiPrompt :: XPConfig -> [(WindowPrompt, XWindowMap)] -> X ()
windowMultiPrompt c :: XPConfig
c modes :: [(WindowPrompt, XWindowMap)]
modes = do
  [XPType]
modes' <- [(WindowPrompt, XWindowMap)]
-> ((WindowPrompt, XWindowMap) -> X XPType) -> X [XPType]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [(WindowPrompt, XWindowMap)]
modes (((WindowPrompt, XWindowMap) -> X XPType) -> X [XPType])
-> ((WindowPrompt, XWindowMap) -> X XPType) -> X [XPType]
forall a b. (a -> b) -> a -> b
$ \(t :: WindowPrompt
t, wm :: XWindowMap
wm) -> do
    Map String Window
wm' <- XWindowMap
wm
    XPType -> X XPType
forall (m :: * -> *) a. Monad m => a -> m a
return (XPType -> X XPType)
-> (WindowModePrompt -> XPType) -> WindowModePrompt -> X XPType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WindowModePrompt -> XPType
forall p. XPrompt p => p -> XPType
XPT (WindowModePrompt -> X XPType) -> WindowModePrompt -> X XPType
forall a b. (a -> b) -> a -> b
$ WindowPrompt
-> Map String Window
-> (String -> String -> Bool)
-> WindowModePrompt
WindowModePrompt WindowPrompt
t Map String Window
wm' (XPConfig -> String -> String -> Bool
searchPredicate XPConfig
c)

  [XPType] -> XPConfig -> X ()
mkXPromptWithModes [XPType]
modes' XPConfig
c

-- | Brings a copy of the specified window into the current workspace.
bringCopyWindow :: Window -> WindowSet -> WindowSet
bringCopyWindow :: Window -> WindowSet -> WindowSet
bringCopyWindow w :: Window
w ws :: WindowSet
ws = Window -> String -> WindowSet -> WindowSet
forall a i s l sd.
(Eq a, Eq i, Eq s) =>
a -> i -> StackSet i l a s sd -> StackSet i l a s sd
copyWindow Window
w (WindowSet -> String
forall i l a s sd. StackSet i l a s sd -> i
W.currentTag WindowSet
ws) WindowSet
ws