{-|
Module      : Monomer.Widgets.Composite
Copyright   : (c) 2018 Francisco Vallarino
License     : BSD-3-Clause (see the LICENSE file)
Maintainer  : fjvallarino@gmail.com
Stability   : experimental
Portability : non-portable

Composite widget. Main glue between all the other widgets, also acts as the main
app widget. Composite allows to split an application into reusable parts without
the need to implement a lower level widget. It can comunicate with its parent
component by reporting events.

Requires two functions:

- UI Builder: creates the widget tree based on the provided Widget Environment
and model. This widget tree is made of other widgets, in general combinations of
containers and singles.
- Event Handler: processes user defined events which are raised by the widgets
created when building the UI.

Composite is discussed in detail in the tutorials.
-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}

module Monomer.Widgets.Composite (
  -- * Re-exported modules
  module Monomer.Core,
  module Monomer.Event,
  module Monomer.Widgets.Util,

  -- * Configuration
  CompositeCfg,
  EventResponse(..),
  CompParentModel,
  CompositeModel,
  CompositeEvent,
  MergeRequired,
  MergeReqsHandler,
  MergeEventsHandler,
  MergeModelHandler,
  EventHandler,
  UIBuilder,
  TaskHandler,
  ProducerHandler,
  CompMsgUpdate,
  compositeMergeReqs,
  compositeMergeEvents,
  compositeMergeModel,

  -- * Constructors
  composite,
  composite_,
  compositeV,
  compositeV_,
  compositeD_
) where

import Debug.Trace

import Control.Applicative ((<|>))
import Control.Exception (AssertionFailed(..), throw)
import Control.Lens (ALens', (&), (^.), (^?), (.~), (%~), (<>~), at, ix, non)
import Control.Monad (when)
import Data.Default
import Data.List (foldl')
import Data.Map.Strict (Map)
import Data.Maybe
import Data.Sequence (Seq(..), (|>), (<|), fromList)
import Data.Typeable (Typeable, cast, typeOf)

import qualified Data.Map.Strict as M
import qualified Data.Sequence as Seq

import Monomer.Core
import Monomer.Core.Combinators
import Monomer.Event
import Monomer.Graphics.Types
import Monomer.Helper
import Monomer.Widgets.Singles.Spacer
import Monomer.Widgets.Util

import qualified Monomer.Core.Lens as L

-- | Type of the parent's model
type CompParentModel sp = Typeable sp
-- | Type of the composite's model
type CompositeModel s = (Eq s, WidgetModel s)
-- | Type of the composite's event
type CompositeEvent e = WidgetEvent e

-- | Checks if merging the composite is required.
type MergeRequired s e
  = WidgetEnv s e  -- ^ Widget environment.
  -> s             -- ^ Old composite model.
  -> s             -- ^ New composite model
  -> Bool          -- ^ True if merge is required.

-- | Generates requests during the merge process.
type MergeReqsHandler s e sp
  = WidgetEnv s e         -- ^ Widget environment.
  -> WidgetNode s e       -- ^ New widget node.
  -> WidgetNode s e       -- ^ Old widget node.
  -> sp                   -- ^ Parent model.
  -> s                    -- ^ Old composite model.
  -> s                    -- ^ New composite model.
  -> [WidgetRequest s e]  -- ^ The list of requests.

-- | Generates events during the merge process.
type MergeEventsHandler s e sp
  = WidgetEnv s e         -- ^ Widget environment.
  -> WidgetNode s e       -- ^ New widget node.
  -> WidgetNode s e       -- ^ Old widget node.
  -> sp                   -- ^ Parent model.
  -> s                    -- ^ Old composite model.
  -> s                    -- ^ New composite model.
  -> [e]                  -- ^ The list of events.

-- | Allows updating the composite model with information from the parent model.
type MergeModelHandler s e sp
  = WidgetEnv s e         -- ^ Widget environment.
  -> sp                   -- ^ Parent model.
  -> s                    -- ^ Old composite model.
  -> s                    -- ^ New composite model.
  -> s                    -- ^ Updated composite model.

-- | Handles a composite event and returns a set of responses.
type EventHandler s e sp ep
  = WidgetEnv s e
  -> WidgetNode s e
  -> s
  -> e
  -> [EventResponse s e sp ep]

-- | Creates the widget tree based on the given model.
type UIBuilder s e = WidgetEnv s e -> s -> WidgetNode s e

-- | Asynchronous task generating a single event.
type TaskHandler e = IO e

-- | Asynchronous task generating multiple events.
type ProducerHandler e = (e -> IO ()) -> IO ()

-- | Model update function wrapped as a message.
data CompMsgUpdate
  = forall s . CompositeModel s => CompMsgUpdate (s -> s)

{-|
Delayed request. Used to account for widget tree changes in previous steps. When
processing EventResponses that depend on WidgetKeys, resolving the key at the
time the response is created may result in missing/no longer valid keys. The
delayed message allows resolving the key right before the WidgetRequest is
processed.
-}
data CompMsgDelayedRequest
  = CompMsgSetFocus WidgetKey
  | CompMsgMoveFocus (Maybe WidgetKey) FocusDirection
  | forall i . Typeable i => CompMsgMessage WidgetKey i

-- | Response options for an event handler.
data EventResponse s e sp ep
  -- | Modifies the current model, prompting a merge.
  = Model s
  -- | Raises a new event, which will be handled in the same cycle.
  | Event e
  -- | Raises an event that will be handled by the parent Composite.
  | Report ep
  -- | Generates a 'WidgetRequest'.
  | Request (WidgetRequest s e)
  {-|
  Generates a 'WidgetRequest' matching the parent Composite's type. Useful when
  receiving requests as configuration from the parent, since the types will not
  match otherwise.
  -}
  | RequestParent (WidgetRequest sp ep)
  {-|
  Generates a request to set focus on the widget with the matching key. If the
  key does not exist, focus remains on the currently focused widget.
  -}
  | SetFocusOnKey WidgetKey
  {-|
  Generates a request to move focus forward/backward, optionally indicating the
  key of the starting widget.
  -}
  | MoveFocusFromKey (Maybe WidgetKey) FocusDirection
  {-|
  Sends a message to the given key. If the key does not exist, the message will
  not be delivered.
  -}
  | forall i . Typeable i => Message WidgetKey i
  {-|
  Runs an asynchronous task that will return a single result. The task is
  responsible for reporting errors using the expected event type. If the task
  crashes without returning a value, the composite will not know about it.
  -}
  | Task (TaskHandler e)
  {-|
  Runs an asynchronous task that will produce unlimited result. The producer is
  responsible for reporting errors using the expected event type. If the
  producer crashes without sending a value, composite will not know about it.
  -}
  | Producer (ProducerHandler e)

{-|
Configuration options for composite:

- 'onInit': event to raise when the widget is created. Useful for initializing
  required resources.
- 'onDispose': event to raise when the widget is disposed. Useful for freeing
  acquired resources.
- 'onResize': event to raise when the size of the widget changes.
- 'onChange': event to raise when the model changes. The value passed to the
  provided event is the previous version of the model. The current version of
  the model is always available as a parameter in the _handleEvent_ function.
- 'onChangeReq': 'WidgetRequest' to generate when the model changes.
- 'onEnabledChange': event to raise when the enabled status changes.
- 'onVisibleChange': event to raise when the visibility changes.
- 'mergeRequired': indicates if merging is necessary for this widget. In case
  the UI build process references information outside the model, it can be used
  to signal that merging is required even if the model has not changed. It can
  also be used as a performance tweak if the changes do not require rebuilding
  the UI.
- 'compositeMergeReqs': functions to generate WidgetRequests during the merge
  process. Since merge is already handled by Composite (by merging its tree),
  this is complementary for the cases when more control, and the previous
  version of the widget tree, is required.  For example, it is used in
  'Monomer.Widgets.Containers.Confirm' to set the focus on its Accept button
  when visibility is restored (this usually means it was brought to the front in
  a zstack, and the visibility flag of the previous version needs to be
  checked).
- 'compositeMergeModel': Allows updating the composite model with information
  from the parent model. Useful when the composite needs a more complex model
  than what the user is binding.
-}
data CompositeCfg s e sp ep = CompositeCfg {
  forall s e sp ep.
CompositeCfg s e sp ep -> Maybe (MergeRequired s e)
_cmcMergeRequired :: Maybe (MergeRequired s e),
  forall s e sp ep.
CompositeCfg s e sp ep -> [MergeReqsHandler s e sp]
_cmcMergeReqs :: [MergeReqsHandler s e sp],
  forall s e sp ep.
CompositeCfg s e sp ep -> Maybe (MergeModelHandler s e sp)
_cmcMergeModel :: Maybe (MergeModelHandler s e sp),
  forall s e sp ep. CompositeCfg s e sp ep -> [WidgetRequest s e]
_cmcOnInitReq :: [WidgetRequest s e],
  forall s e sp ep. CompositeCfg s e sp ep -> [WidgetRequest s e]
_cmcOnDisposeReq :: [WidgetRequest s e],
  forall s e sp ep. CompositeCfg s e sp ep -> [Rect -> e]
_cmcOnResize :: [Rect -> e],
  forall s e sp ep.
CompositeCfg s e sp ep -> [s -> WidgetRequest s e]
_cmcOnChangeReq :: [s -> WidgetRequest s e],
  forall s e sp ep. CompositeCfg s e sp ep -> [e]
_cmcOnEnabledChange :: [e],
  forall s e sp ep. CompositeCfg s e sp ep -> [e]
_cmcOnVisibleChange :: [e]
}

instance Default (CompositeCfg s e sp ep) where
  def :: CompositeCfg s e sp ep
def = CompositeCfg {
    _cmcMergeModel :: Maybe (MergeModelHandler s e sp)
_cmcMergeModel = forall a. Maybe a
Nothing,
    _cmcMergeRequired :: Maybe (MergeRequired s e)
_cmcMergeRequired = forall a. Maybe a
Nothing,
    _cmcMergeReqs :: [MergeReqsHandler s e sp]
_cmcMergeReqs = [],
    _cmcOnInitReq :: [WidgetRequest s e]
_cmcOnInitReq = [],
    _cmcOnDisposeReq :: [WidgetRequest s e]
_cmcOnDisposeReq = [],
    _cmcOnResize :: [Rect -> e]
_cmcOnResize = [],
    _cmcOnChangeReq :: [s -> WidgetRequest s e]
_cmcOnChangeReq = [],
    _cmcOnEnabledChange :: [e]
_cmcOnEnabledChange = [],
    _cmcOnVisibleChange :: [e]
_cmcOnVisibleChange = []
  }

instance Semigroup (CompositeCfg s e sp ep) where
  <> :: CompositeCfg s e sp ep
-> CompositeCfg s e sp ep -> CompositeCfg s e sp ep
(<>) CompositeCfg s e sp ep
c1 CompositeCfg s e sp ep
c2 = CompositeCfg {
    _cmcMergeModel :: Maybe (MergeModelHandler s e sp)
_cmcMergeModel = forall s e sp ep.
CompositeCfg s e sp ep -> Maybe (MergeModelHandler s e sp)
_cmcMergeModel CompositeCfg s e sp ep
c2 forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall s e sp ep.
CompositeCfg s e sp ep -> Maybe (MergeModelHandler s e sp)
_cmcMergeModel CompositeCfg s e sp ep
c1,
    _cmcMergeRequired :: Maybe (MergeRequired s e)
_cmcMergeRequired = forall s e sp ep.
CompositeCfg s e sp ep -> Maybe (MergeRequired s e)
_cmcMergeRequired CompositeCfg s e sp ep
c2 forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall s e sp ep.
CompositeCfg s e sp ep -> Maybe (MergeRequired s e)
_cmcMergeRequired CompositeCfg s e sp ep
c1,
    _cmcMergeReqs :: [MergeReqsHandler s e sp]
_cmcMergeReqs = forall s e sp ep.
CompositeCfg s e sp ep -> [MergeReqsHandler s e sp]
_cmcMergeReqs CompositeCfg s e sp ep
c1 forall a. Semigroup a => a -> a -> a
<> forall s e sp ep.
CompositeCfg s e sp ep -> [MergeReqsHandler s e sp]
_cmcMergeReqs CompositeCfg s e sp ep
c2,
    _cmcOnInitReq :: [WidgetRequest s e]
_cmcOnInitReq = forall s e sp ep. CompositeCfg s e sp ep -> [WidgetRequest s e]
_cmcOnInitReq CompositeCfg s e sp ep
c1 forall a. Semigroup a => a -> a -> a
<> forall s e sp ep. CompositeCfg s e sp ep -> [WidgetRequest s e]
_cmcOnInitReq CompositeCfg s e sp ep
c2,
    _cmcOnDisposeReq :: [WidgetRequest s e]
_cmcOnDisposeReq = forall s e sp ep. CompositeCfg s e sp ep -> [WidgetRequest s e]
_cmcOnDisposeReq CompositeCfg s e sp ep
c1 forall a. Semigroup a => a -> a -> a
<> forall s e sp ep. CompositeCfg s e sp ep -> [WidgetRequest s e]
_cmcOnDisposeReq CompositeCfg s e sp ep
c2,
    _cmcOnResize :: [Rect -> e]
_cmcOnResize = forall s e sp ep. CompositeCfg s e sp ep -> [Rect -> e]
_cmcOnResize CompositeCfg s e sp ep
c1 forall a. Semigroup a => a -> a -> a
<> forall s e sp ep. CompositeCfg s e sp ep -> [Rect -> e]
_cmcOnResize CompositeCfg s e sp ep
c2,
    _cmcOnChangeReq :: [s -> WidgetRequest s e]
_cmcOnChangeReq = forall s e sp ep.
CompositeCfg s e sp ep -> [s -> WidgetRequest s e]
_cmcOnChangeReq CompositeCfg s e sp ep
c1 forall a. Semigroup a => a -> a -> a
<> forall s e sp ep.
CompositeCfg s e sp ep -> [s -> WidgetRequest s e]
_cmcOnChangeReq CompositeCfg s e sp ep
c2,
    _cmcOnEnabledChange :: [e]
_cmcOnEnabledChange = forall s e sp ep. CompositeCfg s e sp ep -> [e]
_cmcOnEnabledChange CompositeCfg s e sp ep
c1 forall a. Semigroup a => a -> a -> a
<> forall s e sp ep. CompositeCfg s e sp ep -> [e]
_cmcOnEnabledChange CompositeCfg s e sp ep
c2,
    _cmcOnVisibleChange :: [e]
_cmcOnVisibleChange = forall s e sp ep. CompositeCfg s e sp ep -> [e]
_cmcOnVisibleChange CompositeCfg s e sp ep
c1 forall a. Semigroup a => a -> a -> a
<> forall s e sp ep. CompositeCfg s e sp ep -> [e]
_cmcOnVisibleChange CompositeCfg s e sp ep
c2
  }

instance Monoid (CompositeCfg s e sp ep) where
  mempty :: CompositeCfg s e sp ep
mempty = forall a. Default a => a
def

instance CmbMergeRequired (CompositeCfg s e sp ep) (WidgetEnv s e) s where
  mergeRequired :: (WidgetEnv s e -> s -> s -> Bool) -> CompositeCfg s e sp ep
mergeRequired WidgetEnv s e -> s -> s -> Bool
fn = forall a. Default a => a
def {
    _cmcMergeRequired :: Maybe (WidgetEnv s e -> s -> s -> Bool)
_cmcMergeRequired = forall a. a -> Maybe a
Just WidgetEnv s e -> s -> s -> Bool
fn
  }

instance WidgetEvent e => CmbOnInit (CompositeCfg s e sp ep) e where
  onInit :: e -> CompositeCfg s e sp ep
onInit e
fn = forall a. Default a => a
def {
    _cmcOnInitReq :: [WidgetRequest s e]
_cmcOnInitReq = [forall s e. WidgetEvent e => e -> WidgetRequest s e
RaiseEvent e
fn]
  }

instance CmbOnInitReq (CompositeCfg s e sp ep) s e where
  onInitReq :: WidgetRequest s e -> CompositeCfg s e sp ep
onInitReq WidgetRequest s e
req = forall a. Default a => a
def {
    _cmcOnInitReq :: [WidgetRequest s e]
_cmcOnInitReq = [WidgetRequest s e
req]
  }

instance WidgetEvent e => CmbOnDispose (CompositeCfg s e sp ep) e where
  onDispose :: e -> CompositeCfg s e sp ep
onDispose e
fn = forall a. Default a => a
def {
    _cmcOnDisposeReq :: [WidgetRequest s e]
_cmcOnDisposeReq = [forall s e. WidgetEvent e => e -> WidgetRequest s e
RaiseEvent e
fn]
  }

instance CmbOnDisposeReq (CompositeCfg s e sp ep) s e where
  onDisposeReq :: WidgetRequest s e -> CompositeCfg s e sp ep
onDisposeReq WidgetRequest s e
req = forall a. Default a => a
def {
    _cmcOnDisposeReq :: [WidgetRequest s e]
_cmcOnDisposeReq = [WidgetRequest s e
req]
  }

instance CmbOnResize (CompositeCfg s e sp ep) e Rect where
  onResize :: (Rect -> e) -> CompositeCfg s e sp ep
onResize Rect -> e
fn = forall a. Default a => a
def {
    _cmcOnResize :: [Rect -> e]
_cmcOnResize = [Rect -> e
fn]
  }

instance WidgetEvent e => CmbOnChange (CompositeCfg s e sp ep) s e where
  onChange :: (s -> e) -> CompositeCfg s e sp ep
onChange s -> e
fn = forall a. Default a => a
def {
    _cmcOnChangeReq :: [s -> WidgetRequest s e]
_cmcOnChangeReq = [forall s e. WidgetEvent e => e -> WidgetRequest s e
RaiseEvent forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> e
fn]
  }

instance CmbOnChangeReq (CompositeCfg s e sp ep) s e s where
  onChangeReq :: (s -> WidgetRequest s e) -> CompositeCfg s e sp ep
onChangeReq s -> WidgetRequest s e
req = forall a. Default a => a
def {
    _cmcOnChangeReq :: [s -> WidgetRequest s e]
_cmcOnChangeReq = [s -> WidgetRequest s e
req]
  }

instance CmbOnEnabledChange (CompositeCfg s e sp ep) e where
  onEnabledChange :: e -> CompositeCfg s e sp ep
onEnabledChange e
fn = forall a. Default a => a
def {
    _cmcOnEnabledChange :: [e]
_cmcOnEnabledChange = [e
fn]
  }

instance CmbOnVisibleChange (CompositeCfg s e sp ep) e where
  onVisibleChange :: e -> CompositeCfg s e sp ep
onVisibleChange e
fn = forall a. Default a => a
def {
    _cmcOnVisibleChange :: [e]
_cmcOnVisibleChange = [e
fn]
  }

{-|
Generate WidgetRequests during the merge process.

This function is not called during initialization; 'onInitReq' can be used.
-}
compositeMergeReqs :: MergeReqsHandler s e sp -> CompositeCfg s e sp ep
compositeMergeReqs :: forall s e sp ep. MergeReqsHandler s e sp -> CompositeCfg s e sp ep
compositeMergeReqs MergeReqsHandler s e sp
fn = forall a. Default a => a
def {
  _cmcMergeReqs :: [MergeReqsHandler s e sp]
_cmcMergeReqs = [MergeReqsHandler s e sp
fn]
}

{-|
Generate events during the merge process.

This function is not called during initialization; 'onInit' can be used.
-}
compositeMergeEvents
  :: WidgetEvent e => MergeEventsHandler s e sp -> CompositeCfg s e sp ep
compositeMergeEvents :: forall e s sp ep.
WidgetEvent e =>
MergeEventsHandler s e sp -> CompositeCfg s e sp ep
compositeMergeEvents MergeEventsHandler s e sp
fn = forall {ep}. CompositeCfg s e sp ep
cfg where
  cfg :: CompositeCfg s e sp ep
cfg = forall a. Default a => a
def {
    _cmcMergeReqs :: [MergeReqsHandler s e sp]
_cmcMergeReqs = [forall {s}.
WidgetEnv s e
-> WidgetNode s e
-> WidgetNode s e
-> sp
-> s
-> s
-> [WidgetRequest s e]
wrapper]
  }
  wrapper :: WidgetEnv s e
-> WidgetNode s e
-> WidgetNode s e
-> sp
-> s
-> s
-> [WidgetRequest s e]
wrapper WidgetEnv s e
wenv WidgetNode s e
node WidgetNode s e
oldNode sp
parentModel s
oldModel s
newModel
    = forall s e. WidgetEvent e => e -> WidgetRequest s e
RaiseEvent forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MergeEventsHandler s e sp
fn WidgetEnv s e
wenv WidgetNode s e
node WidgetNode s e
oldNode sp
parentModel s
oldModel s
newModel

{-|
Allows updating the composite model with information from the parent model.
Useful when the composite needs a more complex model than what the user is
binding.

For example, a database record may be binded as the model from the parent, but
the composite needs its own boolean flags to toggle visibility on different
sections.

This function is called during both merge and init. On init, the oldModel will
be equal to the current model.
-}
compositeMergeModel :: MergeModelHandler s e sp -> CompositeCfg s e sp ep
compositeMergeModel :: forall s e sp ep.
MergeModelHandler s e sp -> CompositeCfg s e sp ep
compositeMergeModel MergeModelHandler s e sp
fn = forall a. Default a => a
def {
  _cmcMergeModel :: Maybe (MergeModelHandler s e sp)
_cmcMergeModel = forall a. a -> Maybe a
Just MergeModelHandler s e sp
fn
}

data Composite s e sp ep = Composite {
  forall s e sp ep. Composite s e sp ep -> WidgetData sp s
_cmpWidgetData :: !(WidgetData sp s),
  forall s e sp ep. Composite s e sp ep -> EventHandler s e sp ep
_cmpEventHandler :: !(EventHandler s e sp ep),
  forall s e sp ep. Composite s e sp ep -> UIBuilder s e
_cmpUiBuilder :: !(UIBuilder s e),
  forall s e sp ep. Composite s e sp ep -> MergeRequired s e
_cmpMergeRequired :: MergeRequired s e,
  forall s e sp ep. Composite s e sp ep -> [MergeReqsHandler s e sp]
_cmpMergeReqs :: [MergeReqsHandler s e sp],
  forall s e sp ep.
Composite s e sp ep -> Maybe (MergeModelHandler s e sp)
_cmpMergeModel :: Maybe (MergeModelHandler s e sp),
  forall s e sp ep. Composite s e sp ep -> [WidgetRequest s e]
_cmpOnInitReq :: [WidgetRequest s e],
  forall s e sp ep. Composite s e sp ep -> [WidgetRequest s e]
_cmpOnDisposeReq :: [WidgetRequest s e],
  forall s e sp ep. Composite s e sp ep -> [Rect -> e]
_cmpOnResize :: [Rect -> e],
  forall s e sp ep. Composite s e sp ep -> [s -> WidgetRequest s e]
_cmpOnChangeReq :: [s -> WidgetRequest s e],
  forall s e sp ep. Composite s e sp ep -> [e]
_cmpOnEnabledChange :: [e],
  forall s e sp ep. Composite s e sp ep -> [e]
_cmpOnVisibleChange :: [e]
}

data CompositeState s e = CompositeState {
  forall s e. CompositeState s e -> Maybe s
_cpsModel :: !(Maybe s),
  forall s e. CompositeState s e -> WidgetNode s e
_cpsRoot :: !(WidgetNode s e),
  forall s e. CompositeState s e -> WidgetKeyMap s e
_cpsWidgetKeyMap :: WidgetKeyMap s e
}

data ReducedEvents s e sp ep = ReducedEvents {
  forall s e sp ep. ReducedEvents s e sp ep -> s
_reModel :: s,
  forall s e sp ep. ReducedEvents s e sp ep -> Seq e
_reEvents :: Seq e,
  forall s e sp ep. ReducedEvents s e sp ep -> Seq ep
_reReports :: Seq ep,
  forall s e sp ep.
ReducedEvents s e sp ep -> Seq (WidgetRequest s e)
_reRequests :: Seq (WidgetRequest s e),
  forall s e sp ep.
ReducedEvents s e sp ep -> Seq (WidgetRequest sp ep)
_reMessages :: Seq (WidgetRequest sp ep),
  forall s e sp ep. ReducedEvents s e sp ep -> Seq (TaskHandler e)
_reTasks :: Seq (TaskHandler e),
  forall s e sp ep.
ReducedEvents s e sp ep -> Seq (ProducerHandler e)
_reProducers :: Seq (ProducerHandler e)
}

{-|
Creates a composite taking its model from a lens into the parent model.
-}
composite
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => WidgetType              -- ^ The name of the composite.
  -> ALens' sp s             -- ^ The lens into the parent's model.
  -> UIBuilder s e           -- ^ The UI builder function.
  -> EventHandler s e sp ep  -- ^ The event handler.
  -> WidgetNode sp ep        -- ^ The resulting widget.
composite :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
WidgetType
-> ALens' sp s
-> UIBuilder s e
-> EventHandler s e sp ep
-> WidgetNode sp ep
composite WidgetType
widgetType ALens' sp s
field UIBuilder s e
uiBuilder EventHandler s e sp ep
evtHandler = WidgetNode sp ep
newNode where
  newNode :: WidgetNode sp ep
newNode = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
WidgetType
-> ALens' sp s
-> UIBuilder s e
-> EventHandler s e sp ep
-> [CompositeCfg s e sp ep]
-> WidgetNode sp ep
composite_ WidgetType
widgetType ALens' sp s
field UIBuilder s e
uiBuilder EventHandler s e sp ep
evtHandler forall a. Default a => a
def

{-|
Creates a composite taking its model from a lens into the parent model. Accepts
config.
-}
composite_
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => WidgetType                -- ^ The name of the composite.
  -> ALens' sp s               -- ^ The lens into the parent's model.
  -> UIBuilder s e             -- ^ The UI builder function.
  -> EventHandler s e sp ep    -- ^ The event handler.
  -> [CompositeCfg s e sp ep]  -- ^ The config options.
  -> WidgetNode sp ep          -- ^ The resulting widget.
composite_ :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
WidgetType
-> ALens' sp s
-> UIBuilder s e
-> EventHandler s e sp ep
-> [CompositeCfg s e sp ep]
-> WidgetNode sp ep
composite_ WidgetType
widgetType ALens' sp s
field UIBuilder s e
uiBuilder EventHandler s e sp ep
evtHandler [CompositeCfg s e sp ep]
cfgs = WidgetNode sp ep
newNode where
  widgetData :: WidgetData sp s
widgetData = forall s a. ALens' s a -> WidgetData s a
WidgetLens ALens' sp s
field
  newNode :: WidgetNode sp ep
newNode = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
WidgetType
-> WidgetData sp s
-> UIBuilder s e
-> EventHandler s e sp ep
-> [CompositeCfg s e sp ep]
-> WidgetNode sp ep
compositeD_ WidgetType
widgetType WidgetData sp s
widgetData UIBuilder s e
uiBuilder EventHandler s e sp ep
evtHandler [CompositeCfg s e sp ep]
cfgs

-- | Creates a composite using the given model and onChange event handler.
compositeV
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => WidgetType              -- ^ The name of the composite.
  -> s                       -- ^ The model.
  -> (s -> e)                -- ^ The event to report when model changes.
  -> UIBuilder s e           -- ^ The UI builder function.
  -> EventHandler s e sp ep  -- ^ The event handler.
  -> WidgetNode sp ep        -- ^ The resulting widget.
compositeV :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
WidgetType
-> s
-> (s -> e)
-> UIBuilder s e
-> EventHandler s e sp ep
-> WidgetNode sp ep
compositeV WidgetType
wType s
val s -> e
handler UIBuilder s e
uiBuilder EventHandler s e sp ep
evtHandler = WidgetNode sp ep
newNode where
  newNode :: WidgetNode sp ep
newNode = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
WidgetType
-> s
-> (s -> e)
-> UIBuilder s e
-> EventHandler s e sp ep
-> [CompositeCfg s e sp ep]
-> WidgetNode sp ep
compositeV_ WidgetType
wType s
val s -> e
handler UIBuilder s e
uiBuilder EventHandler s e sp ep
evtHandler forall a. Default a => a
def

{-|
Creates a composite using the given model and onChange event handler. Accepts
config.
-}
compositeV_
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => WidgetType                -- ^ The name of the composite.
  -> s                         -- ^ The model.
  -> (s -> e)                  -- ^ The event to report when model changes.
  -> UIBuilder s e             -- ^ The UI builder function.
  -> EventHandler s e sp ep    -- ^ The event handler.
  -> [CompositeCfg s e sp ep]  -- ^ The config options.
  -> WidgetNode sp ep          -- ^ The resulting widget.
compositeV_ :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
WidgetType
-> s
-> (s -> e)
-> UIBuilder s e
-> EventHandler s e sp ep
-> [CompositeCfg s e sp ep]
-> WidgetNode sp ep
compositeV_ WidgetType
wType s
val s -> e
handler UIBuilder s e
uiBuilder EventHandler s e sp ep
evtHandler [CompositeCfg s e sp ep]
cfgs = WidgetNode sp ep
newNode where
  widgetData :: WidgetData s s
widgetData = forall s a. a -> WidgetData s a
WidgetValue s
val
  newCfgs :: [CompositeCfg s e sp ep]
newCfgs = forall t a e. CmbOnChange t a e => (a -> e) -> t
onChange s -> e
handler forall a. a -> [a] -> [a]
: [CompositeCfg s e sp ep]
cfgs
  newNode :: WidgetNode sp ep
newNode = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
WidgetType
-> WidgetData sp s
-> UIBuilder s e
-> EventHandler s e sp ep
-> [CompositeCfg s e sp ep]
-> WidgetNode sp ep
compositeD_ WidgetType
wType forall {s}. WidgetData s s
widgetData UIBuilder s e
uiBuilder EventHandler s e sp ep
evtHandler [CompositeCfg s e sp ep]
newCfgs

-- | Creates a composite providing a WidgetData instance and config.
compositeD_
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => WidgetType                -- ^ The name of the composite.
  -> WidgetData sp s           -- ^ The model.
  -> UIBuilder s e             -- ^ The UI builder function.
  -> EventHandler s e sp ep    -- ^ The event handler.
  -> [CompositeCfg s e sp ep]  -- ^ The config options.
  -> WidgetNode sp ep          -- ^ The resulting widget.
compositeD_ :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
WidgetType
-> WidgetData sp s
-> UIBuilder s e
-> EventHandler s e sp ep
-> [CompositeCfg s e sp ep]
-> WidgetNode sp ep
compositeD_ WidgetType
wType WidgetData sp s
wData UIBuilder s e
uiBuilder EventHandler s e sp ep
evtHandler [CompositeCfg s e sp ep]
configs = WidgetNode sp ep
newNode where
  config :: CompositeCfg s e sp ep
config = forall a. Monoid a => [a] -> a
mconcat [CompositeCfg s e sp ep]
configs
  mergeReq :: WidgetEnv s e -> s -> s -> Bool
mergeReq = forall a. a -> Maybe a -> a
fromMaybe (forall a b. a -> b -> a
const forall a. Eq a => a -> a -> Bool
(/=)) (forall s e sp ep.
CompositeCfg s e sp ep -> Maybe (MergeRequired s e)
_cmcMergeRequired CompositeCfg s e sp ep
config)
  !widgetRoot :: WidgetNode s e
widgetRoot = forall s e. WidgetNode s e
spacer
  composite :: Composite s e sp ep
composite = Composite {
    _cmpWidgetData :: WidgetData sp s
_cmpWidgetData = WidgetData sp s
wData,
    _cmpEventHandler :: EventHandler s e sp ep
_cmpEventHandler = EventHandler s e sp ep
evtHandler,
    _cmpUiBuilder :: UIBuilder s e
_cmpUiBuilder = UIBuilder s e
uiBuilder,
    _cmpMergeRequired :: WidgetEnv s e -> s -> s -> Bool
_cmpMergeRequired = WidgetEnv s e -> s -> s -> Bool
mergeReq,
    _cmpMergeReqs :: [MergeReqsHandler s e sp]
_cmpMergeReqs = forall s e sp ep.
CompositeCfg s e sp ep -> [MergeReqsHandler s e sp]
_cmcMergeReqs CompositeCfg s e sp ep
config,
    _cmpMergeModel :: Maybe (MergeModelHandler s e sp)
_cmpMergeModel = forall s e sp ep.
CompositeCfg s e sp ep -> Maybe (MergeModelHandler s e sp)
_cmcMergeModel CompositeCfg s e sp ep
config,
    _cmpOnInitReq :: [WidgetRequest s e]
_cmpOnInitReq = forall s e sp ep. CompositeCfg s e sp ep -> [WidgetRequest s e]
_cmcOnInitReq CompositeCfg s e sp ep
config,
    _cmpOnDisposeReq :: [WidgetRequest s e]
_cmpOnDisposeReq = forall s e sp ep. CompositeCfg s e sp ep -> [WidgetRequest s e]
_cmcOnDisposeReq CompositeCfg s e sp ep
config,
    _cmpOnResize :: [Rect -> e]
_cmpOnResize = forall s e sp ep. CompositeCfg s e sp ep -> [Rect -> e]
_cmcOnResize CompositeCfg s e sp ep
config,
    _cmpOnChangeReq :: [s -> WidgetRequest s e]
_cmpOnChangeReq = forall s e sp ep.
CompositeCfg s e sp ep -> [s -> WidgetRequest s e]
_cmcOnChangeReq CompositeCfg s e sp ep
config,
    _cmpOnEnabledChange :: [e]
_cmpOnEnabledChange = forall s e sp ep. CompositeCfg s e sp ep -> [e]
_cmcOnEnabledChange CompositeCfg s e sp ep
config,
    _cmpOnVisibleChange :: [e]
_cmpOnVisibleChange = forall s e sp ep. CompositeCfg s e sp ep -> [e]
_cmcOnVisibleChange CompositeCfg s e sp ep
config
  }
  state :: CompositeState s e
state = forall s e.
Maybe s -> WidgetNode s e -> WidgetKeyMap s e -> CompositeState s e
CompositeState forall a. Maybe a
Nothing forall s e. WidgetNode s e
widgetRoot forall k a. Map k a
M.empty
  widget :: Widget sp ep
widget = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep -> CompositeState s e -> Widget sp ep
createComposite Composite s e sp ep
composite forall {s} {e}. CompositeState s e
state
  !newNode :: WidgetNode sp ep
newNode = forall s e. WidgetType -> Widget s e -> WidgetNode s e
defaultWidgetNode WidgetType
wType Widget sp ep
widget

createComposite
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> CompositeState s e
  -> Widget sp ep
createComposite :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep -> CompositeState s e -> Widget sp ep
createComposite !Composite s e sp ep
comp !CompositeState s e
state = Widget sp ep
widget where
  widget :: Widget sp ep
widget = Widget {
    widgetInit :: WidgetEnv sp ep -> WidgetNode sp ep -> WidgetResult sp ep
widgetInit = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> WidgetResult sp ep
compositeInit Composite s e sp ep
comp CompositeState s e
state,
    widgetMerge :: WidgetEnv sp ep
-> WidgetNode sp ep -> WidgetNode sp ep -> WidgetResult sp ep
widgetMerge = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> WidgetNode sp ep
-> WidgetResult sp ep
compositeMerge Composite s e sp ep
comp CompositeState s e
state,
    widgetDispose :: WidgetEnv sp ep -> WidgetNode sp ep -> WidgetResult sp ep
widgetDispose = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> WidgetResult sp ep
compositeDispose Composite s e sp ep
comp CompositeState s e
state,
    widgetGetState :: WidgetEnv sp ep -> WidgetNode sp ep -> Maybe WidgetState
widgetGetState = forall i s e.
WidgetModel i =>
i -> WidgetEnv s e -> WidgetNode s e -> Maybe WidgetState
makeState CompositeState s e
state,
    widgetGetInstanceTree :: WidgetEnv sp ep -> WidgetNode sp ep -> WidgetInstanceNode
widgetGetInstanceTree = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> WidgetInstanceNode
compositeGetInstanceTree Composite s e sp ep
comp CompositeState s e
state,
    widgetFindNextFocus :: WidgetEnv sp ep
-> WidgetNode sp ep
-> FocusDirection
-> Path
-> Maybe WidgetNodeInfo
widgetFindNextFocus = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> FocusDirection
-> Path
-> Maybe WidgetNodeInfo
compositeFindNextFocus Composite s e sp ep
comp CompositeState s e
state,
    widgetFindByPoint :: WidgetEnv sp ep
-> WidgetNode sp ep -> Path -> Point -> Maybe WidgetNodeInfo
widgetFindByPoint = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> Path
-> Point
-> Maybe WidgetNodeInfo
compositeFindByPoint Composite s e sp ep
comp CompositeState s e
state,
    widgetFindBranchByPath :: WidgetEnv sp ep -> WidgetNode sp ep -> Path -> Seq WidgetNodeInfo
widgetFindBranchByPath = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> Path
-> Seq WidgetNodeInfo
compositeFindBranchByPath Composite s e sp ep
comp CompositeState s e
state,
    widgetHandleEvent :: WidgetEnv sp ep
-> WidgetNode sp ep
-> Path
-> SystemEvent
-> Maybe (WidgetResult sp ep)
widgetHandleEvent = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> Path
-> SystemEvent
-> Maybe (WidgetResult sp ep)
compositeHandleEvent Composite s e sp ep
comp CompositeState s e
state,
    widgetHandleMessage :: forall i.
Typeable i =>
WidgetEnv sp ep
-> WidgetNode sp ep -> Path -> i -> Maybe (WidgetResult sp ep)
widgetHandleMessage = forall s e ep sp i.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp, Typeable i) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> Path
-> i
-> Maybe (WidgetResult sp ep)
compositeHandleMessage Composite s e sp ep
comp CompositeState s e
state,
    widgetGetSizeReq :: WidgetEnv sp ep -> WidgetNode sp ep -> (SizeReq, SizeReq)
widgetGetSizeReq = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> (SizeReq, SizeReq)
compositeGetSizeReq Composite s e sp ep
comp CompositeState s e
state,
    widgetResize :: WidgetEnv sp ep
-> WidgetNode sp ep -> Rect -> (Path -> Bool) -> WidgetResult sp ep
widgetResize = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> Rect
-> (Path -> Bool)
-> WidgetResult sp ep
compositeResize Composite s e sp ep
comp CompositeState s e
state,
    widgetRender :: WidgetEnv sp ep -> WidgetNode sp ep -> Renderer -> IO ()
widgetRender = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> Renderer
-> IO ()
compositeRender Composite s e sp ep
comp CompositeState s e
state
  }

-- | Init
compositeInit
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> CompositeState s e
  -> WidgetEnv sp ep
  -> WidgetNode sp ep
  -> WidgetResult sp ep
compositeInit :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> WidgetResult sp ep
compositeInit Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp = WidgetResult sp ep
newResult where
  CompositeState{Maybe s
WidgetKeyMap s e
WidgetNode s e
_cpsWidgetKeyMap :: WidgetKeyMap s e
_cpsRoot :: WidgetNode s e
_cpsModel :: Maybe s
_cpsWidgetKeyMap :: forall s e. CompositeState s e -> WidgetKeyMap s e
_cpsRoot :: forall s e. CompositeState s e -> WidgetNode s e
_cpsModel :: forall s e. CompositeState s e -> Maybe s
..} = CompositeState s e
state

  !mergeModel :: Maybe (MergeModelHandler s e sp)
mergeModel = forall s e sp ep.
Composite s e sp ep -> Maybe (MergeModelHandler s e sp)
_cmpMergeModel Composite s e sp ep
comp
  !parentModel :: sp
parentModel = WidgetEnv sp ep
wenv forall s a. s -> Getting a s a -> a
^. forall s a. HasModel s a => Lens' s a
L.model
  !userModel :: s
userModel = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep -> WidgetEnv sp ep -> s
getUserModel Composite s e sp ep
comp WidgetEnv sp ep
wenv
  !model :: s
model = case Maybe (MergeModelHandler s e sp)
mergeModel of
    Just MergeModelHandler s e sp
merge -> MergeModelHandler s e sp
merge WidgetEnv s e
cwenv sp
parentModel s
userModel s
userModel where
      !cwenv :: WidgetEnv s e
cwenv = forall sp ep s e.
WidgetEnv sp ep -> WidgetKeyMap s e -> s -> WidgetEnv s e
convertWidgetEnv WidgetEnv sp ep
wenv WidgetKeyMap s e
_cpsWidgetKeyMap s
userModel
    Maybe (MergeModelHandler s e sp)
_ -> s
userModel

  -- Creates UI using provided function
  !cwenv :: WidgetEnv s e
cwenv = forall sp ep s e.
WidgetEnv sp ep -> WidgetKeyMap s e -> s -> WidgetEnv s e
convertWidgetEnv WidgetEnv sp ep
wenv WidgetKeyMap s e
_cpsWidgetKeyMap s
model
  !builtRoot :: WidgetNode s e
builtRoot = forall s e sp ep. Composite s e sp ep -> UIBuilder s e
_cmpUiBuilder Composite s e sp ep
comp WidgetEnv s e
cwenv s
model
  !tempRoot :: WidgetNode s e
tempRoot = forall sp ep s e.
WidgetEnv sp ep
-> WidgetNode sp ep -> WidgetNode s e -> WidgetNode s e
cascadeCtx WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp WidgetNode s e
builtRoot

  WidgetResult WidgetNode s e
root Seq (WidgetRequest s e)
reqs = forall s e.
Widget s e -> WidgetEnv s e -> WidgetNode s e -> WidgetResult s e
widgetInit (WidgetNode s e
tempRoot forall s a. s -> Getting a s a -> a
^. forall s a. HasWidget s a => Lens' s a
L.widget) WidgetEnv s e
cwenv WidgetNode s e
tempRoot
  !newState :: CompositeState s e
newState = CompositeState s e
state {
    _cpsModel :: Maybe s
_cpsModel = forall a. a -> Maybe a
Just s
model,
    _cpsRoot :: WidgetNode s e
_cpsRoot = WidgetNode s e
root,
    _cpsWidgetKeyMap :: WidgetKeyMap s e
_cpsWidgetKeyMap = forall s e.
Map WidgetKey (WidgetNode s e)
-> WidgetNode s e -> Map WidgetKey (WidgetNode s e)
collectWidgetKeys forall k a. Map k a
M.empty WidgetNode s e
root
  }

  getBaseStyle :: p -> p -> Maybe a
getBaseStyle p
wenv p
node = forall a. Maybe a
Nothing
  styledComp :: WidgetNode sp ep
styledComp = forall s e.
GetBaseStyle s e
-> WidgetEnv s e -> WidgetNode s e -> WidgetNode s e
initNodeStyle forall {p} {p} {a}. p -> p -> Maybe a
getBaseStyle WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp

  initReqs :: Seq (WidgetRequest s e)
initReqs = forall a. [a] -> Seq a
Seq.fromList (forall s e sp ep. Composite s e sp ep -> [WidgetRequest s e]
_cmpOnInitReq Composite s e sp ep
comp)
  tempResult :: WidgetResult s e
tempResult = forall s e.
WidgetNode s e -> Seq (WidgetRequest s e) -> WidgetResult s e
WidgetResult WidgetNode s e
root (forall s e. WidgetRequest s e
RenderOnce forall a. a -> Seq a -> Seq a
<| Seq (WidgetRequest s e)
reqs forall a. Semigroup a => a -> a -> a
<> Seq (WidgetRequest s e)
initReqs)
  !newResult :: WidgetResult sp ep
newResult = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> WidgetResult s e
-> WidgetResult sp ep
toParentResult Composite s e sp ep
comp CompositeState s e
newState WidgetEnv sp ep
wenv WidgetNode sp ep
styledComp WidgetResult s e
tempResult

-- | Merge
compositeMerge
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> CompositeState s e
  -> WidgetEnv sp ep
  -> WidgetNode sp ep
  -> WidgetNode sp ep
  -> WidgetResult sp ep
compositeMerge :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> WidgetNode sp ep
-> WidgetResult sp ep
compositeMerge Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
newComp WidgetNode sp ep
oldComp = WidgetResult sp ep
newResult where
  widgetId :: WidgetId
widgetId = WidgetNode sp ep
oldComp forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasWidgetId s a => Lens' s a
L.widgetId
  oldState :: Maybe WidgetState
oldState = forall s e.
Widget s e -> WidgetEnv s e -> WidgetNode s e -> Maybe WidgetState
widgetGetState (WidgetNode sp ep
oldComp forall s a. s -> Getting a s a -> a
^. forall s a. HasWidget s a => Lens' s a
L.widget) WidgetEnv sp ep
wenv WidgetNode sp ep
oldComp
  validState :: CompositeState s e
validState = forall a. a -> Maybe a -> a
fromMaybe CompositeState s e
state (forall i. WidgetModel i => Maybe WidgetState -> Maybe i
useState Maybe WidgetState
oldState)
  CompositeState Maybe s
oldModel WidgetNode s e
oldRoot WidgetKeyMap s e
oldWidgetKeys = CompositeState s e
validState

  !mergeModel :: Maybe (MergeModelHandler s e sp)
mergeModel = forall s e sp ep.
Composite s e sp ep -> Maybe (MergeModelHandler s e sp)
_cmpMergeModel Composite s e sp ep
comp
  !parentModel :: sp
parentModel = WidgetEnv sp ep
wenv forall s a. s -> Getting a s a -> a
^. forall s a. HasModel s a => Lens' s a
L.model
  !userModel :: s
userModel = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep -> WidgetEnv sp ep -> s
getUserModel Composite s e sp ep
comp WidgetEnv sp ep
wenv
  !model :: s
model = case Maybe (MergeModelHandler s e sp)
mergeModel of
    Just MergeModelHandler s e sp
merge -> MergeModelHandler s e sp
merge WidgetEnv s e
cwenv sp
parentModel (forall a. HasCallStack => Maybe a -> a
fromJust Maybe s
oldModel) s
userModel where
      cwenv :: WidgetEnv s e
cwenv = forall sp ep s e.
WidgetEnv sp ep -> WidgetKeyMap s e -> s -> WidgetEnv s e
convertWidgetEnv WidgetEnv sp ep
wenv WidgetKeyMap s e
oldWidgetKeys s
userModel
    Maybe (MergeModelHandler s e sp)
_ -> s
userModel

  -- Creates new UI using provided function
  cwenv :: WidgetEnv s e
cwenv = forall sp ep s e.
WidgetEnv sp ep -> WidgetKeyMap s e -> s -> WidgetEnv s e
convertWidgetEnv WidgetEnv sp ep
wenv WidgetKeyMap s e
oldWidgetKeys s
model
  tempRoot :: WidgetNode s e
tempRoot = forall sp ep s e.
WidgetEnv sp ep
-> WidgetNode sp ep -> WidgetNode s e -> WidgetNode s e
cascadeCtx WidgetEnv sp ep
wenv WidgetNode sp ep
newComp (forall s e sp ep. Composite s e sp ep -> UIBuilder s e
_cmpUiBuilder Composite s e sp ep
comp WidgetEnv s e
cwenv s
model)
  tempWidget :: Widget s e
tempWidget = WidgetNode s e
tempRoot forall s a. s -> Getting a s a -> a
^. forall s a. HasWidget s a => Lens' s a
L.widget
  -- Needed in case the user references something outside model when building UI
  -- The same model is provided as old since nothing else is available, but
  -- mergeRequired may be using data from a closure
  modelChanged :: Bool
modelChanged = forall s e sp ep. Composite s e sp ep -> MergeRequired s e
_cmpMergeRequired Composite s e sp ep
comp WidgetEnv s e
cwenv (forall a. HasCallStack => Maybe a -> a
fromJust Maybe s
oldModel) s
model
  visibleChg :: Bool
visibleChg = forall s e. WidgetNode s e -> WidgetNode s e -> Bool
nodeVisibleChanged WidgetNode sp ep
oldComp WidgetNode sp ep
newComp
  enabledChg :: Bool
enabledChg = forall s e. WidgetNode s e -> WidgetNode s e -> Bool
nodeEnabledChanged WidgetNode sp ep
oldComp WidgetNode sp ep
newComp
  flagsChanged :: Bool
flagsChanged = Bool
visibleChg Bool -> Bool -> Bool
|| Bool
enabledChg
  themeChanged :: Bool
themeChanged = WidgetEnv sp ep
wenv forall s a. s -> Getting a s a -> a
^. forall s a. HasThemeChanged s a => Lens' s a
L.themeChanged
  mergeRequired :: Bool
mergeRequired
    | forall a. Maybe a -> Bool
isJust Maybe s
oldModel = Bool
modelChanged Bool -> Bool -> Bool
|| Bool
flagsChanged Bool -> Bool -> Bool
|| Bool
themeChanged
    | Bool
otherwise = Bool
True
  initRequired :: Bool
initRequired = Bool -> Bool
not (forall s e. WidgetNode s e -> WidgetNode s e -> Bool
nodeMatches WidgetNode s e
tempRoot WidgetNode s e
oldRoot)
  useNewRoot :: Bool
useNewRoot = Bool
initRequired Bool -> Bool -> Bool
|| Bool
mergeRequired

  WidgetResult !WidgetNode s e
newRoot !Seq (WidgetRequest s e)
tmpReqs
    | Bool
initRequired = forall s e.
Widget s e -> WidgetEnv s e -> WidgetNode s e -> WidgetResult s e
widgetInit Widget s e
tempWidget WidgetEnv s e
cwenv WidgetNode s e
tempRoot
    | Bool
mergeRequired = forall s e.
Widget s e
-> WidgetEnv s e
-> WidgetNode s e
-> WidgetNode s e
-> WidgetResult s e
widgetMerge Widget s e
tempWidget WidgetEnv s e
cwenv WidgetNode s e
tempRoot WidgetNode s e
oldRoot
    | Bool
otherwise = forall s e. WidgetNode s e -> WidgetResult s e
resultNode WidgetNode s e
oldRoot
  !newState :: CompositeState s e
newState = CompositeState s e
validState {
    _cpsModel :: Maybe s
_cpsModel = forall a. a -> Maybe a
Just s
model,
    _cpsRoot :: WidgetNode s e
_cpsRoot = WidgetNode s e
newRoot,
    _cpsWidgetKeyMap :: WidgetKeyMap s e
_cpsWidgetKeyMap = forall s e.
Map WidgetKey (WidgetNode s e)
-> WidgetNode s e -> Map WidgetKey (WidgetNode s e)
collectWidgetKeys forall k a. Map k a
M.empty WidgetNode s e
newRoot
  }
  getBaseStyle :: p -> p -> Maybe a
getBaseStyle p
wenv p
node = forall a. Maybe a
Nothing
  styledComp :: WidgetNode sp ep
styledComp = forall s e.
GetBaseStyle s e
-> WidgetEnv s e -> WidgetNode s e -> WidgetNode s e
initNodeStyle forall {p} {p} {a}. p -> p -> Maybe a
getBaseStyle WidgetEnv sp ep
wenv WidgetNode sp ep
newComp
    forall a b. a -> (a -> b) -> b
& forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasWidgetId s a => Lens' s a
L.widgetId forall s t a b. ASetter s t a b -> b -> s -> t
.~ WidgetNode sp ep
oldComp forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasWidgetId s a => Lens' s a
L.widgetId
    forall a b. a -> (a -> b) -> b
& forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasViewport s a => Lens' s a
L.viewport forall s t a b. ASetter s t a b -> b -> s -> t
.~ WidgetNode sp ep
oldComp forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasViewport s a => Lens' s a
L.viewport
    forall a b. a -> (a -> b) -> b
& forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasSizeReqW s a => Lens' s a
L.sizeReqW forall s t a b. ASetter s t a b -> b -> s -> t
.~ WidgetNode sp ep
oldComp forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasSizeReqW s a => Lens' s a
L.sizeReqW
    forall a b. a -> (a -> b) -> b
& forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasSizeReqH s a => Lens' s a
L.sizeReqH forall s t a b. ASetter s t a b -> b -> s -> t
.~ WidgetNode sp ep
oldComp forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasSizeReqH s a => Lens' s a
L.sizeReqH

  visibleEvts :: [e]
visibleEvts
    | Bool
useNewRoot Bool -> Bool -> Bool
&& Bool
visibleChg = forall s e sp ep. Composite s e sp ep -> [e]
_cmpOnVisibleChange Composite s e sp ep
comp
    | Bool
otherwise = []
  enabledEvts :: [e]
enabledEvts
    | Bool
useNewRoot Bool -> Bool -> Bool
&& Bool
enabledChg = forall s e sp ep. Composite s e sp ep -> [e]
_cmpOnEnabledChange Composite s e sp ep
comp
    | Bool
otherwise = []
  evts :: Seq (WidgetRequest s e)
evts = forall s e. WidgetEvent e => e -> WidgetRequest s e
RaiseEvent forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. [a] -> Seq a
Seq.fromList ([e]
visibleEvts forall a. [a] -> [a] -> [a]
++ [e]
enabledEvts)

  mergeReqsFns :: [MergeReqsHandler s e sp]
mergeReqsFns = forall s e sp ep. Composite s e sp ep -> [MergeReqsHandler s e sp]
_cmpMergeReqs Composite s e sp ep
comp
  mergeHelper :: (WidgetEnv s e
 -> WidgetNode s e -> WidgetNode s e -> sp -> s -> s -> t)
-> t
mergeHelper WidgetEnv s e
-> WidgetNode s e -> WidgetNode s e -> sp -> s -> s -> t
f = WidgetEnv s e
-> WidgetNode s e -> WidgetNode s e -> sp -> s -> s -> t
f WidgetEnv s e
cwenv WidgetNode s e
newRoot WidgetNode s e
oldRoot sp
parentModel (forall a. HasCallStack => Maybe a -> a
fromJust Maybe s
oldModel) s
model
  mergeReqs :: [WidgetRequest s e]
mergeReqs = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall {t}.
(WidgetEnv s e
 -> WidgetNode s e -> WidgetNode s e -> sp -> s -> s -> t)
-> t
mergeHelper [MergeReqsHandler s e sp]
mergeReqsFns
  extraReqs :: Seq (WidgetRequest s ep)
extraReqs = forall a. Seq (Maybe a) -> Seq a
seqCatMaybes (forall s sp e ep.
(CompositeModel s, CompParentModel sp) =>
WidgetId -> WidgetRequest s e -> Maybe (WidgetRequest sp ep)
toParentReq WidgetId
widgetId forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. [a] -> Seq a
Seq.fromList [WidgetRequest s e]
mergeReqs)

  tmpResult :: WidgetResult s e
tmpResult = forall s e.
WidgetNode s e -> Seq (WidgetRequest s e) -> WidgetResult s e
WidgetResult WidgetNode s e
newRoot (forall s e. WidgetRequest s e
RenderOnce forall a. a -> Seq a -> Seq a
<| Seq (WidgetRequest s e)
tmpReqs forall a. Semigroup a => a -> a -> a
<> forall {ep}. Seq (WidgetRequest s ep)
extraReqs forall a. Semigroup a => a -> a -> a
<> forall {s}. Seq (WidgetRequest s e)
evts)
  reducedResult :: WidgetResult sp ep
reducedResult
    | Bool
useNewRoot = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> WidgetResult s e
-> WidgetResult sp ep
toParentResult Composite s e sp ep
comp CompositeState s e
newState WidgetEnv sp ep
wenv WidgetNode sp ep
styledComp WidgetResult s e
tmpResult
    | Bool
otherwise = forall s e. WidgetNode s e -> WidgetResult s e
resultNode WidgetNode sp ep
oldComp
  !newResult :: WidgetResult sp ep
newResult = forall s e. WidgetNode s e -> WidgetResult s e -> WidgetResult s e
handleWidgetIdChange WidgetNode sp ep
oldComp WidgetResult sp ep
reducedResult

-- | Dispose
compositeDispose
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> CompositeState s e
  -> WidgetEnv sp ep
  -> WidgetNode sp ep
  -> WidgetResult sp ep
compositeDispose :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> WidgetResult sp ep
compositeDispose Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp = WidgetResult sp ep
result where
  CompositeState{Maybe s
WidgetKeyMap s e
WidgetNode s e
_cpsWidgetKeyMap :: WidgetKeyMap s e
_cpsRoot :: WidgetNode s e
_cpsModel :: Maybe s
_cpsWidgetKeyMap :: forall s e. CompositeState s e -> WidgetKeyMap s e
_cpsRoot :: forall s e. CompositeState s e -> WidgetNode s e
_cpsModel :: forall s e. CompositeState s e -> Maybe s
..} = CompositeState s e
state

  model :: s
model = forall s e.
(CompositeModel s, CompositeEvent e) =>
CompositeState s e -> s
getCompositeModel CompositeState s e
state
  cwenv :: WidgetEnv s e
cwenv = forall sp ep s e.
WidgetEnv sp ep -> WidgetKeyMap s e -> s -> WidgetEnv s e
convertWidgetEnv WidgetEnv sp ep
wenv WidgetKeyMap s e
_cpsWidgetKeyMap s
model
  widget :: Widget s e
widget = WidgetNode s e
_cpsRoot forall s a. s -> Getting a s a -> a
^. forall s a. HasWidget s a => Lens' s a
L.widget
  widgetId :: WidgetId
widgetId = WidgetNode sp ep
widgetComp forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasWidgetId s a => Lens' s a
L.widgetId

  handleReq :: WidgetRequest s e -> Seq (WidgetRequest sp ep)
handleReq (RaiseEvent e
evt) = Seq (WidgetRequest sp ep)
reqs where
    WidgetResult WidgetNode sp ep
_ Seq (WidgetRequest sp ep)
reqs = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> e
-> WidgetResult sp ep
handleMsgEvent Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp e
evt
  handleReq WidgetRequest s e
req = forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall a. Seq a
Seq.empty forall a. a -> Seq a
Seq.singleton (forall s sp e ep.
(CompositeModel s, CompParentModel sp) =>
WidgetId -> WidgetRequest s e -> Maybe (WidgetRequest sp ep)
toParentReq WidgetId
widgetId WidgetRequest s e
req)

  parentReqs :: Seq (WidgetRequest sp ep)
parentReqs = forall a. Monoid a => [a] -> a
mconcat (forall {s}.
(Eq s, Typeable s) =>
WidgetRequest s e -> Seq (WidgetRequest sp ep)
handleReq forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s e sp ep. Composite s e sp ep -> [WidgetRequest s e]
_cmpOnDisposeReq Composite s e sp ep
comp)

  WidgetResult WidgetNode s e
_ Seq (WidgetRequest s e)
childReqs = forall s e.
Widget s e -> WidgetEnv s e -> WidgetNode s e -> WidgetResult s e
widgetDispose Widget s e
widget WidgetEnv s e
cwenv WidgetNode s e
_cpsRoot
  tempResult :: WidgetResult s e
tempResult = forall s e.
WidgetNode s e -> Seq (WidgetRequest s e) -> WidgetResult s e
WidgetResult WidgetNode s e
_cpsRoot Seq (WidgetRequest s e)
childReqs
  result :: WidgetResult sp ep
result = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> WidgetResult s e
-> WidgetResult sp ep
toParentResult Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp WidgetResult s e
tempResult
    forall a b. a -> (a -> b) -> b
& forall s a. HasRequests s a => Lens' s a
L.requests forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ (Seq (WidgetRequest sp ep)
parentReqs forall a. Semigroup a => a -> a -> a
<>)

compositeGetInstanceTree
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> CompositeState s e
  -> WidgetEnv sp ep
  -> WidgetNode sp ep
  -> WidgetInstanceNode
compositeGetInstanceTree :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> WidgetInstanceNode
compositeGetInstanceTree Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
node = WidgetInstanceNode
instTree where
  CompositeState{Maybe s
WidgetKeyMap s e
WidgetNode s e
_cpsWidgetKeyMap :: WidgetKeyMap s e
_cpsRoot :: WidgetNode s e
_cpsModel :: Maybe s
_cpsWidgetKeyMap :: forall s e. CompositeState s e -> WidgetKeyMap s e
_cpsRoot :: forall s e. CompositeState s e -> WidgetNode s e
_cpsModel :: forall s e. CompositeState s e -> Maybe s
..} = CompositeState s e
state
  widget :: Widget s e
widget = WidgetNode s e
_cpsRoot forall s a. s -> Getting a s a -> a
^. forall s a. HasWidget s a => Lens' s a
L.widget
  model :: s
model = forall s e.
(CompositeModel s, CompositeEvent e) =>
CompositeState s e -> s
getCompositeModel CompositeState s e
state
  cwenv :: WidgetEnv s e
cwenv = forall sp ep s e.
WidgetEnv sp ep -> WidgetKeyMap s e -> s -> WidgetEnv s e
convertWidgetEnv WidgetEnv sp ep
wenv WidgetKeyMap s e
_cpsWidgetKeyMap s
model
  cInstTree :: WidgetInstanceNode
cInstTree = forall s e.
Widget s e -> WidgetEnv s e -> WidgetNode s e -> WidgetInstanceNode
widgetGetInstanceTree Widget s e
widget WidgetEnv s e
cwenv WidgetNode s e
_cpsRoot
  instTree :: WidgetInstanceNode
instTree = WidgetInstanceNode {
    _winInfo :: WidgetNodeInfo
_winInfo = WidgetNode sp ep
node forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info,
    _winState :: Maybe WidgetState
_winState = forall a. a -> Maybe a
Just (forall i. WidgetModel i => i -> WidgetState
WidgetState CompositeState s e
state),
    _winChildren :: Seq WidgetInstanceNode
_winChildren = forall a. a -> Seq a
Seq.singleton WidgetInstanceNode
cInstTree
  }

-- | Next focusable
compositeFindNextFocus
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> CompositeState s e
  -> WidgetEnv sp ep
  -> WidgetNode sp ep
  -> FocusDirection
  -> Path
  -> Maybe WidgetNodeInfo
compositeFindNextFocus :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> FocusDirection
-> Path
-> Maybe WidgetNodeInfo
compositeFindNextFocus Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp FocusDirection
dir Path
start = Maybe WidgetNodeInfo
nextFocus where
  CompositeState{Maybe s
WidgetKeyMap s e
WidgetNode s e
_cpsWidgetKeyMap :: WidgetKeyMap s e
_cpsRoot :: WidgetNode s e
_cpsModel :: Maybe s
_cpsWidgetKeyMap :: forall s e. CompositeState s e -> WidgetKeyMap s e
_cpsRoot :: forall s e. CompositeState s e -> WidgetNode s e
_cpsModel :: forall s e. CompositeState s e -> Maybe s
..} = CompositeState s e
state
  widget :: Widget s e
widget = WidgetNode s e
_cpsRoot forall s a. s -> Getting a s a -> a
^. forall s a. HasWidget s a => Lens' s a
L.widget
  model :: s
model = forall s e.
(CompositeModel s, CompositeEvent e) =>
CompositeState s e -> s
getCompositeModel CompositeState s e
state
  cwenv :: WidgetEnv s e
cwenv = forall sp ep s e.
WidgetEnv sp ep -> WidgetKeyMap s e -> s -> WidgetEnv s e
convertWidgetEnv WidgetEnv sp ep
wenv WidgetKeyMap s e
_cpsWidgetKeyMap s
model
  nextFocus :: Maybe WidgetNodeInfo
nextFocus = forall s e.
Widget s e
-> WidgetEnv s e
-> WidgetNode s e
-> FocusDirection
-> Path
-> Maybe WidgetNodeInfo
widgetFindNextFocus Widget s e
widget WidgetEnv s e
cwenv WidgetNode s e
_cpsRoot FocusDirection
dir Path
start

-- | Find
compositeFindByPoint
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> CompositeState s e
  -> WidgetEnv sp ep
  -> WidgetNode sp ep
  -> Path
  -> Point
  -> Maybe WidgetNodeInfo
compositeFindByPoint :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> Path
-> Point
-> Maybe WidgetNodeInfo
compositeFindByPoint Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp Path
start Point
point
  | WidgetNode sp ep
widgetComp forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasVisible s a => Lens' s a
L.visible Bool -> Bool -> Bool
&& Bool
validStep = Maybe WidgetNodeInfo
resultInfo
  | Bool
otherwise = forall a. Maybe a
Nothing
  where
    CompositeState{Maybe s
WidgetKeyMap s e
WidgetNode s e
_cpsWidgetKeyMap :: WidgetKeyMap s e
_cpsRoot :: WidgetNode s e
_cpsModel :: Maybe s
_cpsWidgetKeyMap :: forall s e. CompositeState s e -> WidgetKeyMap s e
_cpsRoot :: forall s e. CompositeState s e -> WidgetNode s e
_cpsModel :: forall s e. CompositeState s e -> Maybe s
..} = CompositeState s e
state
    widget :: Widget s e
widget = WidgetNode s e
_cpsRoot forall s a. s -> Getting a s a -> a
^. forall s a. HasWidget s a => Lens' s a
L.widget
    model :: s
model = forall s e.
(CompositeModel s, CompositeEvent e) =>
CompositeState s e -> s
getCompositeModel CompositeState s e
state
    cwenv :: WidgetEnv s e
cwenv = forall sp ep s e.
WidgetEnv sp ep -> WidgetKeyMap s e -> s -> WidgetEnv s e
convertWidgetEnv WidgetEnv sp ep
wenv WidgetKeyMap s e
_cpsWidgetKeyMap s
model
    next :: Maybe PathStep
next = forall s e. WidgetNode s e -> Path -> Maybe PathStep
nextTargetStep WidgetNode sp ep
widgetComp Path
start
    validStep :: Bool
validStep = forall a. Maybe a -> Bool
isNothing Maybe PathStep
next Bool -> Bool -> Bool
|| Maybe PathStep
next forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just PathStep
0
    resultInfo :: Maybe WidgetNodeInfo
resultInfo = forall s e.
Widget s e
-> WidgetEnv s e
-> WidgetNode s e
-> Path
-> Point
-> Maybe WidgetNodeInfo
widgetFindByPoint Widget s e
widget WidgetEnv s e
cwenv WidgetNode s e
_cpsRoot Path
start Point
point

compositeFindBranchByPath
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> CompositeState s e
  -> WidgetEnv sp ep
  -> WidgetNode sp ep
  -> Path
  -> Seq WidgetNodeInfo
compositeFindBranchByPath :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> Path
-> Seq WidgetNodeInfo
compositeFindBranchByPath Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp Path
path
  | WidgetNodeInfo
info forall s a. s -> Getting a s a -> a
^. forall s a. HasPath s a => Lens' s a
L.path forall a. Eq a => a -> a -> Bool
== Path
path = forall a. a -> Seq a
Seq.singleton WidgetNodeInfo
info
  | Maybe PathStep
nextStep forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just PathStep
0 = WidgetNodeInfo
info forall a. a -> Seq a -> Seq a
<| Seq WidgetNodeInfo
childrenInst
  | Bool
otherwise = forall a. Seq a
Seq.empty
  where
    CompositeState{Maybe s
WidgetKeyMap s e
WidgetNode s e
_cpsWidgetKeyMap :: WidgetKeyMap s e
_cpsRoot :: WidgetNode s e
_cpsModel :: Maybe s
_cpsWidgetKeyMap :: forall s e. CompositeState s e -> WidgetKeyMap s e
_cpsRoot :: forall s e. CompositeState s e -> WidgetNode s e
_cpsModel :: forall s e. CompositeState s e -> Maybe s
..} = CompositeState s e
state
    model :: s
model = forall s e.
(CompositeModel s, CompositeEvent e) =>
CompositeState s e -> s
getCompositeModel CompositeState s e
state
    cwenv :: WidgetEnv s e
cwenv = forall sp ep s e.
WidgetEnv sp ep -> WidgetKeyMap s e -> s -> WidgetEnv s e
convertWidgetEnv WidgetEnv sp ep
wenv WidgetKeyMap s e
_cpsWidgetKeyMap s
model
    info :: WidgetNodeInfo
info = WidgetNode sp ep
widgetComp forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info
    nextStep :: Maybe PathStep
nextStep = forall s e. WidgetNode s e -> Path -> Maybe PathStep
nextTargetStep WidgetNode sp ep
widgetComp Path
path
    child :: WidgetNode s e
child = WidgetNode s e
_cpsRoot
    childrenInst :: Seq WidgetNodeInfo
childrenInst = forall s e.
Widget s e
-> WidgetEnv s e -> WidgetNode s e -> Path -> Seq WidgetNodeInfo
widgetFindBranchByPath (WidgetNode s e
child forall s a. s -> Getting a s a -> a
^. forall s a. HasWidget s a => Lens' s a
L.widget) WidgetEnv s e
cwenv WidgetNode s e
child Path
path

-- | Event handling
compositeHandleEvent
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> CompositeState s e
  -> WidgetEnv sp ep
  -> WidgetNode sp ep
  -> Path
  -> SystemEvent
  -> Maybe (WidgetResult sp ep)
compositeHandleEvent :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> Path
-> SystemEvent
-> Maybe (WidgetResult sp ep)
compositeHandleEvent Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp Path
target SystemEvent
evt = Maybe (WidgetResult sp ep)
result where
  CompositeState{Maybe s
WidgetKeyMap s e
WidgetNode s e
_cpsWidgetKeyMap :: WidgetKeyMap s e
_cpsRoot :: WidgetNode s e
_cpsModel :: Maybe s
_cpsWidgetKeyMap :: forall s e. CompositeState s e -> WidgetKeyMap s e
_cpsRoot :: forall s e. CompositeState s e -> WidgetNode s e
_cpsModel :: forall s e. CompositeState s e -> Maybe s
..} = CompositeState s e
state
  widget :: Widget s e
widget = WidgetNode s e
_cpsRoot forall s a. s -> Getting a s a -> a
^. forall s a. HasWidget s a => Lens' s a
L.widget
  !model :: s
model = forall s e.
(CompositeModel s, CompositeEvent e) =>
CompositeState s e -> s
getCompositeModel CompositeState s e
state
  !cwenv :: WidgetEnv s e
cwenv = forall sp ep s e.
WidgetEnv sp ep -> WidgetKeyMap s e -> s -> WidgetEnv s e
convertWidgetEnv WidgetEnv sp ep
wenv WidgetKeyMap s e
_cpsWidgetKeyMap s
model
  rootEnabled :: Bool
rootEnabled = WidgetNode s e
_cpsRoot forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasEnabled s a => Lens' s a
L.enabled
  compVisible :: Bool
compVisible = WidgetNode sp ep
widgetComp forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasVisible s a => Lens' s a
L.visible
  compEnabled :: Bool
compEnabled = WidgetNode sp ep
widgetComp forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasEnabled s a => Lens' s a
L.enabled

  processEvent :: WidgetResult s e -> WidgetResult sp ep
processEvent = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> WidgetResult s e
-> WidgetResult sp ep
toParentResult Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp
  !evtResult :: Maybe (WidgetResult s e)
evtResult
    | Bool -> Bool
not (Bool
compVisible Bool -> Bool -> Bool
&& Bool
compEnabled) = forall a. Maybe a
Nothing
    | Bool
rootEnabled = forall s e.
Widget s e
-> WidgetEnv s e
-> WidgetNode s e
-> Path
-> SystemEvent
-> Maybe (WidgetResult s e)
widgetHandleEvent Widget s e
widget WidgetEnv s e
cwenv WidgetNode s e
_cpsRoot Path
target SystemEvent
evt
    | Bool
otherwise = forall a. Maybe a
Nothing
  !result :: Maybe (WidgetResult sp ep)
result = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap WidgetResult s e -> WidgetResult sp ep
processEvent Maybe (WidgetResult s e)
evtResult

-- | Message handling
compositeHandleMessage
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp, Typeable i)
  => Composite s e sp ep
  -> CompositeState s e
  -> WidgetEnv sp ep
  -> WidgetNode sp ep
  -> Path
  -> i
  -> Maybe (WidgetResult sp ep)
compositeHandleMessage :: forall s e ep sp i.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp, Typeable i) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> Path
-> i
-> Maybe (WidgetResult sp ep)
compositeHandleMessage Composite s e sp ep
comp state :: CompositeState s e
state@CompositeState{Maybe s
WidgetKeyMap s e
WidgetNode s e
_cpsWidgetKeyMap :: WidgetKeyMap s e
_cpsRoot :: WidgetNode s e
_cpsModel :: Maybe s
_cpsWidgetKeyMap :: forall s e. CompositeState s e -> WidgetKeyMap s e
_cpsRoot :: forall s e. CompositeState s e -> WidgetNode s e
_cpsModel :: forall s e. CompositeState s e -> Maybe s
..} !WidgetEnv sp ep
wenv !WidgetNode sp ep
widgetComp !Path
target i
arg
  | forall s e. WidgetNode s e -> Path -> Bool
isTargetReached WidgetNode sp ep
widgetComp Path
target = case forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast i
arg of
      Just e
evt -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> e
-> WidgetResult sp ep
handleMsgEvent Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp e
evt
      Maybe e
Nothing -> case forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast i
arg of
        Just (CompMsgUpdate s -> s
msg) -> forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> (s -> s)
-> WidgetResult sp ep
handleMsgUpdate Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast s -> s
msg
        Maybe CompMsgUpdate
Nothing -> case forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast i
arg of
          Just CompMsgDelayedRequest
req -> forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> CompMsgDelayedRequest
-> Maybe (WidgetResult sp ep)
handleDelayedRequest Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp CompMsgDelayedRequest
req
          Maybe CompMsgDelayedRequest
_ -> forall a b. Show a => a -> b -> b
traceShow (String
"Failed match on Composite handleMessage", forall a. Typeable a => a -> TypeRep
typeOf i
arg) forall a. Maybe a
Nothing
  | Bool
otherwise = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap WidgetResult s e -> WidgetResult sp ep
processEvent Maybe (WidgetResult s e)
result where
      processEvent :: WidgetResult s e -> WidgetResult sp ep
processEvent = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> WidgetResult s e
-> WidgetResult sp ep
toParentResult Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp
      cmpWidget :: Widget s e
cmpWidget = WidgetNode s e
_cpsRoot forall s a. s -> Getting a s a -> a
^. forall s a. HasWidget s a => Lens' s a
L.widget
      !model :: s
model = forall s e.
(CompositeModel s, CompositeEvent e) =>
CompositeState s e -> s
getCompositeModel CompositeState s e
state
      !cwenv :: WidgetEnv s e
cwenv = forall sp ep s e.
WidgetEnv sp ep -> WidgetKeyMap s e -> s -> WidgetEnv s e
convertWidgetEnv WidgetEnv sp ep
wenv WidgetKeyMap s e
_cpsWidgetKeyMap s
model
      result :: Maybe (WidgetResult s e)
result = forall s e.
Widget s e
-> forall i.
   Typeable i =>
   WidgetEnv s e
   -> WidgetNode s e -> Path -> i -> Maybe (WidgetResult s e)
widgetHandleMessage Widget s e
cmpWidget WidgetEnv s e
cwenv WidgetNode s e
_cpsRoot Path
target i
arg

-- Preferred size
compositeGetSizeReq
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> CompositeState s e
  -> WidgetEnv sp ep
  -> WidgetNode sp ep
  -> (SizeReq, SizeReq)
compositeGetSizeReq :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> (SizeReq, SizeReq)
compositeGetSizeReq Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp = (SizeReq
newReqW, SizeReq
newReqH) where
  CompositeState{Maybe s
WidgetKeyMap s e
WidgetNode s e
_cpsWidgetKeyMap :: WidgetKeyMap s e
_cpsRoot :: WidgetNode s e
_cpsModel :: Maybe s
_cpsWidgetKeyMap :: forall s e. CompositeState s e -> WidgetKeyMap s e
_cpsRoot :: forall s e. CompositeState s e -> WidgetNode s e
_cpsModel :: forall s e. CompositeState s e -> Maybe s
..} = CompositeState s e
state
  style :: StyleState
style = forall s e. WidgetEnv s e -> WidgetNode s e -> StyleState
currentStyle WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp
  widget :: Widget s e
widget = WidgetNode s e
_cpsRoot forall s a. s -> Getting a s a -> a
^. forall s a. HasWidget s a => Lens' s a
L.widget
  currReqW :: SizeReq
currReqW = WidgetNode s e
_cpsRoot forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasSizeReqW s a => Lens' s a
L.sizeReqW
  currReqH :: SizeReq
currReqH = WidgetNode s e
_cpsRoot forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasSizeReqH s a => Lens' s a
L.sizeReqH
  (SizeReq
tmpReqW, SizeReq
tmpReqH) = StyleState -> (SizeReq, SizeReq) -> (SizeReq, SizeReq)
sizeReqAddStyle StyleState
style (SizeReq
currReqW, SizeReq
currReqH)
  -- User settings take precedence
  newReqW :: SizeReq
newReqW = forall a. a -> Maybe a -> a
fromMaybe SizeReq
tmpReqW (StyleState
style forall s a. s -> Getting a s a -> a
^. forall s a. HasSizeReqW s a => Lens' s a
L.sizeReqW)
  newReqH :: SizeReq
newReqH = forall a. a -> Maybe a -> a
fromMaybe SizeReq
tmpReqH (StyleState
style forall s a. s -> Getting a s a -> a
^. forall s a. HasSizeReqH s a => Lens' s a
L.sizeReqH)

-- Preferred size
updateSizeReq
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> CompositeState s e
  -> WidgetEnv sp ep
  -> WidgetNode sp ep
  -> WidgetNode sp ep
updateSizeReq :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> WidgetNode sp ep
updateSizeReq Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp = WidgetNode sp ep
newComp where
  (SizeReq
newReqW, SizeReq
newReqH) = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> (SizeReq, SizeReq)
compositeGetSizeReq Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp
  newComp :: WidgetNode sp ep
newComp = WidgetNode sp ep
widgetComp
    forall a b. a -> (a -> b) -> b
& forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasSizeReqW s a => Lens' s a
L.sizeReqW forall s t a b. ASetter s t a b -> b -> s -> t
.~ SizeReq
newReqW
    forall a b. a -> (a -> b) -> b
& forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasSizeReqH s a => Lens' s a
L.sizeReqH forall s t a b. ASetter s t a b -> b -> s -> t
.~ SizeReq
newReqH

-- Resize
compositeResize
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> CompositeState s e
  -> WidgetEnv sp ep
  -> WidgetNode sp ep
  -> Rect
  -> (Path -> Bool)
  -> WidgetResult sp ep
compositeResize :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> Rect
-> (Path -> Bool)
-> WidgetResult sp ep
compositeResize Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp Rect
viewport Path -> Bool
rszReq = WidgetResult sp ep
resizedRes where
  CompositeState{Maybe s
WidgetKeyMap s e
WidgetNode s e
_cpsWidgetKeyMap :: WidgetKeyMap s e
_cpsRoot :: WidgetNode s e
_cpsModel :: Maybe s
_cpsWidgetKeyMap :: forall s e. CompositeState s e -> WidgetKeyMap s e
_cpsRoot :: forall s e. CompositeState s e -> WidgetNode s e
_cpsModel :: forall s e. CompositeState s e -> Maybe s
..} = CompositeState s e
state
  style :: StyleState
style = forall s e. WidgetEnv s e -> WidgetNode s e -> StyleState
currentStyle WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp
  carea :: Rect
carea = forall a. a -> Maybe a -> a
fromMaybe forall a. Default a => a
def (StyleState -> Rect -> Maybe Rect
removeOuterBounds StyleState
style Rect
viewport)
  widget :: Widget s e
widget = WidgetNode s e
_cpsRoot forall s a. s -> Getting a s a -> a
^. forall s a. HasWidget s a => Lens' s a
L.widget
  model :: s
model = forall s e.
(CompositeModel s, CompositeEvent e) =>
CompositeState s e -> s
getCompositeModel CompositeState s e
state
  cwenv :: WidgetEnv s e
cwenv = forall sp ep s e.
WidgetEnv sp ep -> WidgetKeyMap s e -> s -> WidgetEnv s e
convertWidgetEnv WidgetEnv sp ep
wenv WidgetKeyMap s e
_cpsWidgetKeyMap s
model

  WidgetResult WidgetNode s e
newRoot Seq (WidgetRequest s e)
newReqs = forall s e.
Widget s e
-> WidgetEnv s e
-> WidgetNode s e
-> Rect
-> (Path -> Bool)
-> WidgetResult s e
widgetResize Widget s e
widget WidgetEnv s e
cwenv WidgetNode s e
_cpsRoot Rect
carea Path -> Bool
rszReq
  oldVp :: Rect
oldVp = WidgetNode sp ep
widgetComp forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasViewport s a => Lens' s a
L.viewport
  sizeChanged :: Bool
sizeChanged = Rect
viewport forall a. Eq a => a -> a -> Bool
/= Rect
oldVp
  resizeEvts :: [e]
resizeEvts = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a b. (a -> b) -> a -> b
$ Rect
viewport) (forall s e sp ep. Composite s e sp ep -> [Rect -> e]
_cmpOnResize Composite s e sp ep
comp)
  resizeReqs :: Seq (WidgetRequest s e)
resizeReqs
    | Bool
sizeChanged = forall s e. WidgetEvent e => e -> WidgetRequest s e
RaiseEvent forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. [a] -> Seq a
Seq.fromList [e]
resizeEvts
    | Bool
otherwise = forall a. Seq a
Empty

  childRes :: WidgetResult s e
childRes = forall s e.
WidgetNode s e -> Seq (WidgetRequest s e) -> WidgetResult s e
WidgetResult WidgetNode s e
newRoot (Seq (WidgetRequest s e)
newReqs forall a. Semigroup a => a -> a -> a
<> forall {s}. Seq (WidgetRequest s e)
resizeReqs)
    forall a b. a -> (a -> b) -> b
& forall s a. HasNode s a => Lens' s a
L.node forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasViewport s a => Lens' s a
L.viewport forall s t a b. ASetter s t a b -> b -> s -> t
.~ Rect
carea
  resizedRes :: WidgetResult sp ep
resizedRes = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> WidgetResult s e
-> WidgetResult sp ep
toParentResult Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp WidgetResult s e
childRes
    forall a b. a -> (a -> b) -> b
& forall s a. HasNode s a => Lens' s a
L.node forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasViewport s a => Lens' s a
L.viewport forall s t a b. ASetter s t a b -> b -> s -> t
.~ Rect
viewport

-- Render
compositeRender
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> CompositeState s e
  -> WidgetEnv sp ep
  -> WidgetNode sp ep
  -> Renderer
  -> IO ()
compositeRender :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> Renderer
-> IO ()
compositeRender Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp Renderer
renderer =
  forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (forall s e. WidgetEnv s e -> WidgetNode s e -> Bool
isWidgetVisible WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp) forall a b. (a -> b) -> a -> b
$
    Renderer -> Rect -> StyleState -> (Rect -> IO ()) -> IO ()
drawStyledAction Renderer
renderer Rect
viewport StyleState
style forall a b. (a -> b) -> a -> b
$ \Rect
_ ->
      forall s e.
Widget s e -> WidgetEnv s e -> WidgetNode s e -> Renderer -> IO ()
widgetRender Widget s e
widget WidgetEnv s e
cwenv WidgetNode s e
_cpsRoot Renderer
renderer
  where
    CompositeState{Maybe s
WidgetKeyMap s e
WidgetNode s e
_cpsWidgetKeyMap :: WidgetKeyMap s e
_cpsModel :: Maybe s
_cpsRoot :: WidgetNode s e
_cpsWidgetKeyMap :: forall s e. CompositeState s e -> WidgetKeyMap s e
_cpsRoot :: forall s e. CompositeState s e -> WidgetNode s e
_cpsModel :: forall s e. CompositeState s e -> Maybe s
..} = CompositeState s e
state
    widget :: Widget s e
widget = WidgetNode s e
_cpsRoot forall s a. s -> Getting a s a -> a
^. forall s a. HasWidget s a => Lens' s a
L.widget
    viewport :: Rect
viewport = WidgetNode sp ep
widgetComp forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasViewport s a => Lens' s a
L.viewport
    style :: StyleState
style = forall s e. WidgetEnv s e -> WidgetNode s e -> StyleState
currentStyle WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp
    !model :: s
model = forall s e.
(CompositeModel s, CompositeEvent e) =>
CompositeState s e -> s
getCompositeModel CompositeState s e
state
    !cwenv :: WidgetEnv s e
cwenv = forall sp ep s e.
WidgetEnv sp ep -> WidgetKeyMap s e -> s -> WidgetEnv s e
convertWidgetEnv WidgetEnv sp ep
wenv WidgetKeyMap s e
_cpsWidgetKeyMap s
model

handleMsgEvent
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> CompositeState s e
  -> WidgetEnv sp ep
  -> WidgetNode sp ep
  -> e
  -> WidgetResult sp ep
handleMsgEvent :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> e
-> WidgetResult sp ep
handleMsgEvent Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp e
event = WidgetResult sp ep
newResult where
  CompositeState{Maybe s
WidgetKeyMap s e
WidgetNode s e
_cpsWidgetKeyMap :: WidgetKeyMap s e
_cpsRoot :: WidgetNode s e
_cpsModel :: Maybe s
_cpsWidgetKeyMap :: forall s e. CompositeState s e -> WidgetKeyMap s e
_cpsRoot :: forall s e. CompositeState s e -> WidgetNode s e
_cpsModel :: forall s e. CompositeState s e -> Maybe s
..} = CompositeState s e
state
  evtHandler :: EventHandler s e sp ep
evtHandler = forall s e sp ep. Composite s e sp ep -> EventHandler s e sp ep
_cmpEventHandler Composite s e sp ep
comp
  !model :: s
model = forall s e.
(CompositeModel s, CompositeEvent e) =>
CompositeState s e -> s
getCompositeModel CompositeState s e
state
  !cwenv :: WidgetEnv s e
cwenv = forall sp ep s e.
WidgetEnv sp ep -> WidgetKeyMap s e -> s -> WidgetEnv s e
convertWidgetEnv WidgetEnv sp ep
wenv WidgetKeyMap s e
_cpsWidgetKeyMap s
model
  !response :: [EventResponse s e sp ep]
response = EventHandler s e sp ep
evtHandler WidgetEnv s e
cwenv WidgetNode s e
_cpsRoot s
model e
event
  !newReqs :: [Maybe (WidgetRequest sp ep)]
newReqs = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
WidgetNode sp ep
-> WidgetKeyMap s e
-> EventResponse s e sp ep
-> Maybe (WidgetRequest sp ep)
evtResponseToRequest WidgetNode sp ep
widgetComp WidgetKeyMap s e
_cpsWidgetKeyMap forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [EventResponse s e sp ep]
response
  !newResult :: WidgetResult sp ep
newResult = forall s e.
WidgetNode s e -> Seq (WidgetRequest s e) -> WidgetResult s e
WidgetResult WidgetNode sp ep
widgetComp (forall a. [a] -> Seq a
Seq.fromList (forall a. [Maybe a] -> [a]
catMaybes [Maybe (WidgetRequest sp ep)]
newReqs))

handleMsgUpdate
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> CompositeState s e
  -> WidgetEnv sp ep
  -> WidgetNode sp ep
  -> (s -> s)
  -> WidgetResult sp ep
handleMsgUpdate :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> (s -> s)
-> WidgetResult sp ep
handleMsgUpdate Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp s -> s
fnUpdate = WidgetResult sp ep
result where
  CompositeState{Maybe s
WidgetKeyMap s e
WidgetNode s e
_cpsWidgetKeyMap :: WidgetKeyMap s e
_cpsRoot :: WidgetNode s e
_cpsModel :: Maybe s
_cpsWidgetKeyMap :: forall s e. CompositeState s e -> WidgetKeyMap s e
_cpsRoot :: forall s e. CompositeState s e -> WidgetNode s e
_cpsModel :: forall s e. CompositeState s e -> Maybe s
..} = CompositeState s e
state
  !model :: s
model = forall s e.
(CompositeModel s, CompositeEvent e) =>
CompositeState s e -> s
getCompositeModel CompositeState s e
state
  !newModel :: s
newModel = s -> s
fnUpdate s
model
  !result :: WidgetResult sp ep
result
    | s
model forall a. Eq a => a -> a -> Bool
== s
newModel = forall s e. WidgetNode s e -> WidgetResult s e
resultNode WidgetNode sp ep
widgetComp
    | Bool
otherwise = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> s
-> WidgetNode s e
-> WidgetNode sp ep
-> WidgetResult sp ep
mergeChild Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv s
newModel WidgetNode s e
_cpsRoot WidgetNode sp ep
widgetComp

toParentResult
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> CompositeState s e
  -> WidgetEnv sp ep
  -> WidgetNode sp ep
  -> WidgetResult s e
  -> WidgetResult sp ep
toParentResult :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> WidgetResult s e
-> WidgetResult sp ep
toParentResult Composite s e sp ep
comp CompositeState s e
state !WidgetEnv sp ep
wenv !WidgetNode sp ep
widgetComp !WidgetResult s e
result = WidgetResult sp ep
newResult where
  WidgetResult WidgetNode s e
newRoot Seq (WidgetRequest s e)
reqs = WidgetResult s e
result
  widgetId :: WidgetId
widgetId = WidgetNode sp ep
widgetComp forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasWidgetId s a => Lens' s a
L.widgetId
  newState :: CompositeState s e
newState = CompositeState s e
state {
    _cpsRoot :: WidgetNode s e
_cpsRoot = WidgetNode s e
newRoot
  }
  newComp :: WidgetNode sp ep
newComp = WidgetNode sp ep
widgetComp
    forall a b. a -> (a -> b) -> b
& forall s a. HasWidget s a => Lens' s a
L.widget forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep -> CompositeState s e -> Widget sp ep
createComposite Composite s e sp ep
comp CompositeState s e
newState
  newNode :: WidgetNode sp ep
newNode = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> WidgetNode sp ep
updateSizeReq Composite s e sp ep
comp CompositeState s e
newState WidgetEnv sp ep
wenv WidgetNode sp ep
newComp
  newReqs :: Seq (WidgetRequest sp ep)
newReqs = forall a. Seq (Maybe a) -> Seq a
seqCatMaybes (forall s sp e ep.
(CompositeModel s, CompParentModel sp) =>
WidgetId -> WidgetRequest s e -> Maybe (WidgetRequest sp ep)
toParentReq WidgetId
widgetId forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Seq (WidgetRequest s e)
reqs)
  !newResult :: WidgetResult sp ep
newResult = forall s e.
WidgetNode s e -> Seq (WidgetRequest s e) -> WidgetResult s e
WidgetResult WidgetNode sp ep
newNode forall {ep}. Seq (WidgetRequest sp ep)
newReqs

evtResponseToRequest
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => WidgetNode sp ep
  -> WidgetKeyMap s e
  -> EventResponse s e sp ep
  -> Maybe (WidgetRequest sp ep)
evtResponseToRequest :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
WidgetNode sp ep
-> WidgetKeyMap s e
-> EventResponse s e sp ep
-> Maybe (WidgetRequest sp ep)
evtResponseToRequest WidgetNode sp ep
widgetComp WidgetKeyMap s e
widgetKeys EventResponse s e sp ep
response = case EventResponse s e sp ep
response of
  Model s
newModel -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall i s e sp ep.
Typeable i =>
WidgetNode s e -> i -> WidgetRequest sp ep
sendMsgTo WidgetNode sp ep
widgetComp (forall s. CompositeModel s => (s -> s) -> CompMsgUpdate
CompMsgUpdate forall a b. (a -> b) -> a -> b
$ forall a b. a -> b -> a
const s
newModel)
  Event e
event -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall i s e sp ep.
Typeable i =>
WidgetNode s e -> i -> WidgetRequest sp ep
sendMsgTo WidgetNode sp ep
widgetComp e
event
  Report ep
report -> forall a. a -> Maybe a
Just (forall s e. WidgetEvent e => e -> WidgetRequest s e
RaiseEvent ep
report)
  Request WidgetRequest s e
req -> forall s sp e ep.
(CompositeModel s, CompParentModel sp) =>
WidgetId -> WidgetRequest s e -> Maybe (WidgetRequest sp ep)
toParentReq WidgetId
widgetId WidgetRequest s e
req
  RequestParent WidgetRequest sp ep
req -> forall a. a -> Maybe a
Just WidgetRequest sp ep
req
  SetFocusOnKey WidgetKey
key -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall i s e sp ep.
Typeable i =>
WidgetNode s e -> i -> WidgetRequest sp ep
sendMsgTo WidgetNode sp ep
widgetComp (WidgetKey -> CompMsgDelayedRequest
CompMsgSetFocus WidgetKey
key)
  MoveFocusFromKey Maybe WidgetKey
key FocusDirection
dir -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall i s e sp ep.
Typeable i =>
WidgetNode s e -> i -> WidgetRequest sp ep
sendMsgTo WidgetNode sp ep
widgetComp (Maybe WidgetKey -> FocusDirection -> CompMsgDelayedRequest
CompMsgMoveFocus Maybe WidgetKey
key FocusDirection
dir)
  Message WidgetKey
key i
msg -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall i s e sp ep.
Typeable i =>
WidgetNode s e -> i -> WidgetRequest sp ep
sendMsgTo WidgetNode sp ep
widgetComp (forall i. Typeable i => WidgetKey -> i -> CompMsgDelayedRequest
CompMsgMessage WidgetKey
key i
msg)
  Task TaskHandler e
task -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall s e i.
Typeable i =>
WidgetId -> Path -> IO i -> WidgetRequest s e
RunTask WidgetId
widgetId Path
path TaskHandler e
task
  Producer ProducerHandler e
producer -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall s e i.
Typeable i =>
WidgetId -> Path -> ((i -> IO ()) -> IO ()) -> WidgetRequest s e
RunProducer WidgetId
widgetId Path
path ProducerHandler e
producer
  where
    widgetId :: WidgetId
widgetId = WidgetNode sp ep
widgetComp forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasWidgetId s a => Lens' s a
L.widgetId
    path :: Path
path = WidgetNode sp ep
widgetComp forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasPath s a => Lens' s a
L.path

handleDelayedRequest
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> CompositeState s e
  -> WidgetEnv sp ep
  -> WidgetNode sp ep
  -> CompMsgDelayedRequest
  -> Maybe (WidgetResult sp ep)
handleDelayedRequest :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> CompMsgDelayedRequest
-> Maybe (WidgetResult sp ep)
handleDelayedRequest Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv WidgetNode sp ep
node CompMsgDelayedRequest
req = Maybe (WidgetResult sp ep)
result where
    widgetKeys :: WidgetKeyMap s e
widgetKeys = forall s e. CompositeState s e -> WidgetKeyMap s e
_cpsWidgetKeyMap CompositeState s e
state
    newReq :: Maybe (WidgetRequest s e)
newReq = case CompMsgDelayedRequest
req of
      CompMsgSetFocus WidgetKey
key -> forall {s} {a} {s} {e}.
(HasInfo s a, HasWidgetId a WidgetId) =>
s -> WidgetRequest s e
setFocus forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s e.
WidgetKeyMap s e -> String -> WidgetKey -> Maybe (WidgetNode s e)
lookupNode WidgetKeyMap s e
widgetKeys String
"SetFocusOnKey" WidgetKey
key
      CompMsgMoveFocus (Just WidgetKey
key) FocusDirection
dir -> forall {s} {e}.
WidgetKey -> FocusDirection -> Maybe (WidgetRequest s e)
moveFocusFrom WidgetKey
key FocusDirection
dir
      CompMsgMoveFocus Maybe WidgetKey
_ FocusDirection
dir -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall s e. Maybe WidgetId -> FocusDirection -> WidgetRequest s e
MoveFocus forall a. Maybe a
Nothing FocusDirection
dir
      CompMsgMessage WidgetKey
key i
msg -> (forall i s e sp ep.
Typeable i =>
WidgetNode s e -> i -> WidgetRequest sp ep
`sendMsgTo` i
msg) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s e.
WidgetKeyMap s e -> String -> WidgetKey -> Maybe (WidgetNode s e)
lookupNode WidgetKeyMap s e
widgetKeys String
"Message" WidgetKey
key
    result :: Maybe (WidgetResult sp ep)
result = forall s e.
WidgetNode s e -> [WidgetRequest s e] -> WidgetResult s e
resultReqs WidgetNode sp ep
node forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. a -> [a] -> [a]
: []) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {s} {e}. Maybe (WidgetRequest s e)
newReq

    setFocus :: s -> WidgetRequest s e
setFocus s
node = forall s e. WidgetId -> WidgetRequest s e
SetFocus (s
node forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasWidgetId s a => Lens' s a
L.widgetId)
    moveFocusFrom :: WidgetKey -> FocusDirection -> Maybe (WidgetRequest s e)
moveFocusFrom WidgetKey
key FocusDirection
dir = Maybe WidgetId
mwid forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall a. a -> Maybe a
Just (forall s e. Maybe WidgetId -> FocusDirection -> WidgetRequest s e
MoveFocus Maybe WidgetId
mwid FocusDirection
dir) where
      mnode :: Maybe (WidgetNode s e)
mnode = forall s e.
WidgetKeyMap s e -> String -> WidgetKey -> Maybe (WidgetNode s e)
lookupNode WidgetKeyMap s e
widgetKeys String
"MoveFocusFromKey" WidgetKey
key
      mwid :: Maybe WidgetId
mwid = (forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasWidgetId s a => Lens' s a
L.widgetId) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (WidgetNode s e)
mnode

mergeChild
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> CompositeState s e
  -> WidgetEnv sp ep
  -> s
  -> WidgetNode s e
  -> WidgetNode sp ep
  -> WidgetResult sp ep
mergeChild :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> s
-> WidgetNode s e
-> WidgetNode sp ep
-> WidgetResult sp ep
mergeChild Composite s e sp ep
comp CompositeState s e
state WidgetEnv sp ep
wenv s
newModel WidgetNode s e
widgetRoot WidgetNode sp ep
widgetComp = WidgetResult sp ep
parentResult where
  CompositeState{Maybe s
WidgetKeyMap s e
WidgetNode s e
_cpsWidgetKeyMap :: WidgetKeyMap s e
_cpsRoot :: WidgetNode s e
_cpsModel :: Maybe s
_cpsWidgetKeyMap :: forall s e. CompositeState s e -> WidgetKeyMap s e
_cpsRoot :: forall s e. CompositeState s e -> WidgetNode s e
_cpsModel :: forall s e. CompositeState s e -> Maybe s
..} = CompositeState s e
state
  oldModel :: s
oldModel = forall s e.
(CompositeModel s, CompositeEvent e) =>
CompositeState s e -> s
getCompositeModel CompositeState s e
state
  cwenv :: WidgetEnv s e
cwenv = forall sp ep s e.
WidgetEnv sp ep -> WidgetKeyMap s e -> s -> WidgetEnv s e
convertWidgetEnv WidgetEnv sp ep
wenv WidgetKeyMap s e
_cpsWidgetKeyMap s
newModel
  widgetId :: WidgetId
widgetId = WidgetNode s e
_cpsRoot forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasWidgetId s a => Lens' s a
L.widgetId
  builtRoot :: WidgetNode s e
builtRoot = forall sp ep s e.
WidgetEnv sp ep
-> WidgetNode sp ep -> WidgetNode s e -> WidgetNode s e
cascadeCtx WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp (forall s e sp ep. Composite s e sp ep -> UIBuilder s e
_cmpUiBuilder Composite s e sp ep
comp WidgetEnv s e
cwenv s
newModel)
      forall a b. a -> (a -> b) -> b
& forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasWidgetId s a => Lens' s a
L.widgetId forall s t a b. ASetter s t a b -> b -> s -> t
.~ WidgetId
widgetId
  builtWidget :: Widget s e
builtWidget = WidgetNode s e
builtRoot forall s a. s -> Getting a s a -> a
^. forall s a. HasWidget s a => Lens' s a
L.widget
  initRequired :: Bool
initRequired = Bool -> Bool
not (forall s e. WidgetNode s e -> WidgetNode s e -> Bool
nodeMatches WidgetNode s e
widgetRoot WidgetNode s e
builtRoot)
  mergedResult :: WidgetResult s e
mergedResult
    | Bool
initRequired = forall s e.
Widget s e -> WidgetEnv s e -> WidgetNode s e -> WidgetResult s e
widgetInit Widget s e
builtWidget WidgetEnv s e
cwenv WidgetNode s e
builtRoot
    | Bool
otherwise = forall s e.
Widget s e
-> WidgetEnv s e
-> WidgetNode s e
-> WidgetNode s e
-> WidgetResult s e
widgetMerge Widget s e
builtWidget WidgetEnv s e
cwenv WidgetNode s e
builtRoot WidgetNode s e
widgetRoot
  !mergedState :: CompositeState s e
mergedState = CompositeState s e
state {
    _cpsModel :: Maybe s
_cpsModel = forall a. a -> Maybe a
Just s
newModel,
    _cpsRoot :: WidgetNode s e
_cpsRoot = WidgetResult s e
mergedResult forall s a. s -> Getting a s a -> a
^. forall s a. HasNode s a => Lens' s a
L.node,
    _cpsWidgetKeyMap :: WidgetKeyMap s e
_cpsWidgetKeyMap = forall s e.
Map WidgetKey (WidgetNode s e)
-> WidgetNode s e -> Map WidgetKey (WidgetNode s e)
collectWidgetKeys forall k a. Map k a
M.empty (WidgetResult s e
mergedResult forall s a. s -> Getting a s a -> a
^. forall s a. HasNode s a => Lens' s a
L.node)
  }
  childReqs :: [WidgetRequest s e]
childReqs = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a b. (a -> b) -> a -> b
$ s
oldModel) (forall s e sp ep. Composite s e sp ep -> [s -> WidgetRequest s e]
_cmpOnChangeReq Composite s e sp ep
comp)
  parentReqs :: [WidgetRequest sp e]
parentReqs = forall s a e. WidgetData s a -> a -> [WidgetRequest s e]
widgetDataSet (forall s e sp ep. Composite s e sp ep -> WidgetData sp s
_cmpWidgetData Composite s e sp ep
comp) s
newModel
    forall a. [a] -> [a] -> [a]
++ [forall s e. WidgetId -> WidgetRequest s e
ResizeWidgets WidgetId
widgetId | Bool
initRequired]
  childResult :: WidgetResult s e
childResult = WidgetResult s e
mergedResult
    forall a b. a -> (a -> b) -> b
& forall s a. HasRequests s a => Lens' s a
L.requests forall a s t. Semigroup a => ASetter s t a a -> a -> s -> t
<>~ forall a. [a] -> Seq a
Seq.fromList [WidgetRequest s e]
childReqs
  result :: WidgetResult sp ep
result = forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep
-> CompositeState s e
-> WidgetEnv sp ep
-> WidgetNode sp ep
-> WidgetResult s e
-> WidgetResult sp ep
toParentResult Composite s e sp ep
comp CompositeState s e
mergedState WidgetEnv sp ep
wenv WidgetNode sp ep
widgetComp WidgetResult s e
childResult
  parentResult :: WidgetResult sp ep
parentResult = WidgetResult sp ep
result
    forall a b. a -> (a -> b) -> b
& forall s a. HasRequests s a => Lens' s a
L.requests forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. [a] -> Seq a
Seq.fromList forall {e}. [WidgetRequest sp e]
parentReqs forall a. Semigroup a => a -> a -> a
<> WidgetResult sp ep
result forall s a. s -> Getting a s a -> a
^. forall s a. HasRequests s a => Lens' s a
L.requests

getUserModel
  :: (CompositeModel s, CompositeEvent e, CompositeEvent ep, CompParentModel sp)
  => Composite s e sp ep
  -> WidgetEnv sp ep
  -> s
getUserModel :: forall s e ep sp.
(CompositeModel s, CompositeEvent e, CompositeEvent ep,
 CompParentModel sp) =>
Composite s e sp ep -> WidgetEnv sp ep -> s
getUserModel Composite s e sp ep
comp WidgetEnv sp ep
wenv = forall s a. s -> WidgetData s a -> a
widgetDataGet (forall s e. WidgetEnv s e -> s
_weModel WidgetEnv sp ep
wenv) (forall s e sp ep. Composite s e sp ep -> WidgetData sp s
_cmpWidgetData Composite s e sp ep
comp)

getCompositeModel
  :: (CompositeModel s, CompositeEvent e)
  => CompositeState s e
  -> s
getCompositeModel :: forall s e.
(CompositeModel s, CompositeEvent e) =>
CompositeState s e -> s
getCompositeModel CompositeState s e
state = case forall s e. CompositeState s e -> Maybe s
_cpsModel CompositeState s e
state of
  Just s
model -> s
model
  Maybe s
_ -> forall a. HasCallStack => String -> a
error String
"Error calling getCompositeModel: widgetInit has not been invoked."

toParentReq
  :: (CompositeModel s, CompParentModel sp)
  => WidgetId
  -> WidgetRequest s e
  -> Maybe (WidgetRequest sp ep)
toParentReq :: forall s sp e ep.
(CompositeModel s, CompParentModel sp) =>
WidgetId -> WidgetRequest s e -> Maybe (WidgetRequest sp ep)
toParentReq WidgetId
_ WidgetRequest s e
IgnoreParentEvents = forall a. a -> Maybe a
Just forall s e. WidgetRequest s e
IgnoreParentEvents
toParentReq WidgetId
_ WidgetRequest s e
IgnoreChildrenEvents = forall a. a -> Maybe a
Just forall s e. WidgetRequest s e
IgnoreChildrenEvents
toParentReq WidgetId
_ (ResizeWidgets WidgetId
wid) = forall a. a -> Maybe a
Just (forall s e. WidgetId -> WidgetRequest s e
ResizeWidgets WidgetId
wid)
toParentReq WidgetId
_ (ResizeWidgetsImmediate WidgetId
wid) = forall a. a -> Maybe a
Just (forall s e. WidgetId -> WidgetRequest s e
ResizeWidgetsImmediate WidgetId
wid)
toParentReq WidgetId
_ (MoveFocus Maybe WidgetId
start FocusDirection
dir) = forall a. a -> Maybe a
Just (forall s e. Maybe WidgetId -> FocusDirection -> WidgetRequest s e
MoveFocus Maybe WidgetId
start FocusDirection
dir)
toParentReq WidgetId
_ (SetFocus WidgetId
path) = forall a. a -> Maybe a
Just (forall s e. WidgetId -> WidgetRequest s e
SetFocus WidgetId
path)
toParentReq WidgetId
_ (GetClipboard WidgetId
path) = forall a. a -> Maybe a
Just (forall s e. WidgetId -> WidgetRequest s e
GetClipboard WidgetId
path)
toParentReq WidgetId
_ (SetClipboard ClipboardData
clipboard) = forall a. a -> Maybe a
Just (forall s e. ClipboardData -> WidgetRequest s e
SetClipboard ClipboardData
clipboard)
toParentReq WidgetId
_ (StartTextInput Rect
rect) = forall a. a -> Maybe a
Just (forall s e. Rect -> WidgetRequest s e
StartTextInput Rect
rect)
toParentReq WidgetId
_ WidgetRequest s e
StopTextInput = forall a. a -> Maybe a
Just forall s e. WidgetRequest s e
StopTextInput
toParentReq WidgetId
_ (ResetOverlay WidgetId
wid) = forall a. a -> Maybe a
Just (forall s e. WidgetId -> WidgetRequest s e
ResetOverlay WidgetId
wid)
toParentReq WidgetId
_ (SetOverlay WidgetId
wid Path
path) = forall a. a -> Maybe a
Just (forall s e. WidgetId -> Path -> WidgetRequest s e
SetOverlay WidgetId
wid Path
path)
toParentReq WidgetId
_ (SetCursorIcon WidgetId
wid CursorIcon
icon) = forall a. a -> Maybe a
Just (forall s e. WidgetId -> CursorIcon -> WidgetRequest s e
SetCursorIcon WidgetId
wid CursorIcon
icon)
toParentReq WidgetId
_ (ResetCursorIcon WidgetId
wid) = forall a. a -> Maybe a
Just (forall s e. WidgetId -> WidgetRequest s e
ResetCursorIcon WidgetId
wid)
toParentReq WidgetId
_ (StartDrag WidgetId
wid Path
path WidgetDragMsg
info) = forall a. a -> Maybe a
Just (forall s e. WidgetId -> Path -> WidgetDragMsg -> WidgetRequest s e
StartDrag WidgetId
wid Path
path WidgetDragMsg
info)
toParentReq WidgetId
_ (StopDrag WidgetId
wid) = forall a. a -> Maybe a
Just (forall s e. WidgetId -> WidgetRequest s e
StopDrag WidgetId
wid)
toParentReq WidgetId
_ WidgetRequest s e
RenderOnce = forall a. a -> Maybe a
Just forall s e. WidgetRequest s e
RenderOnce
toParentReq WidgetId
_ (RenderEvery WidgetId
path Millisecond
ms Maybe PathStep
repeat) = forall a. a -> Maybe a
Just (forall s e.
WidgetId -> Millisecond -> Maybe PathStep -> WidgetRequest s e
RenderEvery WidgetId
path Millisecond
ms Maybe PathStep
repeat)
toParentReq WidgetId
_ (RenderStop WidgetId
path) = forall a. a -> Maybe a
Just (forall s e. WidgetId -> WidgetRequest s e
RenderStop WidgetId
path)
toParentReq WidgetId
_ (RemoveRendererImage Text
name) = forall a. a -> Maybe a
Just (forall s e. Text -> WidgetRequest s e
RemoveRendererImage Text
name)
toParentReq WidgetId
_ (ExitApplication Bool
exit) = forall a. a -> Maybe a
Just (forall s e. Bool -> WidgetRequest s e
ExitApplication Bool
exit)
toParentReq WidgetId
_ (UpdateWindow WindowRequest
req) = forall a. a -> Maybe a
Just (forall s e. WindowRequest -> WidgetRequest s e
UpdateWindow WindowRequest
req)
toParentReq WidgetId
_ (SetWidgetPath WidgetId
wid Path
path) = forall a. a -> Maybe a
Just (forall s e. WidgetId -> Path -> WidgetRequest s e
SetWidgetPath WidgetId
wid Path
path)
toParentReq WidgetId
_ (ResetWidgetPath WidgetId
wid) = forall a. a -> Maybe a
Just (forall s e. WidgetId -> WidgetRequest s e
ResetWidgetPath WidgetId
wid)
toParentReq WidgetId
wid (UpdateModel s -> s
fn) = forall a. a -> Maybe a
Just (forall s e i. Typeable i => WidgetId -> i -> WidgetRequest s e
SendMessage WidgetId
wid (forall s. CompositeModel s => (s -> s) -> CompMsgUpdate
CompMsgUpdate s -> s
fn))
toParentReq WidgetId
wid (RaiseEvent e
message) = forall a. a -> Maybe a
Just (forall s e i. Typeable i => WidgetId -> i -> WidgetRequest s e
SendMessage WidgetId
wid e
message)
toParentReq WidgetId
_ (SendMessage WidgetId
wid i
message) = forall a. a -> Maybe a
Just (forall s e i. Typeable i => WidgetId -> i -> WidgetRequest s e
SendMessage WidgetId
wid i
message)
toParentReq WidgetId
_ (RunTask WidgetId
wid Path
path IO i
action) = forall a. a -> Maybe a
Just (forall s e i.
Typeable i =>
WidgetId -> Path -> IO i -> WidgetRequest s e
RunTask WidgetId
wid Path
path IO i
action)
toParentReq WidgetId
_ (RunProducer WidgetId
wid Path
path (i -> IO ()) -> IO ()
action) = forall a. a -> Maybe a
Just (forall s e i.
Typeable i =>
WidgetId -> Path -> ((i -> IO ()) -> IO ()) -> WidgetRequest s e
RunProducer WidgetId
wid Path
path (i -> IO ()) -> IO ()
action)
toParentReq WidgetId
_ (RunInRenderThread WidgetId
wid Path
path IO i
action) = forall a. a -> Maybe a
Just (forall s e i.
Typeable i =>
WidgetId -> Path -> IO i -> WidgetRequest s e
RunInRenderThread WidgetId
wid Path
path IO i
action)

collectWidgetKeys
  :: Map WidgetKey (WidgetNode s e)
  -> WidgetNode s e
  -> Map WidgetKey (WidgetNode s e)
collectWidgetKeys :: forall s e.
Map WidgetKey (WidgetNode s e)
-> WidgetNode s e -> Map WidgetKey (WidgetNode s e)
collectWidgetKeys Map WidgetKey (WidgetNode s e)
keys WidgetNode s e
node = Map WidgetKey (WidgetNode s e)
newMap where
  children :: Seq (WidgetNode s e)
children = WidgetNode s e
node forall s a. s -> Getting a s a -> a
^. forall s a. HasChildren s a => Lens' s a
L.children
  collect :: Map WidgetKey (WidgetNode s e)
-> WidgetNode s e -> Map WidgetKey (WidgetNode s e)
collect Map WidgetKey (WidgetNode s e)
currKeys WidgetNode s e
child = forall s e.
Map WidgetKey (WidgetNode s e)
-> WidgetNode s e -> Map WidgetKey (WidgetNode s e)
collectWidgetKeys Map WidgetKey (WidgetNode s e)
currKeys WidgetNode s e
child
  updatedMap :: Map WidgetKey (WidgetNode s e)
updatedMap = case WidgetNode s e
node forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasKey s a => Lens' s a
L.key of
    Just WidgetKey
key -> forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert WidgetKey
key WidgetNode s e
node Map WidgetKey (WidgetNode s e)
keys
    Maybe WidgetKey
_ -> Map WidgetKey (WidgetNode s e)
keys
  newMap :: Map WidgetKey (WidgetNode s e)
newMap = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' forall s e.
Map WidgetKey (WidgetNode s e)
-> WidgetNode s e -> Map WidgetKey (WidgetNode s e)
collect Map WidgetKey (WidgetNode s e)
updatedMap Seq (WidgetNode s e)
children

convertWidgetEnv :: WidgetEnv sp ep -> WidgetKeyMap s e -> s -> WidgetEnv s e
convertWidgetEnv :: forall sp ep s e.
WidgetEnv sp ep -> WidgetKeyMap s e -> s -> WidgetEnv s e
convertWidgetEnv WidgetEnv sp ep
wenv WidgetKeyMap s e
widgetKeyMap s
model = WidgetEnv {
  _weOs :: Text
_weOs = forall s e. WidgetEnv s e -> Text
_weOs WidgetEnv sp ep
wenv,
  _weDpr :: Double
_weDpr = forall s e. WidgetEnv s e -> Double
_weDpr WidgetEnv sp ep
wenv,
  _weAppStartTs :: Millisecond
_weAppStartTs = forall s e. WidgetEnv s e -> Millisecond
_weAppStartTs WidgetEnv sp ep
wenv,
  _weFontManager :: FontManager
_weFontManager = forall s e. WidgetEnv s e -> FontManager
_weFontManager WidgetEnv sp ep
wenv,
  _weFindBranchByPath :: Path -> Seq WidgetNodeInfo
_weFindBranchByPath = forall s e. WidgetEnv s e -> Path -> Seq WidgetNodeInfo
_weFindBranchByPath WidgetEnv sp ep
wenv,
  _weMainButton :: Button
_weMainButton = forall s e. WidgetEnv s e -> Button
_weMainButton WidgetEnv sp ep
wenv,
  _weContextButton :: Button
_weContextButton = forall s e. WidgetEnv s e -> Button
_weContextButton WidgetEnv sp ep
wenv,
  _weTheme :: Theme
_weTheme = forall s e. WidgetEnv s e -> Theme
_weTheme WidgetEnv sp ep
wenv,
  _weWindowSize :: Size
_weWindowSize = forall s e. WidgetEnv s e -> Size
_weWindowSize WidgetEnv sp ep
wenv,
  _weWidgetShared :: MVar (Map Text WidgetShared)
_weWidgetShared = forall s e. WidgetEnv s e -> MVar (Map Text WidgetShared)
_weWidgetShared WidgetEnv sp ep
wenv,
  _weWidgetKeyMap :: WidgetKeyMap s e
_weWidgetKeyMap = WidgetKeyMap s e
widgetKeyMap,
  _weCursor :: Maybe (Path, CursorIcon)
_weCursor = forall s e. WidgetEnv s e -> Maybe (Path, CursorIcon)
_weCursor WidgetEnv sp ep
wenv,
  _weHoveredPath :: Maybe Path
_weHoveredPath = forall s e. WidgetEnv s e -> Maybe Path
_weHoveredPath WidgetEnv sp ep
wenv,
  _weFocusedPath :: Path
_weFocusedPath = forall s e. WidgetEnv s e -> Path
_weFocusedPath WidgetEnv sp ep
wenv,
  _weDragStatus :: Maybe (Path, WidgetDragMsg)
_weDragStatus = forall s e. WidgetEnv s e -> Maybe (Path, WidgetDragMsg)
_weDragStatus WidgetEnv sp ep
wenv,
  _weMainBtnPress :: Maybe (Path, Point)
_weMainBtnPress = forall s e. WidgetEnv s e -> Maybe (Path, Point)
_weMainBtnPress WidgetEnv sp ep
wenv,
  _weOverlayPath :: Maybe Path
_weOverlayPath = forall s e. WidgetEnv s e -> Maybe Path
_weOverlayPath WidgetEnv sp ep
wenv,
  _weModel :: s
_weModel = s
model,
  _weInputStatus :: InputStatus
_weInputStatus = forall s e. WidgetEnv s e -> InputStatus
_weInputStatus WidgetEnv sp ep
wenv,
  _weTimestamp :: Millisecond
_weTimestamp = forall s e. WidgetEnv s e -> Millisecond
_weTimestamp WidgetEnv sp ep
wenv,
  _weThemeChanged :: Bool
_weThemeChanged = forall s e. WidgetEnv s e -> Bool
_weThemeChanged WidgetEnv sp ep
wenv,
  _weInTopLayer :: Point -> Bool
_weInTopLayer = forall s e. WidgetEnv s e -> Point -> Bool
_weInTopLayer WidgetEnv sp ep
wenv,
  _weLayoutDirection :: LayoutDirection
_weLayoutDirection = LayoutDirection
LayoutNone,
  _weViewport :: Rect
_weViewport = forall s e. WidgetEnv s e -> Rect
_weViewport WidgetEnv sp ep
wenv,
  _weOffset :: Point
_weOffset = forall s e. WidgetEnv s e -> Point
_weOffset WidgetEnv sp ep
wenv
}

cascadeCtx
  :: WidgetEnv sp ep -> WidgetNode sp ep -> WidgetNode s e -> WidgetNode s e
cascadeCtx :: forall sp ep s e.
WidgetEnv sp ep
-> WidgetNode sp ep -> WidgetNode s e -> WidgetNode s e
cascadeCtx WidgetEnv sp ep
wenv WidgetNode sp ep
parent WidgetNode s e
child = WidgetNode s e
newChild where
  pVisible :: Bool
pVisible = WidgetNode sp ep
parent forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasVisible s a => Lens' s a
L.visible
  pEnabled :: Bool
pEnabled = WidgetNode sp ep
parent forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasEnabled s a => Lens' s a
L.enabled
  cVisible :: Bool
cVisible = WidgetNode s e
child forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasVisible s a => Lens' s a
L.visible
  cEnabled :: Bool
cEnabled = WidgetNode s e
child forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasEnabled s a => Lens' s a
L.enabled
  newPath :: Path
newPath = WidgetNode sp ep
parent forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasPath s a => Lens' s a
L.path forall a. Seq a -> a -> Seq a
|> PathStep
0
  newChild :: WidgetNode s e
newChild = WidgetNode s e
child
    forall a b. a -> (a -> b) -> b
& forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasWidgetId s a => Lens' s a
L.widgetId forall s t a b. ASetter s t a b -> b -> s -> t
.~ Millisecond -> Path -> WidgetId
WidgetId (WidgetEnv sp ep
wenv forall s a. s -> Getting a s a -> a
^. forall s a. HasTimestamp s a => Lens' s a
L.timestamp) Path
newPath
    forall a b. a -> (a -> b) -> b
& forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasPath s a => Lens' s a
L.path forall s t a b. ASetter s t a b -> b -> s -> t
.~ Path
newPath
    forall a b. a -> (a -> b) -> b
& forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasVisible s a => Lens' s a
L.visible forall s t a b. ASetter s t a b -> b -> s -> t
.~ (Bool
cVisible Bool -> Bool -> Bool
&& Bool
pVisible)
    forall a b. a -> (a -> b) -> b
& forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasEnabled s a => Lens' s a
L.enabled forall s t a b. ASetter s t a b -> b -> s -> t
.~ (Bool
cEnabled Bool -> Bool -> Bool
&& Bool
pEnabled)

lookupNode :: WidgetKeyMap s e -> String -> WidgetKey -> Maybe (WidgetNode s e)
lookupNode :: forall s e.
WidgetKeyMap s e -> String -> WidgetKey -> Maybe (WidgetNode s e)
lookupNode WidgetKeyMap s e
widgetKeys String
desc WidgetKey
key = case forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup WidgetKey
key WidgetKeyMap s e
widgetKeys of
  Maybe (WidgetNode s e)
Nothing -> forall a. String -> a -> a
trace (String
"Key " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show WidgetKey
key forall a. [a] -> [a] -> [a]
++ String
" not found for " forall a. [a] -> [a] -> [a]
++ String
desc) forall a. Maybe a
Nothing
  Maybe (WidgetNode s e)
res -> Maybe (WidgetNode s e)
res

sendMsgTo :: Typeable i => WidgetNode s e -> i -> WidgetRequest sp ep
sendMsgTo :: forall i s e sp ep.
Typeable i =>
WidgetNode s e -> i -> WidgetRequest sp ep
sendMsgTo WidgetNode s e
node i
msg = forall s e i. Typeable i => WidgetId -> i -> WidgetRequest s e
SendMessage (WidgetNode s e
node forall s a. s -> Getting a s a -> a
^. forall s a. HasInfo s a => Lens' s a
L.info forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. HasWidgetId s a => Lens' s a
L.widgetId) i
msg