Graphics.UI.Threepenny.Editors

Editors

data Editor a

A widget for editing values of type a.

Constructors

Editor

Fields

• editorTidings :: Tidings a
• editorElement :: Element

Instances

Functor Editor

Methods

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

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

Widget (Editor a)

Methods

getElement :: Editor a -> Element

edited :: Editor a -> Event a

contents :: Editor a -> Behavior a

data EditorFactory a b

A function from Behavior a to Editor a

Instances

Profunctor EditorFactory

Methods

dimap :: (a -> b) -> (c -> d) -> EditorFactory b c -> EditorFactory a d

lmap :: (a -> b) -> EditorFactory b c -> EditorFactory a c

rmap :: (b -> c) -> EditorFactory a b -> EditorFactory a c

(#.) :: Coercible * c b => (b -> c) -> EditorFactory a b -> EditorFactory a c

(.#) :: Coercible * b a => EditorFactory b c -> (a -> b) -> EditorFactory a c

Functor (EditorFactory a)

Methods

fmap :: (a -> b) -> EditorFactory a a -> EditorFactory a b

(<$) :: a -> EditorFactory a b -> EditorFactory a a

createEditor :: EditorFactory b a -> Behavior b -> UI (Editor a)

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

class Editable a where

The class of Editable datatypes. . Define your own instance by using the Applicative composition operators or derive it via SOP.

Methods

editor :: EditorFactory a a

editor :: (Generic a, HasDatatypeInfo a, All (All Editable `And` All Default) (Code a)) => EditorFactory a a

Instances

Editable Bool

Methods

editor :: EditorFactory Bool Bool

Editable Double

Methods

editor :: EditorFactory Double Double

Editable Int

Methods

editor :: EditorFactory Int Int

Editable ()

Methods

editor :: EditorFactory () ()

Editable String

Methods

editor :: EditorFactory String String

Editable (Maybe Double)

Methods

editor :: EditorFactory (Maybe Double) (Maybe Double)

Editable (Maybe Int)

Methods

editor :: EditorFactory (Maybe Int) (Maybe Int)

Editable a => Editable (Identity a)

Methods

editor :: EditorFactory (Identity a) (Identity a)

(Editable a, Editable b) => Editable (a, b)

Methods

editor :: EditorFactory (a, b) (a, b)

All * Editable xs => Editable (NP * I xs)

Tuple editor without fields

Methods

editor :: EditorFactory (NP * I xs) (NP * I xs)

Editor composition

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

Horizontal applicative composition.

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

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

(-*-) :: EditorFactory s (b -> a) -> EditorFactory s b -> EditorFactory s a infixl 4

Vertical applicative composition.

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

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

field :: String -> (out -> inn) -> EditorFactory inn a -> EditorFactory out a

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

newtype Vertically a b

Applicative instance 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{..}

Constructors

Vertically

Fields

• vertically :: EditorFactory a b

Instances

Profunctor Vertically

Methods

dimap :: (a -> b) -> (c -> d) -> Vertically b c -> Vertically a d

lmap :: (a -> b) -> Vertically b c -> Vertically a c

rmap :: (b -> c) -> Vertically a b -> Vertically a c

(#.) :: Coercible * c b => (b -> c) -> Vertically a b -> Vertically a c

(.#) :: Coercible * b a => Vertically b c -> (a -> b) -> Vertically a c

Functor (Vertically a)

Methods

fmap :: (a -> b) -> Vertically a a -> Vertically a b

(<$) :: a -> Vertically a b -> Vertically a a

Applicative (Vertically a)

Methods

pure :: a -> Vertically a a

(<*>) :: Vertically a (a -> b) -> Vertically a a -> Vertically a b

(*>) :: Vertically a a -> Vertically a b -> Vertically a b

(<*) :: Vertically a a -> Vertically a b -> Vertically a a

newtype Horizontally a b

Applicative instance 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{..}

Constructors

Horizontally

Fields

• horizontally :: EditorFactory a b

Instances

Profunctor Horizontally

Methods

dimap :: (a -> b) -> (c -> d) -> Horizontally b c -> Horizontally a d

lmap :: (a -> b) -> Horizontally b c -> Horizontally a c

rmap :: (b -> c) -> Horizontally a b -> Horizontally a c

(#.) :: Coercible * c b => (b -> c) -> Horizontally a b -> Horizontally a c

(.#) :: Coercible * b a => Horizontally b c -> (a -> b) -> Horizontally a c

Functor (Horizontally a)

Methods

fmap :: (a -> b) -> Horizontally a a -> Horizontally a b

(<$) :: a -> Horizontally a b -> Horizontally a a

Applicative (Horizontally a)

Methods

pure :: a -> Horizontally a a

(<*>) :: Horizontally a (a -> b) -> Horizontally a a -> Horizontally a b

(*>) :: Horizontally a a -> Horizontally a b -> Horizontally a b

(<*) :: Horizontally a a -> Horizontally a b -> Horizontally a a

Editor constructors

editorUnit :: EditorFactory a ()

editorIdentity :: EditorFactory a a -> EditorFactory (Identity a) (Identity a)

editorReadShow :: (Read a, Show a) => EditorFactory (Maybe a) (Maybe a)

An editor that presents a free form input.

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

An editor that presents a choice of values.

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

An editor that presents a dynamic choice of values.

editorSum :: (Show tag, Ord tag) => (Layout -> Layout -> Layout) -> [(tag, EditorFactory b b)] -> (b -> tag) -> EditorFactory b b

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

editorJust :: EditorFactory (Maybe a) (Maybe a) -> EditorFactory a a

Ignores Nothing values and only updates for Just values

Generic editors

editorGeneric :: forall a. (Generic a, HasDatatypeInfo a, All (All Editable `And` All Default) (Code a)) => EditorFactory a a

A generic editor for SOP types.

editorGenericSimple :: forall a xs. (Generic a, HasDatatypeInfo a, All Editable xs, Code a ~ '[xs]) => EditorFactory a a

A generic editor for record types.

Layouts

newtype Layout

Constructors

Grid (Seq (Seq (Maybe Element)))

A non empty list of rows, where all the rows are assumed to have the same length

horizontal :: Layout -> Layout -> Layout

vertical :: Layout -> Layout -> Layout