As mentioned in another mail, I'm currently experimenting with handling fullscreening applications in the layout itself, using layout messages. I'll highlight the approach here. First, we'll need a new layout message: data FullscreenMessage = AddFullscreen Window | RemoveFullscreen Window deriving (Typeable) instance Message FullscreenMessage This message will be sent to all layouts when a window requests fullscreen through the _NET_WM_STATE protocol, using a special event hook (resembling the fullscreenEventHook in X.H.EwmhDesktops, but sending messages instead of modifying the window). Also, we'll need a manage hook that sends an AddFullscreen on the window if it starts out with the fullscreen property. Now we can write a simple layout modifier to make the modified layout respect fullscreen: data FullscreenFull a = FullscreenFull [a] deriving (Read, Show) instance LayoutModifier FullscreenFull Window where -- This handler maintains the modifier's list of fullscreen windows pureMess (FullscreenFull fulls) m = case fromMessage m of Just (AddFullscreen win) -> Just $ FullscreenFull $ nub $ win:fulls Just (RemoveFullscreen win) -> Just $ FullscreenFull $ delete win $ fulls Nothing -> Nothing -- All the fullscreened windows should fill the screen, the rest of the windows are left in place pureModifier (FullscreenFull fulls) rect _ list = (zip visfulls (repeat rect) ++ rest, Nothing) where visfulls = intersect fulls $ map fst list rest = [(w,r) | (w,r) <- list, w `notElem` fulls] The advantage of this approach is made clearer by a small variant of the above modifier that only fullscreens the window if it is focused: data FullscreenFocus a = FullscreenFocus [a] deriving (Read, Show) instance LayoutModifier FullscreenFocus Window where -- pureMess like above -- The focused window should fill the screen pureModifier (FullscreenFocus fulls) rect (Just (W.Stack {W.focus = f})) list = (if f `elem` fulls then (f,rect):rest else list, Nothing) where rest = [(w,r) | (w,r) <- list, w /= f] pureModifier _ _ Nothing list = (list, Nothing) You can even toggle between such variants using something like X.L.MultiToggle. There are a few disadvantages to this approach: * Complexity - this is a lot more code than a simple event hook * More configuration - you need to add a manage hook and a layout modifier in addition to the event hook to use this * Floating windows are difficult to handle. I have tried to hack together a layout modifier that would call the X monad in order to fullscreen floating windows, but even if it works it's going to be ugly * Youtube fullscreen won't work with this, unless you add another manage hook like this: className =? "Npviewer.bin" --> doFullFloat I've attached the module I'm currently keeping in my .xmonad/lib directory, implementing all of this. Does anyone have any thoughts about it? -- Audun Skaugen