1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
module Rahm.Desktop.Layout.Layout where
import GHC.TypeLits
import Data.Proxy (Proxy(..))
import Control.Arrow (second)
import XMonad.Hooks.ManageDocks
import XMonad.Layout.Circle
import XMonad.Layout.Accordion
import Control.Applicative
import XMonad.Layout.Spacing
import Data.List
import XMonad.Layout.Spiral
import XMonad.Layout.ThreeColumns
import XMonad.Layout.Grid
import XMonad.Layout.Dishes
import XMonad.Layout.MosaicAlt
import XMonad.Layout.Fullscreen
import qualified XMonad.Layout.Dwindle as D
import XMonad.Layout
import XMonad.Layout.LayoutModifier
import XMonad
import XMonad.Core
import XMonad.Layout.NoBorders (smartBorders, noBorders)
import Rahm.Desktop.Layout.CornerLayout (Corner(..))
import Rahm.Desktop.Layout.LayoutList
import Rahm.Desktop.Windows
import Rahm.Desktop.Layout.ReinterpretMessage
import Rahm.Desktop.Layout.Pop
import Rahm.Desktop.Layout.Flip
import qualified Data.Map as M
import qualified XMonad.StackSet as W
myLayout =
fullscreenFull $
avoidStruts $
spacingRaw True (Border 5 5 5 5) True (Border 5 5 5 5) True $
layoutZipper $
mods (reinterpretIncMaster $ spiral (6/7)) |:
mods (modifyMosaic (MosaicAlt M.empty :: MosaicAlt Window)) |:
mods (reinterpretIncMaster $ Corner (3/4) (3/100)) |:
mods (ModifyDescription TallDescriptionModifier (Tall 1 (3/100) (1/2))) |:
mods (ModifyDescription ThreeColDescMod (ThreeCol 1 (3/100) (1/2))) |:
mods Grid |:
mods (Dishes 2 (1/6)) |:
mods (reinterpretIncMaster $ D.Dwindle D.R D.CW 1.5 1.1) |:
nil
-- Mosaic doesn't have the concept of a "Master Space", so reinterpret messages
-- intended to modify the master space and instead have those messages expand
-- and shrink the current window.
--
-- "ForMosaic" is an instance of the Symbol kind. This is some neat type-system
-- hacking one can do in Haskell.
instance DoReinterpret "ForMosaic" where
-- IncMaster message
reinterpretMessage _ (fromMessage -> Just (IncMasterN n)) = do
fmap (SomeMessage .
(if n > 0
then expandWindowAlt
else shrinkWindowAlt)) <$> getFocusedWindow
-- ResizeMaster message
reinterpretMessage _ (fromMessage -> Just m) = do
fmap (SomeMessage .
(case m of
Expand -> expandWindowAlt
Shrink -> shrinkWindowAlt)) <$> getFocusedWindow
-- Messages that don't match the above, just leave it unmodified.
reinterpretMessage _ m = return (Just m)
instance DoReinterpret "IncMasterToResizeMaster" where
reinterpretMessage _ (fromMessage -> Just (IncMasterN n)) =
return $ Just $
if n > 0
then SomeMessage Expand
else SomeMessage Shrink
reinterpretMessage _ m = return (Just m)
modifyMosaic :: l a -> ModifiedLayout (ReinterpretMessage "ForMosaic") l a
modifyMosaic = ModifiedLayout ReinterpretMessage
reinterpretIncMaster ::
l a -> ModifiedLayout (ReinterpretMessage "IncMasterToResizeMaster") l a
reinterpretIncMaster = ModifiedLayout ReinterpretMessage
mods =
reinterpretResize .
poppable .
flippable .
ModifiedLayout (Rotateable False)
data ModifyDescription m l a = ModifyDescription m (l a)
deriving (Show, Read)
data TallDescriptionModifier = TallDescriptionModifier
deriving (Show, Read)
data ThreeColDescMod = ThreeColDescMod
deriving (Show, Read)
class DescriptionModifier m l where
newDescription :: m -> l a -> String -> String
instance (Typeable m, Show m, DescriptionModifier m l, LayoutClass l a) => LayoutClass (ModifyDescription m l) a where
runLayout (W.Workspace t (ModifyDescription m l) a) rect = do
(rects, maybeNewLayout) <- runLayout (W.Workspace t l a) rect
return (rects, fmap (ModifyDescription m) maybeNewLayout)
doLayout (ModifyDescription m l) a s = do
(rects, maybeNewLayout) <- doLayout l a s
return (rects, fmap (ModifyDescription m) maybeNewLayout)
pureLayout (ModifyDescription m l) a s = pureLayout l a s
emptyLayout (ModifyDescription m l) a = do
(rects, maybeNewLayout) <- emptyLayout l a
return (rects, fmap (ModifyDescription m) maybeNewLayout)
handleMessage (ModifyDescription m l) a = do
maybeNewLayout <- handleMessage l a
return (ModifyDescription m <$> maybeNewLayout)
pureMessage (ModifyDescription m l) a =
let maybeNewLayout = pureMessage l a in
ModifyDescription m <$> maybeNewLayout
description (ModifyDescription m l) = newDescription m l (description l)
instance DescriptionModifier TallDescriptionModifier Tall where
newDescription _ (Tall mast _ _) _ = "Tall(" ++ show mast ++ ")"
instance DescriptionModifier ThreeColDescMod ThreeCol where
newDescription _ (ThreeCol mast _ _) _ = "ThreeCol(" ++ show mast ++ ")"
newDescription _ (ThreeColMid mast _ _) _ = "ThreeColMid(" ++ show mast ++ ")"
newtype Rotateable a = Rotateable Bool -- True if rotated
deriving (Show, Read)
data DoRotate = DoRotate deriving (Typeable)
instance Message DoRotate where
instance (Eq a) => LayoutModifier Rotateable a where
pureModifier (Rotateable rotate) (Rectangle x' y' sw sh) _ returned =
if rotate
then (map (second (unzero . scaleRect . mirrorRect . zero)) returned, Nothing)
else (returned, Nothing)
where
zero (Rectangle x y w h) = Rectangle (x - x') (y - y') w h
unzero (Rectangle x y w h) = Rectangle (x + x') (y + y') w h
scaleRect (Rectangle x y w h) =
Rectangle (x * fi sw `div` fi sh)
(y * fi sh `div` fi sw)
(w * sw `div` sh)
(h * sh `div` sw)
fi = fromIntegral
pureMess (Rotateable rot) mess =
fmap (\DoRotate -> Rotateable (not rot)) (fromMessage mess)
modifyDescription (Rotateable rot) underlying =
let descr = description underlying in
if rot
then descr ++ " Rotated"
else descr
|
