xmonad-contrib-0.13: Third party extensions for xmonad

Copyright | (c) 2010 Audun Skaugen
License | BSD-style (see xmonad/LICENSE)
Maintainer | audunskaugen@gmail.com
Stability | unstable
Portability | unportable
Safe Haskell | None
Language | Haskell98

XMonad.Layout.Fullscreen

Contents

- Usage:
- Types for reference

Description

Hooks for sending messages about fullscreen windows to layouts, and a few example layout modifier that implement fullscreen windows.

Synopsis

- fullscreenSupport :: LayoutClass l Window => XConfig l -> XConfig (ModifiedLayout FullscreenFull l)
- fullscreenFull :: LayoutClass l a => l a -> ModifiedLayout FullscreenFull l a
- fullscreenFocus :: LayoutClass l a => l a -> ModifiedLayout FullscreenFocus l a
- fullscreenFullRect :: LayoutClass l a => RationalRect -> l a -> ModifiedLayout FullscreenFull l a
- fullscreenFocusRect :: LayoutClass l a => RationalRect -> l a -> ModifiedLayout FullscreenFocus l a
- fullscreenFloat :: LayoutClass l a => l a -> ModifiedLayout FullscreenFloat l a
- fullscreenFloatRect :: LayoutClass l a => RationalRect -> l a -> ModifiedLayout FullscreenFloat l a
- fullscreenEventHook :: Event -> X All
- fullscreenManageHook :: ManageHook
- fullscreenManageHookWith :: Query Bool -> ManageHook
- data FullscreenMessage
  - = AddFullscreen Window
  - | RemoveFullscreen Window
  - | FullscreenChanged
- data FullscreenFloat a
- data FullscreenFocus a
- data FullscreenFull a

# Usage:

Provides a ManageHook and an EventHook that sends layout messages with information about fullscreening windows. This allows layouts to make their own decisions about what they should to with a window that requests fullscreen.

The module also includes a few layout modifiers as an illustration of how such layouts should behave.

To use this module, add `fullscreenEventHook` and `fullscreenManageHook` to your config, i.e.

    xmonad def { handleEventHook = fullscreenEventHook,
                 manageHook = fullscreenManageHook,
                 layoutHook = myLayouts }

Now you can use layouts that respect fullscreen, for example the provided `fullscreenFull`:

    myLayouts = fullscreenFull someLayout

fullscreenSupport :: LayoutClass l Window => XConfig l -> XConfig (ModifiedLayout FullscreenFull l) #

Modifies your config to apply basic fullscreen support -- fullscreen windows when they request it. Example usage:

    main = xmonad
         $ fullscreenSupport
         $ defaultConfig { ... }

fullscreenFull :: LayoutClass l a => l a -> ModifiedLayout FullscreenFull l a #

Layout modifier that makes fullscreened window fill the entire screen.

fullscreenFocus :: LayoutClass l a => l a -> ModifiedLayout FullscreenFocus l a #

Layout modifier that makes the fullscreened window fill the entire screen only if it is currently focused.

fullscreenFullRect :: LayoutClass l a => RationalRect -> l a -> ModifiedLayout FullscreenFull l a #

As above, but the fullscreened window will fill the specified rectangle instead of the entire screen.

fullscreenFocusRect :: LayoutClass l a => RationalRect -> l a -> ModifiedLayout FullscreenFocus l a #

As above, but the fullscreened window will fill the specified rectangle instead of the entire screen.

fullscreenFloat :: LayoutClass l a => l a -> ModifiedLayout FullscreenFloat l a #

Hackish layout modifier that makes floating fullscreened windows fill the entire screen.

fullscreenFloatRect :: LayoutClass l a => RationalRect -> l a -> ModifiedLayout FullscreenFloat l a #

As above, but the fullscreened window will fill the specified rectangle instead of the entire screen.

fullscreenEventHook :: Event -> X All #

The event hook required for the layout modifiers to work

fullscreenManageHook :: ManageHook #

Manage hook that sets the fullscreen property for windows that are initially fullscreen

fullscreenManageHookWith :: Query Bool -> ManageHook #

A version of fullscreenManageHook that lets you specify your own query to decide whether a window should be fullscreen.

data FullscreenMessage #

Messages that control the fullscreen state of the window. AddFullscreen and RemoveFullscreen are sent to all layouts when a window wants or no longer wants to be fullscreen. FullscreenChanged is sent to the current layout after one of the above have been sent.

Constructors

AddFullscreen Window |
RemoveFullscreen Window |
FullscreenChanged |

Instances

Message FullscreenMessage # |

# Types for reference

data FullscreenFloat a #

Instances

LayoutModifier FullscreenFloat Window # |

Methods

modifyLayout :: LayoutClass l Window => FullscreenFloat Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => FullscreenFloat Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (FullscreenFloat Window)) #

handleMess :: FullscreenFloat Window -> SomeMessage -> X (Maybe (FullscreenFloat Window)) #

handleMessOrMaybeModifyIt :: FullscreenFloat Window -> SomeMessage -> X (Maybe (Either (FullscreenFloat Window) SomeMessage)) #

pureMess :: FullscreenFloat Window -> SomeMessage -> Maybe (FullscreenFloat Window) #

redoLayout :: FullscreenFloat Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (FullscreenFloat Window)) #

pureModifier :: FullscreenFloat Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (FullscreenFloat Window)) #

hook :: FullscreenFloat Window -> X () #

unhook :: FullscreenFloat Window -> X () #

modifierDescription :: FullscreenFloat Window -> String #

modifyDescription :: LayoutClass l Window => FullscreenFloat Window -> l Window -> String #

(Read a, Ord a) => Read (FullscreenFloat a) # |
Methods readsPrec :: Int -> ReadS (FullscreenFloat a) # readList :: ReadS [FullscreenFloat a] # readPrec :: ReadPrec (FullscreenFloat a) # readListPrec :: ReadPrec [FullscreenFloat a] #
Show a => Show (FullscreenFloat a) # |
Methods showsPrec :: Int -> FullscreenFloat a -> ShowS # show :: FullscreenFloat a -> String # showList :: [FullscreenFloat a] -> ShowS #

data FullscreenFocus a #

Instances

LayoutModifier FullscreenFocus Window # |

Methods

modifyLayout :: LayoutClass l Window => FullscreenFocus Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => FullscreenFocus Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (FullscreenFocus Window)) #

handleMess :: FullscreenFocus Window -> SomeMessage -> X (Maybe (FullscreenFocus Window)) #

handleMessOrMaybeModifyIt :: FullscreenFocus Window -> SomeMessage -> X (Maybe (Either (FullscreenFocus Window) SomeMessage)) #

pureMess :: FullscreenFocus Window -> SomeMessage -> Maybe (FullscreenFocus Window) #

redoLayout :: FullscreenFocus Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (FullscreenFocus Window)) #

pureModifier :: FullscreenFocus Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (FullscreenFocus Window)) #

hook :: FullscreenFocus Window -> X () #

unhook :: FullscreenFocus Window -> X () #

modifierDescription :: FullscreenFocus Window -> String #

modifyDescription :: LayoutClass l Window => FullscreenFocus Window -> l Window -> String #

Read a => Read (FullscreenFocus a) # |
Methods readsPrec :: Int -> ReadS (FullscreenFocus a) # readList :: ReadS [FullscreenFocus a] # readPrec :: ReadPrec (FullscreenFocus a) # readListPrec :: ReadPrec [FullscreenFocus a] #
Show a => Show (FullscreenFocus a) # |
Methods showsPrec :: Int -> FullscreenFocus a -> ShowS # show :: FullscreenFocus a -> String # showList :: [FullscreenFocus a] -> ShowS #

data FullscreenFull a #

Instances

LayoutModifier FullscreenFull Window # |

Methods

modifyLayout :: LayoutClass l Window => FullscreenFull Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => FullscreenFull Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (FullscreenFull Window)) #

handleMess :: FullscreenFull Window -> SomeMessage -> X (Maybe (FullscreenFull Window)) #

handleMessOrMaybeModifyIt :: FullscreenFull Window -> SomeMessage -> X (Maybe (Either (FullscreenFull Window) SomeMessage)) #

pureMess :: FullscreenFull Window -> SomeMessage -> Maybe (FullscreenFull Window) #

redoLayout :: FullscreenFull Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (FullscreenFull Window)) #

pureModifier :: FullscreenFull Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (FullscreenFull Window)) #

hook :: FullscreenFull Window -> X () #

unhook :: FullscreenFull Window -> X () #

modifierDescription :: FullscreenFull Window -> String #

modifyDescription :: LayoutClass l Window => FullscreenFull Window -> l Window -> String #

Read a => Read (FullscreenFull a) # |
Methods readsPrec :: Int -> ReadS (FullscreenFull a) # readList :: ReadS [FullscreenFull a] # readPrec :: ReadPrec (FullscreenFull a) # readListPrec :: ReadPrec [FullscreenFull a] #
Show a => Show (FullscreenFull a) # |
Methods showsPrec :: Int -> FullscreenFull a -> ShowS # show :: FullscreenFull a -> String # showList :: [FullscreenFull a] -> ShowS #