Copyright	(c) Konstantin Sobolev <konstantin.sobolev@gmail.com>
License	BSD-style (see LICENSE)
Maintainer	Konstantin Sobolev <konstantin.sobolev@gmail.com>
Stability	unstable
Portability	unportable
Safe Haskell	None
Language	Haskell98

XMonad.Util.NamedScratchpad

Contents

Usage

Description

Named scratchpads that support several arbitrary applications at the same time.

Synopsis

data NamedScratchpad = NS {
- name :: String
- cmd :: String
- query :: Query Bool
- hook :: ManageHook
}
scratchpadWorkspaceTag :: String
nonFloating :: ManageHook
defaultFloating :: ManageHook
customFloating :: RationalRect -> ManageHook
type NamedScratchpads = [NamedScratchpad]
namedScratchpadAction :: NamedScratchpads -> String -> X ()
spawnHereNamedScratchpadAction :: NamedScratchpads -> String -> X ()
customRunNamedScratchpadAction :: (NamedScratchpad -> X ()) -> NamedScratchpads -> String -> X ()
allNamedScratchpadAction :: NamedScratchpads -> String -> X ()
namedScratchpadManageHook :: NamedScratchpads -> ManageHook
namedScratchpadFilterOutWorkspace :: [WindowSpace] -> [WindowSpace]
namedScratchpadFilterOutWorkspacePP :: PP -> PP
nsHideOnFocusLoss :: NamedScratchpads -> X ()

Usage

Allows to have several floating scratchpads running different applications. Bind a key to namedScratchpadSpawnAction. Pressing it will spawn configured application, or bring it to the current workspace if it already exists. Pressing the key with the application on the current workspace will send it to a hidden workspace called NSP.

If you already have a workspace called NSP, it will use that. NSP will also appear in xmobar and dzen status bars. You can tweak your dynamicLog settings to filter it out if you like.

Create named scratchpads configuration in your xmonad.hs like this:

import XMonad.StackSet as W
import XMonad.ManageHook
import XMonad.Util.NamedScratchpad

scratchpads = [
-- run htop in xterm, find it by title, use default floating window placement
    NS "htop" "xterm -e htop" (title =? "htop") defaultFloating ,

-- run stardict, find it by class name, place it in the floating window
-- 1/6 of screen width from the left, 1/6 of screen height
-- from the top, 2/3 of screen width by 2/3 of screen height
    NS "stardict" "stardict" (className =? "Stardict")
        (customFloating $ W.RationalRect (1/6) (1/6) (2/3) (2/3)) ,

-- run gvim, find by role, don't float
    NS "notes" "gvim --role notes ~/notes.txt" (role =? "notes") nonFloating
] where role = stringProperty "WM_WINDOW_ROLE"

Add keybindings:

 , ((modm .|. controlMask .|. shiftMask, xK_t), namedScratchpadAction scratchpads "htop")
 , ((modm .|. controlMask .|. shiftMask, xK_s), namedScratchpadAction scratchpads "stardict")
 , ((modm .|. controlMask .|. shiftMask, xK_n), namedScratchpadAction scratchpads "notes")

... and a manage hook:

 , manageHook = namedScratchpadManageHook scratchpads

For detailed instruction on editing the key binding see XMonad.Doc.Extending

For some applications (like displaying your workspaces in a status bar) it is convenient to filter out the NSP workspace when looking at all workspaces. For this, you can use filterOutWsPP, or filterOutWs together with addEwmhWorkspaceSort if your status bar gets the list of workspaces from EWMH. See the documentation of these functions for examples.

Further, there is also a logHook that you can use to hide scratchpads when they lose focus; this is functionality akin to what some dropdown terminals provide. See the documentation of nsHideOnFocusLoss for an example how to set this up.

data NamedScratchpad Source #

Single named scratchpad configuration

Constructors

NS
Fields name :: String Scratchpad name cmd :: String Command used to run application query :: Query Bool Query to find already running application hook :: ManageHook Manage hook called for application window, use it to define the placement. See `nonFloating`, `defaultFloating` and `customFloating`

scratchpadWorkspaceTag :: String Source #

Tag of the scratchpad workspace

nonFloating :: ManageHook Source #

Manage hook that makes the window non-floating

defaultFloating :: ManageHook Source #

Manage hook that makes the window floating with the default placement

customFloating :: RationalRect -> ManageHook Source #

Manage hook that makes the window floating with custom placement

type NamedScratchpads = [NamedScratchpad] Source #

Named scratchpads configuration

namedScratchpadAction Source #

Arguments

:: NamedScratchpads	Named scratchpads configuration
-> String	Scratchpad name
-> X ()

Action to pop up specified named scratchpad

spawnHereNamedScratchpadAction Source #

Arguments

:: NamedScratchpads	Named scratchpads configuration
-> String	Scratchpad name
-> X ()

Action to pop up specified named scratchpad, initially starting it on the current workspace.

customRunNamedScratchpadAction Source #

Arguments

:: (NamedScratchpad -> X ())	Function initially running the application, given the configured `scratchpad` cmd
-> NamedScratchpads	Named scratchpads configuration
-> String	Scratchpad name
-> X ()

Action to pop up specified named scratchpad, given a custom way to initially start the application.

allNamedScratchpadAction :: NamedScratchpads -> String -> X () Source #

namedScratchpadManageHook Source #

Arguments

:: NamedScratchpads	Named scratchpads configuration
-> ManageHook

Manage hook to use with named scratchpads

namedScratchpadFilterOutWorkspace :: [WindowSpace] -> [WindowSpace] Source #

Deprecated: Use XMonad.Util.WorkspaceCompare.filterOutWs [scratchpadWorkspaceTag] instead

Transforms a workspace list containing the NSP workspace into one that doesn't contain it. Intended for use with logHooks.

namedScratchpadFilterOutWorkspacePP :: PP -> PP Source #

Deprecated: Use XMonad.Hooks.StatusBar.PP.filterOutWsPP [scratchpadWorkspaceTag] instead

Transforms a pretty-printer into one not displaying the NSP workspace.

A simple use could be:

logHook = dynamicLogWithPP . namedScratchpadFilterOutWorkspace $ def

Here is another example, when using XMonad.Layout.IndependentScreens. If you have handles hLeft and hRight for bars on the left and right screens, respectively, and pp is a pretty-printer function that takes a handle, you could write

logHook = let log screen handle = dynamicLogWithPP . namedScratchpadFilterOutWorkspacePP . marshallPP screen . pp $ handle
          in log 0 hLeft >> log 1 hRight

nsHideOnFocusLoss :: NamedScratchpads -> X () Source #

A logHook to hide scratchpads when they lose focus. This can be useful for e.g. dropdown terminals. Note that this also requires you to use the refocusLastLogHook.

Example

Expand

import XMonad.Hooks.RefocusLast (refocusLastLogHook)
import XMonad.Util.NamedScratchpad

main = xmonad $ def
  { logHook = refocusLastLogHook
           >> nsHideOnFocusLoss myScratchpads
              -- enable hiding for all of @myScratchpads@
  }