Graphics.UI.Threepenny.Editors.Types

GenericWidgets

data GenericWidget control a

A widget for editing values of type a.

Constructors

GenericWidget

Fields

• widgetTidings :: Tidings a
• widgetControl :: control

Instances

Bifunctor GenericWidget

Methods

bimap :: (a -> b) -> (c -> d) -> GenericWidget a c -> GenericWidget b d

first :: (a -> b) -> GenericWidget a c -> GenericWidget b c

second :: (b -> c) -> GenericWidget a b -> GenericWidget a c

Functor (GenericWidget control)

Methods

fmap :: (a -> b) -> GenericWidget control a -> GenericWidget control b

(<$) :: a -> GenericWidget control b -> GenericWidget control a

Widget el => Widget (GenericWidget el a)

Methods

getElement :: GenericWidget el a -> Element

Renderable el => Renderable (GenericWidget el a)

Methods

render :: GenericWidget el a -> UI Element

getLayout :: GenericWidget el a -> Layout

edited :: GenericWidget el a -> Event a

contents :: GenericWidget el a -> Behavior a

liftElement :: UI el -> Editor a el ()

Lift an HTML element into a vacuous editor.

newtype Editor a el b

A widget el for editing b values while displaying a values. For obvious reasons, a and b are usually the same type, except while composing editors. All the three type arguments are functorial, but a is contravariant. Editor is a Biapplicative functor on el and b, and a Profunctor on a and b.

Editors compose using the Applicative interface when el is monoidal or more generally with the Biapplicative interface. In both cases the Profunctor lmap is used to select the value to display.

For an example of the Applicative interface, let's assemble the editor for a tuple of values:

editorTuple = (,) <$> lmap fst editable <*> lmap snd editable

Constructors

Editor

Fields

• create :: Behavior a -> UI (GenericWidget el b)

  Create an editor to display the argument. User edits are fed back via the edited Event.

Instances

Bifunctor (Editor a)

Methods

bimap :: (a -> b) -> (c -> d) -> Editor a a c -> Editor a b d

first :: (a -> b) -> Editor a a c -> Editor a b c

second :: (b -> c) -> Editor a a b -> Editor a a c

Biapplicative (Editor a)

Methods

bipure :: a -> b -> Editor a a b

(<<*>>) :: Editor a (a -> b) (c -> d) -> Editor a a c -> Editor a b d

(*>>) :: Editor a a b -> Editor a c d -> Editor a c d

(<<*) :: Editor a a b -> Editor a c d -> Editor a a b

Functor (Editor a el)

Methods

fmap :: (a -> b) -> Editor a el a -> Editor a el b

(<$) :: a -> Editor a el b -> Editor a el a

Monoid el => Applicative (Editor a el)

Methods

pure :: a -> Editor a el a

(<*>) :: Editor a el (a -> b) -> Editor a el a -> Editor a el b

(*>) :: Editor a el a -> Editor a el b -> Editor a el b

(<*) :: Editor a el a -> Editor a el b -> Editor a el a

dimapE :: (a' -> a) -> (b -> b') -> Editor a el b -> Editor a' el b'

lmapE :: (a' -> a) -> Editor a el b -> Editor a' el b

Applies a function over the input

applyE :: (el1 -> el2 -> el) -> Editor in_ el1 (a -> b) -> Editor in_ el2 a -> Editor in_ el b

GenericWidget composition

(|*|) :: Editor s Layout (b -> a) -> Editor s Layout b -> Editor s Layout a infixl 4

Left-right editor composition

(|*) :: Editor s Layout a -> UI Element -> Editor s Layout a infixl 5

Left-right composition of an element with a editor

(*|) :: UI Element -> Editor s Layout a -> Editor s Layout a infixl 5

Left-right composition of an element with a editor

(-*-) :: Editor s Layout (b -> a) -> Editor s Layout b -> Editor s Layout a infixl 4

Left-right editor composition

(-*) :: Editor s Layout a -> UI Element -> Editor s Layout a infixl 5

Left-right composition of an element with a editor

(*-) :: UI Element -> Editor s Layout a -> Editor s Layout a infixl 5

Left-right composition of an element with a editor

field :: Renderable m => String -> (out -> inn) -> Editor inn m a -> Editor out Layout a

A helper that arranges a label with the field name and the editor horizontally.

fieldLayout :: (Renderable m, Renderable m') => (Layout -> m') -> String -> (out -> inn) -> Editor inn m a -> Editor out m' a

A helper that arranges a label with the field name and the editor horizontally. This version takes a Layout builder as well.

edit :: (a' -> a) -> Editor a el b -> Editor a' el b

Use when composing Biapplicative editors to focus on a field.

personEditor :: Editor Person PersonEditor Person
personEditor =
    bipure Person Person
      <<*>> edit education editor
      <<*>> edit firstName editor
      <<*>> edit lastName  editor

pattern Horizontally :: forall a b. Editor a Layout b -> Editor a Horizontal b

Applicative modifier for horizontal composition of editor factories. This can be used in conjunction with ApplicativeDo as:

editorPerson = horizontally $ do
      firstName <- Horizontally $ field "First:" firstName editor
      lastName  <- Horizontally $ field "Last:"  lastName editor
      age       <- Horizontally $ field "Age:"   age editor
      return Person{..}

DEPRECATED: Use the Horizontal layout builder instead

pattern Vertically :: forall a b. Editor a Layout b -> Editor a Vertical b

Applicative modifier for vertical composition of editor factories. This can be used in conjunction with ApplicativeDo as:

editorPerson = vertically $ do
      firstName <- Vertically $ field "First:" firstName editor
      lastName  <- Vertically $ field "Last:"  lastName editor
      age       <- Vertically $ field "Age:"   age editor
      return Person{..}

DEPRECATED: Use the Vertical layout builder instead

GenericWidget constructors

editorUnit :: Editor b Element b

editorIdentity :: Editor a el a -> Editor (Identity a) el (Identity a)

editorString :: Editor String TextEntry String

editorCheckBox :: Editor Bool Element Bool

editorReadShow :: (Read a, Show a) => Editor (Maybe a) TextEntry (Maybe a)

editorEnumBounded :: (Bounded a, Enum a, Ord a, Show a) => Behavior (a -> UI Element) -> Editor (Maybe a) (ListBox a) (Maybe a)

editorSelection :: Ord a => Behavior [a] -> Behavior (a -> UI Element) -> Editor (Maybe a) (ListBox a) (Maybe a)

An editor that presents a dynamic choice of values.

editorSum :: (Ord tag, Show tag, Renderable el) => (Layout -> Layout -> Layout) -> [(tag, Editor a el a)] -> (a -> tag) -> Editor a Layout a

An editor for union types, built from editors for its constructors.

editorJust :: Editor (Maybe b) el (Maybe b) -> Editor b el b

Ignores Nothing values and only updates for Just values

GenericWidget layout

withLayout :: (layout -> layout') -> Editor a layout b -> Editor a layout' b

Apply a layout builder.

construct :: Renderable m => Editor a m b -> Editor a Layout b

Construct a concrete Layout. Useful when combining heterogeneours layout builders.