{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, PatternGuards #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  XMonad.Layout.Tabbed
-- Description :  A tabbed layout.
-- Copyright   :  (c) 2007 David Roundy, Andrea Rossato
-- License     :  BSD-style (see xmonad/LICENSE)
--
-- Maintainer  :  andrea.rossato@unibz.it
-- Stability   :  unstable
-- Portability :  unportable
--
-- A tabbed layout for the Xmonad Window Manager
--
-----------------------------------------------------------------------------

module XMonad.Layout.Tabbed
    ( -- * Usage:
      -- $usage
      simpleTabbed, tabbed, addTabs
    , simpleTabbedAlways, tabbedAlways, addTabsAlways
    , simpleTabbedBottom, tabbedBottom, addTabsBottom
    , simpleTabbedLeft, tabbedLeft, addTabsLeft
    , simpleTabbedRight, tabbedRight, addTabsRight
    , simpleTabbedBottomAlways, tabbedBottomAlways, addTabsBottomAlways
    , simpleTabbedLeftAlways, tabbedLeftAlways, addTabsLeftAlways
    , simpleTabbedRightAlways, tabbedRightAlways, addTabsRightAlways
    , Theme (..)
    , def
    , TabbedDecoration (..)
    , shrinkText, CustomShrink(CustomShrink)
    , Shrinker(..)
    , TabbarShown, Direction2D(..)
    ) where

import XMonad.Prelude

import XMonad
import qualified XMonad.StackSet as S
import XMonad.Layout.Decoration
import XMonad.Layout.Simplest ( Simplest(Simplest) )
import XMonad.Util.Types (Direction2D(..))

-- $usage
-- You can use this module with the following in your @xmonad.hs@:
--
-- > import XMonad.Layout.Tabbed
--
-- Then edit your @layoutHook@ by adding the Tabbed layout:
--
-- > myLayout = simpleTabbed ||| Full ||| etc..
--
-- or, if you want a specific theme for you tabbed layout:
--
-- > myLayout = tabbed shrinkText def ||| Full ||| etc..
--
-- and then:
--
-- > main = xmonad def { layoutHook = myLayout }
--
-- This layout has hardcoded behaviour for mouse clicks on tab decorations:
-- Left click on the tab switches focus to that window.
-- Middle click on the tab closes the window.
--
-- The default Tabbar behaviour is to hide it when only one window is open
-- on the workspace.  To have it always shown, use one of the layouts or
-- modifiers ending in @Always@.
--
-- For more detailed instructions on editing the layoutHook see
-- <https://xmonad.org/TUTORIAL.html#customizing-xmonad the tutorial> and
-- "XMonad.Doc.Extending#Editing_the_layout_hook".
--
-- You can also edit the default configuration options.
--
-- > myTabConfig = def { inactiveBorderColor = "#FF0000"
-- >                   , activeTextColor = "#00FF00"}
--
-- and
--
-- > mylayout = tabbed shrinkText myTabConfig ||| Full ||| etc..

-- Layouts

-- | A tabbed layout with the default xmonad Theme.
--
-- This is a minimal working configuration:
--
-- > import XMonad
-- > import XMonad.Layout.Tabbed
-- > main = xmonad def { layoutHook = simpleTabbed }
simpleTabbed :: ModifiedLayout (Decoration TabbedDecoration DefaultShrinker) Simplest Window
simpleTabbed :: ModifiedLayout
  (Decoration TabbedDecoration DefaultShrinker) Simplest Window
simpleTabbed = DefaultShrinker
-> Theme
-> ModifiedLayout
     (Decoration TabbedDecoration DefaultShrinker) Simplest Window
forall a s.
(Eq a, Shrinker s) =>
s
-> Theme
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbed DefaultShrinker
shrinkText Theme
forall a. Default a => a
def

simpleTabbedAlways :: ModifiedLayout (Decoration TabbedDecoration DefaultShrinker) Simplest Window
simpleTabbedAlways :: ModifiedLayout
  (Decoration TabbedDecoration DefaultShrinker) Simplest Window
simpleTabbedAlways = DefaultShrinker
-> Theme
-> ModifiedLayout
     (Decoration TabbedDecoration DefaultShrinker) Simplest Window
forall a s.
(Eq a, Shrinker s) =>
s
-> Theme
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedAlways DefaultShrinker
shrinkText Theme
forall a. Default a => a
def

-- | A bottom-tabbed layout with the default xmonad Theme.
simpleTabbedBottom :: ModifiedLayout (Decoration TabbedDecoration DefaultShrinker) Simplest Window
simpleTabbedBottom :: ModifiedLayout
  (Decoration TabbedDecoration DefaultShrinker) Simplest Window
simpleTabbedBottom = DefaultShrinker
-> Theme
-> ModifiedLayout
     (Decoration TabbedDecoration DefaultShrinker) Simplest Window
forall a s.
(Eq a, Shrinker s) =>
s
-> Theme
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedBottom DefaultShrinker
shrinkText Theme
forall a. Default a => a
def

-- | A bottom-tabbed layout with the default xmonad Theme.
simpleTabbedBottomAlways :: ModifiedLayout (Decoration TabbedDecoration DefaultShrinker) Simplest Window
simpleTabbedBottomAlways :: ModifiedLayout
  (Decoration TabbedDecoration DefaultShrinker) Simplest Window
simpleTabbedBottomAlways = DefaultShrinker
-> Theme
-> ModifiedLayout
     (Decoration TabbedDecoration DefaultShrinker) Simplest Window
forall a s.
(Eq a, Shrinker s) =>
s
-> Theme
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedBottomAlways DefaultShrinker
shrinkText Theme
forall a. Default a => a
def

-- | A side-tabbed layout with the default xmonad Theme.
simpleTabbedLeft, simpleTabbedRight :: ModifiedLayout (Decoration TabbedDecoration DefaultShrinker)
                                        Simplest Window
simpleTabbedLeft :: ModifiedLayout
  (Decoration TabbedDecoration DefaultShrinker) Simplest Window
simpleTabbedLeft = DefaultShrinker
-> Theme
-> ModifiedLayout
     (Decoration TabbedDecoration DefaultShrinker) Simplest Window
forall a s.
(Eq a, Shrinker s) =>
s
-> Theme
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedLeft DefaultShrinker
shrinkText Theme
forall a. Default a => a
def
simpleTabbedRight :: ModifiedLayout
  (Decoration TabbedDecoration DefaultShrinker) Simplest Window
simpleTabbedRight = DefaultShrinker
-> Theme
-> ModifiedLayout
     (Decoration TabbedDecoration DefaultShrinker) Simplest Window
forall a s.
(Eq a, Shrinker s) =>
s
-> Theme
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedRight DefaultShrinker
shrinkText Theme
forall a. Default a => a
def

-- | A side-tabbed layout with the default xmonad Theme.
simpleTabbedLeftAlways, simpleTabbedRightAlways :: ModifiedLayout (Decoration TabbedDecoration DefaultShrinker)
                                                  Simplest Window
simpleTabbedLeftAlways :: ModifiedLayout
  (Decoration TabbedDecoration DefaultShrinker) Simplest Window
simpleTabbedLeftAlways = DefaultShrinker
-> Theme
-> ModifiedLayout
     (Decoration TabbedDecoration DefaultShrinker) Simplest Window
forall a s.
(Eq a, Shrinker s) =>
s
-> Theme
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedLeftAlways DefaultShrinker
shrinkText Theme
forall a. Default a => a
def
simpleTabbedRightAlways :: ModifiedLayout
  (Decoration TabbedDecoration DefaultShrinker) Simplest Window
simpleTabbedRightAlways = DefaultShrinker
-> Theme
-> ModifiedLayout
     (Decoration TabbedDecoration DefaultShrinker) Simplest Window
forall a s.
(Eq a, Shrinker s) =>
s
-> Theme
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedRightAlways DefaultShrinker
shrinkText Theme
forall a. Default a => a
def

-- | A layout decorated with tabs and the possibility to set a custom
-- shrinker and theme.
tabbed     :: (Eq a, Shrinker s) => s -> Theme
           -> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbed :: forall a s.
(Eq a, Shrinker s) =>
s
-> Theme
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbed s
s Theme
c = s
-> Theme
-> Simplest a
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabs s
s Theme
c Simplest a
forall a. Simplest a
Simplest

tabbedAlways     :: (Eq a, Shrinker s) => s -> Theme
                 -> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedAlways :: forall a s.
(Eq a, Shrinker s) =>
s
-> Theme
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedAlways s
s Theme
c = s
-> Theme
-> Simplest a
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsAlways s
s Theme
c Simplest a
forall a. Simplest a
Simplest

-- | A layout decorated with tabs at the bottom and the possibility to set a custom
-- shrinker and theme.
tabbedBottom     :: (Eq a, Shrinker s) => s -> Theme
                 -> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedBottom :: forall a s.
(Eq a, Shrinker s) =>
s
-> Theme
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedBottom s
s Theme
c = s
-> Theme
-> Simplest a
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsBottom s
s Theme
c Simplest a
forall a. Simplest a
Simplest

tabbedBottomAlways     :: (Eq a, Shrinker s) => s -> Theme
                       -> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedBottomAlways :: forall a s.
(Eq a, Shrinker s) =>
s
-> Theme
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedBottomAlways s
s Theme
c = s
-> Theme
-> Simplest a
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsBottomAlways s
s Theme
c Simplest a
forall a. Simplest a
Simplest

-- | A layout decorated with tabs and the possibility to set a custom
-- shrinker and theme.
tabbedLeft, tabbedRight :: (Eq a, Shrinker s) => s -> Theme
                        -> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedLeft :: forall a s.
(Eq a, Shrinker s) =>
s
-> Theme
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedLeft s
s Theme
c = s
-> Theme
-> Simplest a
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsLeft s
s Theme
c Simplest a
forall a. Simplest a
Simplest
tabbedRight :: forall a s.
(Eq a, Shrinker s) =>
s
-> Theme
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedRight s
s Theme
c = s
-> Theme
-> Simplest a
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsRight s
s Theme
c Simplest a
forall a. Simplest a
Simplest

-- | A layout decorated with tabs and the possibility to set a custom
-- shrinker and theme.
tabbedLeftAlways, tabbedRightAlways :: (Eq a, Shrinker s) => s -> Theme
                                    -> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedLeftAlways :: forall a s.
(Eq a, Shrinker s) =>
s
-> Theme
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedLeftAlways s
s Theme
c = s
-> Theme
-> Simplest a
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsLeftAlways s
s Theme
c Simplest a
forall a. Simplest a
Simplest
tabbedRightAlways :: forall a s.
(Eq a, Shrinker s) =>
s
-> Theme
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
tabbedRightAlways s
s Theme
c = s
-> Theme
-> Simplest a
-> ModifiedLayout (Decoration TabbedDecoration s) Simplest a
forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsRightAlways s
s Theme
c Simplest a
forall a. Simplest a
Simplest

-- Layout Modifiers

-- | A layout modifier that uses the provided shrinker and theme to add tabs to any layout.
addTabs :: (Eq a, LayoutClass l a, Shrinker s) => s -> Theme -> l a
        -> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabs :: forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabs = TabbarShown
-> Direction2D
-> s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
TabbarShown
-> Direction2D
-> s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
createTabs TabbarShown
WhenPlural Direction2D
U

addTabsAlways :: (Eq a, LayoutClass l a, Shrinker s) => s -> Theme -> l a
              -> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsAlways :: forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsAlways = TabbarShown
-> Direction2D
-> s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
TabbarShown
-> Direction2D
-> s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
createTabs TabbarShown
Always Direction2D
U

-- | A layout modifier that uses the provided shrinker and theme to add tabs to the bottom of any layout.
addTabsBottom :: (Eq a, LayoutClass l a, Shrinker s) => s -> Theme -> l a
              -> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsBottom :: forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsBottom = TabbarShown
-> Direction2D
-> s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
TabbarShown
-> Direction2D
-> s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
createTabs TabbarShown
WhenPlural Direction2D
D

addTabsBottomAlways :: (Eq a, LayoutClass l a, Shrinker s) => s -> Theme -> l a
                    -> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsBottomAlways :: forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsBottomAlways = TabbarShown
-> Direction2D
-> s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
TabbarShown
-> Direction2D
-> s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
createTabs TabbarShown
Always Direction2D
D

-- | A layout modifier that uses the provided shrinker and theme to add tabs to the side of any layout.
addTabsRight, addTabsLeft :: (Eq a, LayoutClass l a, Shrinker s) => s -> Theme -> l a
                            -> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsRight :: forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsRight = TabbarShown
-> Direction2D
-> s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
TabbarShown
-> Direction2D
-> s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
createTabs TabbarShown
WhenPlural Direction2D
R
addTabsLeft :: forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsLeft = TabbarShown
-> Direction2D
-> s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
TabbarShown
-> Direction2D
-> s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
createTabs TabbarShown
WhenPlural Direction2D
L

addTabsRightAlways, addTabsLeftAlways :: (Eq a, LayoutClass l a, Shrinker s) => s -> Theme -> l a
                                      -> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsRightAlways :: forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsRightAlways = TabbarShown
-> Direction2D
-> s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
TabbarShown
-> Direction2D
-> s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
createTabs TabbarShown
Always Direction2D
R
addTabsLeftAlways :: forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
addTabsLeftAlways = TabbarShown
-> Direction2D
-> s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
TabbarShown
-> Direction2D
-> s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
createTabs TabbarShown
Always Direction2D
L

-- Tab creation abstractions.  Internal use only.

-- Create tabbar when required at the given location with the given
-- shrinker and theme to the supplied layout.
createTabs                ::(Eq a, LayoutClass l a, Shrinker s) => TabbarShown -> Direction2D -> s
                          -> Theme -> l a -> ModifiedLayout (Decoration TabbedDecoration s) l a

createTabs :: forall a (l :: * -> *) s.
(Eq a, LayoutClass l a, Shrinker s) =>
TabbarShown
-> Direction2D
-> s
-> Theme
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
createTabs TabbarShown
sh Direction2D
loc s
tx Theme
th = s
-> Theme
-> TabbedDecoration a
-> l a
-> ModifiedLayout (Decoration TabbedDecoration s) l a
forall (ds :: * -> *) a s (l :: * -> *).
(DecorationStyle ds a, Shrinker s) =>
s -> Theme -> ds a -> l a -> ModifiedLayout (Decoration ds s) l a
decoration s
tx Theme
th (Direction2D -> TabbarShown -> TabbedDecoration a
forall a. Direction2D -> TabbarShown -> TabbedDecoration a
Tabbed Direction2D
loc TabbarShown
sh)

data TabbarShown = Always | WhenPlural deriving (ReadPrec [TabbarShown]
ReadPrec TabbarShown
Int -> ReadS TabbarShown
ReadS [TabbarShown]
(Int -> ReadS TabbarShown)
-> ReadS [TabbarShown]
-> ReadPrec TabbarShown
-> ReadPrec [TabbarShown]
-> Read TabbarShown
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TabbarShown
readsPrec :: Int -> ReadS TabbarShown
$creadList :: ReadS [TabbarShown]
readList :: ReadS [TabbarShown]
$creadPrec :: ReadPrec TabbarShown
readPrec :: ReadPrec TabbarShown
$creadListPrec :: ReadPrec [TabbarShown]
readListPrec :: ReadPrec [TabbarShown]
Read, Int -> TabbarShown -> ShowS
[TabbarShown] -> ShowS
TabbarShown -> String
(Int -> TabbarShown -> ShowS)
-> (TabbarShown -> String)
-> ([TabbarShown] -> ShowS)
-> Show TabbarShown
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TabbarShown -> ShowS
showsPrec :: Int -> TabbarShown -> ShowS
$cshow :: TabbarShown -> String
show :: TabbarShown -> String
$cshowList :: [TabbarShown] -> ShowS
showList :: [TabbarShown] -> ShowS
Show, TabbarShown -> TabbarShown -> Bool
(TabbarShown -> TabbarShown -> Bool)
-> (TabbarShown -> TabbarShown -> Bool) -> Eq TabbarShown
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TabbarShown -> TabbarShown -> Bool
== :: TabbarShown -> TabbarShown -> Bool
$c/= :: TabbarShown -> TabbarShown -> Bool
/= :: TabbarShown -> TabbarShown -> Bool
Eq)

data TabbedDecoration a = Tabbed Direction2D TabbarShown deriving (ReadPrec [TabbedDecoration a]
ReadPrec (TabbedDecoration a)
Int -> ReadS (TabbedDecoration a)
ReadS [TabbedDecoration a]
(Int -> ReadS (TabbedDecoration a))
-> ReadS [TabbedDecoration a]
-> ReadPrec (TabbedDecoration a)
-> ReadPrec [TabbedDecoration a]
-> Read (TabbedDecoration a)
forall a. ReadPrec [TabbedDecoration a]
forall a. ReadPrec (TabbedDecoration a)
forall a. Int -> ReadS (TabbedDecoration a)
forall a. ReadS [TabbedDecoration a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Int -> ReadS (TabbedDecoration a)
readsPrec :: Int -> ReadS (TabbedDecoration a)
$creadList :: forall a. ReadS [TabbedDecoration a]
readList :: ReadS [TabbedDecoration a]
$creadPrec :: forall a. ReadPrec (TabbedDecoration a)
readPrec :: ReadPrec (TabbedDecoration a)
$creadListPrec :: forall a. ReadPrec [TabbedDecoration a]
readListPrec :: ReadPrec [TabbedDecoration a]
Read, Int -> TabbedDecoration a -> ShowS
[TabbedDecoration a] -> ShowS
TabbedDecoration a -> String
(Int -> TabbedDecoration a -> ShowS)
-> (TabbedDecoration a -> String)
-> ([TabbedDecoration a] -> ShowS)
-> Show (TabbedDecoration a)
forall a. Int -> TabbedDecoration a -> ShowS
forall a. [TabbedDecoration a] -> ShowS
forall a. TabbedDecoration a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Int -> TabbedDecoration a -> ShowS
showsPrec :: Int -> TabbedDecoration a -> ShowS
$cshow :: forall a. TabbedDecoration a -> String
show :: TabbedDecoration a -> String
$cshowList :: forall a. [TabbedDecoration a] -> ShowS
showList :: [TabbedDecoration a] -> ShowS
Show)

instance Eq a => DecorationStyle TabbedDecoration a where
    describeDeco :: TabbedDecoration a -> String
describeDeco (Tabbed Direction2D
U TabbarShown
_ ) = String
"Tabbed"
    describeDeco (Tabbed Direction2D
D TabbarShown
_ ) = String
"Tabbed Bottom"
    describeDeco (Tabbed Direction2D
L TabbarShown
_ ) = String
"Tabbed Left"
    describeDeco (Tabbed Direction2D
R TabbarShown
_ ) = String
"Tabbed Right"
    decorationEventHook :: TabbedDecoration a -> DecorationState -> Event -> X ()
decorationEventHook TabbedDecoration a
_ DecorationState
ds ButtonEvent { ev_window :: Event -> Window
ev_window     = Window
ew
                                         , ev_event_type :: Event -> Dimension
ev_event_type = Dimension
et
                                         , ev_button :: Event -> Dimension
ev_button     = Dimension
eb }
        | Dimension
et Dimension -> Dimension -> Bool
forall a. Eq a => a -> a -> Bool
== Dimension
buttonPress
        , Just ((Window
w,Rectangle
_),(Window, Maybe Rectangle)
_) <- Window
-> DecorationState
-> Maybe ((Window, Rectangle), (Window, Maybe Rectangle))
findWindowByDecoration Window
ew DecorationState
ds =
           if Dimension
eb Dimension -> Dimension -> Bool
forall a. Eq a => a -> a -> Bool
== Dimension
button2
               then Window -> X ()
killWindow Window
w
               else Window -> X ()
focus Window
w
    decorationEventHook TabbedDecoration a
_ DecorationState
_ Event
_ = () -> X ()
forall a. a -> X a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

    pureDecoration :: TabbedDecoration a
-> Dimension
-> Dimension
-> Rectangle
-> Stack a
-> [(a, Rectangle)]
-> (a, Rectangle)
-> Maybe Rectangle
pureDecoration (Tabbed Direction2D
lc TabbarShown
sh) Dimension
wt Dimension
ht Rectangle
_ Stack a
s [(a, Rectangle)]
wrs (a
w,r :: Rectangle
r@(Rectangle Position
x Position
y Dimension
wh Dimension
hh))
        = if (TabbarShown
sh TabbarShown -> TabbarShown -> Bool
forall a. Eq a => a -> a -> Bool
== TabbarShown
Always Bool -> Bool -> Bool
&& Int
numWindows Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0) Bool -> Bool -> Bool
|| Int
numWindows Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1
          then Rectangle -> Maybe Rectangle
forall a. a -> Maybe a
Just (Rectangle -> Maybe Rectangle) -> Rectangle -> Maybe Rectangle
forall a b. (a -> b) -> a -> b
$ case Direction2D
lc of
                        Direction2D
U -> Rectangle
upperTab
                        Direction2D
D -> Rectangle
lowerTab
                        Direction2D
L -> Rectangle
leftTab
                        Direction2D
R -> Rectangle
rightTab
          else Maybe Rectangle
forall a. Maybe a
Nothing
        where ws :: [a]
ws = (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
filter (a -> [a] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` ((a, Rectangle) -> a) -> [(a, Rectangle)] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map (a, Rectangle) -> a
forall a b. (a, b) -> a
fst (((a, Rectangle) -> Bool) -> [(a, Rectangle)] -> [(a, Rectangle)]
forall a. (a -> Bool) -> [a] -> [a]
filter ((Rectangle -> Rectangle -> Bool
forall a. Eq a => a -> a -> Bool
==Rectangle
r) (Rectangle -> Bool)
-> ((a, Rectangle) -> Rectangle) -> (a, Rectangle) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, Rectangle) -> Rectangle
forall a b. (a, b) -> b
snd) [(a, Rectangle)]
wrs)) (Stack a -> [a]
forall a. Stack a -> [a]
S.integrate Stack a
s)
              loc :: a -> a -> a -> a
loc a
k a
h a
i = a
k a -> a -> a
forall a. Num a => a -> a -> a
+ a -> a
forall a b. (Integral a, Num b) => a -> b
fi ((a
h a -> a -> a
forall a. Num a => a -> a -> a
* a -> a
forall a b. (Integral a, Num b) => a -> b
fi a
i) a -> a -> a
forall a. Integral a => a -> a -> a
`div` a -> a -> a
forall a. Ord a => a -> a -> a
max a
1 (Int -> a
forall a b. (Integral a, Num b) => a -> b
fi (Int -> a) -> Int -> a
forall a b. (a -> b) -> a -> b
$ [a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
ws))
              esize :: a -> a -> b
esize a
k a
h = a -> b
forall a b. (Integral a, Num b) => a -> b
fi (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ a -> (Int -> a) -> Maybe Int -> a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe a
k (\Int
i -> a -> a -> Int -> a
forall {a} {a} {a}.
(Integral a, Integral a, Num a) =>
a -> a -> a -> a
loc a
k a
h (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) a -> a -> a
forall a. Num a => a -> a -> a
- a -> a -> Int -> a
forall {a} {a} {a}.
(Integral a, Integral a, Num a) =>
a -> a -> a -> a
loc a
k a
h Int
i) (Maybe Int -> a) -> Maybe Int -> a
forall a b. (a -> b) -> a -> b
$ a
w a -> [a] -> Maybe Int
forall a. Eq a => a -> [a] -> Maybe Int
`elemIndex` [a]
ws
              wid :: Dimension
wid = Position -> Dimension -> Dimension
forall {a} {a} {b}. (Integral a, Integral a, Num b) => a -> a -> b
esize Position
x Dimension
wh
              n :: b -> a -> b
n b
k a
h = b -> (Int -> b) -> Maybe Int -> b
forall b a. b -> (a -> b) -> Maybe a -> b
maybe b
k (b -> a -> Int -> b
forall {a} {a} {a}.
(Integral a, Integral a, Num a) =>
a -> a -> a -> a
loc b
k a
h) (Maybe Int -> b) -> Maybe Int -> b
forall a b. (a -> b) -> a -> b
$ a
w a -> [a] -> Maybe Int
forall a. Eq a => a -> [a] -> Maybe Int
`elemIndex` [a]
ws
              nx :: Position
nx = Position -> Dimension -> Position
forall {a} {b}. (Integral a, Num b) => b -> a -> b
n Position
x Dimension
wh
              upperTab :: Rectangle
upperTab = Position -> Position -> Dimension -> Dimension -> Rectangle
Rectangle Position
nx  Position
y Dimension
wid (Dimension -> Dimension
forall a b. (Integral a, Num b) => a -> b
fi Dimension
ht)
              lowerTab :: Rectangle
lowerTab = Position -> Position -> Dimension -> Dimension -> Rectangle
Rectangle Position
nx (Position
y Position -> Position -> Position
forall a. Num a => a -> a -> a
+ Dimension -> Position
forall a b. (Integral a, Num b) => a -> b
fi (Dimension
hh Dimension -> Dimension -> Dimension
forall a. Num a => a -> a -> a
- Dimension
ht)) Dimension
wid (Dimension -> Dimension
forall a b. (Integral a, Num b) => a -> b
fi Dimension
ht)
              fixHeightLoc :: a -> Position
fixHeightLoc a
i = Position
y Position -> Position -> Position
forall a. Num a => a -> a -> a
+ Dimension -> Position
forall a b. (Integral a, Num b) => a -> b
fi Dimension
ht Position -> Position -> Position
forall a. Num a => a -> a -> a
* a -> Position
forall a b. (Integral a, Num b) => a -> b
fi a
i
              fixHeightTab :: Position -> Rectangle
fixHeightTab Position
k = Position -> Position -> Dimension -> Dimension -> Rectangle
Rectangle Position
k
                (Position -> (Int -> Position) -> Maybe Int -> Position
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Position
y Int -> Position
forall {a}. Integral a => a -> Position
fixHeightLoc
                 (Maybe Int -> Position) -> Maybe Int -> Position
forall a b. (a -> b) -> a -> b
$ a
w a -> [a] -> Maybe Int
forall a. Eq a => a -> [a] -> Maybe Int
`elemIndex` [a]
ws) (Dimension -> Dimension
forall a b. (Integral a, Num b) => a -> b
fi Dimension
wt) (Dimension -> Dimension
forall a b. (Integral a, Num b) => a -> b
fi Dimension
ht)
              rightTab :: Rectangle
rightTab = Position -> Rectangle
fixHeightTab (Position
x Position -> Position -> Position
forall a. Num a => a -> a -> a
+ Dimension -> Position
forall a b. (Integral a, Num b) => a -> b
fi (Dimension
wh Dimension -> Dimension -> Dimension
forall a. Num a => a -> a -> a
- Dimension
wt))
              leftTab :: Rectangle
leftTab = Position -> Rectangle
fixHeightTab Position
x
              numWindows :: Int
numWindows = [a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
ws
    shrink :: TabbedDecoration a -> Rectangle -> Rectangle -> Rectangle
shrink (Tabbed Direction2D
loc TabbarShown
_ ) (Rectangle Position
_ Position
_ Dimension
dw Dimension
dh) (Rectangle Position
x Position
y Dimension
w Dimension
h)
        = case Direction2D
loc of
            Direction2D
U -> Position -> Position -> Dimension -> Dimension -> Rectangle
Rectangle Position
x (Position
y Position -> Position -> Position
forall a. Num a => a -> a -> a
+ Dimension -> Position
forall a b. (Integral a, Num b) => a -> b
fi Dimension
dh) Dimension
w (Dimension
h Dimension -> Dimension -> Dimension
forall a. Num a => a -> a -> a
- Dimension
dh)
            Direction2D
D -> Position -> Position -> Dimension -> Dimension -> Rectangle
Rectangle Position
x Position
y Dimension
w (Dimension
h Dimension -> Dimension -> Dimension
forall a. Num a => a -> a -> a
- Dimension
dh)
            Direction2D
L -> Position -> Position -> Dimension -> Dimension -> Rectangle
Rectangle (Position
x Position -> Position -> Position
forall a. Num a => a -> a -> a
+ Dimension -> Position
forall a b. (Integral a, Num b) => a -> b
fi Dimension
dw) Position
y (Dimension
w Dimension -> Dimension -> Dimension
forall a. Num a => a -> a -> a
- Dimension
dw) Dimension
h
            Direction2D
R -> Position -> Position -> Dimension -> Dimension -> Rectangle
Rectangle Position
x Position
y (Dimension
w Dimension -> Dimension -> Dimension
forall a. Num a => a -> a -> a
- Dimension
dw) Dimension
h