nixos/components/default.nix

@@ -2,6 +2,5 @@
   imports = [
     ./gui
     ./network
-    ./terminal
   ];
 }

nixos/components/gui/home-manager/xmonad.nix

@@ -0,0 +1,58 @@
+{ pkgs, lib, config, ... }:
+let
+
+  background-repo = pkgs.fetchgit {
+    url = "https://git.ingolf-wagner.de/palo/image-generator-lib";
+    rev = "95bc53de0b73917c5571a061a6702c71c9bf173e";
+    sha256 = "1x14pknv0v38x0g5sf6k25g9w7r7j0mndazq5ixjvybwdynk25kw";
+  };
+
+  nixCommands = { height, width }:
+    pkgs.writeText "NixCommands.hs" # haskell
+      ''
+        module NixCommands where
+
+        nixStartAudacious = "${pkgs.audacious}/bin/audacious"
+        nixStartFlameshot = "${pkgs.flameshot}/bin/flameshot gui -p /share/"
+        nixInvertColors = "${pkgs.xcalib}/bin/xcalib -invert -alter"
+        nixStartRedshift = "${pkgs.redshift}/bin/redshift -O 6100 -g 0.9:0.9:0.9 -b 0.9"
+        nixResetRedshift = "${pkgs.redshift}/bin/redshift -x"
+        nixSetCursorImage = "${pkgs.xorg.xsetroot}/bin/xsetroot -cursor_name left_ptr"
+        nixSetBackground = "${pkgs.polygon-art.polygon-art}/bin/rings --height ${
+          toString height
+        } --width ${
+          toString width
+        } /dev/shm/background.png && ${pkgs.feh}/bin/feh --bg-scale /dev/shm/background.png"
+        nixStartAlbert = "${pkgs.albert}/bin/albert"
+        nixStartCopyq = "${pkgs.copyq}/bin/copyq"
+        nixShowCopyq = "${pkgs.copyq}/bin/copyq show"
+        nixShowChat = "${pkgs.mirage-im}/bin/mirage"
+        nixShowJoplin = "${pkgs.unstable.joplin-desktop}/bin/joplin-desktop"
+        nixStartTerminal = "${pkgs.rxvt_unicode}/bin/urxvtc"
+        nixAlsaRaiseVolume = "${pkgs.alsaUtils}/bin/amixer set Master 5%+"
+        nixAlsaLowerVolume = "${pkgs.alsaUtils}/bin/amixer set Master 5%-"
+        nixAlsaMute = "${pkgs.alsaUtils}/bin/amixer set Master toggle"
+        nixNotifySend = "${pkgs.libnotify}/bin/notify-send"
+      '';
+in
+{
+
+  home-manager.users.mainUser = {
+    home.file.".xmonad/xmonad.hs".source = ./xmonad/Main.hs;
+    home.file.".xmonad/lib/NixCommands.hs".source = nixCommands {
+      height = config.configuration.desktop.height;
+      width = config.configuration.desktop.width;
+    };
+    home.file.".xmonad/lib/SolarizedLight.hs".source =
+      ./xmonad/SolarizedLight.hs;
+    home.file.".xmonad/lib/SolarizedDark.hs".source = ./xmonad/SolarizedDark.hs;
+    home.file.".xmonad/lib/FloatKeys.hs".source = ./xmonad/FloatKeys.hs;
+    home.file.".xmonad/lib/TabbedFix.hs".source = ./xmonad/TabbedFix.hs;
+    home.file.".xmonad/lib/BoringWindows.hs".source = ./xmonad/BoringWindows.hs;
+    home.file.".xmonad/lib/Memo.hs".source = ./xmonad/Memo.hs;
+    home.file.".xmonad/lib/SubLayouts.hs".source = ./xmonad/SubLayouts.hs;
+
+    home.file.".xmonad/xmonad.cabal".source = ./xmonad/palos-xmonad.cabal;
+    home.file.".xmonad/Main.hs".source = ./xmonad/Main.hs;
+  };
+}

nixos/components/gui/home-manager/xmonad/.envrc

@@ -0,0 +1,4 @@
+use nix ./env.nix
+use nix ./lsp.nix
+use nix ./shell.nix
+

nixos/components/gui/home-manager/xmonad/.gitignore

@@ -0,0 +1,24 @@
+dist
+dist-*
+cabal-dev
+*_flymake.hs
+*.o
+*.hi
+*.hie
+*.chi
+*.chs.h
+*.dyn_o
+*.dyn_hi
+.hpc
+.hsenv
+.cabal-sandbox/
+cabal.sandbox.config
+*.prof
+*.aux
+*.hp
+*.eventlog
+.stack-work/
+cabal.project.local
+cabal.project.local~
+.HTF/
+.ghc.environment.*

nixos/components/gui/home-manager/xmonad/BoringWindows.hs

@@ -0,0 +1,153 @@
+{-# LANGUAGE TypeSynonymInstances, MultiParamTypeClasses, DeriveDataTypeable #-}
+{-# LANGUAGE PatternGuards, FlexibleContexts, FlexibleInstances #-}
+
+-- copy because
+-- * export IsBoring
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  XMonad.Layout.BoringWindows
+-- Copyright   :  (c) 2008  David Roundy <droundy@darcs.net>
+-- License     :  BSD3-style (see LICENSE)
+--
+-- Maintainer  :  Adam Vogt <vogt.adam@gmail.com>
+-- Stability   :  unstable
+-- Portability :  unportable
+--
+-- BoringWindows is an extension to allow windows to be marked boring
+--
+-----------------------------------------------------------------------------
+
+module BoringWindows (
+                                   -- * Usage
+                                   -- $usage
+                                   boringWindows, boringAuto,
+                                   markBoring, clearBoring,
+                                   focusUp, focusDown, focusMaster,
+
+                                   UpdateBoring(UpdateBoring),
+                                   BoringMessage(Replace,Merge,IsBoring),
+                                   BoringWindows()
+
+                                   -- * Tips
+                                   -- ** variant of 'Full'
+                                   -- $simplest
+                                  ) where
+
+import XMonad.Layout.LayoutModifier(ModifiedLayout(..),
+                                    LayoutModifier(handleMessOrMaybeModifyIt, redoLayout))
+import XMonad(Typeable, LayoutClass, Message, X, fromMessage,
+              sendMessage, windows, withFocused, Window)
+import Control.Applicative((<$>))
+import Data.List((\\), union)
+import Data.Maybe(fromMaybe, listToMaybe, maybeToList)
+import qualified Data.Map as M
+import qualified XMonad.StackSet as W
+
+-- $usage
+-- You can use this module with the following in your
+-- @~\/.xmonad\/xmonad.hs@:
+--
+-- > import XMonad.Layout.BoringWindows
+--
+-- Then edit your @layoutHook@ by adding the layout modifier:
+--
+-- > myLayout = boringWindows (Full ||| etc..)
+-- > main = xmonad def { layoutHook = myLayout }
+--
+-- Then to your keybindings, add:
+--
+-- > , ((modm, xK_j), focusUp)
+-- > , ((modm, xK_k), focusDown)
+-- > , ((modm, xK_m), focusMaster)
+--
+-- For more detailed instructions on editing the layoutHook see:
+--
+-- "XMonad.Doc.Extending#Editing_the_layout_hook"
+
+
+data BoringMessage = FocusUp | FocusDown | FocusMaster | IsBoring Window | ClearBoring
+                     | Replace String [Window]
+                     | Merge String [Window]
+                     deriving ( Read, Show, Typeable )
+
+instance Message BoringMessage
+
+-- | UpdateBoring is sent before attempting to view another boring window, so
+-- that layouts have a chance to mark boring windows.
+data UpdateBoring = UpdateBoring
+    deriving (Typeable)
+instance Message UpdateBoring
+
+markBoring, clearBoring, focusUp, focusDown, focusMaster :: X ()
+markBoring = withFocused (sendMessage . IsBoring)
+clearBoring = sendMessage ClearBoring
+focusUp = sendMessage UpdateBoring >> sendMessage FocusUp
+focusDown = sendMessage UpdateBoring >> sendMessage FocusDown
+focusMaster = sendMessage UpdateBoring >> sendMessage FocusMaster
+
+data BoringWindows a = BoringWindows
+    { namedBoring :: M.Map String [a] -- ^ store borings with a specific source
+    , chosenBoring :: [a]             -- ^ user-chosen borings
+    , hiddenBoring :: Maybe [a]       -- ^ maybe mark hidden windows
+    } deriving (Show,Read,Typeable)
+
+boringWindows :: (LayoutClass l a, Eq a) => l a -> ModifiedLayout BoringWindows l a
+boringWindows = ModifiedLayout (BoringWindows M.empty [] Nothing)
+
+-- | Mark windows that are not given rectangles as boring
+boringAuto :: (LayoutClass l a, Eq a) => l a -> ModifiedLayout BoringWindows l a
+boringAuto = ModifiedLayout (BoringWindows M.empty [] (Just []))
+
+instance LayoutModifier BoringWindows Window where
+    redoLayout (b@BoringWindows { hiddenBoring = bs }) _r mst arrs = do
+        let bs' = W.integrate' mst \\ map fst arrs
+        return (arrs, Just $ b { hiddenBoring = const bs' <$> bs } )
+
+    handleMessOrMaybeModifyIt bst@(BoringWindows nbs cbs lbs) m
+        | Just (Replace k ws) <- fromMessage m
+        , maybe True (ws/=) (M.lookup k nbs) =
+            let nnb = if null ws then M.delete k nbs
+                          else M.insert k ws nbs
+            in rjl bst { namedBoring = nnb }
+        | Just (Merge k ws) <- fromMessage m
+        , maybe True (not . null . (ws \\)) (M.lookup k nbs) =
+            rjl bst { namedBoring = M.insertWith union k ws nbs }
+        | Just (IsBoring w) <- fromMessage m , w `notElem` cbs =
+            rjl bst { chosenBoring = w:cbs }
+        | Just ClearBoring <- fromMessage m, not (null cbs) =
+            rjl bst { namedBoring = M.empty, chosenBoring = []}
+        | Just FocusUp <- fromMessage m =
+                            do windows $ W.modify' $ skipBoring W.focusUp'
+                               return Nothing
+        | Just FocusDown <- fromMessage m =
+                            do windows $ W.modify' $ skipBoring W.focusDown'
+                               return Nothing
+        | Just FocusMaster <- fromMessage m =
+                            do windows $ W.modify'
+                                            $ skipBoring W.focusDown' -- wiggle focus to make sure
+                                            . skipBoring W.focusUp'   -- no boring window gets the focus
+                                            . focusMaster'
+                               return Nothing
+        where skipBoring f st = fromMaybe st $ listToMaybe
+                                $ filter ((`notElem` W.focus st:bs) . W.focus)
+                                $ take (length $ W.integrate st)
+                                $ iterate f st
+              bs = concat $ cbs:maybeToList lbs ++ M.elems nbs
+              rjl = return . Just . Left
+    handleMessOrMaybeModifyIt _ _ = return Nothing
+
+-- | Variant of 'focusMaster' that works on a
+-- 'Stack' rather than an entire 'StackSet'.
+focusMaster' :: W.Stack a -> W.Stack a
+focusMaster' c@(W.Stack _ [] _) = c
+focusMaster' (W.Stack t ls rs) = W.Stack x [] (xs ++ t : rs) where (x:xs) = reverse ls
+
+{- $simplest
+
+An alternative to 'Full' is "XMonad.Layout.Simplest".  Less windows are
+ignored by 'focusUp' and 'focusDown'. This may be helpful when you want windows
+to be uninteresting by some other layout modifier (ex.
+"XMonad.Layout.Minimize")
+
+-}

nixos/components/gui/home-manager/xmonad/FloatKeys.hs

@@ -0,0 +1,127 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module       : XMonad.Actions.FloatKeys
+-- Copyright    : (c) Karsten Schoelzel <kuser@gmx.de>
+-- License      : BSD
+--
+-- Maintainer   : Karsten Schoelzel <kuser@gmx.de>
+-- Stability    : stable
+-- Portability  : unportable
+--
+-- Move and resize floating windows.
+-----------------------------------------------------------------------------
+
+module FloatKeys (
+                -- * Usage
+                -- $usage
+                keysMoveWindow,
+                keysMoveWindowTo,
+                keysResizeWindow,
+                keysAbsResizeWindow) where
+
+import XMonad
+import Control.Arrow ((***))
+
+-- $usage
+-- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:
+--
+-- >    import XMonad.Actions.FloatKeys
+--
+-- Then add appropriate key bindings, for example:
+--
+-- >  , ((modm,               xK_d     ), withFocused (keysResizeWindow (-10,-10) (1,1)))
+-- >  , ((modm,               xK_s     ), withFocused (keysResizeWindow (10,10) (1,1)))
+-- >  , ((modm .|. shiftMask, xK_d     ), withFocused (keysAbsResizeWindow (-10,-10) (1024,752)))
+-- >  , ((modm .|. shiftMask, xK_s     ), withFocused (keysAbsResizeWindow (10,10) (1024,752)))
+-- >  , ((modm,               xK_a     ), withFocused (keysMoveWindowTo (512,384) (1%2,1%2)))
+--
+-- For detailed instructions on editing your key bindings, see
+-- "XMonad.Doc.Extending#Editing_key_bindings".
+
+-- | @keysMoveWindow (dx, dy)@ moves the window by @dx@ pixels to the
+--   right and @dy@ pixels down.
+keysMoveWindow :: D -> Window -> X ()
+keysMoveWindow (dx,dy) w = whenX (isClient w) $ withDisplay $ \d -> do
+    io $ raiseWindow d w
+    wa <- io $ getWindowAttributes d w
+    io $ moveWindow d w (fromIntegral (fromIntegral (wa_x wa) + dx))
+                        (fromIntegral (fromIntegral (wa_y wa) + dy))
+    float w
+
+-- | @keysMoveWindowTo (x, y) (gx, gy)@ moves the window relative
+--   point @(gx, gy)@ to the point @(x,y)@, where @(gx,gy)@ gives a
+--   position relative to the window border, i.e.  @gx = 0@ is the left
+--   border, @gx = 1@ is the right border, @gy = 0@ is the top border, and
+--   @gy = 1@ the bottom border.
+--
+--   For example, on a 1024x768 screen:
+--
+-- > keysMoveWindowTo (512,384) (1%2, 1%2) -- center the window on screen
+-- > keysMoveWindowTo (1024,0) (1, 0)      -- put window in the top right corner
+keysMoveWindowTo :: P -> G -> Window -> X ()
+keysMoveWindowTo (x,y) (gx, gy) w = whenX (isClient w) $ withDisplay $ \d -> do
+    io $ raiseWindow d w
+    wa <- io $ getWindowAttributes d w
+    io $ moveWindow d w (x - round (gx * fromIntegral (wa_width wa)))
+                        (y - round (gy * fromIntegral (wa_height wa)))
+    float w
+
+type G = (Rational, Rational)
+type P = (Position, Position)
+
+-- | @keysResizeWindow (dx, dy) (gx, gy)@ changes the width by @dx@
+--   and the height by @dy@, leaving the window-relative point @(gx,
+--   gy)@ fixed.
+--
+--   For example:
+--
+-- > keysResizeWindow (10, 0) (0, 0)      -- make the window 10 pixels larger to the right
+-- > keysResizeWindow (10, 0) (0, 1%2)    -- does the same, unless sizeHints are applied
+-- > keysResizeWindow (10, 10) (1%2, 1%2) -- add 5 pixels on each side
+-- > keysResizeWindow (-10, -10) (0, 1)   -- shrink the window in direction of the bottom-left corner
+keysResizeWindow :: D -> G -> Window -> X ()
+keysResizeWindow = keysMoveResize keysResizeWindow'
+
+-- | @keysAbsResizeWindow (dx, dy) (ax, ay)@ changes the width by @dx@
+--   and the height by @dy@, leaving the screen absolute point @(ax,
+--   ay)@ fixed.
+--
+--   For example:
+--
+-- > keysAbsResizeWindow (10, 10) (0, 0)   -- enlarge the window; if it is not in the top-left corner it will also be moved down and to the right.
+keysAbsResizeWindow :: D -> D -> Window -> X ()
+keysAbsResizeWindow = keysMoveResize keysAbsResizeWindow'
+
+keysAbsResizeWindow' :: SizeHints -> P -> D -> D -> D -> (P,D)
+keysAbsResizeWindow' sh (x,y) (w,h) (dx,dy) (ax, ay) = ((round nx, round ny), (nw, nh))
+    where
+        (minw, minh) = maybe (10,10) ((***) (max 10) (max 10)) $ sh_min_size sh
+        (nw, nh) = if w + dx > minw && h + dy > minh then applySizeHintsContents sh (w + dx, h + dy)
+                   else (w, h)
+        nx :: Rational
+        nx = fromIntegral (ax * w + nw * (fromIntegral x - ax)) / fromIntegral w
+        ny :: Rational
+        ny = fromIntegral (ay * h + nh * (fromIntegral y - ay)) / fromIntegral h
+
+keysResizeWindow' :: SizeHints -> P -> D -> D -> G -> (P,D)
+keysResizeWindow' sh (x,y) (w,h) (dx,dy) (gx, gy) = ((nx, ny), (nw, nh))
+    where
+        -- Prevent shrinking a window too small and getting one's foot shot
+        (minw, minh) = maybe (10,10) ((***) (max 10) (max 10)) $ sh_min_size sh
+        (nw, nh) = if w + dx > minw && h + dy > minh then applySizeHintsContents sh (w + dx, h + dy)
+                   else (w, h)
+        nx = round $ fromIntegral x + gx * fromIntegral w - gx * fromIntegral nw
+        ny = round $ fromIntegral y + gy * fromIntegral h - gy * fromIntegral nh
+
+keysMoveResize :: (SizeHints -> P -> D -> a -> b -> (P,D)) -> a -> b -> Window -> X ()
+keysMoveResize f move resize w = whenX (isClient w) $ withDisplay $ \d -> do
+    io $ raiseWindow d w
+    wa <- io $ getWindowAttributes d w
+    sh' <- io $ getWMNormalHints d w
+    let sh = sh' {sh_resize_inc = Nothing, sh_aspect = Nothing}
+        wa_dim = (fromIntegral $ wa_width wa, fromIntegral $ wa_height wa)
+        wa_pos = (fromIntegral $ wa_x wa, fromIntegral $ wa_y wa)
+        (wn_pos, wn_dim) = f sh wa_pos wa_dim move resize
+    io $ resizeWindow d w `uncurry` wn_dim
+    io $ moveWindow d w `uncurry` wn_pos
+    float w

nixos/components/gui/home-manager/xmonad/LICENSE

@@ -0,0 +1,674 @@
+              GNU GENERAL PUBLIC LICENSE
+                Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                     Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+              END OF TERMS AND CONDITIONS
+
+     How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

nixos/components/gui/home-manager/xmonad/Main.hs

@@ -0,0 +1,537 @@
+{-# LANGUAGE FlexibleContexts #-}
+
+module Main where
+
+import XMonad.Util.NamedWindows (getName)
+import XMonad.Util.Run (safeSpawn)
+import           BoringWindows                    (BoringMessage (..),
+                                                   boringWindows, clearBoring,
+                                                   focusDown, focusUp)
+import qualified Data.Map                         as M
+import           Data.Monoid                      (All, Endo)
+import           Data.Ratio                       ((%))
+import           FloatKeys                        (keysResizeWindow)
+import           Memo                             (nextRectangle)
+import           NixCommands
+import qualified SolarizedLight                   as Solarized
+import           System.Exit
+import           XMonad
+import           XMonad.Actions.CopyWindow        (copy, copyToAll, kill1,
+                                                   killAllOtherCopies,
+                                                   wsContainingCopies)
+import           XMonad.Actions.CycleWS           (toggleWS')
+import           XMonad.Actions.DynamicProjects   (Project (..),
+                                                   dynamicProjects)
+import           XMonad.Actions.DynamicWorkspaces (addHiddenWorkspace, removeEmptyWorkspaceAfterExcept,
+                                                   renameWorkspace,
+                                                   withWorkspace)
+import           XMonad.Actions.Navigation2D      (additionalNav2DKeysP,
+                                                   windowGo, windowSwap)
+import           XMonad.Actions.UpdatePointer     (updatePointer)
+import           XMonad.Actions.Warp              (warpToScreen)
+import           XMonad.Hooks.DynamicLog          (dynamicLog)
+import           XMonad.Hooks.ManageDebug         (debugManageHook)
+import           XMonad.Hooks.ManageHelpers       (doCenterFloat)
+import           XMonad.Hooks.SetWMName           (setWMName)
+import           XMonad.Hooks.UrgencyHook         (withUrgencyHook,
+                                                   UrgencyHook(..))
+import           XMonad.Layout.Mosaic             (Aspect (Reset))
+import           XMonad.Layout.NoBorders          (noBorders, smartBorders)
+import           XMonad.Layout.ResizableTile      (MirrorResize (MirrorExpand, MirrorShrink),
+                                                   ResizableTall (..))
+import           XMonad.Layout.StateFull          (focusTracking)
+import           XMonad.Layout.WindowNavigation   (configurableNavigation,
+                                                   noNavigateBorders)
+import           XMonad.Prompt                    (XPConfig (..))
+import qualified XMonad.StackSet                  as W
+import           XMonad.Util.EZConfig             (additionalKeysP)
+import           XMonad.Util.Scratchpad           (scratchpadManageHook,
+                                                   scratchpadSpawnAction)
+import           XMonad.Util.SpawnOnce            (spawnOnce)
+
+------------------------------------------------------------------------
+--
+-- Layouts
+--
+------------------------------------------------------------------------
+selectionColor :: String
+selectionColor = Solarized.magenta
+
+nonSelectionColor :: String
+nonSelectionColor = Solarized.base02
+
+myLayout =
+  (windowConfiguration $ smartBorders $ boringWindows resizeableTall) |||
+  noBorders Full
+  where
+    resizeableTall = ResizableTall nmaster delta ratio []
+     -- The default number of windows in the master pane
+    nmaster = 1
+     -- Default proportion of screen occupied by master pane
+    ratio = 1 / 2
+     -- Percent of screen to increment by when resizing panes
+    delta = 3 / 100
+    windowConfiguration = configurableNavigation noNavigateBorders
+
+-- ------------------------------------------------------------
+--
+-- predefined workspaces
+--
+-- ------------------------------------------------------------
+-- default workspaces they will always be there.
+-- And they are protected against renaming
+myWorkspaces :: [String]
+myWorkspaces = ["1", "2", "3", "4", "5", "6"]
+
+-- workspaces names to be used only by one program, partly spawning on startup.
+autoSpawnWorkspaces :: [String]
+autoSpawnWorkspaces = ["-copyq"]
+
+-- theses workspaces should not be removed by the workspace
+-- switch commands
+nonRemovableWorkspaces :: [String]
+nonRemovableWorkspaces = myWorkspaces ++ autoSpawnWorkspaces
+
+-- projects
+-- named workspaces with predefined behavior
+projects :: [Project]
+projects =
+  [ Project
+      { projectName = "audio"
+      , projectDirectory = "~/music-library"
+      , projectStartHook = Just $ spawn nixStartAudacious
+      }
+  , Project
+      { projectName = "nixos"
+      , projectDirectory = "~/dev/nixos/nixos-config"
+      , projectStartHook = Nothing
+      }
+  , Project
+      { projectName = "-copyq"
+      , projectDirectory = "~/"
+      , projectStartHook = Just $ spawn nixShowCopyq
+      }
+  , Project
+      { projectName = "chat"
+      , projectDirectory = "~/"
+      , projectStartHook = Just $ spawn nixShowChat
+      }
+  , Project
+      { projectName = "joplin"
+      , projectDirectory = "~/"
+      , projectStartHook = Just $ spawn nixShowJoplin
+      }
+  ]
+
+-- ------------------------------------------------------------
+--
+-- key definitions
+--
+-- ------------------------------------------------------------
+myKeys :: XConfig Layout -> M.Map (ButtonMask, KeySym) (X ())
+myKeys XConfig {modMask = modm} =
+  M.fromList $
+    -- ------------------------------------------------------------
+    --
+    -- predefined workspaces
+    --
+    -- ------------------------------------------------------------
+    --
+    -- mod-[1..9], Switch to workspace N
+  [ ( (m .|. modm, k)
+    , do removeEmptyWorkspaceAfterExcept nonRemovableWorkspaces $ windows $ f i
+         updateBoring)
+  | (i, k) <- zip myWorkspaces [xK_1 .. xK_9]
+  , (f, m) <- [(W.greedyView, 0)]
+  ] ++
+    -- mod-<shift>-[1..9] move window to workspace N
+    -- mod-<control>-[1..9] copy window to workspace N
+  [ ( (m .|. modm, k)
+    , do windows $ f i
+         updateBoring)
+  | (i, k) <- zip myWorkspaces [xK_1 .. xK_9]
+  , (f, m) <- [(W.shift, shiftMask), (copy, controlMask)]
+  ]
+
+-- ------------------------------------------------------------
+--
+-- select next Screen/Monitor.
+--  (works for 2 and 1 monitor, but might also work for more)
+--
+-- ------------------------------------------------------------
+selectNextScreen :: X ()
+selectNextScreen = do
+  W.StackSet {W.current = current, W.visible = visible} <- gets windowset
+  warpToScreen (nextScreen current visible) (1 % 2) (1 % 2)
+  where
+    nextScreen current [] = W.screen current
+    nextScreen _ (x:_)    = W.screen x
+
+isFloat :: Window -> X Bool
+isFloat w = gets windowset >>= \ws -> return (M.member w $ W.floating ws)
+
+-- | add different shortcuts for different type
+-- of situation. Floating or Tiling
+floatTileCommand :: X () -> X () -> Window -> X ()
+floatTileCommand forFloating forTileing window = do
+  floating <- isFloat window
+  if floating
+    then forFloating
+    else forTileing
+
+toggleFloating :: W.RationalRect -> Window -> X ()
+toggleFloating position =
+  floatTileCommand
+    (withFocused (windows . W.sink))
+    (withFocused (windows . (`W.float` position)))
+
+multiKeys [] = []
+multiKeys ((key, command):xs) = (createMultiKey key command) ++ multiKeys xs
+  where
+    createMultiKey keyString command =
+      [("M4-" ++ keyString, command), ("M4-z " ++ keyString, command)]
+
+myAdditionaKeys :: [(String, X ())]
+myAdditionaKeys
+    -- ------------------------------------------------------------
+    --
+    -- dynamic workspaces
+    --
+    -- ------------------------------------------------------------
+    -- switch to workspace
+ =
+  (multiKeys
+     [ ( "`"
+       , do removeEmptyWorkspaceAfterExcept
+              nonRemovableWorkspaces
+              (withWorkspace autoXPConfig (windows . W.greedyView))
+            updateBoring)
+    -- move focused window to workspace
+     , ("S-<Space>", withWorkspace myXPConfig (windows . W.shift))
+    -- copy focused window to workspace
+     , ("C-<Space>", withWorkspace myXPConfig (windows . copy))
+    -- make windows "sticky" by copy and remove them to and from all other windows
+     , ( "s"
+       , do copies <- wsContainingCopies
+            if not (null copies)
+              then do
+                killAllOtherCopies
+                clearBoring
+              else do
+                windows copyToAll
+                withFocused (broadcastMessage . IsBoring))
+    -- rename workspace but make sure myWorkspaces still exist
+     , ( "r"
+       , do renameWorkspace myXPConfig
+            sequence_ [addHiddenWorkspace ws | ws <- myWorkspaces])
+     , ( "<Esc>"
+       , do toggleWS' ["NSP"]
+            updateBoring)
+     ]) ++
+    -- ------------------------------------------------------------
+    --
+    -- launch applications
+    --
+    -- ------------------------------------------------------------
+  (multiKeys
+    -- launch a terminal
+     [ ("<Return>", spawn $ XMonad.terminal defaults)
+     , ("q", kill1)
+    -- open scratchpad
+     , ( "-"
+       , do scratchpadSpawnAction defaults
+            updateBoring)
+     ]) ++
+  [ ( "<Print>"
+    -- create screenshot
+    , spawn nixStartFlameshot)
+    -- invert color for bright or dark days
+  , ("<Pause>", spawn nixInvertColors)
+  ] ++
+    -- ------------------------------------------------------------
+    --
+    -- Window and Layout
+    --
+    -- ------------------------------------------------------------
+  (multiKeys
+    -- Move focus to the next window
+     [ ( "j"
+       , do sendMessage FirstLayout
+            focusDown)
+     -- Move focus to the previous window
+     , ( "k"
+       , do sendMessage FirstLayout
+            focusUp)
+    -- Swap the focused window and the master window
+     , ("<Tab>", windows W.swapMaster)
+    -- Swap the focused window with the next window
+     , ( "S-j"
+       , do sendMessage FirstLayout
+            windows W.swapDown)
+    -- Swap the focused window with the previous window
+     , ( "S-k"
+       , do sendMessage FirstLayout
+            windows W.swapUp)
+     -- Rotate through the available layout algorithms
+     , ("f", sendMessage NextLayout)
+    -- Shrink the current area
+    -- Shrink the master area
+     , ( "h"
+       , withFocused $
+         floatTileCommand
+           (withFocused (keysResizeWindow (10, 0) (1, 1 % 2)))
+           (do sendMessage Shrink
+               sendMessage Reset))
+    -- Expand the master area
+     , ( "l"
+       , withFocused $
+         floatTileCommand
+           (withFocused (keysResizeWindow (-10, 0) (1, 1 % 2)))
+           (do sendMessage Expand
+               sendMessage Reset))
+    -- Expand the current area
+     , ( "S-l"
+       , withFocused $
+         floatTileCommand
+           (withFocused (keysResizeWindow (0, -10) (1 % 2, 1)))
+           (do sendMessage MirrorExpand
+               sendMessage Reset))
+     , ( "S-h"
+       , withFocused $
+         floatTileCommand
+           (withFocused (keysResizeWindow (0, 10) (1 % 2, 1)))
+           (do sendMessage MirrorShrink
+               sendMessage Reset))
+    -- Toggle window tiling/floating
+     , ( "t"
+       , do next <- nextRectangle
+            withFocused $ toggleFloating next)
+     , ( "n"
+       , withFocused $
+         floatTileCommand
+           (do position <- nextRectangle
+               withFocused (windows . (`W.float` position)))
+           (return ()))
+    -- Increment the number of windows in the master area
+     , (",", sendMessage (IncMasterN 1))
+    -- Deincrement the number of windows in the master area
+     , (".", sendMessage (IncMasterN (-1)))
+     ]) ++
+    -- ------------------------------------------------------------
+    --
+    -- Xmonad Commands
+    --
+    -- ------------------------------------------------------------
+    --  Quit xmonad
+  (multiKeys
+     [ ("S-q", io exitSuccess)
+    --  restart xmonad
+     , ("S-r", spawn "xmonad --recompile; xmonad --restart")
+    --  select next screen/monitor
+     , ("<Backspace>", selectNextScreen)
+    --  move window next screen/monitor
+    -- , ("M4-S-<Backspace>", moveWindowToNextScreen)
+     ]) ++
+    -- ------------------------------------------------------------
+    --
+    -- Volume Control
+    --
+    -- ------------------------------------------------------------
+  [ ("<XF86AudioRaiseVolume>", spawn nixAlsaRaiseVolume)
+  , ("<XF86AudioLowerVolume>", spawn nixAlsaLowerVolume)
+  , ("<XF86AudioMute>", spawn nixAlsaMute)
+  ] ++
+    -- ------------------------------------------------------------
+    --
+    -- Redshift
+    --
+    -- ------------------------------------------------------------
+  [("M4-<F9>", spawn nixStartRedshift), ("M4-<F10>", spawn nixResetRedshift)] ++
+  -- ------------------------------------------------------------
+  --
+  -- programs
+  --
+  -- ------------------------------------------------------------
+  [("M4-b", spawn nixSetBackground)]
+
+------------------------------------------------------------------------
+-- Mouse bindings: default actions bound to mouse events
+--
+mouse :: XConfig t -> M.Map (KeyMask, Button) (Window -> X ())
+-- mouse _ = M.empty
+mouse XConfig {XMonad.modMask = modm} =
+  M.fromList
+    -- mod-button1, Set the window to floating mode and move by dragging
+    [ ( (modm, button1)
+      , \w -> do
+          focus w
+          mouseMoveWindow w
+          windows W.shiftMaster)
+    -- mod-button2, Raise the window to the top of the stack
+    , ( (modm, button2)
+      , \w -> do
+          focus w
+          windows W.shiftMaster)
+    -- mod-button3, Set the window to floating mode and resize by dragging
+    , ( (modm, button3)
+      , \w -> do
+          focus w
+          mouseResizeWindow w
+          windows W.shiftMaster)
+    -- you may also bind events to the mouse scroll wheel (button4 and button5)
+    ]
+
+------------------------------------------------------------------------
+-- Window rules:
+-- Execute arbitrary actions and WindowSet manipulations when managing
+-- a new window. You can use this to, for example, always float a
+-- particular program, or have a client always appear on a particular
+-- workspace.
+--
+-- To find the property name associated with a program, use
+-- > xprop | grep WM_CLASS
+-- and click on the client you're interested in.
+--
+-- To match on the WM_NAME, you can use 'title' in the same way that
+-- 'className' and 'resource' are used below.
+--
+myManageHook :: Query (Endo WindowSet)
+myManageHook =
+  composeAll
+    [ className =? "Gimp" --> doFloat
+    , className =? "zettlr" --> doFloat
+    , title =? "fzfmenu" --> doCenterFloat
+    , resource =? "copyq" --> doShift "-copyq"
+    , scratchpadManageHook
+        (W.RationalRect
+          -- | percentage distance from left
+           0.2
+          -- | percentage distance from top
+           0.2
+          -- | width
+           0.6
+          -- | height
+           0.6)
+    ]
+
+------------------------------------------------------------------------
+-- Event handling
+-- * EwmhDesktops users should change this to ewmhDesktopsEventHook
+--
+-- Defines a custom handler function for X Events. The function should
+-- return (All True) if the default handler is to be run afterwards. To
+-- combine event hooks use mappend or mconcat from Data.Monoid.
+--
+myEventHook :: Event -> X All
+myEventHook = mempty
+
+------------------------------------------------------------------------
+-- Status bars and logging
+-- Perform an arbitrary action on each internal state change or X event.
+-- See the 'XMonad.Hooks.DynamicLog' extension for examples.
+--
+myLogHook :: X ()
+myLogHook = do
+  dynamicLog
+    -- make sure the pointer always follows the focused window, when we use shortcuts
+  updatePointer (0.5, 0.5) (0, 0)
+
+------------------------------------------------------------------------
+-- Startup hook
+-- Perform an arbitrary action each time xmonad starts or is restarted
+-- with mod-q.  Used by, e.g., XMonad.Layout.PerWorkspace to initialize
+-- per-workspace layout choices.
+--
+-- By default, do nothing.
+startUp :: X ()
+startUp
+  -- java fix
+ = do
+  setWMName "LG3D"
+  spawn nixSetCursorImage
+  spawn nixSetBackground
+  spawn nixStartAlbert
+  spawnOnce nixStartCopyq
+
+------------------------------------------------------------------------
+-- Now run xmonad with all the defaults we set up.
+-- Run xmonad with the settings you specify. No need to modify this.
+--
+main :: IO ()
+main = do
+  xmonad $
+    withUrgencyHook LibNotifyUrgencyHook $
+    dynamicProjects projects $
+    -- debugManageHook $
+    defaults
+
+myTerm :: FilePath
+myTerm = nixStartTerminal
+
+-- make sure we never select a boring window
+-- when we select another workspace.
+updateBoring :: X ()
+updateBoring = do
+  focusUp
+  focusDown
+
+-- A structure containing your configuration settings, overriding
+-- fields in the default config. Any you don't override, will
+-- use the defaults defined in xmonad/XMonad/Config.hs
+--
+-- No need to modify this.
+--
+defaults =
+  additionalNav2DKeysP
+    ("<Up>", "<Left>", "<Down>", "<Right>")
+    [("M-", windowGo), ("M-S-", windowSwap)]
+    False
+    def
+      { terminal = myTerm
+    -- Whether focus follows the mouse pointer.
+      , focusFollowsMouse = True
+    -- Whether clicking on a window to focus also passes the click to the window
+      , clickJustFocuses = False
+    -- color configuration
+      , normalBorderColor = nonSelectionColor
+      , focusedBorderColor = selectionColor
+      , borderWidth = 1
+    -- modMask lets you specify which modkey you want to use.
+    -- mod1Mask ("left alt").
+    -- mod3Mask ("right alt")
+    -- mod4Mask ("windows key")
+      , modMask = mod4Mask
+      , workspaces = nonRemovableWorkspaces
+    -- key bindings
+      , keys = myKeys
+      , mouseBindings = mouse
+    -- , layoutHook = focusTracking $ historyLayout myLayout
+      , layoutHook = focusTracking myLayout
+    -- , logHook = myLogHook <> runAllPending
+      , logHook = myLogHook
+      , startupHook = startUp
+      , manageHook = myManageHook
+      , handleEventHook = myEventHook
+      } `additionalKeysP`
+  myAdditionaKeys
+
+autoXPConfig :: XPConfig
+autoXPConfig = myXPConfig {autoComplete = Just 5000}
+
+myXPConfig :: XPConfig
+myXPConfig =
+  def
+    { bgColor = Solarized.base03
+    , fgColor = Solarized.base0
+    , promptBorderWidth = 0
+    , font = "xft:DejaVu Sans:pixelsize=16:antialias=true:hinting=true"
+    }
+
+data LibNotifyUrgencyHook = LibNotifyUrgencyHook deriving (Read, Show)
+
+instance UrgencyHook LibNotifyUrgencyHook where
+    urgencyHook LibNotifyUrgencyHook w = do
+        name     <- getName w
+        Just idx <- fmap (W.findTag w) $ gets windowset
+
+        safeSpawn nixNotifySend [show name, "workspace " ++ idx]

nixos/components/gui/home-manager/xmonad/Memo.hs

@@ -0,0 +1,37 @@
+{-# LANGUAGE DeriveDataTypeable #-}
+
+{-| A hacky module to cycle through a list of
+rectangles, I'm using this to place a floating window somehwere
+when it is in my way -}
+module Memo where
+
+import           XMonad.Config.Prime
+import qualified XMonad.StackSet             as W
+import qualified XMonad.Util.ExtensibleState as ES
+
+
+
+newtype MemoStorage =
+  MemoStorage [W.RationalRect]
+  deriving (Typeable)
+
+-- (RationalRect x y height width)
+instance ExtensionClass MemoStorage where
+  initialValue =
+    MemoStorage
+      (cycle
+         [ (W.RationalRect 0.6 0.0 0.4 0.4) -- oben rechts
+         , (W.RationalRect 0.6 0.3 0.4 0.4) -- mitte rechts
+         , (W.RationalRect 0.6 0.6 0.4 0.4) -- unten rechts
+         , (W.RationalRect 0.3 0.6 0.4 0.4) -- unten mitte
+         , (W.RationalRect 0.0 0.6 0.4 0.4) -- unten links
+         , (W.RationalRect 0.0 0.3 0.4 0.4) -- mitte links
+         , (W.RationalRect 0.0 0.0 0.4 0.4) -- oben links
+         , (W.RationalRect 0.3 0.0 0.4 0.4) -- oben mitte
+         ])
+
+nextRectangle :: X W.RationalRect
+nextRectangle = do
+  MemoStorage next <- ES.get :: X MemoStorage
+  ES.modify (\(MemoStorage (_:xs)) -> MemoStorage xs)
+  return (head next)

nixos/components/gui/home-manager/xmonad/NixCommands.hs

@@ -0,0 +1,20 @@
+-- this is just a dummy and will not be used
+
+module NixCommands where
+
+nixStartIrc = ""
+nixStartAudacious = ""
+nixStartFlameshot = ""
+nixInvertColors = ""
+nixStartRedshift = ""
+nixResetRedshift = ""
+nixSetCursorImage = ""
+nixSetBackground = ""
+nixStartAlbert = ""
+nixStartCopyq = ""
+nixShowCopyq = ""
+nixStartTerminal = ""
+nixAlsaRaiseVolume = ""
+nixAlsaLowerVolume = ""
+nixAlsaMute = ""
+nixNotifySend = ""

nixos/components/gui/home-manager/xmonad/Setup.hs

@@ -0,0 +1,3 @@
+-- this is only here to satisfy my haskell mode
+import Distribution.Simple
+main = defaultMain

nixos/components/gui/home-manager/xmonad/SolarizedDark.hs

@@ -0,0 +1,49 @@
+module SolarizedDark where
+
+base0 :: String
+base0 = "#839496"
+
+base00 :: String
+base00 = "#657b83"
+
+base01 :: String
+base01 = "#586e75"
+
+base02 :: String
+base02 = "#073642"
+
+base03 :: String
+base03 = "#002b36"
+
+base1 :: String
+base1 = "#93a1a1"
+
+base2 :: String
+base2 = "#eee8d5"
+
+base3 :: String
+base3 = "#fdf6e3"
+
+blue :: String
+blue = "#268bd2"
+
+cyan :: String
+cyan = "#2aa198"
+
+green :: String
+green = "#859900"
+
+magenta :: String
+magenta = "#d33682"
+
+orange :: String
+orange = "#cb4b16"
+
+red :: String
+red = "#dc322f"
+
+violet :: String
+violet = "#6c71c4"
+
+yellow :: String
+yellow = "#b58900"

nixos/components/gui/home-manager/xmonad/SolarizedLight.hs

@@ -0,0 +1,49 @@
+module SolarizedLight where
+
+blue :: String
+blue = "#268bd2"
+
+cyan :: String
+cyan = "#2aa198"
+
+green :: String
+green = "#859900"
+
+magenta :: String
+magenta = "#d33682"
+
+orange :: String
+orange = "#cb4b16"
+
+red :: String
+red = "#dc322f"
+
+violet :: String
+violet = "#6c71c4"
+
+yellow :: String
+yellow = "#b58900"
+
+base0 :: String
+base0 = "#657b83"
+
+base00 :: String
+base00 = "#839496"
+
+base01 :: String
+base01 = "#93a1a1"
+
+base02 :: String
+base02 = "#eee8d5"
+
+base03 :: String
+base03 = "#fdf6e3"
+
+base1 :: String
+base1 = "#586e75"
+
+base2 :: String
+base2 = "#073642"
+
+base3 :: String
+base3 = "#002b36"

nixos/components/gui/home-manager/xmonad/SubLayouts.hs

@@ -0,0 +1,508 @@
+{-# LANGUAGE PatternGuards, ParallelListComp, DeriveDataTypeable, FlexibleInstances, FlexibleContexts, MultiParamTypeClasses, TypeSynonymInstances #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  XMonad.Layout.SubLayouts
+-- Copyright   :  (c) 2009 Adam Vogt
+-- License     :  BSD-style (see xmonad/LICENSE)
+--
+-- Maintainer  :  vogt.adam@gmail.com
+-- Stability   :  unstable
+-- Portability :  unportable
+--
+-- A layout combinator that allows layouts to be nested.
+--
+-- had to copy it because
+-- * uses the wrong Boring Windows library
+-----------------------------------------------------------------------------
+
+module SubLayouts (
+    -- * Usage
+    -- $usage
+    subLayout,
+    subTabbed,
+
+    pushGroup, pullGroup,
+    pushWindow, pullWindow,
+    onGroup, toSubl, mergeDir,
+
+    GroupMsg(..),
+    Broadcast(..),
+
+    defaultSublMap,
+
+    Sublayout,
+
+    -- * Screenshots
+    -- $screenshots
+
+    -- * Todo
+    -- $todo
+    )
+    where
+
+import XMonad.Layout.Circle () -- so haddock can find the link
+
+import XMonad.Layout.Decoration(Decoration, DefaultShrinker)
+import XMonad.Layout.LayoutModifier(LayoutModifier(handleMess, modifyLayout,
+                                    redoLayout),
+                                    ModifiedLayout(..))
+import XMonad.Layout.Simplest(Simplest(..))
+import XMonad.Layout.Tabbed(shrinkText,
+                            TabbedDecoration, addTabs)
+import XMonad.Layout.WindowNavigation(Navigate(Apply))
+import XMonad.Util.Invisible(Invisible(..))
+import XMonad.Util.Types(Direction2D(..))
+import XMonad hiding (def)
+import Control.Applicative((<$>),(<*))
+import Control.Arrow(Arrow(second, (&&&)))
+import Control.Monad(MonadPlus(mplus), foldM, guard, when, join)
+import Data.Function(on)
+import Data.List(nubBy, (\\), find)
+import Data.Maybe(isNothing, fromMaybe, listToMaybe, mapMaybe)
+import Data.Traversable(sequenceA)
+
+import qualified BoringWindows as B
+import qualified XMonad as X
+import qualified XMonad.StackSet as W
+import qualified Data.Map as M
+import Data.Map(Map)
+
+-- $screenshots
+--
+-- <<http://haskell.org/sitewiki/images/thumb/8/8b/Xmonad-SubLayouts-xinerama.png/480px-Xmonad-SubLayouts-xinerama.png>>
+--
+-- Larger version: <http://haskell.org/sitewiki/images/8/8b/Xmonad-SubLayouts-xinerama.png>
+
+-- $todo
+--  /Issue 288/
+--
+--  "XMonad.Layout.ResizableTile" assumes that its environment
+--  contains only the windows it is running: sublayouts are currently run with
+--  the stack containing only the windows passed to it in its environment, but
+--  any changes that the layout makes are not merged back.
+--
+--  Should the behavior be made optional?
+--
+--  /Features/
+--
+--   * suggested managehooks for merging specific windows, or the apropriate
+--     layout based hack to find out the number of groups currently showed, but
+--     the size of current window groups is not available (outside of this
+--     growing module)
+--
+--  /SimpleTabbed as a SubLayout/
+--
+--  'subTabbed' works well, but it would be more uniform to avoid the use of
+--  addTabs, with the sublayout being Simplest (but
+--  'XMonad.Layout.Tabbed.simpleTabbed' is this...).  The only thing to be
+--  gained by fixing this issue is the ability to mix and match decoration
+--  styles. Better compatibility with some other layouts of which I am not
+--  aware could be another benefit.
+--
+--  'simpleTabbed' (and other decorated layouts) fail horribly when used as
+--  subLayouts:
+--
+--    * decorations stick around: layout is run after being told to Hide
+--
+--    * mouse events do not change focus: the group-ungroup does not respect
+--      the focus changes it wants?
+--
+--    * sending ReleaseResources before running it makes xmonad very slow, and
+--      still leaves borders sticking around
+--
+
+-- $usage
+-- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:
+--
+-- > import XMonad.Layout.SubLayouts
+-- > import XMonad.Layout.WindowNavigation
+--
+-- Using "XMonad.Layout.BoringWindows" is optional and it allows you to add a
+-- keybinding to skip over the non-visible windows.
+--
+-- > import XMonad.Layout.BoringWindows
+--
+-- Then edit your @layoutHook@ by adding the 'subTabbed' layout modifier:
+--
+-- > myLayout = windowNavigation $ subTabbed $ boringWindows $
+-- >                        Tall 1 (3/100) (1/2) ||| etc..
+-- > main = xmonad def { layoutHook = myLayout }
+--
+-- "XMonad.Layout.WindowNavigation" is used to specify which windows to merge,
+-- and it is not integrated into the modifier because it can be configured, and
+-- works best as the outer modifier.
+--
+-- Then to your keybindings add:
+--
+--  > , ((modm .|. controlMask, xK_h), sendMessage $ pullGroup L)
+--  > , ((modm .|. controlMask, xK_l), sendMessage $ pullGroup R)
+--  > , ((modm .|. controlMask, xK_k), sendMessage $ pullGroup U)
+--  > , ((modm .|. controlMask, xK_j), sendMessage $ pullGroup D)
+--  >
+--  > , ((modm .|. controlMask, xK_m), withFocused (sendMessage . MergeAll))
+--  > , ((modm .|. controlMask, xK_u), withFocused (sendMessage . UnMerge))
+--  >
+--  > , ((modm .|. controlMask, xK_period), onGroup W.focusUp')
+--  > , ((modm .|. controlMask, xK_comma), onGroup W.focusDown')
+--
+--  These additional keybindings require the optional
+--  "XMonad.Layout.BoringWindows" layoutModifier. The focus will skip over the
+--  windows that are not focused in each sublayout.
+--
+--  > , ((modm, xK_j), focusDown)
+--  > , ((modm, xK_k), focusUp)
+--
+--  A 'submap' can be used to make modifying the sublayouts using 'onGroup' and
+--  'toSubl' simpler:
+--
+--  > ,((modm, xK_s), submap $ defaultSublMap conf)
+--
+--  /NOTE:/ is there some reason that @asks config >>= submap . defaultSublMap@
+--  could not be used in the keybinding instead? It avoids having to explicitly
+--  pass the conf.
+--
+-- For more detailed instructions, see:
+--
+-- "XMonad.Doc.Extending#Editing_the_layout_hook"
+-- "XMonad.Doc.Extending#Adding_key_bindings"
+
+-- | The main layout modifier arguments:
+--
+-- @subLayout advanceInnerLayouts innerLayout outerLayout@
+--
+--  [@advanceInnerLayouts@] When a new group at index @n@ in the outer layout
+--  is created (even with one element), the @innerLayout@ is used as the
+--  layout within that group after being advanced with @advanceInnerLayouts !!
+--  n@ 'NextLayout' messages. If there is no corresponding element in the
+--  @advanceInnerLayouts@ list, then @innerLayout@ is not given any 'NextLayout'
+--  messages.
+--
+--  [@innerLayout@] The single layout given to be run as a sublayout.
+--
+--  [@outerLayout@] The layout that determines the rectangles given to each
+--  group.
+--
+--  Ex. The second group is 'Tall', the third is 'Circle', all others are tabbed
+--  with:
+--
+--  > myLayout = addTabs shrinkText def
+--  >          $ subLayout [0,1,2] (Simplest ||| Tall 1 0.2 0.5 ||| Circle)
+--  >          $ Tall 1 0.2 0.5 ||| Full
+subLayout :: [Int] -> subl a -> l a -> ModifiedLayout (Sublayout subl) l a
+subLayout nextLayout sl x = ModifiedLayout (Sublayout (I []) (nextLayout,sl) []) x
+
+-- | @subTabbed@ is a use of 'subLayout' with 'addTabs' to show decorations.
+subTabbed :: (Eq a, LayoutModifier (Sublayout Simplest) a, LayoutClass l a) =>
+    l a -> ModifiedLayout (Decoration TabbedDecoration DefaultShrinker)
+                          (ModifiedLayout (Sublayout Simplest) l) a
+subTabbed  x = addTabs shrinkText X.def $ subLayout [] Simplest x
+
+-- | @defaultSublMap@ is an attempt to create a set of keybindings like the
+-- defaults ones but to be used as a 'submap' for sending messages to the
+-- sublayout.
+defaultSublMap :: XConfig l -> Map (KeyMask, KeySym) (X ())
+defaultSublMap (XConfig { modMask = modm }) = M.fromList
+         [((modm, xK_space), toSubl NextLayout),
+          ((modm, xK_j), onGroup W.focusDown'),
+          ((modm, xK_k), onGroup W.focusUp'),
+          ((modm, xK_h), toSubl Shrink),
+          ((modm, xK_l), toSubl Expand),
+          ((modm, xK_Tab), onGroup W.focusDown'),
+          ((modm .|. shiftMask, xK_Tab), onGroup W.focusUp'),
+          ((modm, xK_m), onGroup focusMaster'),
+          ((modm, xK_comma), toSubl $ IncMasterN 1),
+          ((modm, xK_period), toSubl $ IncMasterN (-1)),
+          ((modm, xK_Return), onGroup swapMaster')
+         ]
+        where
+         -- should these go into XMonad.StackSet?
+         focusMaster' st = let (f:fs) = W.integrate st
+            in W.Stack f [] fs
+         swapMaster' (W.Stack f u d) = W.Stack f [] $ reverse u ++ d
+
+data Sublayout l a = Sublayout
+    { delayMess :: Invisible [] (SomeMessage,a)
+                          -- ^ messages are handled when running the layout,
+                          -- not in the handleMessage, I'm not sure that this
+                          -- is necessary
+    , def :: ([Int], l a) -- ^ how many NextLayout messages to send to newly
+                          -- populated layouts. If there is no corresponding
+                          -- index, then don't send any.
+    , subls :: [(l a,W.Stack a)]
+                          -- ^ The sublayouts and the stacks they manage
+    }
+    deriving (Read,Show)
+
+-- | Groups assumes this invariant:
+--     M.keys gs == map W.focus (M.elems gs)  (ignoring order)
+--     All windows in the workspace are in the Map
+--
+-- The keys are visible windows, the rest are hidden.
+--
+-- This representation probably simplifies the internals of the modifier.
+type Groups a = Map a (W.Stack a)
+
+-- | GroupMsg take window parameters to determine which group the action should
+-- be applied to
+data GroupMsg a
+    = UnMerge a -- ^ free the focused window from its tab stack
+    | UnMergeAll a
+                -- ^ separate the focused group into singleton groups
+    | Merge a a -- ^ merge the first group into the second group
+    | MergeAll a
+                -- ^ make one large group, keeping the parameter focused
+    | Migrate a a
+                -- ^ used to the window named in the first argument to the
+                -- second argument's group, this may be replaced by a
+                -- combination of 'UnMerge' and 'Merge'
+    | WithGroup (W.Stack a -> X (W.Stack a)) a
+    | SubMessage SomeMessage  a
+                -- ^ the sublayout with the given window will get the message
+    deriving (Typeable)
+
+-- | merge the window that would be focused by the function when applied to the
+-- W.Stack of all windows, with the current group removed. The given window
+-- should be focused by a sublayout. Example usage: @withFocused (sendMessage .
+-- mergeDir W.focusDown')@
+mergeDir :: (W.Stack Window -> W.Stack Window) -> Window -> GroupMsg Window
+mergeDir f w = WithGroup g w
+ where g cs = do
+        let onlyOthers = W.filter (`notElem` W.integrate cs)
+        flip whenJust (sendMessage . Merge (W.focus cs) . W.focus . f)
+            =<< fmap (onlyOthers =<<) currentStack
+        return cs
+
+data Broadcast = Broadcast SomeMessage -- ^ send a message to all sublayouts
+    deriving (Typeable)
+
+instance Message Broadcast
+instance Typeable a => Message (GroupMsg a)
+
+-- | @pullGroup@, @pushGroup@ allow you to merge windows or groups inheriting
+-- the position of the current window (pull) or the other window (push).
+--
+-- @pushWindow@ and @pullWindow@ move individual windows between groups. They
+-- are less effective at preserving window positions.
+pullGroup,pushGroup,pullWindow,pushWindow :: Direction2D -> Navigate
+pullGroup = mergeNav (\o c -> sendMessage $ Merge o c)
+pushGroup = mergeNav (\o c -> sendMessage $ Merge c o)
+pullWindow = mergeNav (\o c -> sendMessage $ Migrate o c)
+pushWindow = mergeNav (\o c -> sendMessage $ Migrate c o)
+
+mergeNav :: (Window -> Window -> X ()) -> Direction2D -> Navigate
+mergeNav f = Apply (\o -> withFocused (f o))
+
+-- | Apply a function on the stack belonging to the currently focused group. It
+-- works for rearranging windows and for changing focus.
+onGroup :: (W.Stack Window -> W.Stack Window) -> X ()
+onGroup f = withFocused (sendMessage . WithGroup (return . f))
+
+-- | Send a message to the currently focused sublayout.
+toSubl :: (Message a) => a -> X ()
+toSubl m = withFocused (sendMessage . SubMessage (SomeMessage m))
+
+instance (Read (l Window), Show (l Window), LayoutClass l Window) => LayoutModifier (Sublayout l) Window where
+    modifyLayout (Sublayout { subls = osls }) (W.Workspace i la st) r = do
+            let gs' = updateGroup st $ toGroups osls
+                st' = W.filter (`elem` M.keys gs') =<< st
+            updateWs gs'
+            oldStack <- gets $ W.stack . W.workspace . W.current . windowset
+            setStack st'
+            runLayout (W.Workspace i la st') r <* setStack oldStack
+            -- FIXME: merge back reordering, deletions?
+
+    redoLayout (Sublayout { delayMess = I ms, def = defl, subls = osls }) _r st arrs = do
+        let gs' = updateGroup st $ toGroups osls
+        sls <- fromGroups defl st gs' osls
+
+        let newL :: LayoutClass l Window => Rectangle -> WorkspaceId -> (l Window) -> Bool
+                    -> (Maybe (W.Stack Window)) -> X ([(Window, Rectangle)], l Window)
+            newL rect n ol isNew sst = do
+                orgStack <- currentStack
+                let handle l (y,_)
+                        | not isNew = fromMaybe l <$> handleMessage l y
+                        | otherwise = return l
+                    kms = filter ((`elem` M.keys gs') . snd) ms
+                setStack sst
+                nl <- foldM handle ol $ filter ((`elem` W.integrate' sst) . snd) kms
+                result <- runLayout (W.Workspace n nl sst) rect
+                setStack orgStack -- FIXME: merge back reordering, deletions?
+                return $ fromMaybe nl `second` result
+
+            (urls,ssts) = unzip [ (newL gr i l isNew sst, sst)
+                    | (isNew,(l,_st)) <- sls
+                    | i <- map show [ 0 :: Int .. ]
+                    | (k,gr) <- arrs, let sst = M.lookup k gs' ]
+
+        arrs' <- sequence urls
+        sls' <- return . Sublayout (I []) defl . map snd <$> fromGroups defl st gs'
+                        [ (l,s) | (_,l) <- arrs' | (Just s) <- ssts ]
+        return (concatMap fst arrs', sls')
+
+    handleMess (Sublayout (I ms) defl sls) m
+        | Just (SubMessage sm w) <- fromMessage m =
+            return $ Just $ Sublayout (I ((sm,w):ms)) defl sls
+
+        | Just (Broadcast sm) <- fromMessage m = do
+            ms' <- fmap (zip (repeat sm) . W.integrate') currentStack
+            return $ if null ms' then Nothing
+                else Just $ Sublayout (I $ ms' ++ ms) defl sls
+
+        | Just B.UpdateBoring <- fromMessage m = do
+            let bs = concatMap unfocused $ M.elems gs
+            ws <- gets (W.workspace . W.current . windowset)
+            flip sendMessageWithNoRefresh ws $ B.Replace "Sublayouts" bs
+            return Nothing
+
+        | Just (WithGroup f w) <- fromMessage m
+        , Just g <- M.lookup w gs = do
+            g' <- f g
+            let gs' = M.insert (W.focus g') g' $ M.delete (W.focus g) gs
+            when (gs' /= gs) $ updateWs gs'
+            when (w /= W.focus g') $ windows (W.focusWindow $ W.focus g')
+            return Nothing
+
+        | Just (MergeAll w) <- fromMessage m =
+            let gs' = fmap (M.singleton w)
+                    $ (focusWindow' w =<<) $ W.differentiate
+                    $ concatMap W.integrate $ M.elems gs
+            in maybe (return Nothing) fgs gs'
+
+        | Just (UnMergeAll w) <- fromMessage m =
+            let ws = concatMap W.integrate $ M.elems gs
+                _ = w :: Window
+                mkSingleton f = M.singleton f (W.Stack f [] [])
+            in fgs $ M.unions $ map mkSingleton ws
+
+        | Just (Merge x y) <- fromMessage m
+        , Just (W.Stack _ xb xn) <- findGroup x
+        , Just yst <- findGroup y =
+            let zs = W.Stack x xb (xn ++ W.integrate yst)
+            in fgs $ M.insert x zs $ M.delete (W.focus yst) gs
+
+        | Just (UnMerge x) <- fromMessage m =
+            fgs . M.fromList . map (W.focus &&& id) . M.elems
+                    $ M.mapMaybe (W.filter (x/=)) gs
+
+        -- XXX sometimes this migrates an incorrect window, why?
+        | Just (Migrate x y) <- fromMessage m
+        , Just xst <- findGroup x
+        , Just (W.Stack yf yu yd) <- findGroup y =
+            let zs = W.Stack x (yf:yu) yd
+                nxsAdd = maybe id (\e -> M.insert (W.focus e) e) $ W.filter (x/=) xst
+            in fgs $ nxsAdd $ M.insert x zs $ M.delete yf gs
+
+
+        | otherwise = fmap join $ sequenceA $ catchLayoutMess <$> fromMessage m
+     where gs = toGroups sls
+           fgs gs' = do
+                st <- currentStack
+                Just . Sublayout (I ms) defl . map snd <$> fromGroups defl st gs' sls
+
+           findGroup z = mplus (M.lookup z gs) $ listToMaybe
+                    $ M.elems $ M.filter ((z `elem`) . W.integrate) gs
+           -- catchLayoutMess :: LayoutMessages -> X (Maybe (Sublayout l Window))
+           --  This l must be the same as from the instance head,
+           --  -XScopedTypeVariables should bring it into scope, but we are
+           --  trying to avoid warnings with ghc-6.8.2 and avoid CPP
+           catchLayoutMess x = do
+            let m' = x `asTypeOf` (undefined :: LayoutMessages)
+            ms' <- zip (repeat $ SomeMessage m') . W.integrate'
+                    <$> currentStack
+            return $ do guard $ not $ null ms'
+                        Just $ Sublayout (I $ ms' ++ ms) defl sls
+
+currentStack :: X (Maybe (W.Stack Window))
+currentStack = gets (W.stack . W.workspace . W.current . windowset)
+
+-- | update Group to follow changes in the workspace
+updateGroup :: Ord a => Maybe (W.Stack a) -> Groups a -> Groups a
+updateGroup mst gs =
+        let flatten = concatMap W.integrate . M.elems
+            news = W.integrate' mst \\ flatten gs
+            deads = flatten gs \\ W.integrate' mst
+
+            uniNew = M.union (M.fromList $ map (\n -> (n,single n)) news)
+            single x = W.Stack x [] []
+
+            -- pass through a list to update/remove keys
+            remDead = M.fromList . map (\w -> (W.focus w,w))
+                        . mapMaybe (W.filter (`notElem` deads)) . M.elems
+
+            -- update the current tab group's order and focus
+            followFocus hs = fromMaybe hs $ do
+                f' <- W.focus `fmap` mst
+                xs <- find (elem f' . W.integrate) $ M.elems hs
+                xs' <- W.filter (`elem` W.integrate xs) =<< mst
+                return $ M.insert f' xs' $ M.delete (W.focus xs) hs
+
+        in remDead $ uniNew $ followFocus gs
+
+-- | rearrange the windowset to put the groups of tabs next to eachother, so
+-- that the stack of tabs stays put.
+updateWs :: Groups Window -> X ()
+updateWs = windowsMaybe . updateWs'
+
+updateWs' :: Groups Window -> WindowSet -> Maybe WindowSet
+updateWs' gs ws = do
+    f <- W.peek ws
+    let w = W.index ws
+        nes = concatMap W.integrate $ mapMaybe (flip M.lookup gs) w
+        ws' = W.focusWindow f $ foldr W.insertUp (foldr W.delete' ws nes) nes
+    guard $ W.index ws' /= W.index ws
+    return ws'
+
+-- | focusWindow'. focus an element of a stack, is Nothing if that element is
+-- absent. See also 'W.focusWindow'
+focusWindow' :: (Eq a) => a -> W.Stack a -> Maybe (W.Stack a)
+focusWindow' w st = do
+    guard $ not $ null $ filter (w==) $ W.integrate st
+    if W.focus st == w then Just st
+        else focusWindow' w $ W.focusDown' st
+
+-- update only when Just
+windowsMaybe :: (WindowSet -> Maybe WindowSet) -> X ()
+windowsMaybe f = do
+    xst <- get
+    ws <- gets windowset
+    let up fws = put xst { windowset = fws }
+    maybe (return ()) up $ f ws
+
+unfocused :: W.Stack a -> [a]
+unfocused x = W.up x ++ W.down x
+
+toGroups :: (Ord a) => [(a1, W.Stack a)] -> Map a (W.Stack a)
+toGroups ws = M.fromList . map (W.focus &&& id) . nubBy (on (==) W.focus)
+                    $ map snd ws
+
+-- | restore the default layout for each group. It needs the X monad to switch
+-- the default layout to a specific one (handleMessage NextLayout)
+fromGroups :: (LayoutClass layout a, Ord k) =>
+              ([Int], layout a)
+              -> Maybe (W.Stack k)
+              -> Groups k
+              -> [(layout a, b)]
+              -> X [(Bool,(layout a, W.Stack k))]
+fromGroups (skips,defl) st gs sls = do
+    defls <- mapM (iterateM nextL defl !!) skips
+    return $ fromGroups' defl defls st gs (map fst sls)
+        where nextL l = fromMaybe l <$> handleMessage l (SomeMessage NextLayout)
+              iterateM f = iterate (>>= f) . return
+
+fromGroups' :: (Ord k) => a -> [a] -> Maybe (W.Stack k) -> Groups k -> [a]
+                    -> [(Bool,(a, W.Stack k))]
+fromGroups' defl defls st gs sls =
+    [ (isNew,fromMaybe2 (dl, single w) (l, M.lookup w gs))
+        | l <- map Just sls ++ repeat Nothing, let isNew = isNothing l
+        | dl <- defls ++ repeat defl
+        | w <- W.integrate' $ W.filter (`notElem` unfocs) =<< st ]
+    where unfocs = unfocused =<< M.elems gs
+          single w = W.Stack w [] []
+          fromMaybe2 (a,b) (x,y) = (fromMaybe a x, fromMaybe b y)
+
+
+-- this would be much cleaner with some kind of data-accessor
+setStack :: Maybe (W.Stack Window) -> X ()
+setStack x = modify (\s -> s { windowset = (windowset s)
+                { W.current = (W.current $ windowset s)
+                { W.workspace = (W.workspace $ W.current $ windowset s) { W.stack = x }}}})

nixos/components/gui/home-manager/xmonad/TabbedFix.hs

@@ -0,0 +1,112 @@
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE TypeSynonymInstances  #-}
+
+
+module TabbedFix (historyLayout, runAllPending) where
+
+import           Control.DeepSeq              (force)
+import qualified Data.List                    as L
+import           XMonad
+import           XMonad.Layout.LayoutModifier (LayoutModifier,
+                                               ModifiedLayout (ModifiedLayout),
+                                               modifyLayout)
+import qualified XMonad.StackSet              as W
+import qualified XMonad.Util.ExtensibleState  as ES
+
+newtype PendingActions =
+  PendingActions [X ()]
+
+instance ExtensionClass PendingActions where
+  initialValue = PendingActions []
+
+addAction :: X () -> X ()
+addAction x = ES.modify (\(PendingActions xs) -> PendingActions (x:xs))
+
+runAllPending :: X ()
+runAllPending = do
+  PendingActions actions <- ES.get
+  ES.put (PendingActions [])
+  sequence_ actions
+
+newtype FocusHistory = FocusHistory {
+  getFocusHistory :: [Window]
+  } deriving (Read, Show, Typeable)
+
+instance ExtensionClass FocusHistory where
+  initialValue = FocusHistory []
+  extensionType = PersistentExtension
+
+data FocusLayout a = FocusLayout deriving (Read,Show,Typeable)
+
+historyLayout :: l Window -> ModifiedLayout FocusLayout l Window
+historyLayout = ModifiedLayout FocusLayout
+
+instance LayoutModifier FocusLayout Window where
+  modifyLayout _ workspace rectangle = do
+    currentFocusedWindow <- getFocused
+    windowHistory <- getFocusHistory <$> ES.get
+    newWindow <- windowHistoryHook currentFocusedWindow
+    case newWindow of
+      Nothing -> runLayout workspace rectangle
+      Just window -> do
+        let currentStack = W.stack workspace
+        let lastFocusedWindow =
+              L.find (`elem` W.integrate' currentStack) windowHistory
+        let focusWindow windowToFocus =
+              until ((windowToFocus ==) . W.focus) W.focusUp' <$> currentStack
+        let newstack =
+              if window `elem` W.integrate' currentStack
+                then focusWindow window
+                else case lastFocusedWindow of
+                       Just window' -> focusWindow window'
+                       Nothing -> currentStack
+        modifyWindowSet (W.focusWindow window)
+        addAction $ do
+          maybe (return ()) makeBorderNormal currentFocusedWindow
+          windows id
+        runLayout workspace {W.stack = newstack} rectangle
+
+windowHistoryHook :: Maybe Window -> X (Maybe Window)
+windowHistoryHook Nothing = return Nothing
+windowHistoryHook (Just currentFocusedWindow) = do
+  currentWindows <- gets $ W.index . windowset
+  windowHistory <- getFocusHistory <$> ES.get
+  withWindowSet $ \windowSet ->
+    case windowHistory of
+      [] -> do
+        ES.put $ FocusHistory [currentFocusedWindow]
+        return Nothing
+      (prevFocusedWindow:focusedWindows)
+        | prevFocusedWindow == currentFocusedWindow -> return Nothing
+          -- Previous focus was removed from windowSet focus on previous existing window in current windowSet
+        | prevFocusedWindow `notElem` currentWindows -> do
+          let windowHistory' = filter (`W.member` windowSet) focusedWindows
+          ES.put (FocusHistory $ force windowHistory')
+          return $ L.find (`elem` currentWindows) windowHistory'
+          -- Add current focus to windowHistory
+        | otherwise -> do
+          ES.put $
+            FocusHistory $
+            force $
+            currentFocusedWindow : L.delete currentFocusedWindow windowHistory
+          return Nothing
+
+makeBorderRed :: Window -> X ()
+makeBorderRed w =
+    withDisplay $ \d -> io $ do
+      setWindowBorder d w 0xff0000
+
+-- wz1000: palo: btw, you will need to change the color in makeBorderNormal to your unfocused border color
+makeBorderNormal :: Window -> X ()
+makeBorderNormal w =
+    withDisplay $ \d -> io $ do
+      setWindowBorder d w 0x2b2b2b
+
+makeBorderFocused :: Window -> X ()
+makeBorderFocused w =
+    withDisplay $ \d -> io $ do
+      setWindowBorder d w 0xcccccc
+
+
+getFocused :: X (Maybe Window)
+getFocused = withWindowSet (return . W.peek)

nixos/components/gui/home-manager/xmonad/current-project.nix

@@ -0,0 +1,12 @@
+# created by cabal2nix
+{ mkDerivation, base, deepseq, lib, xmonad, xmonad-contrib, xmonad-extras }:
+mkDerivation {
+  pname = "palos-xmonad";
+  version = "0.1.0.0";
+  src = ./.;
+  isLibrary = false;
+  isExecutable = true;
+  executableHaskellDepends =
+    [ base deepseq xmonad xmonad-contrib xmonad-extras ];
+  license = lib.licenses.gpl3;
+}

nixos/components/gui/home-manager/xmonad/env.nix

@@ -0,0 +1,13 @@
+{ pkgs ? import <nixpkgs> {
+    overlays = [
+      (self: super: {
+        haskellPackages = super.haskellPackages.override {
+          overrides = self: super: {
+            current-project = super.callPackage ./current-project.nix { };
+          };
+        };
+      })
+    ];
+  }
+}:
+pkgs.haskellPackages.current-project.env

nixos/components/gui/home-manager/xmonad/lsp.nix

@@ -0,0 +1,15 @@
+{ pkgs ? import <nixpkgs> { } }:
+let
+  all-hies =
+    import (fetchTarball "https://github.com/infinisil/all-hies/tarball/master")
+      { };
+in
+pkgs.mkShell {
+  buildInputs = with pkgs; [
+    haskellPackages.hoogle
+    haskellPackages.hindent
+    haskellPackages.hlint
+    haskellPackages.stylish-haskell
+    (all-hies.selection { selector = p: { inherit (p) ghc865; }; })
+  ];
+}

nixos/components/gui/home-manager/xmonad/palos-xmonad.cabal

@@ -0,0 +1,31 @@
+cabal-version:       2.4
+-- this is only here to satisfy my haskell mode in emacs
+
+name:                palos-xmonad
+version:             0.1.0.0
+license:             GPL-3.0-only
+license-file:        LICENSE
+author:              Ingolf Wagner
+maintainer:          contact@ingolf-wagner.de
+category:            Graphics
+
+executable palos-xmonad
+  main-is:             Main.hs
+  other-extensions:
+                   MultiParamTypeClasses
+                 , TypeSynonymInstances
+  other-modules:
+                   BoringWindows
+                 , FloatKeys
+                 , NixCommands
+                 , SolarizedLight
+                 , SubLayouts
+                 , TabbedFix
+
+  build-depends:       base
+                     , xmonad
+                     , containers
+                     , deepseq
+                     , xmonad-contrib
+                     , xmonad-extras
+  default-language:    Haskell2010

nixos/components/gui/home-manager/xmonad/shell.nix

@@ -0,0 +1,10 @@
+{ pkgs ? import <nixpkgs> { } }:
+let
+  updateCabal = pkgs.writeShellScriptBin "update-cabal" # sh
+    ''
+      cd ${toString ./.}
+      echo "# created by cabal2nix " > ${toString ./.}/current-project.nix
+      ${pkgs.cabal2nix}/bin/cabal2nix . >> ${toString ./.}/current-project.nix
+    '';
+in
+pkgs.mkShell { buildInputs = with pkgs; [ updateCabal cabal2nix ]; }

nixos/components/gui/pass.nix

@@ -1,4 +1,4 @@
-{ pkgs, config, lib, ... }:
+{ lib, pkgs, config, ... }:
 with lib;
 let
 
@@ -24,12 +24,7 @@ let
 
 in
 {
-  options.components.gui.pass.enable = mkOption {
+  config = mkIf config.components.gui.enable {
-    type = lib.types.bool;
-    default = config.components.gui.enable;
-  };
-
-  config = mkIf (config.components.gui.pass.enable) {
 
     environment.systemPackages = [
       (pkgs.pass.withExtensions (ext: [ ext.pass-otp ]))

nixos/components/gui/suspend.nix

@@ -3,10 +3,10 @@ with lib;
 {
   options.components.gui.suspend.enable = mkOption {
     type = lib.types.bool;
-    default = config.components.gui.enable;
+    default = true;
   };
 
-  config = mkIf (config.components.gui.suspend.enable) {
+  config = mkIf (config.components.gui.enable && config.components.gui.suspend.enable) {
 
     systemd.services.screenlock = {
       before = [ "sleep.target" ];

nixos/components/terminal/default.nix

@@ -1,18 +0,0 @@
-{ pkgs, lib, ... }:
-with lib;
-{
-  options.components.terminal = {
-    enable = lib.mkEnableOption "Terminal configurations";
-  };
-
-  imports = [
-    ./direnv.nix
-    ./hoard.nix
-    ./remote-install.nix
-    ./wtf.nix
-  ];
-
-  config = mkIf config.components.terminal.enable {
-    # todo extract xorg stuff to prepare wayland
-  };
-}

nixos/components/terminal/direnv.nix

@@ -1,21 +0,0 @@
-{ pkgs, config, lib, ... }:
-with lib;
-{
-  options.components.terminal.direnv.enable = mkOption {
-    type = lib.types.bool;
-    default = config.components.terminal.enable;
-  };
-  config = mkIf (config.components.terminal.direnv.enable) {
-
-    environment.systemPackages = [ pkgs.direnv ];
-
-    home-manager.users.mainUser.programs.direnv.enable = true;
-
-    programs.zsh.interactiveShellInit = ''
-      eval "$(${pkgs.direnv}/bin/direnv hook zsh)"
-    '';
-    programs.bash.interactiveShellInit = ''
-      eval "$(${pkgs.direnv}/bin/direnv hook bash)"
-    '';
-  };
-}

nixos/components/terminal/hoard.nix

@@ -1,62 +0,0 @@
-{ pkgs, config, lib, ... }:
-with lib;
-let
-  hoardSrc = pkgs.fetchFromGitHub {
-    owner = "Hyde46";
-    repo = "hoard";
-    rev = "v1.3.1";
-    sha256 = "sha256-Gm3X6/g5JQJEl7wRvWcO4j5XpROhtfRJ72LNaUeZRGc=";
-  };
-in
-{
-  options.components.terminal.hoard.enable = mkOption {
-    type = lib.types.bool;
-    default = config.components.terminal.enable;
-  };
-
-  config = mkIf (config.components.terminal.hoard.enable) {
-
-    # todo : sync via syncthing
-    backup.dirs = [
-      "/root/.config/hoard"
-      "/home/palo/.config/hoard"
-    ];
-
-    environment.systemPackages = [ pkgs.hoard ];
-
-    home-manager.users.mainUser = {
-      xdg.configFile."hoard/config.yml".text = builtins.toJSON {
-        version = "1.0.1";
-        default_namespace = "default";
-        config_home_path = "/home/palo/.config/hoard";
-        trove_path = "/home/palo/.config/hoard/trove.yml";
-        query_prefix = " >";
-        primary_color = [ 87 142 87 ];
-        secondary_color = [ 203 184 144 ];
-        tertiary_color = [ 30 30 30 ];
-        command_color = [ 30 30 30 ];
-        parameter_token = "#";
-        read_from_current_directory = true;
-      };
-      programs.zsh.initExtra = ''
-        export HOARD_NOBIND=1
-        source ${hoardSrc}/src/shell/hoard.zsh
-        bindkey '^x' _hoard_list_widget
-      '';
-    };
-
-    # use showkey -a
-    # Ctrl-h is equivalent to Ctrl-Backspace (for some reason)
-    programs.zsh.interactiveShellInit = ''
-      export HOARD_NOBIND=1
-      source ${hoardSrc}/src/shell/hoard.zsh
-      bindkey '^x' _hoard_list_widget
-    '';
-    programs.bash.interactiveShellInit = ''
-      export HOARD_NOBIND=1
-      source ${hoardSrc}/src/shell/hoard.bash
-      bind -x '"\C-x": __hoard_list'
-    '';
-
-  };
-}

nixos/components/terminal/remote-install.nix

@@ -1,26 +0,0 @@
-{ pkgs, config, lib, ... }:
-with lib;
-{
-  options.components.terminal.remote-install.enable = mkOption {
-    type = lib.types.bool;
-    default = config.components.terminal.enable;
-  };
-  config = mkIf (config.components.terminal.remote-install.enable) {
-
-    services.tor = {
-      enable = true;
-      client.enable = true;
-      relay.onionServices.liveos.map = [{ port = 1337; }];
-    };
-
-    environment.systemPackages = [
-      (pkgs.writeShellScriptBin "remote-install-start-service" ''
-        echo "starting announcment server to receive remote-install iso onion id"
-        ${pkgs.nmap}/bin/ncat -k -l -p 1337
-      '')
-      (pkgs.writeShellScriptBin "remote-install-get-hiddenReceiver" ''
-        sudo cat /var/lib/tor/onion/liveos/hostname
-      '')
-    ];
-  };
-}

nixos/machines/cream/configuration.nix

@@ -25,7 +25,6 @@
 
 
   components.gui.enable = true;
-  components.terminal.enable = true;
 
   services.nginx.enable = true;
 

nixos/system/desktop/default.nix

@@ -7,12 +7,16 @@
     #./icecast.nix
     ./audio.nix
     ./cachix.nix
+    ./direnv.nix
+    ./hoard.nix
     ./mail-stuff.nix
     ./network.nix
     ./packages.nix
+    ./remote-install.nix
     ./size.nix
     ./user.nix
     ./yubikey.nix
+    ./wtf.nix
   ];
 
   components.network.sshd.onlyTincAccess = lib.mkDefault true;

nixos/system/desktop/direnv.nix

@@ -0,0 +1,14 @@
+{ config, pkgs, ... }: {
+
+  environment.systemPackages = [ pkgs.direnv ];
+
+  home-manager.users.mainUser.programs.direnv.enable = true;
+
+  programs.zsh.interactiveShellInit = ''
+    eval "$(${pkgs.direnv}/bin/direnv hook zsh)"
+  '';
+  programs.bash.interactiveShellInit = ''
+    eval "$(${pkgs.direnv}/bin/direnv hook bash)"
+  '';
+
+}

nixos/system/desktop/hoard.nix

@@ -0,0 +1,54 @@
+{ config, pkgs, ... }:
+let
+  hoardSrc = pkgs.fetchFromGitHub {
+    owner = "Hyde46";
+    repo = "hoard";
+    rev = "v1.3.1";
+    sha256 = "sha256-Gm3X6/g5JQJEl7wRvWcO4j5XpROhtfRJ72LNaUeZRGc=";
+  };
+in
+{
+
+  # todo : sync via syncthing
+  backup.dirs = [
+    "/root/.config/hoard"
+    "/home/palo/.config/hoard"
+  ];
+
+  environment.systemPackages = [ pkgs.hoard ];
+
+  home-manager.users.mainUser = {
+    xdg.configFile."hoard/config.yml".text = builtins.toJSON {
+      version = "1.0.1";
+      default_namespace = "default";
+      config_home_path = "/home/palo/.config/hoard";
+      trove_path = "/home/palo/.config/hoard/trove.yml";
+      query_prefix = " >";
+      primary_color = [ 87 142 87 ];
+      secondary_color = [ 203 184 144 ];
+      tertiary_color = [ 30 30 30 ];
+      command_color = [ 30 30 30 ];
+      parameter_token = "#";
+      read_from_current_directory = true;
+    };
+    programs.zsh.initExtra = ''
+      export HOARD_NOBIND=1
+      source ${hoardSrc}/src/shell/hoard.zsh
+      bindkey '^x' _hoard_list_widget
+    '';
+  };
+
+  # use showkey -a
+  # todo Ctrl-h is equivalent to Ctrl-Backspace (for some reason)
+  programs.zsh.interactiveShellInit = ''
+    export HOARD_NOBIND=1
+    source ${hoardSrc}/src/shell/hoard.zsh
+    bindkey '^x' _hoard_list_widget
+  '';
+  programs.bash.interactiveShellInit = ''
+    export HOARD_NOBIND=1
+    source ${hoardSrc}/src/shell/hoard.bash
+    bind -x '"\C-x": __hoard_list'
+  '';
+
+}

nixos/system/desktop/remote-install.nix

@@ -0,0 +1,18 @@
+{ pkgs, ... }: {
+
+  services.tor = {
+    enable = true;
+    client.enable = true;
+    relay.onionServices.liveos.map = [{ port = 1337; }];
+  };
+
+  environment.systemPackages = [
+    (pkgs.writeShellScriptBin "remote-install-start-service" ''
+      echo "starting announcment server to receive remote-install iso onion id"
+      ${pkgs.nmap}/bin/ncat -k -l -p 1337
+    '')
+    (pkgs.writeShellScriptBin "remote-install-get-hiddenReceiver" ''
+      sudo cat /var/lib/tor/onion/liveos/hostname
+    '')
+  ];
+}

nixos/system/desktop/wtf.nix

@@ -1,5 +1,4 @@
-{ pkgs, config, lib, ... }:
+{ pkgs, lib, config, ... }:
-with lib;
 let
 
   networkStatus =
@@ -376,30 +375,23 @@ let
     '';
 
 in
-
 {
-  options.components.terminal.wtf.enable = mkOption {
-    type = lib.types.bool;
-    default = config.components.terminal.enable;
-  };
-  config = mkIf (config.components.terminal.wtf.enable) {
 
-    services.upower.enable = true;
+  services.upower.enable = true;
 
-    environment.systemPackages = [
+  environment.systemPackages = [
-      pkgs.unstable.wtf
+    pkgs.unstable.wtf
-      (createDashboard {
+    (createDashboard {
-        json = qJson;
+      json = qJson;
-        name = "q";
+      name = "q";
-      })
+    })
-      (createDashboard {
+    (createDashboard {
-        json = newsJson;
+      json = newsJson;
-        name = "news";
+      name = "news";
-      })
+    })
-      #activeUsers
+    #activeUsers
-      #activeTasks
+    #activeTasks
-      pkgs.upower
+    pkgs.upower
-    ];
+  ];
 
-  };
 }