{-|
  Description: Widgets that split the display vertically or horizontally.
-}
module Reflex.Vty.Widget.Split where

import Control.Applicative
import Control.Monad.Fix
import Graphics.Vty as V
import Reflex
import Reflex.Vty.Widget
import Reflex.Vty.Widget.Input.Mouse

-- | A split of the available space into two parts with a draggable separator.
-- Starts with half the space allocated to each, and the first pane has focus.
-- Clicking in a pane switches focus.
splitVDrag :: (MonadFix m, MonadHold t m, HasDisplayRegion t m, HasInput t m, HasImageWriter t m, HasFocusReader t m)
  => m ()
  -> m a
  -> m b
  -> m (a,b)
splitVDrag :: m () -> m a -> m b -> m (a, b)
splitVDrag m ()
wS m a
wA m b
wB = do
  Dynamic t Int
dh <- m (Dynamic t Int)
forall k (t :: k) (m :: * -> *).
HasDisplayRegion t m =>
m (Dynamic t Int)
displayHeight
  Dynamic t Int
dw <- m (Dynamic t Int)
forall k (t :: k) (m :: * -> *).
HasDisplayRegion t m =>
m (Dynamic t Int)
displayWidth
  Int
h0 <- Behavior t Int -> m Int
forall k (t :: k) (m :: * -> *) a.
MonadSample t m =>
Behavior t a -> m a
sample (Behavior t Int -> m Int) -> Behavior t Int -> m Int
forall a b. (a -> b) -> a -> b
$ Dynamic t Int -> Behavior t Int
forall k (t :: k) a. Reflex t => Dynamic t a -> Behavior t a
current Dynamic t Int
dh -- TODO
  Event t Drag
dragE <- Button -> m (Event t Drag)
forall k (t :: k) (m :: * -> *).
(Reflex t, MonadFix m, MonadHold t m, HasInput t m) =>
Button -> m (Event t Drag)
drag Button
V.BLeft
  let splitter0 :: Int
splitter0 = Int
h0 Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
2
  rec Dynamic t Int
splitterCheckpoint <- Int -> Event t Int -> m (Dynamic t Int)
forall k (t :: k) (m :: * -> *) a.
MonadHold t m =>
a -> Event t a -> m (Dynamic t a)
holdDyn Int
splitter0 (Event t Int -> m (Dynamic t Int))
-> Event t Int -> m (Dynamic t Int)
forall a b. (a -> b) -> a -> b
$ [Event t Int] -> Event t Int
forall k (t :: k) a. Reflex t => [Event t a] -> Event t a
leftmost [(Int, Bool) -> Int
forall a b. (a, b) -> a
fst ((Int, Bool) -> Int) -> Event t (Int, Bool) -> Event t Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Int, Bool) -> Bool) -> Event t (Int, Bool) -> Event t (Int, Bool)
forall (f :: * -> *) a. Filterable f => (a -> Bool) -> f a -> f a
ffilter (Int, Bool) -> Bool
forall a b. (a, b) -> b
snd Event t (Int, Bool)
dragSplitter, Event t Int
resizeSplitter]
      Dynamic t Int
splitterPos <- Int -> Event t Int -> m (Dynamic t Int)
forall k (t :: k) (m :: * -> *) a.
MonadHold t m =>
a -> Event t a -> m (Dynamic t a)
holdDyn Int
splitter0 (Event t Int -> m (Dynamic t Int))
-> Event t Int -> m (Dynamic t Int)
forall a b. (a -> b) -> a -> b
$ [Event t Int] -> Event t Int
forall k (t :: k) a. Reflex t => [Event t a] -> Event t a
leftmost [(Int, Bool) -> Int
forall a b. (a, b) -> a
fst ((Int, Bool) -> Int) -> Event t (Int, Bool) -> Event t Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Event t (Int, Bool)
dragSplitter, Event t Int
resizeSplitter]
      Dynamic t Double
splitterFrac <- Double -> Event t Double -> m (Dynamic t Double)
forall k (t :: k) (m :: * -> *) a.
MonadHold t m =>
a -> Event t a -> m (Dynamic t a)
holdDyn ((Double
1::Double) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
2) (Event t Double -> m (Dynamic t Double))
-> Event t Double -> m (Dynamic t Double)
forall a b. (a -> b) -> a -> b
$ Event t (Int, Int) -> ((Int, Int) -> Double) -> Event t Double
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
ffor (Behavior t Int -> Event t Int -> Event t (Int, Int)
forall k (t :: k) a b.
Reflex t =>
Behavior t a -> Event t b -> Event t (a, b)
attach (Dynamic t Int -> Behavior t Int
forall k (t :: k) a. Reflex t => Dynamic t a -> Behavior t a
current Dynamic t Int
dh) ((Int, Bool) -> Int
forall a b. (a, b) -> a
fst ((Int, Bool) -> Int) -> Event t (Int, Bool) -> Event t Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Event t (Int, Bool)
dragSplitter)) (((Int, Int) -> Double) -> Event t Double)
-> ((Int, Int) -> Double) -> Event t Double
forall a b. (a -> b) -> a -> b
$ \(Int
h, Int
x) ->
        Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
x Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double -> Double -> Double
forall a. Ord a => a -> a -> a
max Double
1 (Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
h)
      let dragSplitter :: Event t (Int, Bool)
dragSplitter = Event t (Int, Drag)
-> ((Int, Drag) -> Maybe (Int, Bool)) -> Event t (Int, Bool)
forall (f :: * -> *) a b.
Filterable f =>
f a -> (a -> Maybe b) -> f b
fforMaybe (Behavior t Int -> Event t Drag -> Event t (Int, Drag)
forall k (t :: k) a b.
Reflex t =>
Behavior t a -> Event t b -> Event t (a, b)
attach (Dynamic t Int -> Behavior t Int
forall k (t :: k) a. Reflex t => Dynamic t a -> Behavior t a
current Dynamic t Int
splitterCheckpoint) Event t Drag
dragE) (((Int, Drag) -> Maybe (Int, Bool)) -> Event t (Int, Bool))
-> ((Int, Drag) -> Maybe (Int, Bool)) -> Event t (Int, Bool)
forall a b. (a -> b) -> a -> b
$
            \(Int
splitterY, Drag (Int
_, Int
fromY) (Int
_, Int
toY) Button
_ [Modifier]
_ Bool
end) ->
              if Int
splitterY Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
fromY then (Int, Bool) -> Maybe (Int, Bool)
forall a. a -> Maybe a
Just (Int
toY, Bool
end) else Maybe (Int, Bool)
forall a. Maybe a
Nothing
          regA :: Dynamic t Region
regA = Int -> Int -> Int -> Int -> Region
Region Int
0 Int
0 (Int -> Int -> Region)
-> Dynamic t Int -> Dynamic t (Int -> Region)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Dynamic t Int
dw Dynamic t (Int -> Region) -> Dynamic t Int -> Dynamic t Region
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Dynamic t Int
splitterPos
          regS :: Dynamic t Region
regS = Int -> Int -> Int -> Int -> Region
Region Int
0 (Int -> Int -> Int -> Region)
-> Dynamic t Int -> Dynamic t (Int -> Int -> Region)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Dynamic t Int
splitterPos Dynamic t (Int -> Int -> Region)
-> Dynamic t Int -> Dynamic t (Int -> Region)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Dynamic t Int
dw Dynamic t (Int -> Region) -> Dynamic t Int -> Dynamic t Region
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Dynamic t Int
1
          regB :: Dynamic t Region
regB = Int -> Int -> Int -> Int -> Region
Region Int
0 (Int -> Int -> Int -> Region)
-> Dynamic t Int -> Dynamic t (Int -> Int -> Region)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Dynamic t Int
splitterPos Dynamic t Int -> Dynamic t Int -> Dynamic t Int
forall a. Num a => a -> a -> a
+ Dynamic t Int
1) Dynamic t (Int -> Int -> Region)
-> Dynamic t Int -> Dynamic t (Int -> Region)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Dynamic t Int
dw Dynamic t (Int -> Region) -> Dynamic t Int -> Dynamic t Region
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Dynamic t Int
dh Dynamic t Int -> Dynamic t Int -> Dynamic t Int
forall a. Num a => a -> a -> a
- Dynamic t Int
splitterPos Dynamic t Int -> Dynamic t Int -> Dynamic t Int
forall a. Num a => a -> a -> a
- Dynamic t Int
1)
          resizeSplitter :: Event t Int
resizeSplitter = Event t (Double, Int) -> ((Double, Int) -> Int) -> Event t Int
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
ffor (Behavior t Double -> Event t Int -> Event t (Double, Int)
forall k (t :: k) a b.
Reflex t =>
Behavior t a -> Event t b -> Event t (a, b)
attach (Dynamic t Double -> Behavior t Double
forall k (t :: k) a. Reflex t => Dynamic t a -> Behavior t a
current Dynamic t Double
splitterFrac) (Dynamic t Int -> Event t Int
forall k (t :: k) a. Reflex t => Dynamic t a -> Event t a
updated Dynamic t Int
dh)) (((Double, Int) -> Int) -> Event t Int)
-> ((Double, Int) -> Int) -> Event t Int
forall a b. (a -> b) -> a -> b
$
            \(Double
frac, Int
h) -> Double -> Int
forall a b. (RealFrac a, Integral b) => a -> b
round (Double
frac Double -> Double -> Double
forall a. Num a => a -> a -> a
* Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
h)
      Dynamic t Bool
focA <- Bool -> Event t Bool -> m (Dynamic t Bool)
forall k (t :: k) (m :: * -> *) a.
MonadHold t m =>
a -> Event t a -> m (Dynamic t a)
holdDyn Bool
True (Event t Bool -> m (Dynamic t Bool))
-> Event t Bool -> m (Dynamic t Bool)
forall a b. (a -> b) -> a -> b
$ [Event t Bool] -> Event t Bool
forall k (t :: k) a. Reflex t => [Event t a] -> Event t a
leftmost
        [ Bool
True Bool -> Event t MouseDown -> Event t Bool
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Event t MouseDown
mA
        , Bool
False Bool -> Event t MouseDown -> Event t Bool
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Event t MouseDown
mB
        ]
      (Event t MouseDown
mA, a
rA) <- Dynamic t Region
-> Dynamic t Bool
-> m (Event t MouseDown, a)
-> m (Event t MouseDown, a)
forall k (m :: * -> *) (t :: k) a.
(MonadFix m, MonadHold t m, HasInput t m, HasImageWriter t m,
 HasDisplayRegion t m, HasFocusReader t m) =>
Dynamic t Region -> Dynamic t Bool -> m a -> m a
pane Dynamic t Region
regA Dynamic t Bool
focA (m (Event t MouseDown, a) -> m (Event t MouseDown, a))
-> m (Event t MouseDown, a) -> m (Event t MouseDown, a)
forall a b. (a -> b) -> a -> b
$ m a -> m (Event t MouseDown, a)
forall k (t :: k) (m :: * -> *) b.
(Reflex t, HasInput t m, Monad m) =>
m b -> m (Event t MouseDown, b)
withMouseDown m a
wA
      Dynamic t Region -> Dynamic t Bool -> m () -> m ()
forall k (m :: * -> *) (t :: k) a.
(MonadFix m, MonadHold t m, HasInput t m, HasImageWriter t m,
 HasDisplayRegion t m, HasFocusReader t m) =>
Dynamic t Region -> Dynamic t Bool -> m a -> m a
pane Dynamic t Region
regS (Bool -> Dynamic t Bool
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False) m ()
wS
      (Event t MouseDown
mB, b
rB) <- Dynamic t Region
-> Dynamic t Bool
-> m (Event t MouseDown, b)
-> m (Event t MouseDown, b)
forall k (m :: * -> *) (t :: k) a.
(MonadFix m, MonadHold t m, HasInput t m, HasImageWriter t m,
 HasDisplayRegion t m, HasFocusReader t m) =>
Dynamic t Region -> Dynamic t Bool -> m a -> m a
pane Dynamic t Region
regB (Bool -> Bool
not (Bool -> Bool) -> Dynamic t Bool -> Dynamic t Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Dynamic t Bool
focA) (m (Event t MouseDown, b) -> m (Event t MouseDown, b))
-> m (Event t MouseDown, b) -> m (Event t MouseDown, b)
forall a b. (a -> b) -> a -> b
$ m b -> m (Event t MouseDown, b)
forall k (t :: k) (m :: * -> *) b.
(Reflex t, HasInput t m, Monad m) =>
m b -> m (Event t MouseDown, b)
withMouseDown m b
wB
  (a, b) -> m (a, b)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
rA, b
rB)
  where
    withMouseDown :: m b -> m (Event t MouseDown, b)
withMouseDown m b
x = do
      Event t MouseDown
m <- Button -> m (Event t MouseDown)
forall k (t :: k) (m :: * -> *).
(Reflex t, Monad m, HasInput t m) =>
Button -> m (Event t MouseDown)
mouseDown Button
V.BLeft
      b
x' <- m b
x
      (Event t MouseDown, b) -> m (Event t MouseDown, b)
forall (m :: * -> *) a. Monad m => a -> m a
return (Event t MouseDown
m, b
x')

-- | A plain split of the available space into vertically stacked panes.
-- No visual separator is built in here.
splitV :: (MonadFix m, MonadHold t m, HasDisplayRegion t m, HasInput t m, HasImageWriter t m, HasFocusReader t m)
       => Dynamic t (Int -> Int)
       -- ^ Function used to determine size of first pane based on available size
       -> Dynamic t (Bool, Bool)
       -- ^ How to focus the two sub-panes, given that we are focused.
       -> m a
       -- ^ Widget for first pane
       -> m b
       -- ^ Widget for second pane
       -> m (a,b)
splitV :: Dynamic t (Int -> Int)
-> Dynamic t (Bool, Bool) -> m a -> m b -> m (a, b)
splitV Dynamic t (Int -> Int)
sizeFunD Dynamic t (Bool, Bool)
focD m a
wA m b
wB = do
  Dynamic t Int
dw <- m (Dynamic t Int)
forall k (t :: k) (m :: * -> *).
HasDisplayRegion t m =>
m (Dynamic t Int)
displayWidth
  Dynamic t Int
dh <- m (Dynamic t Int)
forall k (t :: k) (m :: * -> *).
HasDisplayRegion t m =>
m (Dynamic t Int)
displayHeight
  let regA :: Dynamic t Region
regA = Int -> Int -> Int -> Int -> Region
Region Int
0 Int
0 (Int -> Int -> Region)
-> Dynamic t Int -> Dynamic t (Int -> Region)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Dynamic t Int
dw Dynamic t (Int -> Region) -> Dynamic t Int -> Dynamic t Region
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Dynamic t (Int -> Int)
sizeFunD Dynamic t (Int -> Int) -> Dynamic t Int -> Dynamic t Int
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Dynamic t Int
dh)
      regB :: Dynamic t Region
regB = Int -> Int -> Int -> Int -> Region
Region Int
0 (Int -> Int -> Int -> Region)
-> Dynamic t Int -> Dynamic t (Int -> Int -> Region)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Region -> Int
_region_height (Region -> Int) -> Dynamic t Region -> Dynamic t Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Dynamic t Region
regA) Dynamic t (Int -> Int -> Region)
-> Dynamic t Int -> Dynamic t (Int -> Region)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Dynamic t Int
dw Dynamic t (Int -> Region) -> Dynamic t Int -> Dynamic t Region
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Int -> Int -> Int)
-> Dynamic t Int -> Dynamic t Int -> Dynamic t Int
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (-) Dynamic t Int
dh (Region -> Int
_region_height (Region -> Int) -> Dynamic t Region -> Dynamic t Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Dynamic t Region
regA)
  a
ra <- Dynamic t Region -> Dynamic t Bool -> m a -> m a
forall k (m :: * -> *) (t :: k) a.
(MonadFix m, MonadHold t m, HasInput t m, HasImageWriter t m,
 HasDisplayRegion t m, HasFocusReader t m) =>
Dynamic t Region -> Dynamic t Bool -> m a -> m a
pane Dynamic t Region
regA ((Bool, Bool) -> Bool
forall a b. (a, b) -> a
fst ((Bool, Bool) -> Bool) -> Dynamic t (Bool, Bool) -> Dynamic t Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Dynamic t (Bool, Bool)
focD) m a
wA
  b
rb <- Dynamic t Region -> Dynamic t Bool -> m b -> m b
forall k (m :: * -> *) (t :: k) a.
(MonadFix m, MonadHold t m, HasInput t m, HasImageWriter t m,
 HasDisplayRegion t m, HasFocusReader t m) =>
Dynamic t Region -> Dynamic t Bool -> m a -> m a
pane Dynamic t Region
regB ((Bool, Bool) -> Bool
forall a b. (a, b) -> b
snd ((Bool, Bool) -> Bool) -> Dynamic t (Bool, Bool) -> Dynamic t Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Dynamic t (Bool, Bool)
focD) m b
wB
  (a, b) -> m (a, b)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
ra,b
rb)

-- | A plain split of the available space into horizontally stacked panes.
-- No visual separator is built in here.
splitH :: (MonadFix m, MonadHold t m, HasDisplayRegion t m, HasInput t m, HasImageWriter t m, HasFocusReader t m)
       => Dynamic t (Int -> Int)
       -- ^ Function used to determine size of first pane based on available size
       -> Dynamic t (Bool, Bool)
       -- ^ How to focus the two sub-panes, given that we are focused.
       -> m a
       -- ^ Widget for first pane
       -> m b
       -- ^ Widget for second pane
       -> m (a,b)
splitH :: Dynamic t (Int -> Int)
-> Dynamic t (Bool, Bool) -> m a -> m b -> m (a, b)
splitH Dynamic t (Int -> Int)
sizeFunD Dynamic t (Bool, Bool)
focD m a
wA m b
wB = do
  Dynamic t Int
dw <- m (Dynamic t Int)
forall k (t :: k) (m :: * -> *).
HasDisplayRegion t m =>
m (Dynamic t Int)
displayWidth
  Dynamic t Int
dh <- m (Dynamic t Int)
forall k (t :: k) (m :: * -> *).
HasDisplayRegion t m =>
m (Dynamic t Int)
displayHeight
  let regA :: Dynamic t Region
regA = Int -> Int -> Int -> Int -> Region
Region Int
0 Int
0 (Int -> Int -> Region)
-> Dynamic t Int -> Dynamic t (Int -> Region)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Dynamic t (Int -> Int)
sizeFunD Dynamic t (Int -> Int) -> Dynamic t Int -> Dynamic t Int
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Dynamic t Int
dw) Dynamic t (Int -> Region) -> Dynamic t Int -> Dynamic t Region
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Dynamic t Int
dh
      regB :: Dynamic t Region
regB = Int -> Int -> Int -> Int -> Region
Region (Int -> Int -> Int -> Int -> Region)
-> Dynamic t Int -> Dynamic t (Int -> Int -> Int -> Region)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Region -> Int
_region_width (Region -> Int) -> Dynamic t Region -> Dynamic t Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Dynamic t Region
regA) Dynamic t (Int -> Int -> Int -> Region)
-> Dynamic t Int -> Dynamic t (Int -> Int -> Region)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Dynamic t Int
0 Dynamic t (Int -> Int -> Region)
-> Dynamic t Int -> Dynamic t (Int -> Region)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Int -> Int -> Int)
-> Dynamic t Int -> Dynamic t Int -> Dynamic t Int
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (-) Dynamic t Int
dw (Region -> Int
_region_width (Region -> Int) -> Dynamic t Region -> Dynamic t Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Dynamic t Region
regA) Dynamic t (Int -> Region) -> Dynamic t Int -> Dynamic t Region
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Dynamic t Int
dh
  (a -> b -> (a, b)) -> m a -> m b -> m (a, b)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (,) (Dynamic t Region -> Dynamic t Bool -> m a -> m a
forall k (m :: * -> *) (t :: k) a.
(MonadFix m, MonadHold t m, HasInput t m, HasImageWriter t m,
 HasDisplayRegion t m, HasFocusReader t m) =>
Dynamic t Region -> Dynamic t Bool -> m a -> m a
pane Dynamic t Region
regA (((Bool, Bool) -> Bool) -> Dynamic t (Bool, Bool) -> Dynamic t Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Bool, Bool) -> Bool
forall a b. (a, b) -> a
fst Dynamic t (Bool, Bool)
focD) m a
wA) (Dynamic t Region -> Dynamic t Bool -> m b -> m b
forall k (m :: * -> *) (t :: k) a.
(MonadFix m, MonadHold t m, HasInput t m, HasImageWriter t m,
 HasDisplayRegion t m, HasFocusReader t m) =>
Dynamic t Region -> Dynamic t Bool -> m a -> m a
pane Dynamic t Region
regB (((Bool, Bool) -> Bool) -> Dynamic t (Bool, Bool) -> Dynamic t Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Bool, Bool) -> Bool
forall a b. (a, b) -> b
snd Dynamic t (Bool, Bool)
focD) m b
wB)