Format with ormolu.

36 files changed, 1825 insertions, 1690 deletions

diff --git a/src/Main.hs b/src/Main.hs
index a98e568..766716c 100644
--- a/src/Main.hs
+++ b/src/Main.hs
@@ -1,33 +1,30 @@
-import XMonad
-
-import XMonad.Hooks.DynamicProperty
-import Control.Monad.Trans.Class
 import Control.Monad.Reader
-import XMonad.Hooks.ManageDocks (docks)
-import System.Directory (getHomeDirectory)
-import System.FilePath ((</>))
-import XMonad.Hooks.EwmhDesktops (ewmh)
-import XMonad.Hooks.ManageHelpers (isFullscreen, doFullFloat)
-import XMonad.Layout.Fullscreen (fullscreenEventHook)
-import System.Environment (setEnv)
-import Data.Monoid
+import Control.Monad.Trans.Class
 import qualified Data.Map as Map
-import Text.Printf
-
-import Rahm.Desktop.Swallow
-import Rahm.Desktop.Marking
+import Data.Monoid
 import Rahm.Desktop.Common
-import Rahm.Desktop.XMobarLog
+import Rahm.Desktop.DMenu (menuCommandString)
+import Rahm.Desktop.History
+import Rahm.Desktop.Hooks.WindowChange
 import Rahm.Desktop.Keys
 import Rahm.Desktop.Layout
 import Rahm.Desktop.Logger
-import Rahm.Desktop.DMenu (menuCommandString)
+import Rahm.Desktop.Marking
 import Rahm.Desktop.RebindKeys
-import Rahm.Desktop.Hooks.WindowChange
-import Rahm.Desktop.History
-
-import qualified XMonad as X
 import qualified Rahm.Desktop.StackSet as W
+import Rahm.Desktop.Swallow
+import Rahm.Desktop.XMobarLog
+import System.Directory (getHomeDirectory)
+import System.Environment (setEnv)
+import System.FilePath ((</>))
+import Text.Printf
+import XMonad
+import qualified XMonad as X
+import XMonad.Hooks.DynamicProperty
+import XMonad.Hooks.EwmhDesktops (ewmh)
+import XMonad.Hooks.ManageDocks (docks)
+import XMonad.Hooks.ManageHelpers (doFullFloat, isFullscreen)
+import XMonad.Layout.Fullscreen (fullscreenEventHook)
 
 main = do
   putStrLn "Welcome To RDE!"
@@ -41,49 +38,56 @@ main = do
 
   xmobar <- spawnXMobar
 
-  (=<<) X.xmonad $ 
-    applyKeys $ withLocationChangeHook historyHook $ ewmh $ docks $  def
-       { terminal    = "alacritty"
-       , modMask     = mod3Mask
-       , borderWidth = 2
-       , keys = const mempty
-       , focusedBorderColor = "#ff6c00"
-       , normalBorderColor = "#404040"
-       , layoutHook = myLayout
-       , startupHook = spawn fp
-       , manageHook = composeAll [
-           isFullscreen --> doFullFloat
-         , doLogWindow
-         , className =? "Tilda" --> doFloat
-         , className =? "yakuake" --> doFloat
-         , className =? "MPlayer" --> doFloat
-         , title =? "Event Tester" --> doFloat
-         , title =? "Floating Term" --> doCenterFloat
-         , title =? "Notes" --> doCenterFloat
-         , title =? "xmessage" --> doCenterFloat
-         , title =? "gxmessage" --> doCenterFloat
-         , title =? "Volume Control" --> doCenterFloat
-         , className =? "mpv" --> doFloat
-         , className =? "gnubby_ssh_prompt" --> doFloat
-         ]
-         -- This config uses dynamic workspaces, but I have to seed XMonad
-         -- with something. However, this configuration only supports 36
-         -- monitors on boot. If you need more than 36 monitors, you'll have to
-         -- configure those ones after starting XMonad.
-       , workspaces = map return (['0'..'9'] ++ ['a'..'z'])
-       , handleEventHook =
-           composeAll [
-             fullscreenEventHook,
-             remapHook,
-             swallowHook,
-             dynamicTitle (composeAll [
-              title =? "Spotify" --> doMarkWindow "s"
-              ])]
-       , focusFollowsMouse = False
-       , clickJustFocuses = False
-       , logHook = xMobarLogHook xmobar
-       }
-
+  (=<<) X.xmonad $
+    applyKeys $
+      withLocationChangeHook historyHook $
+        ewmh $
+          docks $
+            def
+              { terminal = "alacritty",
+                modMask = mod3Mask,
+                borderWidth = 2,
+                keys = const mempty,
+                focusedBorderColor = "#ff6c00",
+                normalBorderColor = "#404040",
+                layoutHook = myLayout,
+                startupHook = spawn fp,
+                manageHook =
+                  composeAll
+                    [ isFullscreen --> doFullFloat,
+                      doLogWindow,
+                      className =? "Tilda" --> doFloat,
+                      className =? "yakuake" --> doFloat,
+                      className =? "MPlayer" --> doFloat,
+                      title =? "Event Tester" --> doFloat,
+                      title =? "Floating Term" --> doCenterFloat,
+                      title =? "Notes" --> doCenterFloat,
+                      title =? "xmessage" --> doCenterFloat,
+                      title =? "gxmessage" --> doCenterFloat,
+                      title =? "Volume Control" --> doCenterFloat,
+                      className =? "mpv" --> doFloat,
+                      className =? "gnubby_ssh_prompt" --> doFloat
+                    ],
+                -- This config uses dynamic workspaces, but I have to seed XMonad
+                -- with something. However, this configuration only supports 36
+                -- monitors on boot. If you need more than 36 monitors, you'll have to
+                -- configure those ones after starting XMonad.
+                workspaces = map return (['0' .. '9'] ++ ['a' .. 'z']),
+                handleEventHook =
+                  composeAll
+                    [ fullscreenEventHook,
+                      remapHook,
+                      swallowHook,
+                      dynamicTitle
+                        ( composeAll
+                            [ title =? "Spotify" --> doMarkWindow "s"
+                            ]
+                        )
+                    ],
+                focusFollowsMouse = False,
+                clickJustFocuses = False,
+                logHook = xMobarLogHook xmobar
+              }
 
 changeHook :: Location -> Location -> X ()
 changeHook l1 l2 =
@@ -98,9 +102,16 @@ doLogWindow = do
   return (Endo id)
 
 doMarkWindow :: Mark -> ManageHook
-doMarkWindow m = ask >>= (\w -> liftX (do
-  ws <- getCurrentWorkspace
-  markAllLocations m [Location ws (Just w)]) >> return (Endo id))
+doMarkWindow m =
+  ask
+    >>= ( \w ->
+            liftX
+              ( do
+                  ws <- getCurrentWorkspace
+                  markAllLocations m [Location ws (Just w)]
+              )
+              >> return (Endo id)
+        )
 
 doCenterFloat :: ManageHook
 doCenterFloat =
@@ -109,14 +120,11 @@ doCenterFloat =
 centerRect :: W.RationalRect -> W.RationalRect
 centerRect (W.RationalRect x y w h) = W.RationalRect ((1 - w) / 2) ((1 - h) / 2) w h
 
-
 windowHooks :: WindowHook -> XConfig l -> XConfig l
 windowHooks (Query readerT) config = do
-
-  config {
-    startupHook = do
-      withWindowSet $ mapM_ (runReaderT readerT) . W.allWindows
-      startupHook config,
-
-    manageHook = mappend (Query readerT >> return (Endo id)) (manageHook config)
-  }
+  config
+    { startupHook = do
+        withWindowSet $ mapM_ (runReaderT readerT) . W.allWindows
+        startupHook config,
+      manageHook = mappend (Query readerT >> return (Endo id)) (manageHook config)
+    }
diff --git a/src/Rahm/Desktop/Common.hs b/src/Rahm/Desktop/Common.hs
index 3e6d54c..e012a8f 100644
--- a/src/Rahm/Desktop/Common.hs
+++ b/src/Rahm/Desktop/Common.hs
@@ -1,59 +1,61 @@
 module Rahm.Desktop.Common where
 
-import Prelude hiding ((!!))
-
-import Control.Monad (void, when, forM_)
+import Control.Monad (forM_, void, when)
 import Control.Monad.Trans.Maybe
-import XMonad.Util.Run
-import XMonad.Prompt
-import XMonad.Prompt.Input
-import XMonad.Prompt.Shell
-import XMonad.Util.XUtils
-
-import Rahm.Desktop.PromptConfig
-
 import Data.Char
 import Data.List hiding ((!!))
 import Data.List.Safe ((!!))
-import Data.Maybe
-import Text.Printf
-import XMonad hiding (workspaces, Screen)
 import qualified Data.Map as Map
-import Rahm.Desktop.DMenu
+import Data.Maybe
 import Data.Ord (comparing)
-
+import Rahm.Desktop.DMenu
+import Rahm.Desktop.PromptConfig
 import qualified Rahm.Desktop.StackSet as S
+import Text.Printf
+import XMonad hiding (Screen, workspaces)
+import XMonad.Prompt
+import XMonad.Prompt.Input
+import XMonad.Prompt.Shell
+import XMonad.Util.Run
+import XMonad.Util.XUtils
+import Prelude hiding ((!!))
 
 -- A location is a workspace and maybe a window with that workspace.
-data Location = Location {
-    locationWorkspace :: WorkspaceId,
+data Location = Location
+  { locationWorkspace :: WorkspaceId,
     locationWindow :: Maybe Window
-  } deriving (Read, Show, Eq, Ord)
+  }
+  deriving (Read, Show, Eq, Ord)
 
 focusLocation :: Location -> X ()
 focusLocation (Location ws Nothing) = windows $ S.greedyView ws
 focusLocation (Location _ (Just win)) = windows $ S.focusWindow win
 
 masterWindow :: MaybeT X Window
-masterWindow = MaybeT $ withWindowSet $ \ss ->
-  let windows = (S.integrate' . S.stack . S.workspace . S.current) ss
-    in case windows of
-      (a:_) -> return $ Just a
-      _ -> return Nothing
+masterWindow = MaybeT $
+  withWindowSet $ \ss ->
+    let windows = (S.integrate' . S.stack . S.workspace . S.current) ss
+     in case windows of
+          (a : _) -> return $ Just a
+          _ -> return Nothing
 
 windowsInWorkspace :: WorkspaceId -> X [Location]
 windowsInWorkspace wid =
   withWindowSet $
-    return . concatMap (\ws ->
-      if S.tag ws == wid
-        then map (Location wid . Just) $ S.integrate' (S.stack ws)
-        else []) . S.workspaces
+    return
+      . concatMap
+        ( \ws ->
+            if S.tag ws == wid
+              then map (Location wid . Just) $ S.integrate' (S.stack ws)
+              else []
+        )
+      . S.workspaces
 
 data WinPrompt = WinPrompt
 
 instance XPrompt WinPrompt where
-    showXPrompt _ = "[Window] "
-    commandToComplete _ = id
+  showXPrompt _ = "[Window] "
+  commandToComplete _ = id
 
 getString :: Window -> X String
 getString = runQuery $ do
@@ -107,7 +109,7 @@ withBorderWidth width ws fn = do
   forM_ ws $ \window ->
     io $ setWindowBorderWidth d window $ fromIntegral width
 
-  ret <- fn 
+  ret <- fn
 
   forM_ ws $ \window ->
     io $ setWindowBorderWidth d window 2
@@ -119,7 +121,7 @@ withBorderWidth width ws fn = do
 gotoWorkspace :: WorkspaceId -> X ()
 gotoWorkspace wid = windows $ S.greedyView wid
 
-moveLocationToWorkspace :: Location -> WorkspaceId ->  X ()
+moveLocationToWorkspace :: Location -> WorkspaceId -> X ()
 moveLocationToWorkspace (Location _ (Just win)) wid =
   windows $ S.shiftWin wid win
 moveLocationToWorkspace _ _ = return ()
@@ -136,4 +138,4 @@ getCurrentLocation = do
   return (Location ws win)
 
 runMaybeT_ :: (Monad m) => MaybeT m a -> m ()
-runMaybeT_  = void . runMaybeT
+runMaybeT_ = void . runMaybeT
diff --git a/src/Rahm/Desktop/DMenu.hs b/src/Rahm/Desktop/DMenu.hs
index d20d001..eeb0d5f 100644
--- a/src/Rahm/Desktop/DMenu.hs
+++ b/src/Rahm/Desktop/DMenu.hs
@@ -1,19 +1,20 @@
 module Rahm.Desktop.DMenu where
 
-import XMonad.Util.Dmenu
-import XMonad
 import Control.Monad
+import Data.List (intercalate)
 import Data.Map (Map)
 import qualified Data.Map as Map
-import XMonad.Util.Run
-import Data.List (intercalate)
 import Text.Printf (printf)
+import XMonad
+import XMonad.Util.Dmenu
+import XMonad.Util.Run
 
-data Colors =
-  Colors {
-    fg :: String,
-    bg :: String
-  }  | DefaultColors
+data Colors
+  = Colors
+      { fg :: String,
+        bg :: String
+      }
+  | DefaultColors
 
 menuCommand :: [String]
 menuCommand = ["rofi", "-monitor", "-4", "-i", "-dmenu", "-sort", "-levenshtein-sort"]
@@ -22,24 +23,37 @@ menuCommandString :: String
 menuCommandString = unwords menuCommand
 
 runDMenu :: X ()
-runDMenu = void $
-  safeSpawn
-    "rofi"
-    ["-monitor", "-4", "-display-run", "Execute", "-show", "run"]
+runDMenu =
+  void $
+    safeSpawn
+      "rofi"
+      ["-monitor", "-4", "-display-run", "Execute", "-show", "run"]
 
 runDMenuPrompt :: String -> Maybe String -> [String] -> X String
 runDMenuPrompt prompt color select =
   let realColor = maybe [] (\c -> ["-sb", c, "-nf", c]) color
-       in
-    runProcessWithInput "/home/rahm/.local/bin/dmenu_debug.sh" ([
-      "-p", prompt,
-      "-l", "12",
-      "-dim", "0.4" ]  ++ realColor) (intercalate "\n" select)
-
+   in runProcessWithInput
+        "/home/rahm/.local/bin/dmenu_debug.sh"
+        ( [ "-p",
+            prompt,
+            "-l",
+            "12",
+            "-dim",
+            "0.4"
+          ]
+            ++ realColor
+        )
+        (intercalate "\n" select)
 
 runDMenuPromptWithMap :: String -> Maybe String -> Map String a -> X (Maybe a)
 runDMenuPromptWithMap prompt color map = do
-  let realColor = maybe [] (
-          \c -> ["-theme-str", printf "* {theme-color: %s;}" c]) color
-  menuMapArgs (head menuCommand)
-    (tail menuCommand ++ ["-p", prompt] ++ realColor) map
+  let realColor =
+        maybe
+          []
+          ( \c -> ["-theme-str", printf "* {theme-color: %s;}" c]
+          )
+          color
+  menuMapArgs
+    (head menuCommand)
+    (tail menuCommand ++ ["-p", prompt] ++ realColor)
+    map
diff --git a/src/Rahm/Desktop/Desktop.hs b/src/Rahm/Desktop/Desktop.hs
index 053b330..5466fd1 100644
--- a/src/Rahm/Desktop/Desktop.hs
+++ b/src/Rahm/Desktop/Desktop.hs
@@ -4,22 +4,24 @@ module Rahm.Desktop.Desktop where
 -- state of the current screen -> workspace and thus restore it.
 
 -- import XMonad.Operations
-import Data.Maybe (fromMaybe)
+
 import Control.Monad (forM_)
-import XMonad (X(..))
-import qualified XMonad.StackSet as W
-import qualified XMonad as X
+import Data.Default
 import Data.Map (Map)
 import qualified Data.Map as Map
-import Data.Default
+import Data.Maybe (fromMaybe)
+import XMonad (X (..))
+import qualified XMonad as X
+import qualified XMonad.StackSet as W
 import qualified XMonad.Util.ExtensibleState as XS
 
 newtype Desktop si wi = Desktop (Map si wi)
   deriving (Read, Show)
 
-newtype Desktops = Desktops {
-  theaters :: Map String (Desktop X.ScreenId X.WorkspaceId)
-} deriving (Read, Show)
+newtype Desktops = Desktops
+  { theaters :: Map String (Desktop X.ScreenId X.WorkspaceId)
+  }
+  deriving (Read, Show)
 
 instance Default Desktops where
   def = Desktops mempty
@@ -32,9 +34,11 @@ saveCurrentDesktop :: String -> X ()
 saveCurrentDesktop name =
   X.withWindowSet $ \windowSet ->
     XS.modify $ \(Desktops m) ->
-      Desktops $ flip (Map.insert name) m $
-        Desktop $ Map.fromList $
-          map (\(W.Screen ws sid _) -> (sid, W.tag ws)) $ W.screens windowSet  
+      Desktops $
+        flip (Map.insert name) m $
+          Desktop $
+            Map.fromList $
+              map (\(W.Screen ws sid _) -> (sid, W.tag ws)) $ W.screens windowSet
 
 restoreDesktop :: String -> X ()
 restoreDesktop name = do
@@ -47,7 +51,7 @@ restoreDesktop name = do
             fromMaybe scr $ do
               wid <- Map.lookup (W.screen scr) screenToWorkspace
               workspace <- Map.lookup wid workspacesById
-              return $ scr { W.workspace = workspace }
+              return $ scr {W.workspace = workspace}
 
           newScreens = map newScreenWorkspace (cur : vis)
           newVisibleWorkspaces = map (W.tag . W.workspace) newScreens
@@ -55,6 +59,5 @@ restoreDesktop name = do
             filter (\ws -> not (W.tag ws `elem` newVisibleWorkspaces)) $
               W.workspaces ws
 
-          (newCur:newVisible) = newScreens
-        in
-          W.StackSet newCur newVisible newHiddenWorkspaces float
+          (newCur : newVisible) = newScreens
+       in W.StackSet newCur newVisible newHiddenWorkspaces float
diff --git a/src/Rahm/Desktop/Hash.hs b/src/Rahm/Desktop/Hash.hs
index dc58d96..abce660 100644
--- a/src/Rahm/Desktop/Hash.hs
+++ b/src/Rahm/Desktop/Hash.hs
@@ -1,11 +1,12 @@
 {-# LANGUAGE OverloadedStrings #-}
+
 module Rahm.Desktop.Hash where
 
-import Numeric (showHex)
+import qualified Crypto.Hash.SHA1 as SHA1
 import qualified Data.ByteString as BS
 import qualified Data.ByteString.Char8 as BC
-import qualified Crypto.Hash.SHA1 as SHA1
+import Numeric (showHex)
 
 quickHash :: String -> String
 quickHash str =
-    concatMap (`showHex` "") $ BS.unpack (SHA1.hash $ BC.pack str)
+  concatMap (`showHex` "") $ BS.unpack (SHA1.hash $ BC.pack str)
diff --git a/src/Rahm/Desktop/History.hs b/src/Rahm/Desktop/History.hs
index 516cd94..c5bc72d 100644
--- a/src/Rahm/Desktop/History.hs
+++ b/src/Rahm/Desktop/History.hs
@@ -1,19 +1,18 @@
 module Rahm.Desktop.History where
 
-import XMonad
-import Text.Printf
-import qualified Rahm.Desktop.StackSet as W
-import Data.IntMap (IntMap)
-import qualified Data.IntMap as IntMap
 import Data.Default
-import qualified XMonad.Util.ExtensibleState as XS
-
 import Data.Foldable (toList)
-import Rahm.Desktop.Hooks.WindowChange
+import Data.IntMap (IntMap)
+import qualified Data.IntMap as IntMap
+import Data.Sequence (Seq (..))
+import qualified Data.Sequence as Seq
 import Rahm.Desktop.Common
+import Rahm.Desktop.Hooks.WindowChange
 import Rahm.Desktop.Logger
-import Data.Sequence (Seq(..))
-import qualified Data.Sequence as Seq
+import qualified Rahm.Desktop.StackSet as W
+import Text.Printf
+import XMonad
+import qualified XMonad.Util.ExtensibleState as XS
 
 data BoundedSeqZipper a = BoundedSeqZipper Int (Seq a) (Seq a)
   deriving (Eq, Show, Ord, Read)
@@ -24,15 +23,15 @@ instance Functor BoundedSeqZipper where
 zipperDbgPrint :: (Show a) => BoundedSeqZipper a -> String
 zipperDbgPrint (BoundedSeqZipper _ h (c :<| t)) =
   concat $
-    map (printf " %s " . show) (toList h) ++
-    [printf "[%s]" (show c)] ++
-    map (printf " %s " . show) (toList t)
+    map (printf " %s " . show) (toList h)
+      ++ [printf "[%s]" (show c)]
+      ++ map (printf " %s " . show) (toList t)
 zipperDbgPrint _ = "<empty>"
 
 pushZipper :: a -> BoundedSeqZipper a -> BoundedSeqZipper a
 pushZipper e (BoundedSeqZipper maxSize _ (tail :|> _))
-    | maxSize <= Seq.length tail =
-  BoundedSeqZipper maxSize mempty (e :<| tail)
+  | maxSize <= Seq.length tail =
+    BoundedSeqZipper maxSize mempty (e :<| tail)
 pushZipper e (BoundedSeqZipper maxSize _ tail) =
   BoundedSeqZipper maxSize mempty (e :<| tail)
 
@@ -48,16 +47,18 @@ zipperForward :: BoundedSeqZipper a -> BoundedSeqZipper a
 zipperForward (BoundedSeqZipper s (e :<| h) t) = BoundedSeqZipper s h (e :<| t)
 zipperForward b = b
 
-newtype History = History {
-  currentZipper :: BoundedSeqZipper Location
-} deriving (Read, Show)
+newtype History = History
+  { currentZipper :: BoundedSeqZipper Location
+  }
+  deriving (Read, Show)
 
 instance Default History where
   def = History (BoundedSeqZipper 1000 mempty mempty)
 
 instance ExtensionClass History where
   initialValue = def
-  -- extensionType = PersistentExtension
+
+-- extensionType = PersistentExtension
 
 pastHistory :: Int -> X (Maybe Location)
 pastHistory i = do
@@ -72,7 +73,6 @@ getMostRecentLocationInHistory = do
     (BoundedSeqZipper _ _ (t :<| _)) -> return $ Just t
     _ -> return Nothing
 
-
 historyBack :: X ()
 historyBack = do
   History z <- XS.get
@@ -101,5 +101,4 @@ historyHook Nothing loc =
   XS.modify $ \(History z) -> History (pushZipper loc z)
 historyHook (Just (Location ws _)) l@(Location ws' _) | ws /= ws' = do
   XS.modify $ \(History z) -> History (pushZipper l z)
-
 historyHook _ _ = return ()
diff --git a/src/Rahm/Desktop/Hooks/WindowChange.hs b/src/Rahm/Desktop/Hooks/WindowChange.hs
index 3bc66a4..092fbf4 100644
--- a/src/Rahm/Desktop/Hooks/WindowChange.hs
+++ b/src/Rahm/Desktop/Hooks/WindowChange.hs
@@ -1,12 +1,11 @@
 module Rahm.Desktop.Hooks.WindowChange where
 
-import XMonad
 import Control.Monad
-import qualified XMonad.Util.ExtensibleState as XS
 import Data.Default
 import Rahm.Desktop.Common
-
 import qualified Rahm.Desktop.StackSet as W
+import XMonad
+import qualified XMonad.Util.ExtensibleState as XS
 
 newtype LastLocation = LastLocation (Maybe Location)
   deriving (Read, Show)
@@ -17,7 +16,7 @@ instance Default LastLocation where
 instance ExtensionClass LastLocation where
   initialValue = def
   extensionType = PersistentExtension
-  
+
 -- Creates a log hook from the function provided.
 --
 -- The first argument to the function is the old window, the second argument in
@@ -26,18 +25,18 @@ instance ExtensionClass LastLocation where
 -- If the first window is Nothing, this is the first time XMonad started.
 withLocationChangeHook :: (Maybe Location -> Location -> X ()) -> XConfig l -> XConfig l
 withLocationChangeHook fn config =
-  config {
-    logHook = do
-      logHook config
+  config
+    { logHook = do
+        logHook config
 
-      currentLocation <-
-        Location <$> getCurrentWorkspace <*> withWindowSet (return . W.peek)
+        currentLocation <-
+          Location <$> getCurrentWorkspace <*> withWindowSet (return . W.peek)
 
-      LastLocation last <- XS.get
+        LastLocation last <- XS.get
 
-      when (last /= Just currentLocation) $
-        fn last currentLocation
+        when (last /= Just currentLocation) $
+          fn last currentLocation
 
-      XS.put $ LastLocation $ Just currentLocation
-      return ()
-  }
+        XS.put $ LastLocation $ Just currentLocation
+        return ()
+    }
diff --git a/src/Rahm/Desktop/Keys.hs b/src/Rahm/Desktop/Keys.hs
index eae1c34..0ab868f 100644
--- a/src/Rahm/Desktop/Keys.hs
+++ b/src/Rahm/Desktop/Keys.hs
@@ -1,78 +1,75 @@
 module Rahm.Desktop.Keys (applyKeys) where
 
-import Control.Monad.Trans.Maybe
 import Control.Applicative
 import Control.Monad
 import Control.Monad.Fix (fix)
 import Control.Monad.Loops (iterateWhile)
 import Control.Monad.Reader
 import Control.Monad.Trans.Class
+import Control.Monad.Trans.Maybe
 import Control.Monad.Writer
 import Data.Char
 import Data.List hiding ((!!))
 import Data.List.Safe ((!!))
 import Data.Map (Map)
-import Data.Maybe (isJust, fromMaybe, mapMaybe)
-import Data.Monoid (Endo(..))
+import qualified Data.Map as Map
+import Data.Maybe (fromMaybe, isJust, mapMaybe)
+import Data.Monoid (Endo (..))
 import Data.Proxy
 import Debug.Trace
-import Graphics.X11.ExtraTypes.XF86;
+import Graphics.X11.ExtraTypes.XF86
 import Graphics.X11.ExtraTypes.XorgDefault
-import Prelude hiding ((!!))
-import System.IO
-import System.Process
-import Text.Printf
-import XMonad
-import XMonad.Actions.CopyWindow as CopyWindow
-import XMonad.Actions.RotSlaves
-import XMonad.Actions.SpawnOn as SpawnOn
-import XMonad.Actions.WindowNavigation
-import XMonad.Hooks.ManageDocks
-import XMonad.Layout.MosaicAlt
-import XMonad.Layout.Spacing
-import XMonad.Prompt
-import XMonad.Prompt.Input
-import XMonad.Prompt.Shell
-import XMonad.Util.XUtils
-import XMonad.Util.CustomKeys
-import XMonad.Util.Run (safeSpawn)
-import XMonad.Util.Scratchpad
-import XMonad.Util.Ungrab
 import Prettyprinter
-
-import qualified Data.Map as Map
-
+import Rahm.Desktop.Common
 import Rahm.Desktop.DMenu
+import Rahm.Desktop.Desktop
+import Rahm.Desktop.History
 import Rahm.Desktop.Keys.Dsl
+import Rahm.Desktop.Keys.Wml
 import Rahm.Desktop.Layout
 import Rahm.Desktop.Layout.Bordering
 import Rahm.Desktop.Layout.ConsistentMosaic
 import Rahm.Desktop.Layout.Flip (flipHorizontally, flipVertically)
 import Rahm.Desktop.Layout.Hole (toggleHole)
-import Rahm.Desktop.Layout.List (toNextLayout, toPreviousLayout, toFirstLayout, toIndexedLayout)
+import Rahm.Desktop.Layout.List (toFirstLayout, toIndexedLayout, toNextLayout, toPreviousLayout)
 import Rahm.Desktop.Layout.Pop (togglePop)
 import Rahm.Desktop.Layout.Rotate (rotateLayout)
-import Rahm.Desktop.Common
 import Rahm.Desktop.Logger
 import Rahm.Desktop.Marking
-import Rahm.Desktop.Keys.Wml
 import Rahm.Desktop.MouseMotion
 import Rahm.Desktop.PassMenu
 import Rahm.Desktop.PromptConfig
 import Rahm.Desktop.RebindKeys
+import qualified Rahm.Desktop.StackSet as W
 import Rahm.Desktop.Submap
 import Rahm.Desktop.Swallow
 import Rahm.Desktop.SwapMaster (swapMaster)
-import Rahm.Desktop.Workspaces
-import Rahm.Desktop.Desktop
 import Rahm.Desktop.Theater
-
-import qualified Rahm.Desktop.StackSet as W
-import Rahm.Desktop.History
+import Rahm.Desktop.Workspaces
+import System.IO
+import System.Process
+import Text.Printf
+import XMonad
+import XMonad.Actions.CopyWindow as CopyWindow
+import XMonad.Actions.RotSlaves
+import XMonad.Actions.SpawnOn as SpawnOn
+import XMonad.Actions.WindowNavigation
+import XMonad.Hooks.ManageDocks
+import XMonad.Layout.MosaicAlt
+import XMonad.Layout.Spacing
+import XMonad.Prompt
+import XMonad.Prompt.Input
+import XMonad.Prompt.Shell
+import XMonad.Util.CustomKeys
+import XMonad.Util.Run (safeSpawn)
+import XMonad.Util.Scratchpad
+import XMonad.Util.Ungrab
+import XMonad.Util.XUtils
+import Prelude hiding ((!!))
 
 type KeyMap l = XConfig l -> Map (KeyMask, KeySym) (X ())
-type ButtonsMap l = XConfig l -> Map (KeyMask, Button) (Window -> X ())
 
+type ButtonsMap l = XConfig l -> Map (KeyMask, Button) (Window -> X ())
 
 spawnX :: String -> X ()
 spawnX = spawn