{-|
Module: Reflex.Vty.Widget
Description: Basic set of widgets and building blocks for reflex-vty applications
-}
{-# Language UndecidableInstances #-}

module Reflex.Vty.Widget where

import Control.Applicative (liftA2)
import Control.Monad.Catch (MonadCatch, MonadThrow, MonadMask)
import Control.Monad.Fix (MonadFix)
import Control.Monad.IO.Class (MonadIO)
import Control.Monad.Morph (MFunctor(..))
import Control.Monad.NodeId
import Control.Monad.Reader (ReaderT, ask, local, runReaderT)
import Control.Monad.Ref
import Control.Monad.Trans (MonadTrans, lift)
import Data.Set (Set)
import qualified Data.Set as Set
import Graphics.Vty (Image)
import qualified Graphics.Vty as V
import Reflex
import Reflex.Class ()
import Reflex.Host.Class (MonadReflexCreateTrigger)
import Reflex.Vty.Host

-- * Running a vty application

-- | Sets up the top-level context for a vty widget and runs it with that context
mainWidgetWithHandle
  :: V.Vty
  -> (forall t m.
      ( MonadVtyApp t m
      , HasImageWriter t m
      , MonadNodeId m
      , HasDisplayRegion t m
      , HasFocusReader t m
      , HasInput t m
      , HasTheme t m
      ) => m (Event t ()))
  -> IO ()
mainWidgetWithHandle :: Vty
-> (forall t (m :: * -> *).
    (MonadVtyApp t m, HasImageWriter t m, MonadNodeId m,
     HasDisplayRegion t m, HasFocusReader t m, HasInput t m,
     HasTheme t m) =>
    m (Event t ()))
-> IO ()
mainWidgetWithHandle Vty
vty forall t (m :: * -> *).
(MonadVtyApp t m, HasImageWriter t m, MonadNodeId m,
 HasDisplayRegion t m, HasFocusReader t m, HasInput t m,
 HasTheme t m) =>
m (Event t ())
child =
  Vty -> (forall t (m :: * -> *). VtyApp t m) -> IO ()
runVtyAppWithHandle Vty
vty ((forall t (m :: * -> *). VtyApp t m) -> IO ())
-> (forall t (m :: * -> *). VtyApp t m) -> IO ()
forall a b. (a -> b) -> a -> b
$ \DisplayRegion
dr0 Event t Event
inp -> do
    Dynamic t DisplayRegion
size <- DisplayRegion
-> Event t DisplayRegion -> m (Dynamic t DisplayRegion)
forall k (t :: k) (m :: * -> *) a.
MonadHold t m =>
a -> Event t a -> m (Dynamic t a)
holdDyn DisplayRegion
dr0 (Event t DisplayRegion -> m (Dynamic t DisplayRegion))
-> Event t DisplayRegion -> m (Dynamic t DisplayRegion)
forall a b. (a -> b) -> a -> b
$ Event t Event
-> (Event -> Maybe DisplayRegion) -> Event t DisplayRegion
forall (f :: * -> *) a b.
Filterable f =>
f a -> (a -> Maybe b) -> f b
fforMaybe Event t Event
inp ((Event -> Maybe DisplayRegion) -> Event t DisplayRegion)
-> (Event -> Maybe DisplayRegion) -> Event t DisplayRegion
forall a b. (a -> b) -> a -> b
$ \case
      V.EvResize Int
w Int
h -> DisplayRegion -> Maybe DisplayRegion
forall a. a -> Maybe a
Just (Int
w, Int
h)
      Event
_ -> Maybe DisplayRegion
forall a. Maybe a
Nothing
    let inp' :: Event t Event
inp' = Event t Event -> (Event -> Maybe Event) -> Event t Event
forall (f :: * -> *) a b.
Filterable f =>
f a -> (a -> Maybe b) -> f b
fforMaybe Event t Event
inp ((Event -> Maybe Event) -> Event t Event)
-> (Event -> Maybe Event) -> Event t Event
forall a b. (a -> b) -> a -> b
$ \case
          V.EvResize {} -> Maybe Event
forall a. Maybe a
Nothing
          Event
x -> Event -> Maybe Event
forall a. a -> Maybe a
Just Event
x
    (Event t ()
shutdown, Behavior t [Image]
images) <- Behavior t Attr
-> ThemeReader t m (Event t (), Behavior t [Image])
-> m (Event t (), Behavior t [Image])
forall k (t :: k) (m :: * -> *) a.
(Reflex t, Monad m) =>
Behavior t Attr -> ThemeReader t m a -> m a
runThemeReader (Attr -> Behavior t Attr
forall k (t :: k) a. Reflex t => a -> Behavior t a
constant Attr
V.defAttr) (ThemeReader t m (Event t (), Behavior t [Image])
 -> m (Event t (), Behavior t [Image]))
-> ThemeReader t m (Event t (), Behavior t [Image])
-> m (Event t (), Behavior t [Image])
forall a b. (a -> b) -> a -> b
$
      Dynamic t Bool
-> FocusReader t (ThemeReader t m) (Event t (), Behavior t [Image])
-> ThemeReader t m (Event t (), Behavior t [Image])
forall k (t :: k) (m :: * -> *) a.
(Reflex t, Monad m) =>
Dynamic t Bool -> FocusReader t m a -> m a
runFocusReader (Bool -> Dynamic t Bool
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True) (FocusReader t (ThemeReader t m) (Event t (), Behavior t [Image])
 -> ThemeReader t m (Event t (), Behavior t [Image]))
-> FocusReader t (ThemeReader t m) (Event t (), Behavior t [Image])
-> ThemeReader t m (Event t (), Behavior t [Image])
forall a b. (a -> b) -> a -> b
$
        Dynamic t Region
-> DisplayRegion
     t
     (FocusReader t (ThemeReader t m))
     (Event t (), Behavior t [Image])
-> FocusReader t (ThemeReader t m) (Event t (), Behavior t [Image])
forall k (t :: k) (m :: * -> *) a.
(Reflex t, Monad m) =>
Dynamic t Region -> DisplayRegion t m a -> m a
runDisplayRegion ((DisplayRegion -> Region)
-> Dynamic t DisplayRegion -> Dynamic t Region
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(Int
w, Int
h) -> Int -> Int -> Int -> Int -> Region
Region Int
0 Int
0 Int
w Int
h) Dynamic t DisplayRegion
size) (DisplayRegion
   t
   (FocusReader t (ThemeReader t m))
   (Event t (), Behavior t [Image])
 -> FocusReader
      t (ThemeReader t m) (Event t (), Behavior t [Image]))
-> DisplayRegion
     t
     (FocusReader t (ThemeReader t m))
     (Event t (), Behavior t [Image])
-> FocusReader t (ThemeReader t m) (Event t (), Behavior t [Image])
forall a b. (a -> b) -> a -> b
$
          ImageWriter
  t (DisplayRegion t (FocusReader t (ThemeReader t m))) (Event t ())
-> DisplayRegion
     t
     (FocusReader t (ThemeReader t m))
     (Event t (), Behavior t [Image])
forall t (m :: * -> *) a.
(Reflex t, Monad m) =>
ImageWriter t m a -> m (a, Behavior t [Image])
runImageWriter (ImageWriter
   t (DisplayRegion t (FocusReader t (ThemeReader t m))) (Event t ())
 -> DisplayRegion
      t
      (FocusReader t (ThemeReader t m))
      (Event t (), Behavior t [Image]))
-> ImageWriter
     t (DisplayRegion t (FocusReader t (ThemeReader t m))) (Event t ())
-> DisplayRegion
     t
     (FocusReader t (ThemeReader t m))
     (Event t (), Behavior t [Image])
forall a b. (a -> b) -> a -> b
$
            NodeIdT
  (ImageWriter t (DisplayRegion t (FocusReader t (ThemeReader t m))))
  (Event t ())
-> ImageWriter
     t (DisplayRegion t (FocusReader t (ThemeReader t m))) (Event t ())
forall (m :: * -> *) a. MonadIO m => NodeIdT m a -> m a
runNodeIdT (NodeIdT
   (ImageWriter t (DisplayRegion t (FocusReader t (ThemeReader t m))))
   (Event t ())
 -> ImageWriter
      t (DisplayRegion t (FocusReader t (ThemeReader t m))) (Event t ()))
-> NodeIdT
     (ImageWriter t (DisplayRegion t (FocusReader t (ThemeReader t m))))
     (Event t ())
-> ImageWriter
     t (DisplayRegion t (FocusReader t (ThemeReader t m))) (Event t ())
forall a b. (a -> b) -> a -> b
$
              Event t Event
-> Input
     t
     (NodeIdT
        (ImageWriter
           t (DisplayRegion t (FocusReader t (ThemeReader t m)))))
     (Event t ())
-> NodeIdT
     (ImageWriter t (DisplayRegion t (FocusReader t (ThemeReader t m))))
     (Event t ())
forall k (t :: k) (m :: * -> *) a.
Reflex t =>
Event t Event -> Input t m a -> m a
runInput Event t Event
inp' (Input
   t
   (NodeIdT
      (ImageWriter
         t (DisplayRegion t (FocusReader t (ThemeReader t m)))))
   (Event t ())
 -> NodeIdT
      (ImageWriter t (DisplayRegion t (FocusReader t (ThemeReader t m))))
      (Event t ()))
-> Input
     t
     (NodeIdT
        (ImageWriter
           t (DisplayRegion t (FocusReader t (ThemeReader t m)))))
     (Event t ())
-> NodeIdT
     (ImageWriter t (DisplayRegion t (FocusReader t (ThemeReader t m))))
     (Event t ())
forall a b. (a -> b) -> a -> b
$ do
                Behavior t [Image]
-> Input
     t
     (NodeIdT
        (ImageWriter
           t (DisplayRegion t (FocusReader t (ThemeReader t m)))))
     ()
forall k (t :: k) (m :: * -> *).
HasImageWriter t m =>
Behavior t [Image] -> m ()
tellImages (Behavior t [Image]
 -> Input
      t
      (NodeIdT
         (ImageWriter
            t (DisplayRegion t (FocusReader t (ThemeReader t m)))))
      ())
-> ((DisplayRegion -> [Image]) -> Behavior t [Image])
-> (DisplayRegion -> [Image])
-> Input
     t
     (NodeIdT
        (ImageWriter
           t (DisplayRegion t (FocusReader t (ThemeReader t m)))))
     ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Behavior t DisplayRegion
-> (DisplayRegion -> [Image]) -> Behavior t [Image]
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
ffor (Dynamic t DisplayRegion -> Behavior t DisplayRegion
forall k (t :: k) a. Reflex t => Dynamic t a -> Behavior t a
current Dynamic t DisplayRegion
size) ((DisplayRegion -> [Image])
 -> Input
      t
      (NodeIdT
         (ImageWriter
            t (DisplayRegion t (FocusReader t (ThemeReader t m)))))
      ())
-> (DisplayRegion -> [Image])
-> Input
     t
     (NodeIdT
        (ImageWriter
           t (DisplayRegion t (FocusReader t (ThemeReader t m)))))
     ()
forall a b. (a -> b) -> a -> b
$ \(Int
w, Int
h) -> [Attr -> Char -> Int -> Int -> Image
forall d. Integral d => Attr -> Char -> d -> d -> Image
V.charFill Attr
V.defAttr Char
' ' Int
w Int
h]
                Input
  t
  (NodeIdT
     (ImageWriter
        t (DisplayRegion t (FocusReader t (ThemeReader t m)))))
  (Event t ())
forall t (m :: * -> *).
(MonadVtyApp t m, HasImageWriter t m, MonadNodeId m,
 HasDisplayRegion t m, HasFocusReader t m, HasInput t m,
 HasTheme t m) =>
m (Event t ())
child
    VtyResult t -> m (VtyResult t)
forall (m :: * -> *) a. Monad m => a -> m a
return (VtyResult t -> m (VtyResult t)) -> VtyResult t -> m (VtyResult t)
forall a b. (a -> b) -> a -> b
$ VtyResult :: forall k (t :: k). Behavior t Picture -> Event t () -> VtyResult t
VtyResult
      { _vtyResult_picture :: Behavior t Picture
_vtyResult_picture = ([Image] -> Picture) -> Behavior t [Image] -> Behavior t Picture
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Image] -> Picture
V.picForLayers ([Image] -> Picture) -> ([Image] -> [Image]) -> [Image] -> Picture
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Image] -> [Image]
forall a. [a] -> [a]
reverse) Behavior t [Image]
images
      , _vtyResult_shutdown :: Event t ()
_vtyResult_shutdown = Event t ()
shutdown
      }

-- | The output of a vty widget
data VtyWidgetOut t = VtyWidgetOut
  { VtyWidgetOut t -> Event t ()
_vtyWidgetOut_shutdown :: Event t ()
  }

-- | Like 'mainWidgetWithHandle', but uses a default vty configuration
mainWidget
  :: (forall t m.
      ( MonadVtyApp t m
      , HasImageWriter t m
      , MonadNodeId m
      , HasDisplayRegion t m
      , HasFocusReader t m
      , HasTheme t m
      , HasInput t m
      ) => m (Event t ()))
  -> IO ()
mainWidget :: (forall t (m :: * -> *).
 (MonadVtyApp t m, HasImageWriter t m, MonadNodeId m,
  HasDisplayRegion t m, HasFocusReader t m, HasTheme t m,
  HasInput t m) =>
 m (Event t ()))
-> IO ()
mainWidget forall t (m :: * -> *).
(MonadVtyApp t m, HasImageWriter t m, MonadNodeId m,
 HasDisplayRegion t m, HasFocusReader t m, HasTheme t m,
 HasInput t m) =>
m (Event t ())
child = do
  Vty
vty <- IO Vty
getDefaultVty
  Vty
-> (forall t (m :: * -> *).
    (MonadVtyApp t m, HasImageWriter t m, MonadNodeId m,
     HasDisplayRegion t m, HasFocusReader t m, HasInput t m,
     HasTheme t m) =>
    m (Event t ()))
-> IO ()
mainWidgetWithHandle Vty
vty forall t (m :: * -> *).
(MonadVtyApp t m, HasImageWriter t m, MonadNodeId m,
 HasDisplayRegion t m, HasFocusReader t m, HasTheme t m,
 HasInput t m) =>
m (Event t ())
forall t (m :: * -> *).
(MonadVtyApp t m, HasImageWriter t m, MonadNodeId m,
 HasDisplayRegion t m, HasFocusReader t m, HasInput t m,
 HasTheme t m) =>
m (Event t ())
child

-- * Input Events

-- | A class for things that can receive vty events as input
class HasInput t m | m -> t where
  input :: m (Event t VtyEvent)
  default input :: (f m' ~ m, Monad m', MonadTrans f, HasInput t m') => m (Event t VtyEvent)
  input = m' (Event t Event) -> f m' (Event t Event)
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m' (Event t Event)
forall k (t :: k) (m :: * -> *). HasInput t m => m (Event t Event)
input
  -- | User input events that the widget's parent chooses to share. These will generally
  -- be filtered for relevance.
  localInput :: (Event t VtyEvent -> Event t VtyEvent) -> m a -> m a
  default localInput :: (f m' ~ m, Monad m', MFunctor f, HasInput t m') => (Event t VtyEvent -> Event t VtyEvent) -> m a -> m a
  localInput Event t Event -> Event t Event
f = (forall a. m' a -> m' a) -> f m' a -> f m' a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist ((Event t Event -> Event t Event) -> m' a -> m' a
forall k (t :: k) (m :: * -> *) a.
HasInput t m =>
(Event t Event -> Event t Event) -> m a -> m a
localInput Event t Event -> Event t Event
f)

instance (Reflex t, Monad m) => HasInput t (Input t m) where
  input :: Input t m (Event t Event)
input = ReaderT (Event t Event) m (Event t Event)
-> Input t m (Event t Event)
forall k (t :: k) (m :: * -> *) a.
ReaderT (Event t Event) m a -> Input t m a
Input ReaderT (Event t Event) m (Event t Event)
forall r (m :: * -> *). MonadReader r m => m r
ask
  localInput :: (Event t Event -> Event t Event) -> Input t m a -> Input t m a
localInput Event t Event -> Event t Event
f (Input ReaderT (Event t Event) m a
m) = ReaderT (Event t Event) m a -> Input t m a
forall k (t :: k) (m :: * -> *) a.
ReaderT (Event t Event) m a -> Input t m a
Input (ReaderT (Event t Event) m a -> Input t m a)
-> ReaderT (Event t Event) m a -> Input t m a
forall a b. (a -> b) -> a -> b
$ (Event t Event -> Event t Event)
-> ReaderT (Event t Event) m a -> ReaderT (Event t Event) m a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local Event t Event -> Event t Event
f ReaderT (Event t Event) m a
m

-- | A widget that can receive input events. See 'Graphics.Vty.Event'
newtype Input t m a = Input
  { Input t m a -> ReaderT (Event t Event) m a
unInput :: ReaderT (Event t VtyEvent) m a
  } deriving
    ( a -> Input t m b -> Input t m a
(a -> b) -> Input t m a -> Input t m b
(forall a b. (a -> b) -> Input t m a -> Input t m b)
-> (forall a b. a -> Input t m b -> Input t m a)
-> Functor (Input t m)
forall k (t :: k) (m :: * -> *) a b.
Functor m =>
a -> Input t m b -> Input t m a
forall k (t :: k) (m :: * -> *) a b.
Functor m =>
(a -> b) -> Input t m a -> Input t m b
forall a b. a -> Input t m b -> Input t m a
forall a b. (a -> b) -> Input t m a -> Input t m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Input t m b -> Input t m a
$c<$ :: forall k (t :: k) (m :: * -> *) a b.
Functor m =>
a -> Input t m b -> Input t m a
fmap :: (a -> b) -> Input t m a -> Input t m b
$cfmap :: forall k (t :: k) (m :: * -> *) a b.
Functor m =>
(a -> b) -> Input t m a -> Input t m b
Functor
    , Functor (Input t m)
a -> Input t m a
Functor (Input t m)
-> (forall a. a -> Input t m a)
-> (forall a b. Input t m (a -> b) -> Input t m a -> Input t m b)
-> (forall a b c.
    (a -> b -> c) -> Input t m a -> Input t m b -> Input t m c)
-> (forall a b. Input t m a -> Input t m b -> Input t m b)
-> (forall a b. Input t m a -> Input t m b -> Input t m a)
-> Applicative (Input t m)
Input t m a -> Input t m b -> Input t m b
Input t m a -> Input t m b -> Input t m a
Input t m (a -> b) -> Input t m a -> Input t m b
(a -> b -> c) -> Input t m a -> Input t m b -> Input t m c
forall a. a -> Input t m a
forall k (t :: k) (m :: * -> *).
Applicative m =>
Functor (Input t m)
forall k (t :: k) (m :: * -> *) a.
Applicative m =>
a -> Input t m a
forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
Input t m a -> Input t m b -> Input t m a
forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
Input t m a -> Input t m b -> Input t m b
forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
Input t m (a -> b) -> Input t m a -> Input t m b
forall k (t :: k) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> Input t m a -> Input t m b -> Input t m c
forall a b. Input t m a -> Input t m b -> Input t m a
forall a b. Input t m a -> Input t m b -> Input t m b
forall a b. Input t m (a -> b) -> Input t m a -> Input t m b
forall a b c.
(a -> b -> c) -> Input t m a -> Input t m b -> Input t m c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: Input t m a -> Input t m b -> Input t m a
$c<* :: forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
Input t m a -> Input t m b -> Input t m a
*> :: Input t m a -> Input t m b -> Input t m b
$c*> :: forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
Input t m a -> Input t m b -> Input t m b
liftA2 :: (a -> b -> c) -> Input t m a -> Input t m b -> Input t m c
$cliftA2 :: forall k (t :: k) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> Input t m a -> Input t m b -> Input t m c
<*> :: Input t m (a -> b) -> Input t m a -> Input t m b
$c<*> :: forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
Input t m (a -> b) -> Input t m a -> Input t m b
pure :: a -> Input t m a
$cpure :: forall k (t :: k) (m :: * -> *) a.
Applicative m =>
a -> Input t m a
$cp1Applicative :: forall k (t :: k) (m :: * -> *).
Applicative m =>
Functor (Input t m)
Applicative
    , Applicative (Input t m)
a -> Input t m a
Applicative (Input t m)
-> (forall a b. Input t m a -> (a -> Input t m b) -> Input t m b)
-> (forall a b. Input t m a -> Input t m b -> Input t m b)
-> (forall a. a -> Input t m a)
-> Monad (Input t m)
Input t m a -> (a -> Input t m b) -> Input t m b
Input t m a -> Input t m b -> Input t m b
forall a. a -> Input t m a
forall k (t :: k) (m :: * -> *). Monad m => Applicative (Input t m)
forall k (t :: k) (m :: * -> *) a. Monad m => a -> Input t m a
forall k (t :: k) (m :: * -> *) a b.
Monad m =>
Input t m a -> Input t m b -> Input t m b
forall k (t :: k) (m :: * -> *) a b.
Monad m =>
Input t m a -> (a -> Input t m b) -> Input t m b
forall a b. Input t m a -> Input t m b -> Input t m b
forall a b. Input t m a -> (a -> Input t m b) -> Input t m b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> Input t m a
$creturn :: forall k (t :: k) (m :: * -> *) a. Monad m => a -> Input t m a
>> :: Input t m a -> Input t m b -> Input t m b
$c>> :: forall k (t :: k) (m :: * -> *) a b.
Monad m =>
Input t m a -> Input t m b -> Input t m b
>>= :: Input t m a -> (a -> Input t m b) -> Input t m b
$c>>= :: forall k (t :: k) (m :: * -> *) a b.
Monad m =>
Input t m a -> (a -> Input t m b) -> Input t m b
$cp1Monad :: forall k (t :: k) (m :: * -> *). Monad m => Applicative (Input t m)
Monad
    , MonadSample t
    , MonadHold t
    , Monad (Input t m)
Monad (Input t m)
-> (forall a. (a -> Input t m a) -> Input t m a)
-> MonadFix (Input t m)
(a -> Input t m a) -> Input t m a
forall a. (a -> Input t m a) -> Input t m a
forall k (t :: k) (m :: * -> *). MonadFix m => Monad (Input t m)
forall k (t :: k) (m :: * -> *) a.
MonadFix m =>
(a -> Input t m a) -> Input t m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
mfix :: (a -> Input t m a) -> Input t m a
$cmfix :: forall k (t :: k) (m :: * -> *) a.
MonadFix m =>
(a -> Input t m a) -> Input t m a
$cp1MonadFix :: forall k (t :: k) (m :: * -> *). MonadFix m => Monad (Input t m)
MonadFix
    , Monad (Input t m)
Monad (Input t m)
-> (forall a. IO a -> Input t m a) -> MonadIO (Input t m)
IO a -> Input t m a
forall a. IO a -> Input t m a
forall k (t :: k) (m :: * -> *). MonadIO m => Monad (Input t m)
forall k (t :: k) (m :: * -> *) a. MonadIO m => IO a -> Input t m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
liftIO :: IO a -> Input t m a
$cliftIO :: forall k (t :: k) (m :: * -> *) a. MonadIO m => IO a -> Input t m a
$cp1MonadIO :: forall k (t :: k) (m :: * -> *). MonadIO m => Monad (Input t m)
MonadIO
    , Monad (Input t m)
a -> Input t m (Ref (Input t m) a)
Monad (Input t m)
-> (forall a. a -> Input t m (Ref (Input t m) a))
-> (forall a. Ref (Input t m) a -> Input t m a)
-> (forall a. Ref (Input t m) a -> a -> Input t m ())
-> (forall a. Ref (Input t m) a -> (a -> a) -> Input t m ())
-> (forall a. Ref (Input t m) a -> (a -> a) -> Input t m ())
-> MonadRef (Input t m)
Ref (Input t m) a -> Input t m a
Ref (Input t m) a -> a -> Input t m ()
Ref (Input t m) a -> (a -> a) -> Input t m ()
Ref (Input t m) a -> (a -> a) -> Input t m ()
forall a. a -> Input t m (Ref (Input t m) a)
forall a. Ref (Input t m) a -> Input t m a
forall a. Ref (Input t m) a -> a -> Input t m ()
forall a. Ref (Input t m) a -> (a -> a) -> Input t m ()
forall k (t :: k) (m :: * -> *). MonadRef m => Monad (Input t m)
forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
a -> Input t m (Ref (Input t m) a)
forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (Input t m) a -> Input t m a
forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (Input t m) a -> a -> Input t m ()
forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (Input t m) a -> (a -> a) -> Input t m ()
forall (m :: * -> *).
Monad m
-> (forall a. a -> m (Ref m a))
-> (forall a. Ref m a -> m a)
-> (forall a. Ref m a -> a -> m ())
-> (forall a. Ref m a -> (a -> a) -> m ())
-> (forall a. Ref m a -> (a -> a) -> m ())
-> MonadRef m
modifyRef' :: Ref (Input t m) a -> (a -> a) -> Input t m ()
$cmodifyRef' :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (Input t m) a -> (a -> a) -> Input t m ()
modifyRef :: Ref (Input t m) a -> (a -> a) -> Input t m ()
$cmodifyRef :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (Input t m) a -> (a -> a) -> Input t m ()
writeRef :: Ref (Input t m) a -> a -> Input t m ()
$cwriteRef :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (Input t m) a -> a -> Input t m ()
readRef :: Ref (Input t m) a -> Input t m a
$creadRef :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (Input t m) a -> Input t m a
newRef :: a -> Input t m (Ref (Input t m) a)
$cnewRef :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
a -> Input t m (Ref (Input t m) a)
$cp1MonadRef :: forall k (t :: k) (m :: * -> *). MonadRef m => Monad (Input t m)
MonadRef
    , MonadThrow (Input t m)
MonadThrow (Input t m)
-> (forall e a.
    Exception e =>
    Input t m a -> (e -> Input t m a) -> Input t m a)
-> MonadCatch (Input t m)
Input t m a -> (e -> Input t m a) -> Input t m a
forall k (t :: k) (m :: * -> *).
MonadCatch m =>
MonadThrow (Input t m)
forall k (t :: k) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
Input t m a -> (e -> Input t m a) -> Input t m a
forall e a.
Exception e =>
Input t m a -> (e -> Input t m a) -> Input t m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
catch :: Input t m a -> (e -> Input t m a) -> Input t m a
$ccatch :: forall k (t :: k) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
Input t m a -> (e -> Input t m a) -> Input t m a
$cp1MonadCatch :: forall k (t :: k) (m :: * -> *).
MonadCatch m =>
MonadThrow (Input t m)
MonadCatch
    , Monad (Input t m)
e -> Input t m a
Monad (Input t m)
-> (forall e a. Exception e => e -> Input t m a)
-> MonadThrow (Input t m)
forall k (t :: k) (m :: * -> *). MonadThrow m => Monad (Input t m)
forall k (t :: k) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> Input t m a
forall e a. Exception e => e -> Input t m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
throwM :: e -> Input t m a
$cthrowM :: forall k (t :: k) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> Input t m a
$cp1MonadThrow :: forall k (t :: k) (m :: * -> *). MonadThrow m => Monad (Input t m)
MonadThrow
    , MonadCatch (Input t m)
MonadCatch (Input t m)
-> (forall b.
    ((forall a. Input t m a -> Input t m a) -> Input t m b)
    -> Input t m b)
-> (forall b.
    ((forall a. Input t m a -> Input t m a) -> Input t m b)
    -> Input t m b)
-> (forall a b c.
    Input t m a
    -> (a -> ExitCase b -> Input t m c)
    -> (a -> Input t m b)
    -> Input t m (b, c))
-> MonadMask (Input t m)
Input t m a
-> (a -> ExitCase b -> Input t m c)
-> (a -> Input t m b)
-> Input t m (b, c)
((forall a. Input t m a -> Input t m a) -> Input t m b)
-> Input t m b
((forall a. Input t m a -> Input t m a) -> Input t m b)
-> Input t m b
forall b.
((forall a. Input t m a -> Input t m a) -> Input t m b)
-> Input t m b
forall k (t :: k) (m :: * -> *).
MonadMask m =>
MonadCatch (Input t m)
forall k (t :: k) (m :: * -> *) b.
MonadMask m =>
((forall a. Input t m a -> Input t m a) -> Input t m b)
-> Input t m b
forall k (t :: k) (m :: * -> *) a b c.
MonadMask m =>
Input t m a
-> (a -> ExitCase b -> Input t m c)
-> (a -> Input t m b)
-> Input t m (b, c)
forall a b c.
Input t m a
-> (a -> ExitCase b -> Input t m c)
-> (a -> Input t m b)
-> Input t m (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
generalBracket :: Input t m a
-> (a -> ExitCase b -> Input t m c)
-> (a -> Input t m b)
-> Input t m (b, c)
$cgeneralBracket :: forall k (t :: k) (m :: * -> *) a b c.
MonadMask m =>
Input t m a
-> (a -> ExitCase b -> Input t m c)
-> (a -> Input t m b)
-> Input t m (b, c)
uninterruptibleMask :: ((forall a. Input t m a -> Input t m a) -> Input t m b)
-> Input t m b
$cuninterruptibleMask :: forall k (t :: k) (m :: * -> *) b.
MonadMask m =>
((forall a. Input t m a -> Input t m a) -> Input t m b)
-> Input t m b
mask :: ((forall a. Input t m a -> Input t m a) -> Input t m b)
-> Input t m b
$cmask :: forall k (t :: k) (m :: * -> *) b.
MonadMask m =>
((forall a. Input t m a -> Input t m a) -> Input t m b)
-> Input t m b
$cp1MonadMask :: forall k (t :: k) (m :: * -> *).
MonadMask m =>
MonadCatch (Input t m)
MonadMask
    )

instance (Adjustable t m, MonadHold t m, Reflex t) => Adjustable t (Input t m) where
  runWithReplace :: Input t m a -> Event t (Input t m b) -> Input t m (a, Event t b)
runWithReplace Input t m a
a0 Event t (Input t m b)
a' = ReaderT (Event t Event) m (a, Event t b)
-> Input t m (a, Event t b)
forall k (t :: k) (m :: * -> *) a.
ReaderT (Event t Event) m a -> Input t m a
Input (ReaderT (Event t Event) m (a, Event t b)
 -> Input t m (a, Event t b))
-> ReaderT (Event t Event) m (a, Event t b)
-> Input t m (a, Event t b)
forall a b. (a -> b) -> a -> b
$ ReaderT (Event t Event) m a
-> Event t (ReaderT (Event t Event) m b)
-> ReaderT (Event t Event) m (a, Event t b)
forall t (m :: * -> *) a b.
Adjustable t m =>
m a -> Event t (m b) -> m (a, Event t b)
runWithReplace (Input t m a -> ReaderT (Event t Event) m a
forall k (t :: k) (m :: * -> *) a.
Input t m a -> ReaderT (Event t Event) m a
unInput Input t m a
a0) (Event t (ReaderT (Event t Event) m b)
 -> ReaderT (Event t Event) m (a, Event t b))
-> Event t (ReaderT (Event t Event) m b)
-> ReaderT (Event t Event) m (a, Event t b)
forall a b. (a -> b) -> a -> b
$ (Input t m b -> ReaderT (Event t Event) m b)
-> Event t (Input t m b) -> Event t (ReaderT (Event t Event) m b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Input t m b -> ReaderT (Event t Event) m b
forall k (t :: k) (m :: * -> *) a.
Input t m a -> ReaderT (Event t Event) m a
unInput Event t (Input t m b)
a'
  traverseIntMapWithKeyWithAdjust :: (Int -> v -> Input t m v')
-> IntMap v
-> Event t (PatchIntMap v)
-> Input t m (IntMap v', Event t (PatchIntMap v'))
traverseIntMapWithKeyWithAdjust Int -> v -> Input t m v'
f IntMap v
dm0 Event t (PatchIntMap v)
dm' = ReaderT (Event t Event) m (IntMap v', Event t (PatchIntMap v'))
-> Input t m (IntMap v', Event t (PatchIntMap v'))
forall k (t :: k) (m :: * -> *) a.
ReaderT (Event t Event) m a -> Input t m a
Input (ReaderT (Event t Event) m (IntMap v', Event t (PatchIntMap v'))
 -> Input t m (IntMap v', Event t (PatchIntMap v')))
-> ReaderT (Event t Event) m (IntMap v', Event t (PatchIntMap v'))
-> Input t m (IntMap v', Event t (PatchIntMap v'))
forall a b. (a -> b) -> a -> b
$
    (Int -> v -> ReaderT (Event t Event) m v')
-> IntMap v
-> Event t (PatchIntMap v)
-> ReaderT (Event t Event) m (IntMap v', Event t (PatchIntMap v'))
forall t (m :: * -> *) v v'.
Adjustable t m =>
(Int -> v -> m v')
-> IntMap v
-> Event t (PatchIntMap v)
-> m (IntMap v', Event t (PatchIntMap v'))
traverseIntMapWithKeyWithAdjust (\Int
k v
v -> Input t m v' -> ReaderT (Event t Event) m v'
forall k (t :: k) (m :: * -> *) a.
Input t m a -> ReaderT (Event t Event) m a
unInput (Int -> v -> Input t m v'
f Int
k v
v)) IntMap v
dm0 Event t (PatchIntMap v)
dm'
  traverseDMapWithKeyWithAdjust :: (forall a. k a -> v a -> Input t m (v' a))
-> DMap k v
-> Event t (PatchDMap k v)
-> Input t m (DMap k v', Event t (PatchDMap k v'))
traverseDMapWithKeyWithAdjust forall a. k a -> v a -> Input t m (v' a)
f DMap k v
dm0 Event t (PatchDMap k v)
dm' = ReaderT (Event t Event) m (DMap k v', Event t (PatchDMap k v'))
-> Input t m (DMap k v', Event t (PatchDMap k v'))
forall k (t :: k) (m :: * -> *) a.
ReaderT (Event t Event) m a -> Input t m a
Input (ReaderT (Event t Event) m (DMap k v', Event t (PatchDMap k v'))
 -> Input t m (DMap k v', Event t (PatchDMap k v')))
-> ReaderT (Event t Event) m (DMap k v', Event t (PatchDMap k v'))
-> Input t m (DMap k v', Event t (PatchDMap k v'))
forall a b. (a -> b) -> a -> b
$ do
    (forall a. k a -> v a -> ReaderT (Event t Event) m (v' a))
-> DMap k v
-> Event t (PatchDMap k v)
-> ReaderT (Event t Event) m (DMap k v', Event t (PatchDMap k v'))
forall t (m :: * -> *) (k :: * -> *) (v :: * -> *) (v' :: * -> *).
(Adjustable t m, GCompare k) =>
(forall a. k a -> v a -> m (v' a))
-> DMap k v
-> Event t (PatchDMap k v)
-> m (DMap k v', Event t (PatchDMap k v'))
traverseDMapWithKeyWithAdjust (\k a
k v a
v -> Input t m (v' a) -> ReaderT (Event t Event) m (v' a)
forall k (t :: k) (m :: * -> *) a.
Input t m a -> ReaderT (Event t Event) m a
unInput (k a -> v a -> Input t m (v' a)
forall a. k a -> v a -> Input t m (v' a)
f k a
k v a
v)) DMap k v
dm0 Event t (PatchDMap k v)
dm'
  traverseDMapWithKeyWithAdjustWithMove :: (forall a. k a -> v a -> Input t m (v' a))
-> DMap k v
-> Event t (PatchDMapWithMove k v)
-> Input t m (DMap k v', Event t (PatchDMapWithMove k v'))
traverseDMapWithKeyWithAdjustWithMove forall a. k a -> v a -> Input t m (v' a)
f DMap k v
dm0 Event t (PatchDMapWithMove k v)
dm' = ReaderT
  (Event t Event) m (DMap k v', Event t (PatchDMapWithMove k v'))
-> Input t m (DMap k v', Event t (PatchDMapWithMove k v'))
forall k (t :: k) (m :: * -> *) a.
ReaderT (Event t Event) m a -> Input t m a
Input (ReaderT
   (Event t Event) m (DMap k v', Event t (PatchDMapWithMove k v'))
 -> Input t m (DMap k v', Event t (PatchDMapWithMove k v')))
-> ReaderT
     (Event t Event) m (DMap k v', Event t (PatchDMapWithMove k v'))
-> Input t m (DMap k v', Event t (PatchDMapWithMove k v'))
forall a b. (a -> b) -> a -> b
$ do
    (forall a. k a -> v a -> ReaderT (Event t Event) m (v' a))
-> DMap k v
-> Event t (PatchDMapWithMove k v)
-> ReaderT
     (Event t Event) m (DMap k v', Event t (PatchDMapWithMove k v'))
forall t (m :: * -> *) (k :: * -> *) (v :: * -> *) (v' :: * -> *).
(Adjustable t m, GCompare k) =>
(forall a. k a -> v a -> m (v' a))
-> DMap k v
-> Event t (PatchDMapWithMove k v)
-> m (DMap k v', Event t (PatchDMapWithMove k v'))
traverseDMapWithKeyWithAdjustWithMove (\k a
k v a
v -> Input t m (v' a) -> ReaderT (Event t Event) m (v' a)
forall k (t :: k) (m :: * -> *) a.
Input t m a -> ReaderT (Event t Event) m a
unInput (k a -> v a -> Input t m (v' a)
forall a. k a -> v a -> Input t m (v' a)
f k a
k v a
v)) DMap k v
dm0 Event t (PatchDMapWithMove k v)
dm'

deriving instance MonadReflexCreateTrigger t m => MonadReflexCreateTrigger t (Input t m)
deriving instance NotReady t m => NotReady t (Input t m)
deriving instance PerformEvent t m => PerformEvent t (Input t m)
deriving instance PostBuild t m => PostBuild t (Input t m)
deriving instance TriggerEvent t m => TriggerEvent t (Input t m)
instance HasImageWriter t m => HasImageWriter t (Input t m)
instance HasDisplayRegion t m => HasDisplayRegion t (Input t m)
instance HasFocusReader t m => HasFocusReader t (Input t m)

instance MonadTrans (Input t) where
  lift :: m a -> Input t m a
lift m a
f = ReaderT (Event t Event) m a -> Input t m a
forall k (t :: k) (m :: * -> *) a.
ReaderT (Event t Event) m a -> Input t m a
Input (ReaderT (Event t Event) m a -> Input t m a)
-> ReaderT (Event t Event) m a -> Input t m a
forall a b. (a -> b) -> a -> b
$ m a -> ReaderT (Event t Event) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m a
f

instance MFunctor (Input t) where
  hoist :: (forall a. m a -> n a) -> Input t m b -> Input t n b
hoist forall a. m a -> n a
f = ReaderT (Event t Event) n b -> Input t n b
forall k (t :: k) (m :: * -> *) a.
ReaderT (Event t Event) m a -> Input t m a
Input (ReaderT (Event t Event) n b -> Input t n b)
-> (Input t m b -> ReaderT (Event t Event) n b)
-> Input t m b
-> Input t n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. m a -> n a)
-> ReaderT (Event t Event) m b -> ReaderT (Event t Event) n b
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. m a -> n a
f (ReaderT (Event t Event) m b -> ReaderT (Event t Event) n b)
-> (Input t m b -> ReaderT (Event t Event) m b)
-> Input t m b
-> ReaderT (Event t Event) n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Input t m b -> ReaderT (Event t Event) m b
forall k (t :: k) (m :: * -> *) a.
Input t m a -> ReaderT (Event t Event) m a
unInput

instance MonadNodeId m => MonadNodeId (Input t m)

-- | Runs an 'Input' with a given context
runInput
  :: Reflex t
  => Event t VtyEvent
  -> Input t m a
  -> m a
runInput :: Event t Event -> Input t m a -> m a
runInput Event t Event
e Input t m a
w = ReaderT (Event t Event) m a -> Event t Event -> m a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (Input t m a -> ReaderT (Event t Event) m a
forall k (t :: k) (m :: * -> *) a.
Input t m a -> ReaderT (Event t Event) m a
unInput Input t m a
w) Event t Event
e

-- ** Filtering input

-- | Type synonym for a key and modifier combination
type KeyCombo = (V.Key, [V.Modifier])

-- | Emits an event that fires on a particular key press (without modifiers)
key :: (Monad m, Reflex t, HasInput t m) => V.Key -> m (Event t KeyCombo)
key :: Key -> m (Event t KeyCombo)
key = Set KeyCombo -> m (Event t KeyCombo)
forall k (t :: k) (m :: * -> *).
(Reflex t, Monad m, HasInput t m) =>
Set KeyCombo -> m (Event t KeyCombo)
keyCombos (Set KeyCombo -> m (Event t KeyCombo))
-> (Key -> Set KeyCombo) -> Key -> m (Event t KeyCombo)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyCombo -> Set KeyCombo
forall a. a -> Set a
Set.singleton (KeyCombo -> Set KeyCombo)
-> (Key -> KeyCombo) -> Key -> Set KeyCombo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (,[])

-- | Emits an event that fires on particular key presses (without modifiers)
keys :: (Monad m, Reflex t, HasInput t m) => [V.Key] -> m (Event t KeyCombo)
keys :: [Key] -> m (Event t KeyCombo)
keys = Set KeyCombo -> m (Event t KeyCombo)
forall k (t :: k) (m :: * -> *).
(Reflex t, Monad m, HasInput t m) =>
Set KeyCombo -> m (Event t KeyCombo)
keyCombos (Set KeyCombo -> m (Event t KeyCombo))
-> ([Key] -> Set KeyCombo) -> [Key] -> m (Event t KeyCombo)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [KeyCombo] -> Set KeyCombo
forall a. Ord a => [a] -> Set a
Set.fromList ([KeyCombo] -> Set KeyCombo)
-> ([Key] -> [KeyCombo]) -> [Key] -> Set KeyCombo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Key -> KeyCombo) -> [Key] -> [KeyCombo]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (,[])

-- | Emit an event that fires whenever the provided key combination occurs
keyCombo
  :: (Reflex t, Monad m, HasInput t m)
  => KeyCombo
  -> m (Event t KeyCombo)
keyCombo :: KeyCombo -> m (Event t KeyCombo)
keyCombo = Set KeyCombo -> m (Event t KeyCombo)
forall k (t :: k) (m :: * -> *).
(Reflex t, Monad m, HasInput t m) =>
Set KeyCombo -> m (Event t KeyCombo)
keyCombos (Set KeyCombo -> m (Event t KeyCombo))
-> (KeyCombo -> Set KeyCombo) -> KeyCombo -> m (Event t KeyCombo)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyCombo -> Set KeyCombo
forall a. a -> Set a
Set.singleton

-- | Emit an event that fires whenever any of the provided key combinations occur
keyCombos
  :: (Reflex t, Monad m, HasInput t m)
  => Set KeyCombo
  -> m (Event t KeyCombo)
keyCombos :: Set KeyCombo -> m (Event t KeyCombo)
keyCombos Set KeyCombo
ks = do
  Event t Event
i <- m (Event t Event)
forall k (t :: k) (m :: * -> *). HasInput t m => m (Event t Event)
input
  Event t KeyCombo -> m (Event t KeyCombo)
forall (m :: * -> *) a. Monad m => a -> m a
return (Event t KeyCombo -> m (Event t KeyCombo))
-> Event t KeyCombo -> m (Event t KeyCombo)
forall a b. (a -> b) -> a -> b
$ Event t Event -> (Event -> Maybe KeyCombo) -> Event t KeyCombo
forall (f :: * -> *) a b.
Filterable f =>
f a -> (a -> Maybe b) -> f b
fforMaybe Event t Event
i ((Event -> Maybe KeyCombo) -> Event t KeyCombo)
-> (Event -> Maybe KeyCombo) -> Event t KeyCombo
forall a b. (a -> b) -> a -> b
$ \case
    V.EvKey Key
k [Modifier]
m -> if KeyCombo -> Set KeyCombo -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.member (Key
k, [Modifier]
m) Set KeyCombo
ks
      then KeyCombo -> Maybe KeyCombo
forall a. a -> Maybe a
Just (Key
k, [Modifier]
m)
      else Maybe KeyCombo
forall a. Maybe a
Nothing
    Event
_ -> Maybe KeyCombo
forall a. Maybe a
Nothing

-- | Filter the keyboard input that a child widget may receive
filterKeys :: (Reflex t, HasInput t m) => (KeyCombo -> Bool) -> m a -> m a
filterKeys :: (KeyCombo -> Bool) -> m a -> m a
filterKeys KeyCombo -> Bool
f m a
x = (Event t Event -> Event t Event) -> m a -> m a
forall k (t :: k) (m :: * -> *) a.
HasInput t m =>
(Event t Event -> Event t Event) -> m a -> m a
localInput ((Event -> Bool) -> Event t Event -> Event t Event
forall (f :: * -> *) a. Filterable f => (a -> Bool) -> f a -> f a
ffilter (\case
  V.EvKey Key
k [Modifier]
mods -> KeyCombo -> Bool
f (Key
k, [Modifier]
mods)
  Event
_ -> Bool
True)) m a
x

-- | Filter mouse input events based on whether they target a particular region
-- and translate them to the internal coordinate system of that region.
--
-- NB: Non-mouse events are passed through unfiltered and unchanged
mouseInRegion :: Region -> VtyEvent -> Maybe VtyEvent
mouseInRegion :: Region -> Event -> Maybe Event
mouseInRegion (Region Int
l Int
t Int
w Int
h) Event
e = case Event
e of
  V.EvMouseDown Int
x Int
y Button
btn [Modifier]
m -> (Int -> Int -> Event) -> Int -> Int -> Maybe Event
mouse (\Int
u Int
v -> Int -> Int -> Button -> [Modifier] -> Event
V.EvMouseDown Int
u Int
v Button
btn [Modifier]
m) Int
x Int
y
  V.EvMouseUp Int
x Int
y Maybe Button
btn -> (Int -> Int -> Event) -> Int -> Int -> Maybe Event
mouse (\Int
u Int
v -> Int -> Int -> Maybe Button -> Event
V.EvMouseUp Int
u Int
v Maybe Button
btn) Int
x Int
y
  Event
_ -> Event -> Maybe Event
forall a. a -> Maybe a
Just Event
e
  where
    mouse :: (Int -> Int -> Event) -> Int -> Int -> Maybe Event
mouse Int -> Int -> Event
con Int
x Int
y
      | [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
or [ Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
l
           , Int
y Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
t
           , Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
l Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
w
           , Int
y Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
t Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
h ] = Maybe Event
forall a. Maybe a
Nothing
      | Bool
otherwise =
        Event -> Maybe Event
forall a. a -> Maybe a
Just (Int -> Int -> Event
con (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
l) (Int
y Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
t))

-- |
-- * 'Tracking' state means actively tracking the current stream of mouse events
-- * 'NotTracking' state means not tracking the current stream of mouse events
-- * 'WaitingForInput' means state will be set on next 'EvMouseDown' event
data MouseTrackingState = Tracking V.Button | NotTracking | WaitingForInput deriving (Int -> MouseTrackingState -> ShowS
[MouseTrackingState] -> ShowS
MouseTrackingState -> String
(Int -> MouseTrackingState -> ShowS)
-> (MouseTrackingState -> String)
-> ([MouseTrackingState] -> ShowS)
-> Show MouseTrackingState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MouseTrackingState] -> ShowS
$cshowList :: [MouseTrackingState] -> ShowS
show :: MouseTrackingState -> String
$cshow :: MouseTrackingState -> String
showsPrec :: Int -> MouseTrackingState -> ShowS
$cshowsPrec :: Int -> MouseTrackingState -> ShowS
Show, MouseTrackingState -> MouseTrackingState -> Bool
(MouseTrackingState -> MouseTrackingState -> Bool)
-> (MouseTrackingState -> MouseTrackingState -> Bool)
-> Eq MouseTrackingState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MouseTrackingState -> MouseTrackingState -> Bool
$c/= :: MouseTrackingState -> MouseTrackingState -> Bool
== :: MouseTrackingState -> MouseTrackingState -> Bool
$c== :: MouseTrackingState -> MouseTrackingState -> Bool
Eq)

-- | Filter mouse input outside the current display region
-- keyboard input is reported only if the region is focused
-- scroll wheel input is reported only if the region is focused
-- mouse input is reported if the mouse is in the region
-- EXCEPT mouse drag sequences that start OFF the region are NOT reported
-- AND mouse drag sequences that start ON the region and drag off ARE reported
inputInFocusedRegion
  :: forall t m. (MonadFix m, MonadHold t m, HasDisplayRegion t m, HasFocusReader t m, HasInput t m)
  => m (Event t VtyEvent)
inputInFocusedRegion :: m (Event t Event)
inputInFocusedRegion = do
  Event t Event
inp <- m (Event t Event)
forall k (t :: k) (m :: * -> *). HasInput t m => m (Event t Event)
input
  Behavior t Region
regBeh <- Dynamic t Region -> Behavior t Region
forall k (t :: k) a. Reflex t => Dynamic t a -> Behavior t a
current (Dynamic t Region -> Behavior t Region)
-> m (Dynamic t Region) -> m (Behavior t Region)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Dynamic t Region)
forall k (t :: k) (m :: * -> *).
HasDisplayRegion t m =>
m (Dynamic t Region)
askRegion
  Behavior t Bool
foc <- Dynamic t Bool -> Behavior t Bool
forall k (t :: k) a. Reflex t => Dynamic t a -> Behavior t a
current (Dynamic t Bool -> Behavior t Bool)
-> m (Dynamic t Bool) -> m (Behavior t Bool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Dynamic t Bool)
forall k (t :: k) (m :: * -> *).
HasFocusReader t m =>
m (Dynamic t Bool)
focus
  let
    trackMouse ::
      VtyEvent
      -> (MouseTrackingState, Maybe VtyEvent)
      -> PushM t (Maybe (MouseTrackingState, Maybe VtyEvent))
    trackMouse :: Event
-> (MouseTrackingState, Maybe Event)
-> PushM t (Maybe (MouseTrackingState, Maybe Event))
trackMouse Event
e (MouseTrackingState
tracking, Maybe Event
_) = do
      -- sampling (as oppose to using attachPromptlyDyn) is necessary here as the focus may change from the event produced here
      Bool
focused <- Behavior t Bool -> PushM t Bool
forall k (t :: k) (m :: * -> *) a.
MonadSample t m =>
Behavior t a -> m a
sample Behavior t Bool
foc
      -- strictly speaking the same could also happen here too
      reg :: Region
reg@(Region Int
l Int
t Int
_ Int
_) <- Behavior t Region -> PushM t Region
forall k (t :: k) (m :: * -> *) a.
MonadSample t m =>
Behavior t a -> m a
sample Behavior t Region
regBeh
      Maybe (MouseTrackingState, Maybe Event)
-> PushM t (Maybe (MouseTrackingState, Maybe Event))
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (MouseTrackingState, Maybe Event)
 -> PushM t (Maybe (MouseTrackingState, Maybe Event)))
-> Maybe (MouseTrackingState, Maybe Event)
-> PushM t (Maybe (MouseTrackingState, Maybe Event))
forall a b. (a -> b) -> a -> b
$ case Event
e of

        -- filter keyboard input if region is not focused
        V.EvKey Key
_ [Modifier]
_ | Bool -> Bool
not Bool
focused -> Maybe (MouseTrackingState, Maybe Event)
forall a. Maybe a
Nothing

        -- filter scroll wheel input based on mouse position
        ev :: Event
ev@(V.EvMouseDown Int
x Int
y Button
btn [Modifier]
m) | Button
btn Button -> Button -> Bool
forall a. Eq a => a -> a -> Bool
== Button
V.BScrollUp Bool -> Bool -> Bool
|| Button
btn Button -> Button -> Bool
forall a. Eq a => a -> a -> Bool
== Button
V.BScrollDown -> case MouseTrackingState
tracking of
          trck :: MouseTrackingState
trck@(Tracking Button
_) -> (MouseTrackingState, Maybe Event)
-> Maybe (MouseTrackingState, Maybe Event)
forall a. a -> Maybe a
Just (MouseTrackingState
trck, Maybe Event
forall a. Maybe a
Nothing)
          MouseTrackingState
_ -> (MouseTrackingState, Maybe Event)
-> Maybe (MouseTrackingState, Maybe Event)
forall a. a -> Maybe a
Just (MouseTrackingState
WaitingForInput, if Region -> Int -> Int -> Bool
withinRegion Region
reg Int
x Int
y then Event -> Maybe Event
forall a. a -> Maybe a
Just (Int -> Int -> Button -> [Modifier] -> Event
V.EvMouseDown (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
l) (Int
y Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
t) Button
btn [Modifier]
m) else Maybe Event
forall a. Maybe a
Nothing)

        -- only do tracking for l/m/r mouse buttons
        V.EvMouseDown Int
x Int
y Button
btn [Modifier]
m ->
          if MouseTrackingState
tracking MouseTrackingState -> MouseTrackingState -> Bool
forall a. Eq a => a -> a -> Bool
== Button -> MouseTrackingState
Tracking Button
btn Bool -> Bool -> Bool
|| (MouseTrackingState
tracking MouseTrackingState -> MouseTrackingState -> Bool
forall a. Eq a => a -> a -> Bool
== MouseTrackingState
WaitingForInput Bool -> Bool -> Bool
&& Region -> Int -> Int -> Bool
withinRegion Region
reg Int
x Int
y)
            then (MouseTrackingState, Maybe Event)
-> Maybe (MouseTrackingState, Maybe Event)
forall a. a -> Maybe a
Just (Button -> MouseTrackingState
Tracking Button
btn, Event -> Maybe Event
forall a. a -> Maybe a
Just (Event -> Maybe Event) -> Event -> Maybe Event
forall a b. (a -> b) -> a -> b
$ Int -> Int -> Button -> [Modifier] -> Event
V.EvMouseDown (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
l) (Int
y Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
t) Button
btn [Modifier]
m)
            else (MouseTrackingState, Maybe Event)
-> Maybe (MouseTrackingState, Maybe Event)
forall a. a -> Maybe a
Just (MouseTrackingState
NotTracking, Maybe Event
forall a. Maybe a
Nothing)
        V.EvMouseUp Int
x Int
y Maybe Button
mbtn -> case Maybe Button
mbtn of
          Maybe Button
Nothing -> case MouseTrackingState
tracking of
            Tracking Button
_ -> (MouseTrackingState, Maybe Event)
-> Maybe (MouseTrackingState, Maybe Event)
forall a. a -> Maybe a
Just (MouseTrackingState
WaitingForInput, Event -> Maybe Event
forall a. a -> Maybe a
Just (Event -> Maybe Event) -> Event -> Maybe Event
forall a b. (a -> b) -> a -> b
$ Int -> Int -> Maybe Button -> Event
V.EvMouseUp (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
l) (Int
y Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
t) Maybe Button
mbtn)
            MouseTrackingState
_ -> (MouseTrackingState, Maybe Event)
-> Maybe (MouseTrackingState, Maybe Event)
forall a. a -> Maybe a
Just (MouseTrackingState
WaitingForInput, Maybe Event
forall a. Maybe a
Nothing)
          Just Button
btn -> if MouseTrackingState
tracking MouseTrackingState -> MouseTrackingState -> Bool
forall a. Eq a => a -> a -> Bool
== Button -> MouseTrackingState
Tracking Button
btn
            -- NOTE we only report EvMouseUp for the button we are tracking
            -- vty has mouse buttons override others (seems to be based on ordering of Button) when multiple are pressed.
            -- so it IS possible for child widget to miss out on a 'EvMouseUp' event with this current implementation
            then (MouseTrackingState, Maybe Event)
-> Maybe (MouseTrackingState, Maybe Event)
forall a. a -> Maybe a
Just (MouseTrackingState
WaitingForInput, Event -> Maybe Event
forall a. a -> Maybe a
Just (Event -> Maybe Event) -> Event -> Maybe Event
forall a b. (a -> b) -> a -> b
$ Int -> Int -> Maybe Button -> Event
V.EvMouseUp (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
l) (Int
y Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
t) Maybe Button
mbtn)
            else (MouseTrackingState, Maybe Event)
-> Maybe (MouseTrackingState, Maybe Event)
forall a. a -> Maybe a
Just (MouseTrackingState
WaitingForInput, Maybe Event
forall a. Maybe a
Nothing)
        Event
_ -> (MouseTrackingState, Maybe Event)
-> Maybe (MouseTrackingState, Maybe Event)
forall a. a -> Maybe a
Just (MouseTrackingState
tracking, Event -> Maybe Event
forall a. a -> Maybe a
Just Event
e)
  Dynamic t (MouseTrackingState, Maybe Event)
dynInputEvTracking <- (Event
 -> (MouseTrackingState, Maybe Event)
 -> PushM t (Maybe (MouseTrackingState, Maybe Event)))
-> (MouseTrackingState, Maybe Event)
-> Event t Event
-> m (Dynamic t (MouseTrackingState, Maybe Event))
forall k (t :: k) (m :: * -> *) a b.
(Reflex t, MonadHold t m, MonadFix m) =>
(a -> b -> PushM t (Maybe b)) -> b -> Event t a -> m (Dynamic t b)
foldDynMaybeM Event
-> (MouseTrackingState, Maybe Event)
-> PushM t (Maybe (MouseTrackingState, Maybe Event))
trackMouse (MouseTrackingState
WaitingForInput, Maybe Event
forall a. Maybe a
Nothing) (Event t Event -> m (Dynamic t (MouseTrackingState, Maybe Event)))
-> Event t Event -> m (Dynamic t (MouseTrackingState, Maybe Event))
forall a b. (a -> b) -> a -> b
$ Event t Event
inp
  Event t Event -> m (Event t Event)
forall (m :: * -> *) a. Monad m => a -> m a
return (((MouseTrackingState, Maybe Event) -> Maybe Event)
-> Event t (MouseTrackingState, Maybe Event) -> Event t Event
forall (f :: * -> *) a b.
Filterable f =>
(a -> Maybe b) -> f a -> f b
fmapMaybe (MouseTrackingState, Maybe Event) -> Maybe Event
forall a b. (a, b) -> b
snd (Event t (MouseTrackingState, Maybe Event) -> Event t Event)
-> Event t (MouseTrackingState, Maybe Event) -> Event t Event
forall a b. (a -> b) -> a -> b
$ Dynamic t (MouseTrackingState, Maybe Event)
-> Event t (MouseTrackingState, Maybe Event)
forall k (t :: k) a. Reflex t => Dynamic t a -> Event t a
updated Dynamic t (MouseTrackingState, Maybe Event)
dynInputEvTracking)

-- * Getting and setting the display region

-- | A chunk of the display area
data Region = Region
  { Region -> Int
_region_left :: Int
  , Region -> Int
_region_top :: Int
  , Region -> Int
_region_width :: Int
  , Region -> Int
_region_height :: Int
  }
  deriving (Int -> Region -> ShowS
[Region] -> ShowS
Region -> String
(Int -> Region -> ShowS)
-> (Region -> String) -> ([Region] -> ShowS) -> Show Region
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Region] -> ShowS
$cshowList :: [Region] -> ShowS
show :: Region -> String
$cshow :: Region -> String
showsPrec :: Int -> Region -> ShowS
$cshowsPrec :: Int -> Region -> ShowS
Show, ReadPrec [Region]
ReadPrec Region
Int -> ReadS Region
ReadS [Region]
(Int -> ReadS Region)
-> ReadS [Region]
-> ReadPrec Region
-> ReadPrec [Region]
-> Read Region
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Region]
$creadListPrec :: ReadPrec [Region]
readPrec :: ReadPrec Region
$creadPrec :: ReadPrec Region
readList :: ReadS [Region]
$creadList :: ReadS [Region]
readsPrec :: Int -> ReadS Region
$creadsPrec :: Int -> ReadS Region
Read, Region -> Region -> Bool
(Region -> Region -> Bool)
-> (Region -> Region -> Bool) -> Eq Region
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Region -> Region -> Bool
$c/= :: Region -> Region -> Bool
== :: Region -> Region -> Bool
$c== :: Region -> Region -> Bool
Eq, Eq Region
Eq Region
-> (Region -> Region -> Ordering)
-> (Region -> Region -> Bool)
-> (Region -> Region -> Bool)
-> (Region -> Region -> Bool)
-> (Region -> Region -> Bool)
-> (Region -> Region -> Region)
-> (Region -> Region -> Region)
-> Ord Region
Region -> Region -> Bool
Region -> Region -> Ordering
Region -> Region -> Region
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Region -> Region -> Region
$cmin :: Region -> Region -> Region
max :: Region -> Region -> Region
$cmax :: Region -> Region -> Region
>= :: Region -> Region -> Bool
$c>= :: Region -> Region -> Bool
> :: Region -> Region -> Bool
$c> :: Region -> Region -> Bool
<= :: Region -> Region -> Bool
$c<= :: Region -> Region -> Bool
< :: Region -> Region -> Bool
$c< :: Region -> Region -> Bool
compare :: Region -> Region -> Ordering
$ccompare :: Region -> Region -> Ordering
$cp1Ord :: Eq Region
Ord)

-- | A region that occupies no space.
nilRegion :: Region
nilRegion :: Region
nilRegion = Int -> Int -> Int -> Int -> Region
Region Int
0 Int
0 Int
0 Int
0

-- | The width and height of a 'Region'
regionSize :: Region -> (Int, Int)
regionSize :: Region -> DisplayRegion
regionSize (Region Int
_ Int
_ Int
w Int
h) = (Int
w, Int
h)

-- | Check whether the x,y coordinates are within the specified region
withinRegion
  :: Region
  -> Int
  -- ^ x-coordinate
  -> Int
  -- ^ y-coordinate
  -> Bool
withinRegion :: Region -> Int -> Int -> Bool
withinRegion (Region Int
l Int
t Int
w Int
h) Int
x Int
y = Bool -> Bool
not (Bool -> Bool) -> ([Bool] -> Bool) -> [Bool] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
or ([Bool] -> Bool) -> [Bool] -> Bool
forall a b. (a -> b) -> a -> b
$
  [ Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
l
  , Int
y Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
t
  , Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
l Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
w
  , Int
y Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
t Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
h
  ]

-- | Produces an 'Image' that fills a region with space characters
regionBlankImage :: V.Attr -> Region -> Image
regionBlankImage :: Attr -> Region -> Image
regionBlankImage Attr
attr r :: Region
r@(Region Int
_ Int
_ Int
width Int
height) =
  Region -> Image -> Image
withinImage Region
r (Image -> Image) -> Image -> Image
forall a b. (a -> b) -> a -> b
$ Attr -> Char -> Int -> Int -> Image
forall d. Integral d => Attr -> Char -> d -> d -> Image
V.charFill Attr
attr Char
' ' Int
width Int
height

-- | A class for things that know their own display size dimensions
class (Reflex t, Monad m) => HasDisplayRegion t m | m -> t where
  -- | Retrieve the display region
  askRegion :: m (Dynamic t Region)
  default askRegion :: (f m' ~ m, MonadTrans f, HasDisplayRegion t m') => m (Dynamic t Region)
  askRegion = m' (Dynamic t Region) -> f m' (Dynamic t Region)
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m' (Dynamic t Region)
forall k (t :: k) (m :: * -> *).
HasDisplayRegion t m =>
m (Dynamic t Region)
askRegion
  -- | Run an action in a local region, by applying a transformation to the region
  localRegion :: (Dynamic t Region -> Dynamic t Region) -> m a -> m a
  default localRegion :: (f m' ~ m, Monad m', MFunctor f, HasDisplayRegion t m') => (Dynamic t Region -> Dynamic t Region) -> m a -> m a
  localRegion Dynamic t Region -> Dynamic t Region
f = (forall a. m' a -> m' a) -> f m' a -> f m' a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist ((Dynamic t Region -> Dynamic t Region) -> m' a -> m' a
forall k (t :: k) (m :: * -> *) a.
HasDisplayRegion t m =>
(Dynamic t Region -> Dynamic t Region) -> m a -> m a
localRegion Dynamic t Region -> Dynamic t Region
f)

-- | Retrieve the display width
displayWidth :: HasDisplayRegion t m => m (Dynamic t Int)
displayWidth :: m (Dynamic t Int)
displayWidth = (Region -> Int) -> Dynamic t Region -> Dynamic t Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Region -> Int
_region_width (Dynamic t Region -> Dynamic t Int)
-> m (Dynamic t Region) -> m (Dynamic t Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Dynamic t Region)
forall k (t :: k) (m :: * -> *).
HasDisplayRegion t m =>
m (Dynamic t Region)
askRegion

-- | Retrieve the display height
displayHeight :: HasDisplayRegion t m => m (Dynamic t Int)
displayHeight :: m (Dynamic t Int)
displayHeight = (Region -> Int) -> Dynamic t Region -> Dynamic t Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Region -> Int
_region_height (Dynamic t Region -> Dynamic t Int)
-> m (Dynamic t Region) -> m (Dynamic t Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Dynamic t Region)
forall k (t :: k) (m :: * -> *).
HasDisplayRegion t m =>
m (Dynamic t Region)
askRegion

instance HasDisplayRegion t m => HasDisplayRegion t (ReaderT x m)
instance HasDisplayRegion t m => HasDisplayRegion t (BehaviorWriterT t x m)
instance HasDisplayRegion t m => HasDisplayRegion t (DynamicWriterT t x m)
instance HasDisplayRegion t m => HasDisplayRegion t (EventWriterT t x m)
instance HasDisplayRegion t m => HasDisplayRegion t (NodeIdT m)

-- | A widget that has access to a particular region of the vty display
newtype DisplayRegion t m a = DisplayRegion
  { DisplayRegion t m a -> ReaderT (Dynamic t Region) m a
unDisplayRegion :: ReaderT (Dynamic t Region) m a }
  deriving
    ( a -> DisplayRegion t m b -> DisplayRegion t m a
(a -> b) -> DisplayRegion t m a -> DisplayRegion t m b
(forall a b.
 (a -> b) -> DisplayRegion t m a -> DisplayRegion t m b)
-> (forall a b. a -> DisplayRegion t m b -> DisplayRegion t m a)
-> Functor (DisplayRegion t m)
forall k (t :: k) (m :: * -> *) a b.
Functor m =>
a -> DisplayRegion t m b -> DisplayRegion t m a
forall k (t :: k) (m :: * -> *) a b.
Functor m =>
(a -> b) -> DisplayRegion t m a -> DisplayRegion t m b
forall a b. a -> DisplayRegion t m b -> DisplayRegion t m a
forall a b. (a -> b) -> DisplayRegion t m a -> DisplayRegion t m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> DisplayRegion t m b -> DisplayRegion t m a
$c<$ :: forall k (t :: k) (m :: * -> *) a b.
Functor m =>
a -> DisplayRegion t m b -> DisplayRegion t m a
fmap :: (a -> b) -> DisplayRegion t m a -> DisplayRegion t m b
$cfmap :: forall k (t :: k) (m :: * -> *) a b.
Functor m =>
(a -> b) -> DisplayRegion t m a -> DisplayRegion t m b
Functor
    , Functor (DisplayRegion t m)
a -> DisplayRegion t m a
Functor (DisplayRegion t m)
-> (forall a. a -> DisplayRegion t m a)
-> (forall a b.
    DisplayRegion t m (a -> b)
    -> DisplayRegion t m a -> DisplayRegion t m b)
-> (forall a b c.
    (a -> b -> c)
    -> DisplayRegion t m a
    -> DisplayRegion t m b
    -> DisplayRegion t m c)
-> (forall a b.
    DisplayRegion t m a -> DisplayRegion t m b -> DisplayRegion t m b)
-> (forall a b.
    DisplayRegion t m a -> DisplayRegion t m b -> DisplayRegion t m a)
-> Applicative (DisplayRegion t m)
DisplayRegion t m a -> DisplayRegion t m b -> DisplayRegion t m b
DisplayRegion t m a -> DisplayRegion t m b -> DisplayRegion t m a
DisplayRegion t m (a -> b)
-> DisplayRegion t m a -> DisplayRegion t m b
(a -> b -> c)
-> DisplayRegion t m a
-> DisplayRegion t m b
-> DisplayRegion t m c
forall a. a -> DisplayRegion t m a
forall k (t :: k) (m :: * -> *).
Applicative m =>
Functor (DisplayRegion t m)
forall k (t :: k) (m :: * -> *) a.
Applicative m =>
a -> DisplayRegion t m a
forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
DisplayRegion t m a -> DisplayRegion t m b -> DisplayRegion t m a
forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
DisplayRegion t m a -> DisplayRegion t m b -> DisplayRegion t m b
forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
DisplayRegion t m (a -> b)
-> DisplayRegion t m a -> DisplayRegion t m b
forall k (t :: k) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> DisplayRegion t m a
-> DisplayRegion t m b
-> DisplayRegion t m c
forall a b.
DisplayRegion t m a -> DisplayRegion t m b -> DisplayRegion t m a
forall a b.
DisplayRegion t m a -> DisplayRegion t m b -> DisplayRegion t m b
forall a b.
DisplayRegion t m (a -> b)
-> DisplayRegion t m a -> DisplayRegion t m b
forall a b c.
(a -> b -> c)
-> DisplayRegion t m a
-> DisplayRegion t m b
-> DisplayRegion t m c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: DisplayRegion t m a -> DisplayRegion t m b -> DisplayRegion t m a
$c<* :: forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
DisplayRegion t m a -> DisplayRegion t m b -> DisplayRegion t m a
*> :: DisplayRegion t m a -> DisplayRegion t m b -> DisplayRegion t m b
$c*> :: forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
DisplayRegion t m a -> DisplayRegion t m b -> DisplayRegion t m b
liftA2 :: (a -> b -> c)
-> DisplayRegion t m a
-> DisplayRegion t m b
-> DisplayRegion t m c
$cliftA2 :: forall k (t :: k) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> DisplayRegion t m a
-> DisplayRegion t m b
-> DisplayRegion t m c
<*> :: DisplayRegion t m (a -> b)
-> DisplayRegion t m a -> DisplayRegion t m b
$c<*> :: forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
DisplayRegion t m (a -> b)
-> DisplayRegion t m a -> DisplayRegion t m b
pure :: a -> DisplayRegion t m a
$cpure :: forall k (t :: k) (m :: * -> *) a.
Applicative m =>
a -> DisplayRegion t m a
$cp1Applicative :: forall k (t :: k) (m :: * -> *).
Applicative m =>
Functor (DisplayRegion t m)
Applicative
    , Applicative (DisplayRegion t m)
a -> DisplayRegion t m a
Applicative (DisplayRegion t m)
-> (forall a b.
    DisplayRegion t m a
    -> (a -> DisplayRegion t m b) -> DisplayRegion t m b)
-> (forall a b.
    DisplayRegion t m a -> DisplayRegion t m b -> DisplayRegion t m b)
-> (forall a. a -> DisplayRegion t m a)
-> Monad (DisplayRegion t m)
DisplayRegion t m a
-> (a -> DisplayRegion t m b) -> DisplayRegion t m b
DisplayRegion t m a -> DisplayRegion t m b -> DisplayRegion t m b
forall a. a -> DisplayRegion t m a
forall k (t :: k) (m :: * -> *).
Monad m =>
Applicative (DisplayRegion t m)
forall k (t :: k) (m :: * -> *) a.
Monad m =>
a -> DisplayRegion t m a
forall k (t :: k) (m :: * -> *) a b.
Monad m =>
DisplayRegion t m a -> DisplayRegion t m b -> DisplayRegion t m b
forall k (t :: k) (m :: * -> *) a b.
Monad m =>
DisplayRegion t m a
-> (a -> DisplayRegion t m b) -> DisplayRegion t m b
forall a b.
DisplayRegion t m a -> DisplayRegion t m b -> DisplayRegion t m b
forall a b.
DisplayRegion t m a
-> (a -> DisplayRegion t m b) -> DisplayRegion t m b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> DisplayRegion t m a
$creturn :: forall k (t :: k) (m :: * -> *) a.
Monad m =>
a -> DisplayRegion t m a
>> :: DisplayRegion t m a -> DisplayRegion t m b -> DisplayRegion t m b
$c>> :: forall k (t :: k) (m :: * -> *) a b.
Monad m =>
DisplayRegion t m a -> DisplayRegion t m b -> DisplayRegion t m b
>>= :: DisplayRegion t m a
-> (a -> DisplayRegion t m b) -> DisplayRegion t m b
$c>>= :: forall k (t :: k) (m :: * -> *) a b.
Monad m =>
DisplayRegion t m a
-> (a -> DisplayRegion t m b) -> DisplayRegion t m b
$cp1Monad :: forall k (t :: k) (m :: * -> *).
Monad m =>
Applicative (DisplayRegion t m)
Monad
    , Monad (DisplayRegion t m)
Monad (DisplayRegion t m)
-> (forall a. (a -> DisplayRegion t m a) -> DisplayRegion t m a)
-> MonadFix (DisplayRegion t m)
(a -> DisplayRegion t m a) -> DisplayRegion t m a
forall a. (a -> DisplayRegion t m a) -> DisplayRegion t m a
forall k (t :: k) (m :: * -> *).
MonadFix m =>
Monad (DisplayRegion t m)
forall k (t :: k) (m :: * -> *) a.
MonadFix m =>
(a -> DisplayRegion t m a) -> DisplayRegion t m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
mfix :: (a -> DisplayRegion t m a) -> DisplayRegion t m a
$cmfix :: forall k (t :: k) (m :: * -> *) a.
MonadFix m =>
(a -> DisplayRegion t m a) -> DisplayRegion t m a
$cp1MonadFix :: forall k (t :: k) (m :: * -> *).
MonadFix m =>
Monad (DisplayRegion t m)
MonadFix
    , MonadHold t
    , Monad (DisplayRegion t m)
Monad (DisplayRegion t m)
-> (forall a. IO a -> DisplayRegion t m a)
-> MonadIO (DisplayRegion t m)
IO a -> DisplayRegion t m a
forall a. IO a -> DisplayRegion t m a
forall k (t :: k) (m :: * -> *).
MonadIO m =>
Monad (DisplayRegion t m)
forall k (t :: k) (m :: * -> *) a.
MonadIO m =>
IO a -> DisplayRegion t m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
liftIO :: IO a -> DisplayRegion t m a
$cliftIO :: forall k (t :: k) (m :: * -> *) a.
MonadIO m =>
IO a -> DisplayRegion t m a
$cp1MonadIO :: forall k (t :: k) (m :: * -> *).
MonadIO m =>
Monad (DisplayRegion t m)
MonadIO
    , Monad (DisplayRegion t m)
a -> DisplayRegion t m (Ref (DisplayRegion t m) a)
Monad (DisplayRegion t m)
-> (forall a. a -> DisplayRegion t m (Ref (DisplayRegion t m) a))
-> (forall a. Ref (DisplayRegion t m) a -> DisplayRegion t m a)
-> (forall a.
    Ref (DisplayRegion t m) a -> a -> DisplayRegion t m ())
-> (forall a.
    Ref (DisplayRegion t m) a -> (a -> a) -> DisplayRegion t m ())
-> (forall a.
    Ref (DisplayRegion t m) a -> (a -> a) -> DisplayRegion t m ())
-> MonadRef (DisplayRegion t m)
Ref (DisplayRegion t m) a -> DisplayRegion t m a
Ref (DisplayRegion t m) a -> a -> DisplayRegion t m ()
Ref (DisplayRegion t m) a -> (a -> a) -> DisplayRegion t m ()
Ref (DisplayRegion t m) a -> (a -> a) -> DisplayRegion t m ()
forall a. a -> DisplayRegion t m (Ref (DisplayRegion t m) a)
forall a. Ref (DisplayRegion t m) a -> DisplayRegion t m a
forall a. Ref (DisplayRegion t m) a -> a -> DisplayRegion t m ()
forall a.
Ref (DisplayRegion t m) a -> (a -> a) -> DisplayRegion t m ()
forall k (t :: k) (m :: * -> *).
MonadRef m =>
Monad (DisplayRegion t m)
forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
a -> DisplayRegion t m (Ref (DisplayRegion t m) a)
forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (DisplayRegion t m) a -> DisplayRegion t m a
forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (DisplayRegion t m) a -> a -> DisplayRegion t m ()
forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (DisplayRegion t m) a -> (a -> a) -> DisplayRegion t m ()
forall (m :: * -> *).
Monad m
-> (forall a. a -> m (Ref m a))
-> (forall a. Ref m a -> m a)
-> (forall a. Ref m a -> a -> m ())
-> (forall a. Ref m a -> (a -> a) -> m ())
-> (forall a. Ref m a -> (a -> a) -> m ())
-> MonadRef m
modifyRef' :: Ref (DisplayRegion t m) a -> (a -> a) -> DisplayRegion t m ()
$cmodifyRef' :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (DisplayRegion t m) a -> (a -> a) -> DisplayRegion t m ()
modifyRef :: Ref (DisplayRegion t m) a -> (a -> a) -> DisplayRegion t m ()
$cmodifyRef :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (DisplayRegion t m) a -> (a -> a) -> DisplayRegion t m ()
writeRef :: Ref (DisplayRegion t m) a -> a -> DisplayRegion t m ()
$cwriteRef :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (DisplayRegion t m) a -> a -> DisplayRegion t m ()
readRef :: Ref (DisplayRegion t m) a -> DisplayRegion t m a
$creadRef :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (DisplayRegion t m) a -> DisplayRegion t m a
newRef :: a -> DisplayRegion t m (Ref (DisplayRegion t m) a)
$cnewRef :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
a -> DisplayRegion t m (Ref (DisplayRegion t m) a)
$cp1MonadRef :: forall k (t :: k) (m :: * -> *).
MonadRef m =>
Monad (DisplayRegion t m)
MonadRef
    , MonadSample t
    , MonadThrow (DisplayRegion t m)
MonadThrow (DisplayRegion t m)
-> (forall e a.
    Exception e =>
    DisplayRegion t m a
    -> (e -> DisplayRegion t m a) -> DisplayRegion t m a)
-> MonadCatch (DisplayRegion t m)
DisplayRegion t m a
-> (e -> DisplayRegion t m a) -> DisplayRegion t m a
forall k (t :: k) (m :: * -> *).
MonadCatch m =>
MonadThrow (DisplayRegion t m)
forall k (t :: k) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
DisplayRegion t m a
-> (e -> DisplayRegion t m a) -> DisplayRegion t m a
forall e a.
Exception e =>
DisplayRegion t m a
-> (e -> DisplayRegion t m a) -> DisplayRegion t m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
catch :: DisplayRegion t m a
-> (e -> DisplayRegion t m a) -> DisplayRegion t m a
$ccatch :: forall k (t :: k) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
DisplayRegion t m a
-> (e -> DisplayRegion t m a) -> DisplayRegion t m a
$cp1MonadCatch :: forall k (t :: k) (m :: * -> *).
MonadCatch m =>
MonadThrow (DisplayRegion t m)
MonadCatch
    , Monad (DisplayRegion t m)
e -> DisplayRegion t m a
Monad (DisplayRegion t m)
-> (forall e a. Exception e => e -> DisplayRegion t m a)
-> MonadThrow (DisplayRegion t m)
forall k (t :: k) (m :: * -> *).
MonadThrow m =>
Monad (DisplayRegion t m)
forall k (t :: k) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> DisplayRegion t m a
forall e a. Exception e => e -> DisplayRegion t m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
throwM :: e -> DisplayRegion t m a
$cthrowM :: forall k (t :: k) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> DisplayRegion t m a
$cp1MonadThrow :: forall k (t :: k) (m :: * -> *).
MonadThrow m =>
Monad (DisplayRegion t m)
MonadThrow
    , MonadCatch (DisplayRegion t m)
MonadCatch (DisplayRegion t m)
-> (forall b.
    ((forall a. DisplayRegion t m a -> DisplayRegion t m a)
     -> DisplayRegion t m b)
    -> DisplayRegion t m b)
-> (forall b.
    ((forall a. DisplayRegion t m a -> DisplayRegion t m a)
     -> DisplayRegion t m b)
    -> DisplayRegion t m b)
-> (forall a b c.
    DisplayRegion t m a
    -> (a -> ExitCase b -> DisplayRegion t m c)
    -> (a -> DisplayRegion t m b)
    -> DisplayRegion t m (b, c))
-> MonadMask (DisplayRegion t m)
DisplayRegion t m a
-> (a -> ExitCase b -> DisplayRegion t m c)
-> (a -> DisplayRegion t m b)
-> DisplayRegion t m (b, c)
((forall a. DisplayRegion t m a -> DisplayRegion t m a)
 -> DisplayRegion t m b)
-> DisplayRegion t m b
((forall a. DisplayRegion t m a -> DisplayRegion t m a)
 -> DisplayRegion t m b)
-> DisplayRegion t m b
forall b.
((forall a. DisplayRegion t m a -> DisplayRegion t m a)
 -> DisplayRegion t m b)
-> DisplayRegion t m b
forall k (t :: k) (m :: * -> *).
MonadMask m =>
MonadCatch (DisplayRegion t m)
forall k (t :: k) (m :: * -> *) b.
MonadMask m =>
((forall a. DisplayRegion t m a -> DisplayRegion t m a)
 -> DisplayRegion t m b)
-> DisplayRegion t m b
forall k (t :: k) (m :: * -> *) a b c.
MonadMask m =>
DisplayRegion t m a
-> (a -> ExitCase b -> DisplayRegion t m c)
-> (a -> DisplayRegion t m b)
-> DisplayRegion t m (b, c)
forall a b c.
DisplayRegion t m a
-> (a -> ExitCase b -> DisplayRegion t m c)
-> (a -> DisplayRegion t m b)
-> DisplayRegion t m (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
generalBracket :: DisplayRegion t m a
-> (a -> ExitCase b -> DisplayRegion t m c)
-> (a -> DisplayRegion t m b)
-> DisplayRegion t m (b, c)
$cgeneralBracket :: forall k (t :: k) (m :: * -> *) a b c.
MonadMask m =>
DisplayRegion t m a
-> (a -> ExitCase b -> DisplayRegion t m c)
-> (a -> DisplayRegion t m b)
-> DisplayRegion t m (b, c)
uninterruptibleMask :: ((forall a. DisplayRegion t m a -> DisplayRegion t m a)
 -> DisplayRegion t m b)
-> DisplayRegion t m b
$cuninterruptibleMask :: forall k (t :: k) (m :: * -> *) b.
MonadMask m =>
((forall a. DisplayRegion t m a -> DisplayRegion t m a)
 -> DisplayRegion t m b)
-> DisplayRegion t m b
mask :: ((forall a. DisplayRegion t m a -> DisplayRegion t m a)
 -> DisplayRegion t m b)
-> DisplayRegion t m b
$cmask :: forall k (t :: k) (m :: * -> *) b.
MonadMask m =>
((forall a. DisplayRegion t m a -> DisplayRegion t m a)
 -> DisplayRegion t m b)
-> DisplayRegion t m b
$cp1MonadMask :: forall k (t :: k) (m :: * -> *).
MonadMask m =>
MonadCatch (DisplayRegion t m)
MonadMask
    )

instance (Monad m, Reflex t) => HasDisplayRegion t (DisplayRegion t m) where
  askRegion :: DisplayRegion t m (Dynamic t Region)
askRegion = ReaderT (Dynamic t Region) m (Dynamic t Region)
-> DisplayRegion t m (Dynamic t Region)
forall k (t :: k) (m :: * -> *) a.
ReaderT (Dynamic t Region) m a -> DisplayRegion t m a
DisplayRegion ReaderT (Dynamic t Region) m (Dynamic t Region)
forall r (m :: * -> *). MonadReader r m => m r
ask
  localRegion :: (Dynamic t Region -> Dynamic t Region)
-> DisplayRegion t m a -> DisplayRegion t m a
localRegion Dynamic t Region -> Dynamic t Region
f = ReaderT (Dynamic t Region) m a -> DisplayRegion t m a
forall k (t :: k) (m :: * -> *) a.
ReaderT (Dynamic t Region) m a -> DisplayRegion t m a
DisplayRegion (ReaderT (Dynamic t Region) m a -> DisplayRegion t m a)
-> (DisplayRegion t m a -> ReaderT (Dynamic t Region) m a)
-> DisplayRegion t m a
-> DisplayRegion t m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Dynamic t Region -> Dynamic t Region)
-> ReaderT (Dynamic t Region) m a -> ReaderT (Dynamic t Region) m a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local Dynamic t Region -> Dynamic t Region
f (ReaderT (Dynamic t Region) m a -> ReaderT (Dynamic t Region) m a)
-> (DisplayRegion t m a -> ReaderT (Dynamic t Region) m a)
-> DisplayRegion t m a
-> ReaderT (Dynamic t Region) m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DisplayRegion t m a -> ReaderT (Dynamic t Region) m a
forall k (t :: k) (m :: * -> *) a.
DisplayRegion t m a -> ReaderT (Dynamic t Region) m a
unDisplayRegion

deriving instance MonadReflexCreateTrigger t m => MonadReflexCreateTrigger t (DisplayRegion t m)
deriving instance NotReady t m => NotReady t (DisplayRegion t m)
deriving instance PerformEvent t m => PerformEvent t (DisplayRegion t m)
deriving instance PostBuild t m => PostBuild t (DisplayRegion t m)
deriving instance TriggerEvent t m => TriggerEvent t (DisplayRegion t m)
instance HasImageWriter t m => HasImageWriter t (DisplayRegion t m)
instance HasFocusReader t m => HasFocusReader t (DisplayRegion t m)

instance (Adjustable t m, MonadFix m, MonadHold t m) => Adjustable t (DisplayRegion t m) where
  runWithReplace :: DisplayRegion t m a
-> Event t (DisplayRegion t m b)
-> DisplayRegion t m (a, Event t b)
runWithReplace (DisplayRegion ReaderT (Dynamic t Region) m a
a) Event t (DisplayRegion t m b)
e = ReaderT (Dynamic t Region) m (a, Event t b)
-> DisplayRegion t m (a, Event t b)
forall k (t :: k) (m :: * -> *) a.
ReaderT (Dynamic t Region) m a -> DisplayRegion t m a
DisplayRegion (ReaderT (Dynamic t Region) m (a, Event t b)
 -> DisplayRegion t m (a, Event t b))
-> ReaderT (Dynamic t Region) m (a, Event t b)
-> DisplayRegion t m (a, Event t b)
forall a b. (a -> b) -> a -> b
$ ReaderT (Dynamic t Region) m a
-> Event t (ReaderT (Dynamic t Region) m b)
-> ReaderT (Dynamic t Region) m (a, Event t b)
forall t (m :: * -> *) a b.
Adjustable t m =>
m a -> Event t (m b) -> m (a, Event t b)
runWithReplace ReaderT (Dynamic t Region) m a
a (Event t (ReaderT (Dynamic t Region) m b)
 -> ReaderT (Dynamic t Region) m (a, Event t b))
-> Event t (ReaderT (Dynamic t Region) m b)
-> ReaderT (Dynamic t Region) m (a, Event t b)
forall a b. (a -> b) -> a -> b
$ (DisplayRegion t m b -> ReaderT (Dynamic t Region) m b)
-> Event t (DisplayRegion t m b)
-> Event t (ReaderT (Dynamic t Region) m b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DisplayRegion t m b -> ReaderT (Dynamic t Region) m b
forall k (t :: k) (m :: * -> *) a.
DisplayRegion t m a -> ReaderT (Dynamic t Region) m a
unDisplayRegion Event t (DisplayRegion t m b)
e
  traverseIntMapWithKeyWithAdjust :: (Int -> v -> DisplayRegion t m v')
-> IntMap v
-> Event t (PatchIntMap v)
-> DisplayRegion t m (IntMap v', Event t (PatchIntMap v'))
traverseIntMapWithKeyWithAdjust Int -> v -> DisplayRegion t m v'
f IntMap v
m Event t (PatchIntMap v)
e = ReaderT (Dynamic t Region) m (IntMap v', Event t (PatchIntMap v'))
-> DisplayRegion t m (IntMap v', Event t (PatchIntMap v'))
forall k (t :: k) (m :: * -> *) a.
ReaderT (Dynamic t Region) m a -> DisplayRegion t m a
DisplayRegion (ReaderT (Dynamic t Region) m (IntMap v', Event t (PatchIntMap v'))
 -> DisplayRegion t m (IntMap v', Event t (PatchIntMap v')))
-> ReaderT
     (Dynamic t Region) m (IntMap v', Event t (PatchIntMap v'))
-> DisplayRegion t m (IntMap v', Event t (PatchIntMap v'))
forall a b. (a -> b) -> a -> b
$ (Int -> v -> ReaderT (Dynamic t Region) m v')
-> IntMap v
-> Event t (PatchIntMap v)
-> ReaderT
     (Dynamic t Region) m (IntMap v', Event t (PatchIntMap v'))
forall t (m :: * -> *) v v'.
Adjustable t m =>
(Int -> v -> m v')
-> IntMap v
-> Event t (PatchIntMap v)
-> m (IntMap v', Event t (PatchIntMap v'))
traverseIntMapWithKeyWithAdjust (\Int
k v
v -> DisplayRegion t m v' -> ReaderT (Dynamic t Region) m v'
forall k (t :: k) (m :: * -> *) a.
DisplayRegion t m a -> ReaderT (Dynamic t Region) m a
unDisplayRegion (DisplayRegion t m v' -> ReaderT (Dynamic t Region) m v')
-> DisplayRegion t m v' -> ReaderT (Dynamic t Region) m v'
forall a b. (a -> b) -> a -> b
$ Int -> v -> DisplayRegion t m v'
f Int
k v
v) IntMap v
m Event t (PatchIntMap v)
e
  traverseDMapWithKeyWithAdjust :: (forall a. k a -> v a -> DisplayRegion t m (v' a))
-> DMap k v
-> Event t (PatchDMap k v)
-> DisplayRegion t m (DMap k v', Event t (PatchDMap k v'))
traverseDMapWithKeyWithAdjust forall a. k a -> v a -> DisplayRegion t m (v' a)
f DMap k v
m Event t (PatchDMap k v)
e = ReaderT (Dynamic t Region) m (DMap k v', Event t (PatchDMap k v'))
-> DisplayRegion t m (DMap k v', Event t (PatchDMap k v'))
forall k (t :: k) (m :: * -> *) a.
ReaderT (Dynamic t Region) m a -> DisplayRegion t m a
DisplayRegion (ReaderT (Dynamic t Region) m (DMap k v', Event t (PatchDMap k v'))
 -> DisplayRegion t m (DMap k v', Event t (PatchDMap k v')))
-> ReaderT
     (Dynamic t Region) m (DMap k v', Event t (PatchDMap k v'))
-> DisplayRegion t m (DMap k v', Event t (PatchDMap k v'))
forall a b. (a -> b) -> a -> b
$ (forall a. k a -> v a -> ReaderT (Dynamic t Region) m (v' a))
-> DMap k v
-> Event t (PatchDMap k v)
-> ReaderT
     (Dynamic t Region) m (DMap k v', Event t (PatchDMap k v'))
forall t (m :: * -> *) (k :: * -> *) (v :: * -> *) (v' :: * -> *).
(Adjustable t m, GCompare k) =>
(forall a. k a -> v a -> m (v' a))
-> DMap k v
-> Event t (PatchDMap k v)
-> m (DMap k v', Event t (PatchDMap k v'))
traverseDMapWithKeyWithAdjust (\k a
k v a
v -> DisplayRegion t m (v' a) -> ReaderT (Dynamic t Region) m (v' a)
forall k (t :: k) (m :: * -> *) a.
DisplayRegion t m a -> ReaderT (Dynamic t Region) m a
unDisplayRegion (DisplayRegion t m (v' a) -> ReaderT (Dynamic t Region) m (v' a))
-> DisplayRegion t m (v' a) -> ReaderT (Dynamic t Region) m (v' a)
forall a b. (a -> b) -> a -> b
$ k a -> v a -> DisplayRegion t m (v' a)
forall a. k a -> v a -> DisplayRegion t m (v' a)
f k a
k v a
v) DMap k v
m Event t (PatchDMap k v)
e
  traverseDMapWithKeyWithAdjustWithMove :: (forall a. k a -> v a -> DisplayRegion t m (v' a))
-> DMap k v
-> Event t (PatchDMapWithMove k v)
-> DisplayRegion t m (DMap k v', Event t (PatchDMapWithMove k v'))
traverseDMapWithKeyWithAdjustWithMove forall a. k a -> v a -> DisplayRegion t m (v' a)
f DMap k v
m Event t (PatchDMapWithMove k v)
e = ReaderT
  (Dynamic t Region) m (DMap k v', Event t (PatchDMapWithMove k v'))
-> DisplayRegion t m (DMap k v', Event t (PatchDMapWithMove k v'))
forall k (t :: k) (m :: * -> *) a.
ReaderT (Dynamic t Region) m a -> DisplayRegion t m a
DisplayRegion (ReaderT
   (Dynamic t Region) m (DMap k v', Event t (PatchDMapWithMove k v'))
 -> DisplayRegion t m (DMap k v', Event t (PatchDMapWithMove k v')))
-> ReaderT
     (Dynamic t Region) m (DMap k v', Event t (PatchDMapWithMove k v'))
-> DisplayRegion t m (DMap k v', Event t (PatchDMapWithMove k v'))
forall a b. (a -> b) -> a -> b
$ (forall a. k a -> v a -> ReaderT (Dynamic t Region) m (v' a))
-> DMap k v
-> Event t (PatchDMapWithMove k v)
-> ReaderT
     (Dynamic t Region) m (DMap k v', Event t (PatchDMapWithMove k v'))
forall t (m :: * -> *) (k :: * -> *) (v :: * -> *) (v' :: * -> *).
(Adjustable t m, GCompare k) =>
(forall a. k a -> v a -> m (v' a))
-> DMap k v
-> Event t (PatchDMapWithMove k v)
-> m (DMap k v', Event t (PatchDMapWithMove k v'))
traverseDMapWithKeyWithAdjustWithMove (\k a
k v a
v -> DisplayRegion t m (v' a) -> ReaderT (Dynamic t Region) m (v' a)
forall k (t :: k) (m :: * -> *) a.
DisplayRegion t m a -> ReaderT (Dynamic t Region) m a
unDisplayRegion (DisplayRegion t m (v' a) -> ReaderT (Dynamic t Region) m (v' a))
-> DisplayRegion t m (v' a) -> ReaderT (Dynamic t Region) m (v' a)
forall a b. (a -> b) -> a -> b
$ k a -> v a -> DisplayRegion t m (v' a)
forall a. k a -> v a -> DisplayRegion t m (v' a)
f k a
k v a
v) DMap k v
m Event t (PatchDMapWithMove k v)
e

instance MonadTrans (DisplayRegion t) where
  lift :: m a -> DisplayRegion t m a
lift = ReaderT (Dynamic t Region) m a -> DisplayRegion t m a
forall k (t :: k) (m :: * -> *) a.
ReaderT (Dynamic t Region) m a -> DisplayRegion t m a
DisplayRegion (ReaderT (Dynamic t Region) m a -> DisplayRegion t m a)
-> (m a -> ReaderT (Dynamic t Region) m a)
-> m a
-> DisplayRegion t m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> ReaderT (Dynamic t Region) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

instance MFunctor (DisplayRegion t) where
  hoist :: (forall a. m a -> n a)
-> DisplayRegion t m b -> DisplayRegion t n b
hoist forall a. m a -> n a
f = ReaderT (Dynamic t Region) n b -> DisplayRegion t n b
forall k (t :: k) (m :: * -> *) a.
ReaderT (Dynamic t Region) m a -> DisplayRegion t m a
DisplayRegion (ReaderT (Dynamic t Region) n b -> DisplayRegion t n b)
-> (DisplayRegion t m b -> ReaderT (Dynamic t Region) n b)
-> DisplayRegion t m b
-> DisplayRegion t n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. m a -> n a)
-> ReaderT (Dynamic t Region) m b -> ReaderT (Dynamic t Region) n b
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. m a -> n a
f (ReaderT (Dynamic t Region) m b -> ReaderT (Dynamic t Region) n b)
-> (DisplayRegion t m b -> ReaderT (Dynamic t Region) m b)
-> DisplayRegion t m b
-> ReaderT (Dynamic t Region) n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DisplayRegion t m b -> ReaderT (Dynamic t Region) m b
forall k (t :: k) (m :: * -> *) a.
DisplayRegion t m a -> ReaderT (Dynamic t Region) m a
unDisplayRegion

instance MonadNodeId m => MonadNodeId (DisplayRegion t m)

-- | Run a 'DisplayRegion' action with a given 'Region'
runDisplayRegion
  :: (Reflex t, Monad m)
  => Dynamic t Region
  -> DisplayRegion t m a
  -> m a
runDisplayRegion :: Dynamic t Region -> DisplayRegion t m a -> m a
runDisplayRegion Dynamic t Region
r = (ReaderT (Dynamic t Region) m a -> Dynamic t Region -> m a)
-> Dynamic t Region -> ReaderT (Dynamic t Region) m a -> m a
forall a b c. (a -> b -> c) -> b -> a -> c
flip ReaderT (Dynamic t Region) m a -> Dynamic t Region -> m a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT Dynamic t Region
r (ReaderT (Dynamic t Region) m a -> m a)
-> (DisplayRegion t m a -> ReaderT (Dynamic t Region) m a)
-> DisplayRegion t m a
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DisplayRegion t m a -> ReaderT (Dynamic t Region) m a
forall k (t :: k) (m :: * -> *) a.
DisplayRegion t m a -> ReaderT (Dynamic t Region) m a
unDisplayRegion

-- * Getting focus state

-- | A class for things that can dynamically gain and lose focus
class (Reflex t, Monad m) => HasFocusReader t m | m -> t where
  focus :: m (Dynamic t Bool)
  default focus :: (f m' ~ m, Monad m', MonadTrans f, HasFocusReader t m') => m (Dynamic t Bool)
  focus = m' (Dynamic t Bool) -> f m' (Dynamic t Bool)
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m' (Dynamic t Bool)
forall k (t :: k) (m :: * -> *).
HasFocusReader t m =>
m (Dynamic t Bool)
focus
  localFocus :: (Dynamic t Bool -> Dynamic t Bool) -> m a -> m a
  default localFocus :: (f m' ~ m, Monad m', MFunctor f, HasFocusReader t m') => (Dynamic t Bool -> Dynamic t Bool) -> m a -> m a
  localFocus Dynamic t Bool -> Dynamic t Bool
f = (forall a. m' a -> m' a) -> f m' a -> f m' a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist ((Dynamic t Bool -> Dynamic t Bool) -> m' a -> m' a
forall k (t :: k) (m :: * -> *) a.
HasFocusReader t m =>
(Dynamic t Bool -> Dynamic t Bool) -> m a -> m a
localFocus Dynamic t Bool -> Dynamic t Bool
f)

instance HasFocusReader t m => HasFocusReader t (ReaderT x m)
instance HasFocusReader t m => HasFocusReader t (BehaviorWriterT t x m)
instance HasFocusReader t m => HasFocusReader t (DynamicWriterT t x m)
instance HasFocusReader t m => HasFocusReader t (EventWriterT t x m)
instance HasFocusReader t m => HasFocusReader t (NodeIdT m)

-- | A widget that has access to information about whether it is focused
newtype FocusReader t m a = FocusReader
  { FocusReader t m a -> ReaderT (Dynamic t Bool) m a
unFocusReader :: ReaderT (Dynamic t Bool) m a }
  deriving
    ( a -> FocusReader t m b -> FocusReader t m a
(a -> b) -> FocusReader t m a -> FocusReader t m b
(forall a b. (a -> b) -> FocusReader t m a -> FocusReader t m b)
-> (forall a b. a -> FocusReader t m b -> FocusReader t m a)
-> Functor (FocusReader t m)
forall k (t :: k) (m :: * -> *) a b.
Functor m =>
a -> FocusReader t m b -> FocusReader t m a
forall k (t :: k) (m :: * -> *) a b.
Functor m =>
(a -> b) -> FocusReader t m a -> FocusReader t m b
forall a b. a -> FocusReader t m b -> FocusReader t m a
forall a b. (a -> b) -> FocusReader t m a -> FocusReader t m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> FocusReader t m b -> FocusReader t m a
$c<$ :: forall k (t :: k) (m :: * -> *) a b.
Functor m =>
a -> FocusReader t m b -> FocusReader t m a
fmap :: (a -> b) -> FocusReader t m a -> FocusReader t m b
$cfmap :: forall k (t :: k) (m :: * -> *) a b.
Functor m =>
(a -> b) -> FocusReader t m a -> FocusReader t m b
Functor
    , Functor (FocusReader t m)
a -> FocusReader t m a
Functor (FocusReader t m)
-> (forall a. a -> FocusReader t m a)
-> (forall a b.
    FocusReader t m (a -> b) -> FocusReader t m a -> FocusReader t m b)
-> (forall a b c.
    (a -> b -> c)
    -> FocusReader t m a -> FocusReader t m b -> FocusReader t m c)
-> (forall a b.
    FocusReader t m a -> FocusReader t m b -> FocusReader t m b)
-> (forall a b.
    FocusReader t m a -> FocusReader t m b -> FocusReader t m a)
-> Applicative (FocusReader t m)
FocusReader t m a -> FocusReader t m b -> FocusReader t m b
FocusReader t m a -> FocusReader t m b -> FocusReader t m a
FocusReader t m (a -> b) -> FocusReader t m a -> FocusReader t m b
(a -> b -> c)
-> FocusReader t m a -> FocusReader t m b -> FocusReader t m c
forall a. a -> FocusReader t m a
forall k (t :: k) (m :: * -> *).
Applicative m =>
Functor (FocusReader t m)
forall k (t :: k) (m :: * -> *) a.
Applicative m =>
a -> FocusReader t m a
forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
FocusReader t m a -> FocusReader t m b -> FocusReader t m a
forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
FocusReader t m a -> FocusReader t m b -> FocusReader t m b
forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
FocusReader t m (a -> b) -> FocusReader t m a -> FocusReader t m b
forall k (t :: k) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> FocusReader t m a -> FocusReader t m b -> FocusReader t m c
forall a b.
FocusReader t m a -> FocusReader t m b -> FocusReader t m a
forall a b.
FocusReader t m a -> FocusReader t m b -> FocusReader t m b
forall a b.
FocusReader t m (a -> b) -> FocusReader t m a -> FocusReader t m b
forall a b c.
(a -> b -> c)
-> FocusReader t m a -> FocusReader t m b -> FocusReader t m c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: FocusReader t m a -> FocusReader t m b -> FocusReader t m a
$c<* :: forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
FocusReader t m a -> FocusReader t m b -> FocusReader t m a
*> :: FocusReader t m a -> FocusReader t m b -> FocusReader t m b
$c*> :: forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
FocusReader t m a -> FocusReader t m b -> FocusReader t m b
liftA2 :: (a -> b -> c)
-> FocusReader t m a -> FocusReader t m b -> FocusReader t m c
$cliftA2 :: forall k (t :: k) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> FocusReader t m a -> FocusReader t m b -> FocusReader t m c
<*> :: FocusReader t m (a -> b) -> FocusReader t m a -> FocusReader t m b
$c<*> :: forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
FocusReader t m (a -> b) -> FocusReader t m a -> FocusReader t m b
pure :: a -> FocusReader t m a
$cpure :: forall k (t :: k) (m :: * -> *) a.
Applicative m =>
a -> FocusReader t m a
$cp1Applicative :: forall k (t :: k) (m :: * -> *).
Applicative m =>
Functor (FocusReader t m)
Applicative
    , Applicative (FocusReader t m)
a -> FocusReader t m a
Applicative (FocusReader t m)
-> (forall a b.
    FocusReader t m a -> (a -> FocusReader t m b) -> FocusReader t m b)
-> (forall a b.
    FocusReader t m a -> FocusReader t m b -> FocusReader t m b)
-> (forall a. a -> FocusReader t m a)
-> Monad (FocusReader t m)
FocusReader t m a -> (a -> FocusReader t m b) -> FocusReader t m b
FocusReader t m a -> FocusReader t m b -> FocusReader t m b
forall a. a -> FocusReader t m a
forall k (t :: k) (m :: * -> *).
Monad m =>
Applicative (FocusReader t m)
forall k (t :: k) (m :: * -> *) a.
Monad m =>
a -> FocusReader t m a
forall k (t :: k) (m :: * -> *) a b.
Monad m =>
FocusReader t m a -> FocusReader t m b -> FocusReader t m b
forall k (t :: k) (m :: * -> *) a b.
Monad m =>
FocusReader t m a -> (a -> FocusReader t m b) -> FocusReader t m b
forall a b.
FocusReader t m a -> FocusReader t m b -> FocusReader t m b
forall a b.
FocusReader t m a -> (a -> FocusReader t m b) -> FocusReader t m b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> FocusReader t m a
$creturn :: forall k (t :: k) (m :: * -> *) a.
Monad m =>
a -> FocusReader t m a
>> :: FocusReader t m a -> FocusReader t m b -> FocusReader t m b
$c>> :: forall k (t :: k) (m :: * -> *) a b.
Monad m =>
FocusReader t m a -> FocusReader t m b -> FocusReader t m b
>>= :: FocusReader t m a -> (a -> FocusReader t m b) -> FocusReader t m b
$c>>= :: forall k (t :: k) (m :: * -> *) a b.
Monad m =>
FocusReader t m a -> (a -> FocusReader t m b) -> FocusReader t m b
$cp1Monad :: forall k (t :: k) (m :: * -> *).
Monad m =>
Applicative (FocusReader t m)
Monad
    , Monad (FocusReader t m)
Monad (FocusReader t m)
-> (forall a. (a -> FocusReader t m a) -> FocusReader t m a)
-> MonadFix (FocusReader t m)
(a -> FocusReader t m a) -> FocusReader t m a
forall a. (a -> FocusReader t m a) -> FocusReader t m a
forall k (t :: k) (m :: * -> *).
MonadFix m =>
Monad (FocusReader t m)
forall k (t :: k) (m :: * -> *) a.
MonadFix m =>
(a -> FocusReader t m a) -> FocusReader t m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
mfix :: (a -> FocusReader t m a) -> FocusReader t m a
$cmfix :: forall k (t :: k) (m :: * -> *) a.
MonadFix m =>
(a -> FocusReader t m a) -> FocusReader t m a
$cp1MonadFix :: forall k (t :: k) (m :: * -> *).
MonadFix m =>
Monad (FocusReader t m)
MonadFix
    , MonadHold t
    , Monad (FocusReader t m)
Monad (FocusReader t m)
-> (forall a. IO a -> FocusReader t m a)
-> MonadIO (FocusReader t m)
IO a -> FocusReader t m a
forall a. IO a -> FocusReader t m a
forall k (t :: k) (m :: * -> *).
MonadIO m =>
Monad (FocusReader t m)
forall k (t :: k) (m :: * -> *) a.
MonadIO m =>
IO a -> FocusReader t m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
liftIO :: IO a -> FocusReader t m a
$cliftIO :: forall k (t :: k) (m :: * -> *) a.
MonadIO m =>
IO a -> FocusReader t m a
$cp1MonadIO :: forall k (t :: k) (m :: * -> *).
MonadIO m =>
Monad (FocusReader t m)
MonadIO
    , Monad (FocusReader t m)
a -> FocusReader t m (Ref (FocusReader t m) a)
Monad (FocusReader t m)
-> (forall a. a -> FocusReader t m (Ref (FocusReader t m) a))
-> (forall a. Ref (FocusReader t m) a -> FocusReader t m a)
-> (forall a. Ref (FocusReader t m) a -> a -> FocusReader t m ())
-> (forall a.
    Ref (FocusReader t m) a -> (a -> a) -> FocusReader t m ())
-> (forall a.
    Ref (FocusReader t m) a -> (a -> a) -> FocusReader t m ())
-> MonadRef (FocusReader t m)
Ref (FocusReader t m) a -> FocusReader t m a
Ref (FocusReader t m) a -> a -> FocusReader t m ()
Ref (FocusReader t m) a -> (a -> a) -> FocusReader t m ()
Ref (FocusReader t m) a -> (a -> a) -> FocusReader t m ()
forall a. a -> FocusReader t m (Ref (FocusReader t m) a)
forall a. Ref (FocusReader t m) a -> FocusReader t m a
forall a. Ref (FocusReader t m) a -> a -> FocusReader t m ()
forall a. Ref (FocusReader t m) a -> (a -> a) -> FocusReader t m ()
forall k (t :: k) (m :: * -> *).
MonadRef m =>
Monad (FocusReader t m)
forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
a -> FocusReader t m (Ref (FocusReader t m) a)
forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (FocusReader t m) a -> FocusReader t m a
forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (FocusReader t m) a -> a -> FocusReader t m ()
forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (FocusReader t m) a -> (a -> a) -> FocusReader t m ()
forall (m :: * -> *).
Monad m
-> (forall a. a -> m (Ref m a))
-> (forall a. Ref m a -> m a)
-> (forall a. Ref m a -> a -> m ())
-> (forall a. Ref m a -> (a -> a) -> m ())
-> (forall a. Ref m a -> (a -> a) -> m ())
-> MonadRef m
modifyRef' :: Ref (FocusReader t m) a -> (a -> a) -> FocusReader t m ()
$cmodifyRef' :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (FocusReader t m) a -> (a -> a) -> FocusReader t m ()
modifyRef :: Ref (FocusReader t m) a -> (a -> a) -> FocusReader t m ()
$cmodifyRef :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (FocusReader t m) a -> (a -> a) -> FocusReader t m ()
writeRef :: Ref (FocusReader t m) a -> a -> FocusReader t m ()
$cwriteRef :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (FocusReader t m) a -> a -> FocusReader t m ()
readRef :: Ref (FocusReader t m) a -> FocusReader t m a
$creadRef :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (FocusReader t m) a -> FocusReader t m a
newRef :: a -> FocusReader t m (Ref (FocusReader t m) a)
$cnewRef :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
a -> FocusReader t m (Ref (FocusReader t m) a)
$cp1MonadRef :: forall k (t :: k) (m :: * -> *).
MonadRef m =>
Monad (FocusReader t m)
MonadRef
    , MonadSample t
    , MonadThrow (FocusReader t m)
MonadThrow (FocusReader t m)
-> (forall e a.
    Exception e =>
    FocusReader t m a -> (e -> FocusReader t m a) -> FocusReader t m a)
-> MonadCatch (FocusReader t m)
FocusReader t m a -> (e -> FocusReader t m a) -> FocusReader t m a
forall k (t :: k) (m :: * -> *).
MonadCatch m =>
MonadThrow (FocusReader t m)
forall k (t :: k) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
FocusReader t m a -> (e -> FocusReader t m a) -> FocusReader t m a
forall e a.
Exception e =>
FocusReader t m a -> (e -> FocusReader t m a) -> FocusReader t m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
catch :: FocusReader t m a -> (e -> FocusReader t m a) -> FocusReader t m a
$ccatch :: forall k (t :: k) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
FocusReader t m a -> (e -> FocusReader t m a) -> FocusReader t m a
$cp1MonadCatch :: forall k (t :: k) (m :: * -> *).
MonadCatch m =>
MonadThrow (FocusReader t m)
MonadCatch
    , Monad (FocusReader t m)
e -> FocusReader t m a
Monad (FocusReader t m)
-> (forall e a. Exception e => e -> FocusReader t m a)
-> MonadThrow (FocusReader t m)
forall k (t :: k) (m :: * -> *).
MonadThrow m =>
Monad (FocusReader t m)
forall k (t :: k) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> FocusReader t m a
forall e a. Exception e => e -> FocusReader t m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
throwM :: e -> FocusReader t m a
$cthrowM :: forall k (t :: k) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> FocusReader t m a
$cp1MonadThrow :: forall k (t :: k) (m :: * -> *).
MonadThrow m =>
Monad (FocusReader t m)
MonadThrow
    , MonadCatch (FocusReader t m)
MonadCatch (FocusReader t m)
-> (forall b.
    ((forall a. FocusReader t m a -> FocusReader t m a)
     -> FocusReader t m b)
    -> FocusReader t m b)
-> (forall b.
    ((forall a. FocusReader t m a -> FocusReader t m a)
     -> FocusReader t m b)
    -> FocusReader t m b)
-> (forall a b c.
    FocusReader t m a
    -> (a -> ExitCase b -> FocusReader t m c)
    -> (a -> FocusReader t m b)
    -> FocusReader t m (b, c))
-> MonadMask (FocusReader t m)
FocusReader t m a
-> (a -> ExitCase b -> FocusReader t m c)
-> (a -> FocusReader t m b)
-> FocusReader t m (b, c)
((forall a. FocusReader t m a -> FocusReader t m a)
 -> FocusReader t m b)
-> FocusReader t m b
((forall a. FocusReader t m a -> FocusReader t m a)
 -> FocusReader t m b)
-> FocusReader t m b
forall b.
((forall a. FocusReader t m a -> FocusReader t m a)
 -> FocusReader t m b)
-> FocusReader t m b
forall k (t :: k) (m :: * -> *).
MonadMask m =>
MonadCatch (FocusReader t m)
forall k (t :: k) (m :: * -> *) b.
MonadMask m =>
((forall a. FocusReader t m a -> FocusReader t m a)
 -> FocusReader t m b)
-> FocusReader t m b
forall k (t :: k) (m :: * -> *) a b c.
MonadMask m =>
FocusReader t m a
-> (a -> ExitCase b -> FocusReader t m c)
-> (a -> FocusReader t m b)
-> FocusReader t m (b, c)
forall a b c.
FocusReader t m a
-> (a -> ExitCase b -> FocusReader t m c)
-> (a -> FocusReader t m b)
-> FocusReader t m (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
generalBracket :: FocusReader t m a
-> (a -> ExitCase b -> FocusReader t m c)
-> (a -> FocusReader t m b)
-> FocusReader t m (b, c)
$cgeneralBracket :: forall k (t :: k) (m :: * -> *) a b c.
MonadMask m =>
FocusReader t m a
-> (a -> ExitCase b -> FocusReader t m c)
-> (a -> FocusReader t m b)
-> FocusReader t m (b, c)
uninterruptibleMask :: ((forall a. FocusReader t m a -> FocusReader t m a)
 -> FocusReader t m b)
-> FocusReader t m b
$cuninterruptibleMask :: forall k (t :: k) (m :: * -> *) b.
MonadMask m =>
((forall a. FocusReader t m a -> FocusReader t m a)
 -> FocusReader t m b)
-> FocusReader t m b
mask :: ((forall a. FocusReader t m a -> FocusReader t m a)
 -> FocusReader t m b)
-> FocusReader t m b
$cmask :: forall k (t :: k) (m :: * -> *) b.
MonadMask m =>
((forall a. FocusReader t m a -> FocusReader t m a)
 -> FocusReader t m b)
-> FocusReader t m b
$cp1MonadMask :: forall k (t :: k) (m :: * -> *).
MonadMask m =>
MonadCatch (FocusReader t m)
MonadMask
    )

instance (Monad m, Reflex t) => HasFocusReader t (FocusReader t m) where
  focus :: FocusReader t m (Dynamic t Bool)
focus = ReaderT (Dynamic t Bool) m (Dynamic t Bool)
-> FocusReader t m (Dynamic t Bool)
forall k (t :: k) (m :: * -> *) a.
ReaderT (Dynamic t Bool) m a -> FocusReader t m a
FocusReader ReaderT (Dynamic t Bool) m (Dynamic t Bool)
forall r (m :: * -> *). MonadReader r m => m r
ask
  localFocus :: (Dynamic t Bool -> Dynamic t Bool)
-> FocusReader t m a -> FocusReader t m a
localFocus Dynamic t Bool -> Dynamic t Bool
f = ReaderT (Dynamic t Bool) m a -> FocusReader t m a
forall k (t :: k) (m :: * -> *) a.
ReaderT (Dynamic t Bool) m a -> FocusReader t m a
FocusReader (ReaderT (Dynamic t Bool) m a -> FocusReader t m a)
-> (FocusReader t m a -> ReaderT (Dynamic t Bool) m a)
-> FocusReader t m a
-> FocusReader t m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Dynamic t Bool -> Dynamic t Bool)
-> ReaderT (Dynamic t Bool) m a -> ReaderT (Dynamic t Bool) m a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local Dynamic t Bool -> Dynamic t Bool
f (ReaderT (Dynamic t Bool) m a -> ReaderT (Dynamic t Bool) m a)
-> (FocusReader t m a -> ReaderT (Dynamic t Bool) m a)
-> FocusReader t m a
-> ReaderT (Dynamic t Bool) m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FocusReader t m a -> ReaderT (Dynamic t Bool) m a
forall k (t :: k) (m :: * -> *) a.
FocusReader t m a -> ReaderT (Dynamic t Bool) m a
unFocusReader

deriving instance MonadReflexCreateTrigger t m => MonadReflexCreateTrigger t (FocusReader t m)
deriving instance NotReady t m => NotReady t (FocusReader t m)
deriving instance PerformEvent t m => PerformEvent t (FocusReader t m)
deriving instance PostBuild t m => PostBuild t (FocusReader t m)
deriving instance TriggerEvent t m => TriggerEvent t (FocusReader t m)
instance HasImageWriter t m => HasImageWriter t (FocusReader t m)

instance (Adjustable t m, MonadFix m, MonadHold t m) => Adjustable t (FocusReader t m) where
  runWithReplace :: FocusReader t m a
-> Event t (FocusReader t m b) -> FocusReader t m (a, Event t b)
runWithReplace (FocusReader ReaderT (Dynamic t Bool) m a
a) Event t (FocusReader t m b)
e = ReaderT (Dynamic t Bool) m (a, Event t b)
-> FocusReader t m (a, Event t b)
forall k (t :: k) (m :: * -> *) a.
ReaderT (Dynamic t Bool) m a -> FocusReader t m a
FocusReader (ReaderT (Dynamic t Bool) m (a, Event t b)
 -> FocusReader t m (a, Event t b))
-> ReaderT (Dynamic t Bool) m (a, Event t b)
-> FocusReader t m (a, Event t b)
forall a b. (a -> b) -> a -> b
$ ReaderT (Dynamic t Bool) m a
-> Event t (ReaderT (Dynamic t Bool) m b)
-> ReaderT (Dynamic t Bool) m (a, Event t b)
forall t (m :: * -> *) a b.
Adjustable t m =>
m a -> Event t (m b) -> m (a, Event t b)
runWithReplace ReaderT (Dynamic t Bool) m a
a (Event t (ReaderT (Dynamic t Bool) m b)
 -> ReaderT (Dynamic t Bool) m (a, Event t b))
-> Event t (ReaderT (Dynamic t Bool) m b)
-> ReaderT (Dynamic t Bool) m (a, Event t b)
forall a b. (a -> b) -> a -> b
$ (FocusReader t m b -> ReaderT (Dynamic t Bool) m b)
-> Event t (FocusReader t m b)
-> Event t (ReaderT (Dynamic t Bool) m b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap FocusReader t m b -> ReaderT (Dynamic t Bool) m b
forall k (t :: k) (m :: * -> *) a.
FocusReader t m a -> ReaderT (Dynamic t Bool) m a
unFocusReader Event t (FocusReader t m b)
e
  traverseIntMapWithKeyWithAdjust :: (Int -> v -> FocusReader t m v')
-> IntMap v
-> Event t (PatchIntMap v)
-> FocusReader t m (IntMap v', Event t (PatchIntMap v'))
traverseIntMapWithKeyWithAdjust Int -> v -> FocusReader t m v'
f IntMap v
m Event t (PatchIntMap v)
e = ReaderT (Dynamic t Bool) m (IntMap v', Event t (PatchIntMap v'))
-> FocusReader t m (IntMap v', Event t (PatchIntMap v'))
forall k (t :: k) (m :: * -> *) a.
ReaderT (Dynamic t Bool) m a -> FocusReader t m a
FocusReader (ReaderT (Dynamic t Bool) m (IntMap v', Event t (PatchIntMap v'))
 -> FocusReader t m (IntMap v', Event t (PatchIntMap v')))
-> ReaderT (Dynamic t Bool) m (IntMap v', Event t (PatchIntMap v'))
-> FocusReader t m (IntMap v', Event t (PatchIntMap v'))
forall a b. (a -> b) -> a -> b
$ (Int -> v -> ReaderT (Dynamic t Bool) m v')
-> IntMap v
-> Event t (PatchIntMap v)
-> ReaderT (Dynamic t Bool) m (IntMap v', Event t (PatchIntMap v'))
forall t (m :: * -> *) v v'.
Adjustable t m =>
(Int -> v -> m v')
-> IntMap v
-> Event t (PatchIntMap v)
-> m (IntMap v', Event t (PatchIntMap v'))
traverseIntMapWithKeyWithAdjust (\Int
k v
v -> FocusReader t m v' -> ReaderT (Dynamic t Bool) m v'
forall k (t :: k) (m :: * -> *) a.
FocusReader t m a -> ReaderT (Dynamic t Bool) m a
unFocusReader (FocusReader t m v' -> ReaderT (Dynamic t Bool) m v')
-> FocusReader t m v' -> ReaderT (Dynamic t Bool) m v'
forall a b. (a -> b) -> a -> b
$ Int -> v -> FocusReader t m v'
f Int
k v
v) IntMap v
m Event t (PatchIntMap v)
e
  traverseDMapWithKeyWithAdjust :: (forall a. k a -> v a -> FocusReader t m (v' a))
-> DMap k v
-> Event t (PatchDMap k v)
-> FocusReader t m (DMap k v', Event t (PatchDMap k v'))
traverseDMapWithKeyWithAdjust forall a. k a -> v a -> FocusReader t m (v' a)
f DMap k v
m Event t (PatchDMap k v)
e = ReaderT (Dynamic t Bool) m (DMap k v', Event t (PatchDMap k v'))
-> FocusReader t m (DMap k v', Event t (PatchDMap k v'))
forall k (t :: k) (m :: * -> *) a.
ReaderT (Dynamic t Bool) m a -> FocusReader t m a
FocusReader (ReaderT (Dynamic t Bool) m (DMap k v', Event t (PatchDMap k v'))
 -> FocusReader t m (DMap k v', Event t (PatchDMap k v')))
-> ReaderT (Dynamic t Bool) m (DMap k v', Event t (PatchDMap k v'))
-> FocusReader t m (DMap k v', Event t (PatchDMap k v'))
forall a b. (a -> b) -> a -> b
$ (forall a. k a -> v a -> ReaderT (Dynamic t Bool) m (v' a))
-> DMap k v
-> Event t (PatchDMap k v)
-> ReaderT (Dynamic t Bool) m (DMap k v', Event t (PatchDMap k v'))
forall t (m :: * -> *) (k :: * -> *) (v :: * -> *) (v' :: * -> *).
(Adjustable t m, GCompare k) =>
(forall a. k a -> v a -> m (v' a))
-> DMap k v
-> Event t (PatchDMap k v)
-> m (DMap k v', Event t (PatchDMap k v'))
traverseDMapWithKeyWithAdjust (\k a
k v a
v -> FocusReader t m (v' a) -> ReaderT (Dynamic t Bool) m (v' a)
forall k (t :: k) (m :: * -> *) a.
FocusReader t m a -> ReaderT (Dynamic t Bool) m a
unFocusReader (FocusReader t m (v' a) -> ReaderT (Dynamic t Bool) m (v' a))
-> FocusReader t m (v' a) -> ReaderT (Dynamic t Bool) m (v' a)
forall a b. (a -> b) -> a -> b
$ k a -> v a -> FocusReader t m (v' a)
forall a. k a -> v a -> FocusReader t m (v' a)
f k a
k v a
v) DMap k v
m Event t (PatchDMap k v)
e
  traverseDMapWithKeyWithAdjustWithMove :: (forall a. k a -> v a -> FocusReader t m (v' a))
-> DMap k v
-> Event t (PatchDMapWithMove k v)
-> FocusReader t m (DMap k v', Event t (PatchDMapWithMove k v'))
traverseDMapWithKeyWithAdjustWithMove forall a. k a -> v a -> FocusReader t m (v' a)
f DMap k v
m Event t (PatchDMapWithMove k v)
e = ReaderT
  (Dynamic t Bool) m (DMap k v', Event t (PatchDMapWithMove k v'))
-> FocusReader t m (DMap k v', Event t (PatchDMapWithMove k v'))
forall k (t :: k) (m :: * -> *) a.
ReaderT (Dynamic t Bool) m a -> FocusReader t m a
FocusReader (ReaderT
   (Dynamic t Bool) m (DMap k v', Event t (PatchDMapWithMove k v'))
 -> FocusReader t m (DMap k v', Event t (PatchDMapWithMove k v')))
-> ReaderT
     (Dynamic t Bool) m (DMap k v', Event t (PatchDMapWithMove k v'))
-> FocusReader t m (DMap k v', Event t (PatchDMapWithMove k v'))
forall a b. (a -> b) -> a -> b
$ (forall a. k a -> v a -> ReaderT (Dynamic t Bool) m (v' a))
-> DMap k v
-> Event t (PatchDMapWithMove k v)
-> ReaderT
     (Dynamic t Bool) m (DMap k v', Event t (PatchDMapWithMove k v'))
forall t (m :: * -> *) (k :: * -> *) (v :: * -> *) (v' :: * -> *).
(Adjustable t m, GCompare k) =>
(forall a. k a -> v a -> m (v' a))
-> DMap k v
-> Event t (PatchDMapWithMove k v)
-> m (DMap k v', Event t (PatchDMapWithMove k v'))
traverseDMapWithKeyWithAdjustWithMove (\k a
k v a
v -> FocusReader t m (v' a) -> ReaderT (Dynamic t Bool) m (v' a)
forall k (t :: k) (m :: * -> *) a.
FocusReader t m a -> ReaderT (Dynamic t Bool) m a
unFocusReader (FocusReader t m (v' a) -> ReaderT (Dynamic t Bool) m (v' a))
-> FocusReader t m (v' a) -> ReaderT (Dynamic t Bool) m (v' a)
forall a b. (a -> b) -> a -> b
$ k a -> v a -> FocusReader t m (v' a)
forall a. k a -> v a -> FocusReader t m (v' a)
f k a
k v a
v) DMap k v
m Event t (PatchDMapWithMove k v)
e

instance MonadTrans (FocusReader t) where
  lift :: m a -> FocusReader t m a
lift = ReaderT (Dynamic t Bool) m a -> FocusReader t m a
forall k (t :: k) (m :: * -> *) a.
ReaderT (Dynamic t Bool) m a -> FocusReader t m a
FocusReader (ReaderT (Dynamic t Bool) m a -> FocusReader t m a)
-> (m a -> ReaderT (Dynamic t Bool) m a)
-> m a
-> FocusReader t m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> ReaderT (Dynamic t Bool) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

instance MFunctor (FocusReader t) where
  hoist :: (forall a. m a -> n a) -> FocusReader t m b -> FocusReader t n b
hoist forall a. m a -> n a
f = ReaderT (Dynamic t Bool) n b -> FocusReader t n b
forall k (t :: k) (m :: * -> *) a.
ReaderT (Dynamic t Bool) m a -> FocusReader t m a
FocusReader (ReaderT (Dynamic t Bool) n b -> FocusReader t n b)
-> (FocusReader t m b -> ReaderT (Dynamic t Bool) n b)
-> FocusReader t m b
-> FocusReader t n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. m a -> n a)
-> ReaderT (Dynamic t Bool) m b -> ReaderT (Dynamic t Bool) n b
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. m a -> n a
f (ReaderT (Dynamic t Bool) m b -> ReaderT (Dynamic t Bool) n b)
-> (FocusReader t m b -> ReaderT (Dynamic t Bool) m b)
-> FocusReader t m b
-> ReaderT (Dynamic t Bool) n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FocusReader t m b -> ReaderT (Dynamic t Bool) m b
forall k (t :: k) (m :: * -> *) a.
FocusReader t m a -> ReaderT (Dynamic t Bool) m a
unFocusReader

instance MonadNodeId m => MonadNodeId (FocusReader t m)

-- | Run a 'FocusReader' action with the given focus value
runFocusReader
  :: (Reflex t, Monad m)
  => Dynamic t Bool
  -> FocusReader t m a
  -> m a
runFocusReader :: Dynamic t Bool -> FocusReader t m a -> m a
runFocusReader Dynamic t Bool
b = (ReaderT (Dynamic t Bool) m a -> Dynamic t Bool -> m a)
-> Dynamic t Bool -> ReaderT (Dynamic t Bool) m a -> m a
forall a b c. (a -> b -> c) -> b -> a -> c
flip ReaderT (Dynamic t Bool) m a -> Dynamic t Bool -> m a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT Dynamic t Bool
b (ReaderT (Dynamic t Bool) m a -> m a)
-> (FocusReader t m a -> ReaderT (Dynamic t Bool) m a)
-> FocusReader t m a
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FocusReader t m a -> ReaderT (Dynamic t Bool) m a
forall k (t :: k) (m :: * -> *) a.
FocusReader t m a -> ReaderT (Dynamic t Bool) m a
unFocusReader

-- * "Image" output

-- | A class for widgets that can produce images to draw to the display
class (Reflex t, Monad m) => HasImageWriter t m | m -> t where
  -- | Send images upstream for rendering
  tellImages :: Behavior t [Image] -> m ()
  default tellImages :: (f m' ~ m, Monad m', MonadTrans f, HasImageWriter t m') => Behavior t [Image] -> m ()
  tellImages = m' () -> f m' ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m' () -> f m' ())
-> (Behavior t [Image] -> m' ()) -> Behavior t [Image] -> f m' ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Behavior t [Image] -> m' ()
forall k (t :: k) (m :: * -> *).
HasImageWriter t m =>
Behavior t [Image] -> m ()
tellImages
  -- | Apply a transformation to the images produced by the child actions
  mapImages :: (Behavior t [Image] -> Behavior t [Image]) -> m a -> m a
  default mapImages :: (f m' ~ m, Monad m', MFunctor f, HasImageWriter t m') => (Behavior t [Image] -> Behavior t [Image]) -> m a -> m a
  mapImages Behavior t [Image] -> Behavior t [Image]
f = (forall a. m' a -> m' a) -> f m' a -> f m' a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist ((Behavior t [Image] -> Behavior t [Image]) -> m' a -> m' a
forall k (t :: k) (m :: * -> *) a.
HasImageWriter t m =>
(Behavior t [Image] -> Behavior t [Image]) -> m a -> m a
mapImages Behavior t [Image] -> Behavior t [Image]
f)

-- | A widget that can produce images to draw onto the display
newtype ImageWriter t m a = ImageWriter
  { ImageWriter t m a -> BehaviorWriterT t [Image] m a
unImageWriter :: BehaviorWriterT t [Image] m a }
  deriving
    ( a -> ImageWriter t m b -> ImageWriter t m a
(a -> b) -> ImageWriter t m a -> ImageWriter t m b
(forall a b. (a -> b) -> ImageWriter t m a -> ImageWriter t m b)
-> (forall a b. a -> ImageWriter t m b -> ImageWriter t m a)
-> Functor (ImageWriter t m)
forall a b. a -> ImageWriter t m b -> ImageWriter t m a
forall a b. (a -> b) -> ImageWriter t m a -> ImageWriter t m b
forall t (m :: * -> *) a b.
Functor m =>
a -> ImageWriter t m b -> ImageWriter t m a
forall t (m :: * -> *) a b.
Functor m =>
(a -> b) -> ImageWriter t m a -> ImageWriter t m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ImageWriter t m b -> ImageWriter t m a
$c<$ :: forall t (m :: * -> *) a b.
Functor m =>
a -> ImageWriter t m b -> ImageWriter t m a
fmap :: (a -> b) -> ImageWriter t m a -> ImageWriter t m b
$cfmap :: forall t (m :: * -> *) a b.
Functor m =>
(a -> b) -> ImageWriter t m a -> ImageWriter t m b
Functor
    , Functor (ImageWriter t m)
a -> ImageWriter t m a
Functor (ImageWriter t m)
-> (forall a. a -> ImageWriter t m a)
-> (forall a b.
    ImageWriter t m (a -> b) -> ImageWriter t m a -> ImageWriter t m b)
-> (forall a b c.
    (a -> b -> c)
    -> ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m c)
-> (forall a b.
    ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m b)
-> (forall a b.
    ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m a)
-> Applicative (ImageWriter t m)
ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m b
ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m a
ImageWriter t m (a -> b) -> ImageWriter t m a -> ImageWriter t m b
(a -> b -> c)
-> ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m c
forall a. a -> ImageWriter t m a
forall a b.
ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m a
forall a b.
ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m b
forall a b.
ImageWriter t m (a -> b) -> ImageWriter t m a -> ImageWriter t m b
forall a b c.
(a -> b -> c)
-> ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m c
forall t (m :: * -> *). Monad m => Functor (ImageWriter t m)
forall t (m :: * -> *) a. Monad m => a -> ImageWriter t m a
forall t (m :: * -> *) a b.
Monad m =>
ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m a
forall t (m :: * -> *) a b.
Monad m =>
ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m b
forall t (m :: * -> *) a b.
Monad m =>
ImageWriter t m (a -> b) -> ImageWriter t m a -> ImageWriter t m b
forall t (m :: * -> *) a b c.
Monad m =>
(a -> b -> c)
-> ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m a
$c<* :: forall t (m :: * -> *) a b.
Monad m =>
ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m a
*> :: ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m b
$c*> :: forall t (m :: * -> *) a b.
Monad m =>
ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m b
liftA2 :: (a -> b -> c)
-> ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m c
$cliftA2 :: forall t (m :: * -> *) a b c.
Monad m =>
(a -> b -> c)
-> ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m c
<*> :: ImageWriter t m (a -> b) -> ImageWriter t m a -> ImageWriter t m b
$c<*> :: forall t (m :: * -> *) a b.
Monad m =>
ImageWriter t m (a -> b) -> ImageWriter t m a -> ImageWriter t m b
pure :: a -> ImageWriter t m a
$cpure :: forall t (m :: * -> *) a. Monad m => a -> ImageWriter t m a
$cp1Applicative :: forall t (m :: * -> *). Monad m => Functor (ImageWriter t m)
Applicative
    , Applicative (ImageWriter t m)
a -> ImageWriter t m a
Applicative (ImageWriter t m)
-> (forall a b.
    ImageWriter t m a -> (a -> ImageWriter t m b) -> ImageWriter t m b)
-> (forall a b.
    ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m b)
-> (forall a. a -> ImageWriter t m a)
-> Monad (ImageWriter t m)
ImageWriter t m a -> (a -> ImageWriter t m b) -> ImageWriter t m b
ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m b
forall a. a -> ImageWriter t m a
forall a b.
ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m b
forall a b.
ImageWriter t m a -> (a -> ImageWriter t m b) -> ImageWriter t m b
forall t (m :: * -> *). Monad m => Applicative (ImageWriter t m)
forall t (m :: * -> *) a. Monad m => a -> ImageWriter t m a
forall t (m :: * -> *) a b.
Monad m =>
ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m b
forall t (m :: * -> *) a b.
Monad m =>
ImageWriter t m a -> (a -> ImageWriter t m b) -> ImageWriter t m b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> ImageWriter t m a
$creturn :: forall t (m :: * -> *) a. Monad m => a -> ImageWriter t m a
>> :: ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m b
$c>> :: forall t (m :: * -> *) a b.
Monad m =>
ImageWriter t m a -> ImageWriter t m b -> ImageWriter t m b
>>= :: ImageWriter t m a -> (a -> ImageWriter t m b) -> ImageWriter t m b
$c>>= :: forall t (m :: * -> *) a b.
Monad m =>
ImageWriter t m a -> (a -> ImageWriter t m b) -> ImageWriter t m b
$cp1Monad :: forall t (m :: * -> *). Monad m => Applicative (ImageWriter t m)
Monad
    , Monad (ImageWriter t m)
Monad (ImageWriter t m)
-> (forall a. (a -> ImageWriter t m a) -> ImageWriter t m a)
-> MonadFix (ImageWriter t m)
(a -> ImageWriter t m a) -> ImageWriter t m a
forall a. (a -> ImageWriter t m a) -> ImageWriter t m a
forall t (m :: * -> *). MonadFix m => Monad (ImageWriter t m)
forall t (m :: * -> *) a.
MonadFix m =>
(a -> ImageWriter t m a) -> ImageWriter t m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
mfix :: (a -> ImageWriter t m a) -> ImageWriter t m a
$cmfix :: forall t (m :: * -> *) a.
MonadFix m =>
(a -> ImageWriter t m a) -> ImageWriter t m a
$cp1MonadFix :: forall t (m :: * -> *). MonadFix m => Monad (ImageWriter t m)
MonadFix
    , MonadHold t
    , Monad (ImageWriter t m)
Monad (ImageWriter t m)
-> (forall a. IO a -> ImageWriter t m a)
-> MonadIO (ImageWriter t m)
IO a -> ImageWriter t m a
forall a. IO a -> ImageWriter t m a
forall t (m :: * -> *). MonadIO m => Monad (ImageWriter t m)
forall t (m :: * -> *) a. MonadIO m => IO a -> ImageWriter t m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
liftIO :: IO a -> ImageWriter t m a
$cliftIO :: forall t (m :: * -> *) a. MonadIO m => IO a -> ImageWriter t m a
$cp1MonadIO :: forall t (m :: * -> *). MonadIO m => Monad (ImageWriter t m)
MonadIO
    , Monad (ImageWriter t m)
a -> ImageWriter t m (Ref (ImageWriter t m) a)
Monad (ImageWriter t m)
-> (forall a. a -> ImageWriter t m (Ref (ImageWriter t m) a))
-> (forall a. Ref (ImageWriter t m) a -> ImageWriter t m a)
-> (forall a. Ref (ImageWriter t m) a -> a -> ImageWriter t m ())
-> (forall a.
    Ref (ImageWriter t m) a -> (a -> a) -> ImageWriter t m ())
-> (forall a.
    Ref (ImageWriter t m) a -> (a -> a) -> ImageWriter t m ())
-> MonadRef (ImageWriter t m)
Ref (ImageWriter t m) a -> ImageWriter t m a
Ref (ImageWriter t m) a -> a -> ImageWriter t m ()
Ref (ImageWriter t m) a -> (a -> a) -> ImageWriter t m ()
Ref (ImageWriter t m) a -> (a -> a) -> ImageWriter t m ()
forall a. a -> ImageWriter t m (Ref (ImageWriter t m) a)
forall a. Ref (ImageWriter t m) a -> ImageWriter t m a
forall a. Ref (ImageWriter t m) a -> a -> ImageWriter t m ()
forall a. Ref (ImageWriter t m) a -> (a -> a) -> ImageWriter t m ()
forall t (m :: * -> *). MonadRef m => Monad (ImageWriter t m)
forall t (m :: * -> *) a.
MonadRef m =>
a -> ImageWriter t m (Ref (ImageWriter t m) a)
forall t (m :: * -> *) a.
MonadRef m =>
Ref (ImageWriter t m) a -> ImageWriter t m a
forall t (m :: * -> *) a.
MonadRef m =>
Ref (ImageWriter t m) a -> a -> ImageWriter t m ()
forall t (m :: * -> *) a.
MonadRef m =>
Ref (ImageWriter t m) a -> (a -> a) -> ImageWriter t m ()
forall (m :: * -> *).
Monad m
-> (forall a. a -> m (Ref m a))
-> (forall a. Ref m a -> m a)
-> (forall a. Ref m a -> a -> m ())
-> (forall a. Ref m a -> (a -> a) -> m ())
-> (forall a. Ref m a -> (a -> a) -> m ())
-> MonadRef m
modifyRef' :: Ref (ImageWriter t m) a -> (a -> a) -> ImageWriter t m ()
$cmodifyRef' :: forall t (m :: * -> *) a.
MonadRef m =>
Ref (ImageWriter t m) a -> (a -> a) -> ImageWriter t m ()
modifyRef :: Ref (ImageWriter t m) a -> (a -> a) -> ImageWriter t m ()
$cmodifyRef :: forall t (m :: * -> *) a.
MonadRef m =>
Ref (ImageWriter t m) a -> (a -> a) -> ImageWriter t m ()
writeRef :: Ref (ImageWriter t m) a -> a -> ImageWriter t m ()
$cwriteRef :: forall t (m :: * -> *) a.
MonadRef m =>
Ref (ImageWriter t m) a -> a -> ImageWriter t m ()
readRef :: Ref (ImageWriter t m) a -> ImageWriter t m a
$creadRef :: forall t (m :: * -> *) a.
MonadRef m =>
Ref (ImageWriter t m) a -> ImageWriter t m a
newRef :: a -> ImageWriter t m (Ref (ImageWriter t m) a)
$cnewRef :: forall t (m :: * -> *) a.
MonadRef m =>
a -> ImageWriter t m (Ref (ImageWriter t m) a)
$cp1MonadRef :: forall t (m :: * -> *). MonadRef m => Monad (ImageWriter t m)
MonadRef
    , MonadReflexCreateTrigger t
    , MonadSample t
    , NotReady t
    , PerformEvent t
    , PostBuild t
    , TriggerEvent t
    , MonadThrow (ImageWriter t m)
MonadThrow (ImageWriter t m)
-> (forall e a.
    Exception e =>
    ImageWriter t m a -> (e -> ImageWriter t m a) -> ImageWriter t m a)
-> MonadCatch (ImageWriter t m)
ImageWriter t m a -> (e -> ImageWriter t m a) -> ImageWriter t m a
forall e a.
Exception e =>
ImageWriter t m a -> (e -> ImageWriter t m a) -> ImageWriter t m a
forall t (m :: * -> *).
MonadCatch m =>
MonadThrow (ImageWriter t m)
forall t (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
ImageWriter t m a -> (e -> ImageWriter t m a) -> ImageWriter t m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
catch :: ImageWriter t m a -> (e -> ImageWriter t m a) -> ImageWriter t m a
$ccatch :: forall t (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
ImageWriter t m a -> (e -> ImageWriter t m a) -> ImageWriter t m a
$cp1MonadCatch :: forall t (m :: * -> *).
MonadCatch m =>
MonadThrow (ImageWriter t m)
MonadCatch
    , Monad (ImageWriter t m)
e -> ImageWriter t m a
Monad (ImageWriter t m)
-> (forall e a. Exception e => e -> ImageWriter t m a)
-> MonadThrow (ImageWriter t m)
forall e a. Exception e => e -> ImageWriter t m a
forall t (m :: * -> *). MonadThrow m => Monad (ImageWriter t m)
forall t (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> ImageWriter t m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
throwM :: e -> ImageWriter t m a
$cthrowM :: forall t (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> ImageWriter t m a
$cp1MonadThrow :: forall t (m :: * -> *). MonadThrow m => Monad (ImageWriter t m)
MonadThrow
    , MonadCatch (ImageWriter t m)
MonadCatch (ImageWriter t m)
-> (forall b.
    ((forall a. ImageWriter t m a -> ImageWriter t m a)
     -> ImageWriter t m b)
    -> ImageWriter t m b)
-> (forall b.
    ((forall a. ImageWriter t m a -> ImageWriter t m a)
     -> ImageWriter t m b)
    -> ImageWriter t m b)
-> (forall a b c.
    ImageWriter t m a
    -> (a -> ExitCase b -> ImageWriter t m c)
    -> (a -> ImageWriter t m b)
    -> ImageWriter t m (b, c))
-> MonadMask (ImageWriter t m)
ImageWriter t m a
-> (a -> ExitCase b -> ImageWriter t m c)
-> (a -> ImageWriter t m b)
-> ImageWriter t m (b, c)
((forall a. ImageWriter t m a -> ImageWriter t m a)
 -> ImageWriter t m b)
-> ImageWriter t m b
((forall a. ImageWriter t m a -> ImageWriter t m a)
 -> ImageWriter t m b)
-> ImageWriter t m b
forall b.
((forall a. ImageWriter t m a -> ImageWriter t m a)
 -> ImageWriter t m b)
-> ImageWriter t m b
forall a b c.
ImageWriter t m a
-> (a -> ExitCase b -> ImageWriter t m c)
-> (a -> ImageWriter t m b)
-> ImageWriter t m (b, c)
forall t (m :: * -> *). MonadMask m => MonadCatch (ImageWriter t m)
forall t (m :: * -> *) b.
MonadMask m =>
((forall a. ImageWriter t m a -> ImageWriter t m a)
 -> ImageWriter t m b)
-> ImageWriter t m b
forall t (m :: * -> *) a b c.
MonadMask m =>
ImageWriter t m a
-> (a -> ExitCase b -> ImageWriter t m c)
-> (a -> ImageWriter t m b)
-> ImageWriter t m (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
generalBracket :: ImageWriter t m a
-> (a -> ExitCase b -> ImageWriter t m c)
-> (a -> ImageWriter t m b)
-> ImageWriter t m (b, c)
$cgeneralBracket :: forall t (m :: * -> *) a b c.
MonadMask m =>
ImageWriter t m a
-> (a -> ExitCase b -> ImageWriter t m c)
-> (a -> ImageWriter t m b)
-> ImageWriter t m (b, c)
uninterruptibleMask :: ((forall a. ImageWriter t m a -> ImageWriter t m a)
 -> ImageWriter t m b)
-> ImageWriter t m b
$cuninterruptibleMask :: forall t (m :: * -> *) b.
MonadMask m =>
((forall a. ImageWriter t m a -> ImageWriter t m a)
 -> ImageWriter t m b)
-> ImageWriter t m b
mask :: ((forall a. ImageWriter t m a -> ImageWriter t m a)
 -> ImageWriter t m b)
-> ImageWriter t m b
$cmask :: forall t (m :: * -> *) b.
MonadMask m =>
((forall a. ImageWriter t m a -> ImageWriter t m a)
 -> ImageWriter t m b)
-> ImageWriter t m b
$cp1MonadMask :: forall t (m :: * -> *). MonadMask m => MonadCatch (ImageWriter t m)
MonadMask
    )

instance MonadTrans (ImageWriter t) where
  lift :: m a -> ImageWriter t m a
lift = BehaviorWriterT t [Image] m a -> ImageWriter t m a
forall t (m :: * -> *) a.
BehaviorWriterT t [Image] m a -> ImageWriter t m a
ImageWriter (BehaviorWriterT t [Image] m a -> ImageWriter t m a)
-> (m a -> BehaviorWriterT t [Image] m a)
-> m a
-> ImageWriter t m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> BehaviorWriterT t [Image] m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

instance MFunctor (ImageWriter t) where
  hoist :: (forall a. m a -> n a) -> ImageWriter t m b -> ImageWriter t n b
hoist forall a. m a -> n a
f = BehaviorWriterT t [Image] n b -> ImageWriter t n b
forall t (m :: * -> *) a.
BehaviorWriterT t [Image] m a -> ImageWriter t m a
ImageWriter (BehaviorWriterT t [Image] n b -> ImageWriter t n b)
-> (ImageWriter t m b -> BehaviorWriterT t [Image] n b)
-> ImageWriter t m b
-> ImageWriter t n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((forall a. m a -> n a)
-> BehaviorWriterT t [Image] m b -> BehaviorWriterT t [Image] n b
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. m a -> n a
f) (BehaviorWriterT t [Image] m b -> BehaviorWriterT t [Image] n b)
-> (ImageWriter t m b -> BehaviorWriterT t [Image] m b)
-> ImageWriter t m b
-> BehaviorWriterT t [Image] n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ImageWriter t m b -> BehaviorWriterT t [Image] m b
forall t (m :: * -> *) a.
ImageWriter t m a -> BehaviorWriterT t [Image] m a
unImageWriter

instance (Adjustable t m, MonadFix m, MonadHold t m) => Adjustable t (ImageWriter t m) where
  runWithReplace :: ImageWriter t m a
-> Event t (ImageWriter t m b) -> ImageWriter t m (a, Event t b)
runWithReplace (ImageWriter BehaviorWriterT t [Image] m a
a) Event t (ImageWriter t m b)
e = BehaviorWriterT t [Image] m (a, Event t b)
-> ImageWriter t m (a, Event t b)
forall t (m :: * -> *) a.
BehaviorWriterT t [Image] m a -> ImageWriter t m a
ImageWriter (BehaviorWriterT t [Image] m (a, Event t b)
 -> ImageWriter t m (a, Event t b))
-> BehaviorWriterT t [Image] m (a, Event t b)
-> ImageWriter t m (a, Event t b)
forall a b. (a -> b) -> a -> b
$ BehaviorWriterT t [Image] m a
-> Event t (BehaviorWriterT t [Image] m b)
-> BehaviorWriterT t [Image] m (a, Event t b)
forall t (m :: * -> *) a b.
Adjustable t m =>
m a -> Event t (m b) -> m (a, Event t b)
runWithReplace BehaviorWriterT t [Image] m a
a (Event t (BehaviorWriterT t [Image] m b)
 -> BehaviorWriterT t [Image] m (a, Event t b))
-> Event t (BehaviorWriterT t [Image] m b)
-> BehaviorWriterT t [Image] m (a, Event t b)
forall a b. (a -> b) -> a -> b
$ (ImageWriter t m b -> BehaviorWriterT t [Image] m b)
-> Event t (ImageWriter t m b)
-> Event t (BehaviorWriterT t [Image] m b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ImageWriter t m b -> BehaviorWriterT t [Image] m b
forall t (m :: * -> *) a.
ImageWriter t m a -> BehaviorWriterT t [Image] m a
unImageWriter Event t (ImageWriter t m b)
e
  traverseIntMapWithKeyWithAdjust :: (Int -> v -> ImageWriter t m v')
-> IntMap v
-> Event t (PatchIntMap v)
-> ImageWriter t m (IntMap v', Event t (PatchIntMap v'))
traverseIntMapWithKeyWithAdjust Int -> v -> ImageWriter t m v'
f IntMap v
m Event t (PatchIntMap v)
e = BehaviorWriterT t [Image] m (IntMap v', Event t (PatchIntMap v'))
-> ImageWriter t m (IntMap v', Event t (PatchIntMap v'))
forall t (m :: * -> *) a.
BehaviorWriterT t [Image] m a -> ImageWriter t m a
ImageWriter (BehaviorWriterT t [Image] m (IntMap v', Event t (PatchIntMap v'))
 -> ImageWriter t m (IntMap v', Event t (PatchIntMap v')))
-> BehaviorWriterT
     t [Image] m (IntMap v', Event t (PatchIntMap v'))
-> ImageWriter t m (IntMap v', Event t (PatchIntMap v'))
forall a b. (a -> b) -> a -> b
$ (Int -> v -> BehaviorWriterT t [Image] m v')
-> IntMap v
-> Event t (PatchIntMap v)
-> BehaviorWriterT
     t [Image] m (IntMap v', Event t (PatchIntMap v'))
forall t (m :: * -> *) v v'.
Adjustable t m =>
(Int -> v -> m v')
-> IntMap v
-> Event t (PatchIntMap v)
-> m (IntMap v', Event t (PatchIntMap v'))
traverseIntMapWithKeyWithAdjust (\Int
k v
v -> ImageWriter t m v' -> BehaviorWriterT t [Image] m v'
forall t (m :: * -> *) a.
ImageWriter t m a -> BehaviorWriterT t [Image] m a
unImageWriter (ImageWriter t m v' -> BehaviorWriterT t [Image] m v')
-> ImageWriter t m v' -> BehaviorWriterT t [Image] m v'
forall a b. (a -> b) -> a -> b
$ Int -> v -> ImageWriter t m v'
f Int
k v
v) IntMap v
m Event t (PatchIntMap v)
e
  traverseDMapWithKeyWithAdjust :: (forall a. k a -> v a -> ImageWriter t m (v' a))
-> DMap k v
-> Event t (PatchDMap k v)
-> ImageWriter t m (DMap k v', Event t (PatchDMap k v'))
traverseDMapWithKeyWithAdjust forall a. k a -> v a -> ImageWriter t m (v' a)
f DMap k v
m Event t (PatchDMap k v)
e = BehaviorWriterT t [Image] m (DMap k v', Event t (PatchDMap k v'))
-> ImageWriter t m (DMap k v', Event t (PatchDMap k v'))
forall t (m :: * -> *) a.
BehaviorWriterT t [Image] m a -> ImageWriter t m a
ImageWriter (BehaviorWriterT t [Image] m (DMap k v', Event t (PatchDMap k v'))
 -> ImageWriter t m (DMap k v', Event t (PatchDMap k v')))
-> BehaviorWriterT
     t [Image] m (DMap k v', Event t (PatchDMap k v'))
-> ImageWriter t m (DMap k v', Event t (PatchDMap k v'))
forall a b. (a -> b) -> a -> b
$ (forall a. k a -> v a -> BehaviorWriterT t [Image] m (v' a))
-> DMap k v
-> Event t (PatchDMap k v)
-> BehaviorWriterT
     t [Image] m (DMap k v', Event t (PatchDMap k v'))
forall t (m :: * -> *) (k :: * -> *) (v :: * -> *) (v' :: * -> *).
(Adjustable t m, GCompare k) =>
(forall a. k a -> v a -> m (v' a))
-> DMap k v
-> Event t (PatchDMap k v)
-> m (DMap k v', Event t (PatchDMap k v'))
traverseDMapWithKeyWithAdjust (\k a
k v a
v -> ImageWriter t m (v' a) -> BehaviorWriterT t [Image] m (v' a)
forall t (m :: * -> *) a.
ImageWriter t m a -> BehaviorWriterT t [Image] m a
unImageWriter (ImageWriter t m (v' a) -> BehaviorWriterT t [Image] m (v' a))
-> ImageWriter t m (v' a) -> BehaviorWriterT t [Image] m (v' a)
forall a b. (a -> b) -> a -> b
$ k a -> v a -> ImageWriter t m (v' a)
forall a. k a -> v a -> ImageWriter t m (v' a)
f k a
k v a
v) DMap k v
m Event t (PatchDMap k v)
e
  traverseDMapWithKeyWithAdjustWithMove :: (forall a. k a -> v a -> ImageWriter t m (v' a))
-> DMap k v
-> Event t (PatchDMapWithMove k v)
-> ImageWriter t m (DMap k v', Event t (PatchDMapWithMove k v'))
traverseDMapWithKeyWithAdjustWithMove forall a. k a -> v a -> ImageWriter t m (v' a)
f DMap k v
m Event t (PatchDMapWithMove k v)
e = BehaviorWriterT
  t [Image] m (DMap k v', Event t (PatchDMapWithMove k v'))
-> ImageWriter t m (DMap k v', Event t (PatchDMapWithMove k v'))
forall t (m :: * -> *) a.
BehaviorWriterT t [Image] m a -> ImageWriter t m a
ImageWriter (BehaviorWriterT
   t [Image] m (DMap k v', Event t (PatchDMapWithMove k v'))
 -> ImageWriter t m (DMap k v', Event t (PatchDMapWithMove k v')))
-> BehaviorWriterT
     t [Image] m (DMap k v', Event t (PatchDMapWithMove k v'))
-> ImageWriter t m (DMap k v', Event t (PatchDMapWithMove k v'))
forall a b. (a -> b) -> a -> b
$ (forall a. k a -> v a -> BehaviorWriterT t [Image] m (v' a))
-> DMap k v
-> Event t (PatchDMapWithMove k v)
-> BehaviorWriterT
     t [Image] m (DMap k v', Event t (PatchDMapWithMove k v'))
forall t (m :: * -> *) (k :: * -> *) (v :: * -> *) (v' :: * -> *).
(Adjustable t m, GCompare k) =>
(forall a. k a -> v a -> m (v' a))
-> DMap k v
-> Event t (PatchDMapWithMove k v)
-> m (DMap k v', Event t (PatchDMapWithMove k v'))
traverseDMapWithKeyWithAdjustWithMove (\k a
k v a
v -> ImageWriter t m (v' a) -> BehaviorWriterT t [Image] m (v' a)
forall t (m :: * -> *) a.
ImageWriter t m a -> BehaviorWriterT t [Image] m a
unImageWriter (ImageWriter t m (v' a) -> BehaviorWriterT t [Image] m (v' a))
-> ImageWriter t m (v' a) -> BehaviorWriterT t [Image] m (v' a)
forall a b. (a -> b) -> a -> b
$ k a -> v a -> ImageWriter t m (v' a)
forall a. k a -> v a -> ImageWriter t m (v' a)
f k a
k v a
v) DMap k v
m Event t (PatchDMapWithMove k v)
e

instance HasImageWriter t m => HasImageWriter t (ReaderT x m)
instance HasImageWriter t m => HasImageWriter t (BehaviorWriterT t x m)
instance HasImageWriter t m => HasImageWriter t (DynamicWriterT t x m)
instance HasImageWriter t m => HasImageWriter t (EventWriterT t x m)
instance HasImageWriter t m => HasImageWriter t (NodeIdT m)

instance (Monad m, Reflex t) => HasImageWriter t (ImageWriter t m) where
  tellImages :: Behavior t [Image] -> ImageWriter t m ()
tellImages = BehaviorWriterT t [Image] m () -> ImageWriter t m ()
forall t (m :: * -> *) a.
BehaviorWriterT t [Image] m a -> ImageWriter t m a
ImageWriter (BehaviorWriterT t [Image] m () -> ImageWriter t m ())
-> (Behavior t [Image] -> BehaviorWriterT t [Image] m ())
-> Behavior t [Image]
-> ImageWriter t m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Behavior t [Image] -> BehaviorWriterT t [Image] m ()
forall t w (m :: * -> *).
BehaviorWriter t w m =>
Behavior t w -> m ()
tellBehavior
  mapImages :: (Behavior t [Image] -> Behavior t [Image])
-> ImageWriter t m a -> ImageWriter t m a
mapImages Behavior t [Image] -> Behavior t [Image]
f (ImageWriter BehaviorWriterT t [Image] m a
x) = BehaviorWriterT t [Image] m a -> ImageWriter t m a
forall t (m :: * -> *) a.
BehaviorWriterT t [Image] m a -> ImageWriter t m a
ImageWriter (BehaviorWriterT t [Image] m a -> ImageWriter t m a)
-> BehaviorWriterT t [Image] m a -> ImageWriter t m a
forall a b. (a -> b) -> a -> b
$ do
    (a
a, Behavior t [Image]
images) <- m (a, Behavior t [Image])
-> BehaviorWriterT t [Image] m (a, Behavior t [Image])
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (a, Behavior t [Image])
 -> BehaviorWriterT t [Image] m (a, Behavior t [Image]))
-> m (a, Behavior t [Image])
-> BehaviorWriterT t [Image] m (a, Behavior t [Image])
forall a b. (a -> b) -> a -> b
$ BehaviorWriterT t [Image] m a -> m (a, Behavior t [Image])
forall (m :: * -> *) t w a.
(Monad m, Reflex t, Monoid w) =>
BehaviorWriterT t w m a -> m (a, Behavior t w)
runBehaviorWriterT BehaviorWriterT t [Image] m a
x
    Behavior t [Image] -> BehaviorWriterT t [Image] m ()
forall t w (m :: * -> *).
BehaviorWriter t w m =>
Behavior t w -> m ()
tellBehavior (Behavior t [Image] -> BehaviorWriterT t [Image] m ())
-> Behavior t [Image] -> BehaviorWriterT t [Image] m ()
forall a b. (a -> b) -> a -> b
$ Behavior t [Image] -> Behavior t [Image]
f Behavior t [Image]
images
    a -> BehaviorWriterT t [Image] m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
a

instance HasDisplayRegion t m => HasDisplayRegion t (ImageWriter t m)
instance HasFocusReader t m => HasFocusReader t (ImageWriter t m)

-- | Run a widget that can produce images
runImageWriter
  :: (Reflex t, Monad m)
  => ImageWriter t m a
  -> m (a, Behavior t [Image])
runImageWriter :: ImageWriter t m a -> m (a, Behavior t [Image])
runImageWriter = BehaviorWriterT t [Image] m a -> m (a, Behavior t [Image])
forall (m :: * -> *) t w a.
(Monad m, Reflex t, Monoid w) =>
BehaviorWriterT t w m a -> m (a, Behavior t w)
runBehaviorWriterT (BehaviorWriterT t [Image] m a -> m (a, Behavior t [Image]))
-> (ImageWriter t m a -> BehaviorWriterT t [Image] m a)
-> ImageWriter t m a
-> m (a, Behavior t [Image])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ImageWriter t m a -> BehaviorWriterT t [Image] m a
forall t (m :: * -> *) a.
ImageWriter t m a -> BehaviorWriterT t [Image] m a
unImageWriter

-- * Theming

-- | A class for things that can be visually styled
class (Reflex t, Monad m) => HasTheme t m | m -> t where
  theme :: m (Behavior t V.Attr)
  default theme :: (f m' ~ m, Monad m', MonadTrans f, HasTheme t m') => m (Behavior t V.Attr)
  theme = m' (Behavior t Attr) -> f m' (Behavior t Attr)
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m' (Behavior t Attr)
forall k (t :: k) (m :: * -> *).
HasTheme t m =>
m (Behavior t Attr)
theme
  localTheme :: (Behavior t V.Attr -> Behavior t V.Attr) -> m a -> m a
  default localTheme :: (f m' ~ m, Monad m', MFunctor f, HasTheme t m') => (Behavior t V.Attr -> Behavior t V.Attr) -> m a -> m a
  localTheme Behavior t Attr -> Behavior t Attr
f = (forall a. m' a -> m' a) -> f m' a -> f m' a
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist ((Behavior t Attr -> Behavior t Attr) -> m' a -> m' a
forall k (t :: k) (m :: * -> *) a.
HasTheme t m =>
(Behavior t Attr -> Behavior t Attr) -> m a -> m a
localTheme Behavior t Attr -> Behavior t Attr
f)

instance HasTheme t m => HasTheme t (ReaderT x m)
instance HasTheme t m => HasTheme t (BehaviorWriterT t x m)
instance HasTheme t m => HasTheme t (DynamicWriterT t x m)
instance HasTheme t m => HasTheme t (EventWriterT t x m)
instance HasTheme t m => HasTheme t (NodeIdT m)
instance HasTheme t m => HasTheme t (Input t m)
instance HasTheme t m => HasTheme t (ImageWriter t m)
instance HasTheme t m => HasTheme t (DisplayRegion t m)
instance HasTheme t m => HasTheme t (FocusReader t m)

-- | A widget that has access to theme information
newtype ThemeReader t m a = ThemeReader
  { ThemeReader t m a -> ReaderT (Behavior t Attr) m a
unThemeReader :: ReaderT (Behavior t V.Attr) m a }
  deriving
    ( a -> ThemeReader t m b -> ThemeReader t m a
(a -> b) -> ThemeReader t m a -> ThemeReader t m b
(forall a b. (a -> b) -> ThemeReader t m a -> ThemeReader t m b)
-> (forall a b. a -> ThemeReader t m b -> ThemeReader t m a)
-> Functor (ThemeReader t m)
forall k (t :: k) (m :: * -> *) a b.
Functor m =>
a -> ThemeReader t m b -> ThemeReader t m a
forall k (t :: k) (m :: * -> *) a b.
Functor m =>
(a -> b) -> ThemeReader t m a -> ThemeReader t m b
forall a b. a -> ThemeReader t m b -> ThemeReader t m a
forall a b. (a -> b) -> ThemeReader t m a -> ThemeReader t m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ThemeReader t m b -> ThemeReader t m a
$c<$ :: forall k (t :: k) (m :: * -> *) a b.
Functor m =>
a -> ThemeReader t m b -> ThemeReader t m a
fmap :: (a -> b) -> ThemeReader t m a -> ThemeReader t m b
$cfmap :: forall k (t :: k) (m :: * -> *) a b.
Functor m =>
(a -> b) -> ThemeReader t m a -> ThemeReader t m b
Functor
    , Functor (ThemeReader t m)
a -> ThemeReader t m a
Functor (ThemeReader t m)
-> (forall a. a -> ThemeReader t m a)
-> (forall a b.
    ThemeReader t m (a -> b) -> ThemeReader t m a -> ThemeReader t m b)
-> (forall a b c.
    (a -> b -> c)
    -> ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m c)
-> (forall a b.
    ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m b)
-> (forall a b.
    ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m a)
-> Applicative (ThemeReader t m)
ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m b
ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m a
ThemeReader t m (a -> b) -> ThemeReader t m a -> ThemeReader t m b
(a -> b -> c)
-> ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m c
forall a. a -> ThemeReader t m a
forall k (t :: k) (m :: * -> *).
Applicative m =>
Functor (ThemeReader t m)
forall k (t :: k) (m :: * -> *) a.
Applicative m =>
a -> ThemeReader t m a
forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m a
forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m b
forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
ThemeReader t m (a -> b) -> ThemeReader t m a -> ThemeReader t m b
forall k (t :: k) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m c
forall a b.
ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m a
forall a b.
ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m b
forall a b.
ThemeReader t m (a -> b) -> ThemeReader t m a -> ThemeReader t m b
forall a b c.
(a -> b -> c)
-> ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m a
$c<* :: forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m a
*> :: ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m b
$c*> :: forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m b
liftA2 :: (a -> b -> c)
-> ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m c
$cliftA2 :: forall k (t :: k) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m c
<*> :: ThemeReader t m (a -> b) -> ThemeReader t m a -> ThemeReader t m b
$c<*> :: forall k (t :: k) (m :: * -> *) a b.
Applicative m =>
ThemeReader t m (a -> b) -> ThemeReader t m a -> ThemeReader t m b
pure :: a -> ThemeReader t m a
$cpure :: forall k (t :: k) (m :: * -> *) a.
Applicative m =>
a -> ThemeReader t m a
$cp1Applicative :: forall k (t :: k) (m :: * -> *).
Applicative m =>
Functor (ThemeReader t m)
Applicative
    , Applicative (ThemeReader t m)
a -> ThemeReader t m a
Applicative (ThemeReader t m)
-> (forall a b.
    ThemeReader t m a -> (a -> ThemeReader t m b) -> ThemeReader t m b)
-> (forall a b.
    ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m b)
-> (forall a. a -> ThemeReader t m a)
-> Monad (ThemeReader t m)
ThemeReader t m a -> (a -> ThemeReader t m b) -> ThemeReader t m b
ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m b
forall a. a -> ThemeReader t m a
forall k (t :: k) (m :: * -> *).
Monad m =>
Applicative (ThemeReader t m)
forall k (t :: k) (m :: * -> *) a.
Monad m =>
a -> ThemeReader t m a
forall k (t :: k) (m :: * -> *) a b.
Monad m =>
ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m b
forall k (t :: k) (m :: * -> *) a b.
Monad m =>
ThemeReader t m a -> (a -> ThemeReader t m b) -> ThemeReader t m b
forall a b.
ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m b
forall a b.
ThemeReader t m a -> (a -> ThemeReader t m b) -> ThemeReader t m b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> ThemeReader t m a
$creturn :: forall k (t :: k) (m :: * -> *) a.
Monad m =>
a -> ThemeReader t m a
>> :: ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m b
$c>> :: forall k (t :: k) (m :: * -> *) a b.
Monad m =>
ThemeReader t m a -> ThemeReader t m b -> ThemeReader t m b
>>= :: ThemeReader t m a -> (a -> ThemeReader t m b) -> ThemeReader t m b
$c>>= :: forall k (t :: k) (m :: * -> *) a b.
Monad m =>
ThemeReader t m a -> (a -> ThemeReader t m b) -> ThemeReader t m b
$cp1Monad :: forall k (t :: k) (m :: * -> *).
Monad m =>
Applicative (ThemeReader t m)
Monad
    , Monad (ThemeReader t m)
Monad (ThemeReader t m)
-> (forall a. (a -> ThemeReader t m a) -> ThemeReader t m a)
-> MonadFix (ThemeReader t m)
(a -> ThemeReader t m a) -> ThemeReader t m a
forall a. (a -> ThemeReader t m a) -> ThemeReader t m a
forall k (t :: k) (m :: * -> *).
MonadFix m =>
Monad (ThemeReader t m)
forall k (t :: k) (m :: * -> *) a.
MonadFix m =>
(a -> ThemeReader t m a) -> ThemeReader t m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
mfix :: (a -> ThemeReader t m a) -> ThemeReader t m a
$cmfix :: forall k (t :: k) (m :: * -> *) a.
MonadFix m =>
(a -> ThemeReader t m a) -> ThemeReader t m a
$cp1MonadFix :: forall k (t :: k) (m :: * -> *).
MonadFix m =>
Monad (ThemeReader t m)
MonadFix
    , MonadHold t
    , Monad (ThemeReader t m)
Monad (ThemeReader t m)
-> (forall a. IO a -> ThemeReader t m a)
-> MonadIO (ThemeReader t m)
IO a -> ThemeReader t m a
forall a. IO a -> ThemeReader t m a
forall k (t :: k) (m :: * -> *).
MonadIO m =>
Monad (ThemeReader t m)
forall k (t :: k) (m :: * -> *) a.
MonadIO m =>
IO a -> ThemeReader t m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
liftIO :: IO a -> ThemeReader t m a
$cliftIO :: forall k (t :: k) (m :: * -> *) a.
MonadIO m =>
IO a -> ThemeReader t m a
$cp1MonadIO :: forall k (t :: k) (m :: * -> *).
MonadIO m =>
Monad (ThemeReader t m)
MonadIO
    , Monad (ThemeReader t m)
a -> ThemeReader t m (Ref (ThemeReader t m) a)
Monad (ThemeReader t m)
-> (forall a. a -> ThemeReader t m (Ref (ThemeReader t m) a))
-> (forall a. Ref (ThemeReader t m) a -> ThemeReader t m a)
-> (forall a. Ref (ThemeReader t m) a -> a -> ThemeReader t m ())
-> (forall a.
    Ref (ThemeReader t m) a -> (a -> a) -> ThemeReader t m ())
-> (forall a.
    Ref (ThemeReader t m) a -> (a -> a) -> ThemeReader t m ())
-> MonadRef (ThemeReader t m)
Ref (ThemeReader t m) a -> ThemeReader t m a
Ref (ThemeReader t m) a -> a -> ThemeReader t m ()
Ref (ThemeReader t m) a -> (a -> a) -> ThemeReader t m ()
Ref (ThemeReader t m) a -> (a -> a) -> ThemeReader t m ()
forall a. a -> ThemeReader t m (Ref (ThemeReader t m) a)
forall a. Ref (ThemeReader t m) a -> ThemeReader t m a
forall a. Ref (ThemeReader t m) a -> a -> ThemeReader t m ()
forall a. Ref (ThemeReader t m) a -> (a -> a) -> ThemeReader t m ()
forall k (t :: k) (m :: * -> *).
MonadRef m =>
Monad (ThemeReader t m)
forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
a -> ThemeReader t m (Ref (ThemeReader t m) a)
forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (ThemeReader t m) a -> ThemeReader t m a
forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (ThemeReader t m) a -> a -> ThemeReader t m ()
forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (ThemeReader t m) a -> (a -> a) -> ThemeReader t m ()
forall (m :: * -> *).
Monad m
-> (forall a. a -> m (Ref m a))
-> (forall a. Ref m a -> m a)
-> (forall a. Ref m a -> a -> m ())
-> (forall a. Ref m a -> (a -> a) -> m ())
-> (forall a. Ref m a -> (a -> a) -> m ())
-> MonadRef m
modifyRef' :: Ref (ThemeReader t m) a -> (a -> a) -> ThemeReader t m ()
$cmodifyRef' :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (ThemeReader t m) a -> (a -> a) -> ThemeReader t m ()
modifyRef :: Ref (ThemeReader t m) a -> (a -> a) -> ThemeReader t m ()
$cmodifyRef :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (ThemeReader t m) a -> (a -> a) -> ThemeReader t m ()
writeRef :: Ref (ThemeReader t m) a -> a -> ThemeReader t m ()
$cwriteRef :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (ThemeReader t m) a -> a -> ThemeReader t m ()
readRef :: Ref (ThemeReader t m) a -> ThemeReader t m a
$creadRef :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
Ref (ThemeReader t m) a -> ThemeReader t m a
newRef :: a -> ThemeReader t m (Ref (ThemeReader t m) a)
$cnewRef :: forall k (t :: k) (m :: * -> *) a.
MonadRef m =>
a -> ThemeReader t m (Ref (ThemeReader t m) a)
$cp1MonadRef :: forall k (t :: k) (m :: * -> *).
MonadRef m =>
Monad (ThemeReader t m)
MonadRef
    , MonadSample t
    , MonadThrow (ThemeReader t m)
MonadThrow (ThemeReader t m)
-> (forall e a.
    Exception e =>
    ThemeReader t m a -> (e -> ThemeReader t m a) -> ThemeReader t m a)
-> MonadCatch (ThemeReader t m)
ThemeReader t m a -> (e -> ThemeReader t m a) -> ThemeReader t m a
forall k (t :: k) (m :: * -> *).
MonadCatch m =>
MonadThrow (ThemeReader t m)
forall k (t :: k) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
ThemeReader t m a -> (e -> ThemeReader t m a) -> ThemeReader t m a
forall e a.
Exception e =>
ThemeReader t m a -> (e -> ThemeReader t m a) -> ThemeReader t m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
catch :: ThemeReader t m a -> (e -> ThemeReader t m a) -> ThemeReader t m a
$ccatch :: forall k (t :: k) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
ThemeReader t m a -> (e -> ThemeReader t m a) -> ThemeReader t m a
$cp1MonadCatch :: forall k (t :: k) (m :: * -> *).
MonadCatch m =>
MonadThrow (ThemeReader t m)
MonadCatch
    , Monad (ThemeReader t m)
e -> ThemeReader t m a
Monad (ThemeReader t m)
-> (forall e a. Exception e => e -> ThemeReader t m a)
-> MonadThrow (ThemeReader t m)
forall k (t :: k) (m :: * -> *).
MonadThrow m =>
Monad (ThemeReader t m)
forall k (t :: k) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> ThemeReader t m a
forall e a. Exception e => e -> ThemeReader t m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
throwM :: e -> ThemeReader t m a
$cthrowM :: forall k (t :: k) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> ThemeReader t m a
$cp1MonadThrow :: forall k (t :: k) (m :: * -> *).
MonadThrow m =>
Monad (ThemeReader t m)
MonadThrow
    , MonadCatch (ThemeReader t m)
MonadCatch (ThemeReader t m)
-> (forall b.
    ((forall a. ThemeReader t m a -> ThemeReader t m a)
     -> ThemeReader t m b)
    -> ThemeReader t m b)
-> (forall b.
    ((forall a. ThemeReader t m a -> ThemeReader t m a)
     -> ThemeReader t m b)
    -> ThemeReader t m b)
-> (forall a b c.
    ThemeReader t m a
    -> (a -> ExitCase b -> ThemeReader t m c)
    -> (a -> ThemeReader t m b)
    -> ThemeReader t m (b, c))
-> MonadMask (ThemeReader t m)
ThemeReader t m a
-> (a -> ExitCase b -> ThemeReader t m c)
-> (a -> ThemeReader t m b)
-> ThemeReader t m (b, c)
((forall a. ThemeReader t m a -> ThemeReader t m a)
 -> ThemeReader t m b)
-> ThemeReader t m b
((forall a. ThemeReader t m a -> ThemeReader t m a)
 -> ThemeReader t m b)
-> ThemeReader t m b
forall b.
((forall a. ThemeReader t m a -> ThemeReader t m a)
 -> ThemeReader t m b)
-> ThemeReader t m b
forall k (t :: k) (m :: * -> *).
MonadMask m =>
MonadCatch (ThemeReader t m)
forall k (t :: k) (m :: * -> *) b.
MonadMask m =>
((forall a. ThemeReader t m a -> ThemeReader t m a)
 -> ThemeReader t m b)
-> ThemeReader t m b
forall k (t :: k) (m :: * -> *) a b c.
MonadMask m =>
ThemeReader t m a
-> (a -> ExitCase b -> ThemeReader t m c)
-> (a -> ThemeReader t m b)
-> ThemeReader t m (b, c)
forall a b c.
ThemeReader t m a
-> (a -> ExitCase b -> ThemeReader t m c)
-> (a -> ThemeReader t m b)
-> ThemeReader t m (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
generalBracket :: ThemeReader t m a
-> (a -> ExitCase b -> ThemeReader t m c)
-> (a -> ThemeReader t m b)
-> ThemeReader t m (b, c)
$cgeneralBracket :: forall k (t :: k) (m :: * -> *) a b c.
MonadMask m =>
ThemeReader t m a
-> (a -> ExitCase b -> ThemeReader t m c)
-> (a -> ThemeReader t m b)
-> ThemeReader t m (b, c)
uninterruptibleMask :: ((forall a. ThemeReader t m a -> ThemeReader t m a)
 -> ThemeReader t m b)
-> ThemeReader t m b
$cuninterruptibleMask :: forall k (t :: k) (m :: * -> *) b.
MonadMask m =>
((forall a. ThemeReader t m a -> ThemeReader t m a)
 -> ThemeReader t m b)
-> ThemeReader t m b
mask :: ((forall a. ThemeReader t m a -> ThemeReader t m a)
 -> ThemeReader t m b)
-> ThemeReader t m b
$cmask :: forall k (t :: k) (m :: * -> *) b.
MonadMask m =>
((forall a. ThemeReader t m a -> ThemeReader t m a)
 -> ThemeReader t m b)
-> ThemeReader t m b
$cp1MonadMask :: forall k (t :: k) (m :: * -> *).
MonadMask m =>
MonadCatch (ThemeReader t m)
MonadMask
    )

instance (Monad m, Reflex t) => HasTheme t (ThemeReader t m) where
  theme :: ThemeReader t m (Behavior t Attr)
theme = ReaderT (Behavior t Attr) m (Behavior t Attr)
-> ThemeReader t m (Behavior t Attr)
forall k (t :: k) (m :: * -> *) a.
ReaderT (Behavior t Attr) m a -> ThemeReader t m a
ThemeReader ReaderT (Behavior t Attr) m (Behavior t Attr)
forall r (m :: * -> *). MonadReader r m => m r
ask
  localTheme :: (Behavior t Attr -> Behavior t Attr)
-> ThemeReader t m a -> ThemeReader t m a
localTheme Behavior t Attr -> Behavior t Attr
f = ReaderT (Behavior t Attr) m a -> ThemeReader t m a
forall k (t :: k) (m :: * -> *) a.
ReaderT (Behavior t Attr) m a -> ThemeReader t m a
ThemeReader (ReaderT (Behavior t Attr) m a -> ThemeReader t m a)
-> (ThemeReader t m a -> ReaderT (Behavior t Attr) m a)
-> ThemeReader t m a
-> ThemeReader t m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Behavior t Attr -> Behavior t Attr)
-> ReaderT (Behavior t Attr) m a -> ReaderT (Behavior t Attr) m a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local Behavior t Attr -> Behavior t Attr
f (ReaderT (Behavior t Attr) m a -> ReaderT (Behavior t Attr) m a)
-> (ThemeReader t m a -> ReaderT (Behavior t Attr) m a)
-> ThemeReader t m a
-> ReaderT (Behavior t Attr) m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ThemeReader t m a -> ReaderT (Behavior t Attr) m a
forall k (t :: k) (m :: * -> *) a.
ThemeReader t m a -> ReaderT (Behavior t Attr) m a
unThemeReader

deriving instance MonadReflexCreateTrigger t m => MonadReflexCreateTrigger t (ThemeReader t m)
deriving instance NotReady t m => NotReady t (ThemeReader t m)
deriving instance PerformEvent t m => PerformEvent t (ThemeReader t m)
deriving instance PostBuild t m => PostBuild t (ThemeReader t m)
deriving instance TriggerEvent t m => TriggerEvent t (ThemeReader t m)
instance HasImageWriter t m => HasImageWriter t (ThemeReader t m)

instance (Adjustable t m, MonadFix m, MonadHold t m) => Adjustable t (ThemeReader t m) where
  runWithReplace :: ThemeReader t m a
-> Event t (ThemeReader t m b) -> ThemeReader t m (a, Event t b)
runWithReplace (ThemeReader ReaderT (Behavior t Attr) m a
a) Event t (ThemeReader t m b)
e = ReaderT (Behavior t Attr) m (a, Event t b)
-> ThemeReader t m (a, Event t b)
forall k (t :: k) (m :: * -> *) a.
ReaderT (Behavior t Attr) m a -> ThemeReader t m a
ThemeReader (ReaderT (Behavior t Attr) m (a, Event t b)
 -> ThemeReader t m (a, Event t b))
-> ReaderT (Behavior t Attr) m (a, Event t b)
-> ThemeReader t m (a, Event t b)
forall a b. (a -> b) -> a -> b
$ ReaderT (Behavior t Attr) m a
-> Event t (ReaderT (Behavior t Attr) m b)
-> ReaderT (Behavior t Attr) m (a, Event t b)
forall t (m :: * -> *) a b.
Adjustable t m =>
m a -> Event t (m b) -> m (a, Event t b)
runWithReplace ReaderT (Behavior t Attr) m a
a (Event t (ReaderT (Behavior t Attr) m b)
 -> ReaderT (Behavior t Attr) m (a, Event t b))
-> Event t (ReaderT (Behavior t Attr) m b)
-> ReaderT (Behavior t Attr) m (a, Event t b)
forall a b. (a -> b) -> a -> b
$ (ThemeReader t m b -> ReaderT (Behavior t Attr) m b)
-> Event t (ThemeReader t m b)
-> Event t (ReaderT (Behavior t Attr) m b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ThemeReader t m b -> ReaderT (Behavior t Attr) m b
forall k (t :: k) (m :: * -> *) a.
ThemeReader t m a -> ReaderT (Behavior t Attr) m a
unThemeReader Event t (ThemeReader t m b)
e
  traverseIntMapWithKeyWithAdjust :: (Int -> v -> ThemeReader t m v')
-> IntMap v
-> Event t (PatchIntMap v)
-> ThemeReader t m (IntMap v', Event t (PatchIntMap v'))
traverseIntMapWithKeyWithAdjust Int -> v -> ThemeReader t m v'
f IntMap v
m Event t (PatchIntMap v)
e = ReaderT (Behavior t Attr) m (IntMap v', Event t (PatchIntMap v'))
-> ThemeReader t m (IntMap v', Event t (PatchIntMap v'))
forall k (t :: k) (m :: * -> *) a.
ReaderT (Behavior t Attr) m a -> ThemeReader t m a
ThemeReader (ReaderT (Behavior t Attr) m (IntMap v', Event t (PatchIntMap v'))
 -> ThemeReader t m (IntMap v', Event t (PatchIntMap v')))
-> ReaderT
     (Behavior t Attr) m (IntMap v', Event t (PatchIntMap v'))
-> ThemeReader t m (IntMap v', Event t (PatchIntMap v'))
forall a b. (a -> b) -> a -> b
$ (Int -> v -> ReaderT (Behavior t Attr) m v')
-> IntMap v
-> Event t (PatchIntMap v)
-> ReaderT
     (Behavior t Attr) m (IntMap v', Event t (PatchIntMap v'))
forall t (m :: * -> *) v v'.
Adjustable t m =>
(Int -> v -> m v')
-> IntMap v
-> Event t (PatchIntMap v)
-> m (IntMap v', Event t (PatchIntMap v'))
traverseIntMapWithKeyWithAdjust (\Int
k v
v -> ThemeReader t m v' -> ReaderT (Behavior t Attr) m v'
forall k (t :: k) (m :: * -> *) a.
ThemeReader t m a -> ReaderT (Behavior t Attr) m a
unThemeReader (ThemeReader t m v' -> ReaderT (Behavior t Attr) m v')
-> ThemeReader t m v' -> ReaderT (Behavior t Attr) m v'
forall a b. (a -> b) -> a -> b
$ Int -> v -> ThemeReader t m v'
f Int
k v
v) IntMap v
m Event t (PatchIntMap v)
e
  traverseDMapWithKeyWithAdjust :: (forall a. k a -> v a -> ThemeReader t m (v' a))
-> DMap k v
-> Event t (PatchDMap k v)
-> ThemeReader t m (DMap k v', Event t (PatchDMap k v'))
traverseDMapWithKeyWithAdjust forall a. k a -> v a -> ThemeReader t m (v' a)
f DMap k v
m Event t (PatchDMap k v)
e = ReaderT (Behavior t Attr) m (DMap k v', Event t (PatchDMap k v'))
-> ThemeReader t m (DMap k v', Event t (PatchDMap k v'))
forall k (t :: k) (m :: * -> *) a.
ReaderT (Behavior t Attr) m a -> ThemeReader t m a
ThemeReader (ReaderT (Behavior t Attr) m (DMap k v', Event t (PatchDMap k v'))
 -> ThemeReader t m (DMap k v', Event t (PatchDMap k v')))
-> ReaderT
     (Behavior t Attr) m (DMap k v', Event t (PatchDMap k v'))
-> ThemeReader t m (DMap k v', Event t (PatchDMap k v'))
forall a b. (a -> b) -> a -> b
$ (forall a. k a -> v a -> ReaderT (Behavior t Attr) m (v' a))
-> DMap k v
-> Event t (PatchDMap k v)
-> ReaderT
     (Behavior t Attr) m (DMap k v', Event t (PatchDMap k v'))
forall t (m :: * -> *) (k :: * -> *) (v :: * -> *) (v' :: * -> *).
(Adjustable t m, GCompare k) =>
(forall a. k a -> v a -> m (v' a))
-> DMap k v
-> Event t (PatchDMap k v)
-> m (DMap k v', Event t (PatchDMap k v'))
traverseDMapWithKeyWithAdjust (\k a
k v a
v -> ThemeReader t m (v' a) -> ReaderT (Behavior t Attr) m (v' a)
forall k (t :: k) (m :: * -> *) a.
ThemeReader t m a -> ReaderT (Behavior t Attr) m a
unThemeReader (ThemeReader t m (v' a) -> ReaderT (Behavior t Attr) m (v' a))
-> ThemeReader t m (v' a) -> ReaderT (Behavior t Attr) m (v' a)
forall a b. (a -> b) -> a -> b
$ k a -> v a -> ThemeReader t m (v' a)
forall a. k a -> v a -> ThemeReader t m (v' a)
f k a
k v a
v) DMap k v
m Event t (PatchDMap k v)
e
  traverseDMapWithKeyWithAdjustWithMove :: (forall a. k a -> v a -> ThemeReader t m (v' a))
-> DMap k v
-> Event t (PatchDMapWithMove k v)
-> ThemeReader t m (DMap k v', Event t (PatchDMapWithMove k v'))
traverseDMapWithKeyWithAdjustWithMove forall a. k a -> v a -> ThemeReader t m (v' a)
f DMap k v
m Event t (PatchDMapWithMove k v)
e = ReaderT
  (Behavior t Attr) m (DMap k v', Event t (PatchDMapWithMove k v'))
-> ThemeReader t m (DMap k v', Event t (PatchDMapWithMove k v'))
forall k (t :: k) (m :: * -> *) a.
ReaderT (Behavior t Attr) m a -> ThemeReader t m a
ThemeReader (ReaderT
   (Behavior t Attr) m (DMap k v', Event t (PatchDMapWithMove k v'))
 -> ThemeReader t m (DMap k v', Event t (PatchDMapWithMove k v')))
-> ReaderT
     (Behavior t Attr) m (DMap k v', Event t (PatchDMapWithMove k v'))
-> ThemeReader t m (DMap k v', Event t (PatchDMapWithMove k v'))
forall a b. (a -> b) -> a -> b
$ (forall a. k a -> v a -> ReaderT (Behavior t Attr) m (v' a))
-> DMap k v
-> Event t (PatchDMapWithMove k v)
-> ReaderT
     (Behavior t Attr) m (DMap k v', Event t (PatchDMapWithMove k v'))
forall t (m :: * -> *) (k :: * -> *) (v :: * -> *) (v' :: * -> *).
(Adjustable t m, GCompare k) =>
(forall a. k a -> v a -> m (v' a))
-> DMap k v
-> Event t (PatchDMapWithMove k v)
-> m (DMap k v', Event t (PatchDMapWithMove k v'))
traverseDMapWithKeyWithAdjustWithMove (\k a
k v a
v -> ThemeReader t m (v' a) -> ReaderT (Behavior t Attr) m (v' a)
forall k (t :: k) (m :: * -> *) a.
ThemeReader t m a -> ReaderT (Behavior t Attr) m a
unThemeReader (ThemeReader t m (v' a) -> ReaderT (Behavior t Attr) m (v' a))
-> ThemeReader t m (v' a) -> ReaderT (Behavior t Attr) m (v' a)
forall a b. (a -> b) -> a -> b
$ k a -> v a -> ThemeReader t m (v' a)
forall a. k a -> v a -> ThemeReader t m (v' a)
f k a
k v a
v) DMap k v
m Event t (PatchDMapWithMove k v)
e

instance MonadTrans (ThemeReader t) where
  lift :: m a -> ThemeReader t m a
lift = ReaderT (Behavior t Attr) m a -> ThemeReader t m a
forall k (t :: k) (m :: * -> *) a.
ReaderT (Behavior t Attr) m a -> ThemeReader t m a
ThemeReader (ReaderT (Behavior t Attr) m a -> ThemeReader t m a)
-> (m a -> ReaderT (Behavior t Attr) m a)
-> m a
-> ThemeReader t m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> ReaderT (Behavior t Attr) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

instance MFunctor (ThemeReader t) where
  hoist :: (forall a. m a -> n a) -> ThemeReader t m b -> ThemeReader t n b
hoist forall a. m a -> n a
f = ReaderT (Behavior t Attr) n b -> ThemeReader t n b
forall k (t :: k) (m :: * -> *) a.
ReaderT (Behavior t Attr) m a -> ThemeReader t m a
ThemeReader (ReaderT (Behavior t Attr) n b -> ThemeReader t n b)
-> (ThemeReader t m b -> ReaderT (Behavior t Attr) n b)
-> ThemeReader t m b
-> ThemeReader t n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. m a -> n a)
-> ReaderT (Behavior t Attr) m b -> ReaderT (Behavior t Attr) n b
forall k (t :: (* -> *) -> k -> *) (m :: * -> *) (n :: * -> *)
       (b :: k).
(MFunctor t, Monad m) =>
(forall a. m a -> n a) -> t m b -> t n b
hoist forall a. m a -> n a
f (ReaderT (Behavior t Attr) m b -> ReaderT (Behavior t Attr) n b)
-> (ThemeReader t m b -> ReaderT (Behavior t Attr) m b)
-> ThemeReader t m b
-> ReaderT (Behavior t Attr) n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ThemeReader t m b -> ReaderT (Behavior t Attr) m b
forall k (t :: k) (m :: * -> *) a.
ThemeReader t m a -> ReaderT (Behavior t Attr) m a
unThemeReader

instance MonadNodeId m => MonadNodeId (ThemeReader t m)

-- | Run a 'ThemeReader' action with the given focus value
runThemeReader
  :: (Reflex t, Monad m)
  => Behavior t V.Attr
  -> ThemeReader t m a
  -> m a
runThemeReader :: Behavior t Attr -> ThemeReader t m a -> m a
runThemeReader Behavior t Attr
b = (ReaderT (Behavior t Attr) m a -> Behavior t Attr -> m a)
-> Behavior t Attr -> ReaderT (Behavior t Attr) m a -> m a
forall a b c. (a -> b -> c) -> b -> a -> c
flip ReaderT (Behavior t Attr) m a -> Behavior t Attr -> m a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT Behavior t Attr
b (ReaderT (Behavior t Attr) m a -> m a)
-> (ThemeReader t m a -> ReaderT (Behavior t Attr) m a)
-> ThemeReader t m a
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ThemeReader t m a -> ReaderT (Behavior t Attr) m a
forall k (t :: k) (m :: * -> *) a.
ThemeReader t m a -> ReaderT (Behavior t Attr) m a
unThemeReader


-- ** Manipulating images

-- | Translates and crops an 'Image' so that it is contained by
-- the given 'Region'.
withinImage
  :: Region
  -> Image
  -> Image
withinImage :: Region -> Image -> Image
withinImage (Region Int
left Int
top Int
width Int
height)
  | Int
width Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 Bool -> Bool -> Bool
|| Int
height Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 = Region -> Image -> Image
withinImage (Int -> Int -> Int -> Int -> Region
Region Int
left Int
top Int
0 Int
0)
  | Bool
otherwise = Int -> Int -> Image -> Image
V.translate Int
left Int
top (Image -> Image) -> (Image -> Image) -> Image -> Image
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Image -> Image
V.crop Int
width Int
height

-- | Crop a behavior of images to a behavior of regions. See 'withinImage'.
imagesInRegion
  :: Reflex t
  => Behavior t Region
  -> Behavior t [Image]
  -> Behavior t [Image]
imagesInRegion :: Behavior t Region -> Behavior t [Image] -> Behavior t [Image]
imagesInRegion Behavior t Region
reg = (Region -> [Image] -> [Image])
-> Behavior t Region -> Behavior t [Image] -> Behavior t [Image]
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (\Region
r [Image]
is -> (Image -> Image) -> [Image] -> [Image]
forall a b. (a -> b) -> [a] -> [b]
map (Region -> Image -> Image
withinImage Region
r) [Image]
is) Behavior t Region
reg

-- * Running sub-widgets

-- | Low-level widget combinator that runs a child widget within
-- a given region and context. This widget filters and modifies the input
-- that the child widget receives such that:
-- * unfocused widgets receive no key events
-- * mouse inputs inside the region have their coordinates translated such
--   that (0,0) is the top-left corner of the region
-- * mouse drag sequences that start OFF the region are ignored
-- * mouse drag sequences that start ON the region and drag off are NOT ignored
pane
  :: (MonadFix m, MonadHold t m, HasInput t m, HasImageWriter t m, HasDisplayRegion t m, HasFocusReader t m)
  => Dynamic t Region
  -> Dynamic t Bool -- ^ Whether the widget should be focused when the parent is.
  -> m a
  -> m a
pane :: Dynamic t Region -> Dynamic t Bool -> m a -> m a
pane Dynamic t Region
dr Dynamic t Bool
foc m a
child = (Dynamic t Region -> Dynamic t Region) -> m a -> m a
forall k (t :: k) (m :: * -> *) a.
HasDisplayRegion t m =>
(Dynamic t Region -> Dynamic t Region) -> m a -> m a
localRegion (Dynamic t Region -> Dynamic t Region -> Dynamic t Region
forall a b. a -> b -> a
const Dynamic t Region
dr) (m a -> m a) -> m a -> m a
forall a b. (a -> b) -> a -> b
$
  (Behavior t [Image] -> Behavior t [Image]) -> m a -> m a
forall k (t :: k) (m :: * -> *) a.
HasImageWriter t m =>
(Behavior t [Image] -> Behavior t [Image]) -> m a -> m a
mapImages (Behavior t Region -> Behavior t [Image] -> Behavior t [Image]
forall k (t :: k).
Reflex t =>
Behavior t Region -> Behavior t [Image] -> Behavior t [Image]
imagesInRegion (Behavior t Region -> Behavior t [Image] -> Behavior t [Image])
-> Behavior t Region -> Behavior t [Image] -> Behavior t [Image]
forall a b. (a -> b) -> a -> b
$ Dynamic t Region -> Behavior t Region
forall k (t :: k) a. Reflex t => Dynamic t a -> Behavior t a
current Dynamic t Region
dr) (m a -> m a) -> m a -> m a
forall a b. (a -> b) -> a -> b
$
    (Dynamic t Bool -> Dynamic t Bool) -> m a -> m a
forall k (t :: k) (m :: * -> *) a.
HasFocusReader t m =>
(Dynamic t Bool -> Dynamic t Bool) -> m a -> m a
localFocus (Dynamic t Bool -> Dynamic t Bool -> Dynamic t Bool
forall a b. a -> b -> a
const Dynamic t Bool
foc) (m a -> m a) -> m a -> m a
forall a b. (a -> b) -> a -> b
$
      m (Event t Event)
forall k (t :: k) (m :: * -> *).
(MonadFix m, MonadHold t m, HasDisplayRegion t m,
 HasFocusReader t m, HasInput t m) =>
m (Event t Event)
inputInFocusedRegion m (Event t Event) -> (Event t Event -> m a) -> m a
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Event t Event
e -> (Event t Event -> Event t Event) -> m a -> m a
forall k (t :: k) (m :: * -> *) a.
HasInput t m =>
(Event t Event -> Event t Event) -> m a -> m a
localInput (Event t Event -> Event t Event -> Event t Event
forall a b. a -> b -> a
const Event t Event
e) m a
child

-- * Misc

-- | A widget that draws nothing
blank :: Monad m => m ()
blank :: m ()
blank = () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()