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

widgetControl :: forall control a control. Lens (GenericWidget control a) (GenericWidget control a) control control

widgetTidings :: forall control a a. Lens (GenericWidget control a) (GenericWidget control a) (Tidings a) (Tidings a)

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

Lift an HTML element into a vacuous editor.

newtype Editor a el b

A function from Behavior a to GenericWidget b 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.

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

editorFactoryElement :: Setter (Editor a el b) (Editor a el' b) el el'

A Setter over the element of the editor being built

editorFactoryInput :: Setter (Editor a el b) (Editor a' el b) a' a

A Setter over the input thing

editorFactoryOutput :: Setter (Editor a el b) (Editor a el b') b b'

A Setter over the output thing

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

Focus the editor on the field retrieved by the getter. Use when composing editors via the Biapplicative interface

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.