Graphics.UI.Threepenny.Editors

Editors

data Editor editorElement a

A widget for editing values of type a.

Constructors

Editor

Fields

• _editorTidings :: Tidings a
• _editorElement :: editorElement

Instances

Bifunctor Editor

Methods

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

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

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

Functor (Editor editorElement)

Methods

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

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

Widget el => Widget (Editor el a)

Methods

getElement :: Editor el a -> Element

edited :: Editor el a -> Event a

contents :: Editor el a -> Behavior a

editorElement :: Lens (Editor el a) (Editor el' a) el el'

A lens over the editorElement field

Editor factories

data EditorFactory a el b

A function from Behavior a to Editor b All the three type arguments are functorial, but a is contravariant. EditorFactory is a Biapplicative functor on el and b, and a Profunctor on a and b.

Instances

Bifunctor (EditorFactory a)

Methods

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

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

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

Biapplicative (EditorFactory a)

Methods

bipure :: a -> b -> EditorFactory a a b

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

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

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

Functor (EditorFactory a el)

Methods

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

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

Monoid el => Applicative (EditorFactory a el)

Methods

pure :: a -> EditorFactory a el a

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

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

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

someEditor :: Editable a => EditorFactory a Layout a

A version of editor with a concealed widget type.

createEditor :: Renderable w => EditorFactory a w b -> Behavior a -> UI (Editor Element b)

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

class Renderable (EditorWidget a) => Editable a where

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

Associated Types

type EditorWidget a

Methods

editor :: EditorFactory a (EditorWidget a) a

The editor factory

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

The editor factory

Instances

Editable Bool

Associated Types

type EditorWidget Bool :: *

Methods

editor :: EditorFactory Bool (EditorWidget Bool) Bool

Editable Double

Associated Types

type EditorWidget Double :: *

Methods

editor :: EditorFactory Double (EditorWidget Double) Double

Editable Int

Associated Types

type EditorWidget Int :: *

Methods

editor :: EditorFactory Int (EditorWidget Int) Int

Editable ()

Associated Types

type EditorWidget () :: *

Methods

editor :: EditorFactory () (EditorWidget ()) ()

(~) * a Char => Editable [a]

Associated Types

type EditorWidget [a] :: *

Methods

editor :: EditorFactory [a] (EditorWidget [a]) [a]

Editable (Maybe Double)

Associated Types

type EditorWidget (Maybe Double) :: *

Methods

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

Editable (Maybe Int)

Associated Types

type EditorWidget (Maybe Int) :: *

Methods

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

Editable a => Editable (Identity a)

Associated Types

type EditorWidget (Identity a) :: *

Methods

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

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

Associated Types

type EditorWidget (a, b) :: *

Methods

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

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

Tuple editor without fields

Associated Types

type EditorWidget (NP * I xs) :: *

Methods

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

data EditorWidgetFor a where

A container for EditorWidget.

Constructors

EditorWidgetFor :: Editable a => EditorWidget a -> EditorWidgetFor a

type family Field (usage :: Usage) a where ...

Type level fields. Use this helper to define EditorWidget types. Example:

data PersonF (usage :: Usage) = Person
  { education           :: Field usage Education
  , firstName, lastName :: Field usage String
  , age                 :: Field usage (Maybe Int)

type Person = PersonF Value
type PersonEditor = PersonF Edit

Equations

Field Value a = a

Field Edit a = EditorWidget a

data Usage

Usage is a kind for type level Fields

Constructors

Value

Edit

Editor composition

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

Left-right editor composition

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

Left-right composition of an editorElement with a editor

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

Left-right composition of an editorElement with a editor

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

Left-right editor composition

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

Left-right composition of an editorElement with a editor

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

Left-right composition of an editorElement with a editor

field :: Renderable m => String -> (out -> inn) -> EditorFactory inn m a -> EditorFactory 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) -> EditorFactory inn m a -> EditorFactory 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.

pattern Horizontally :: forall a b. EditorFactory a Layout b -> EditorFactory 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. EditorFactory a Layout b -> EditorFactory 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

Editor layout

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

Apply a layout builder.

withSomeWidget :: Renderable w => EditorFactory a w b -> EditorFactory a Layout b

Conceal the widget type of some Editor

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

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

Editor constructors

editorUnit :: EditorFactory b Element b

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

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

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

editorSelection :: Ord a => Behavior [a] -> Behavior (a -> UI Element) -> EditorFactory (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, EditorFactory a el a)] -> (a -> tag) -> EditorFactory a Layout a

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

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

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 Layout a

A generic editor for SOP types.

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

A generic editor for record types.

Layouts

data Layout

Instances

Renderable Layout

Methods

render :: Layout -> UI Element

getLayout :: Layout -> Layout

above :: Layout -> Layout -> Layout

beside :: Layout -> Layout -> Layout

Monoidal layouts

newtype Vertical

A layout monoid that places everything in a single column

Constructors

Vertical

Fields

• getVertical :: Layout

Instances

Monoid Vertical

Methods

mempty :: Vertical

mappend :: Vertical -> Vertical -> Vertical

mconcat :: [Vertical] -> Vertical

Renderable Vertical

Methods

render :: Vertical -> UI Element

getLayout :: Vertical -> Layout

newtype Horizontal

A layout monoid that places everything in a single row

Constructors

Horizontal

Fields

• getHorizontal :: Layout

Instances

Monoid Horizontal

Methods

mempty :: Horizontal

mappend :: Horizontal -> Horizontal -> Horizontal

mconcat :: [Horizontal] -> Horizontal

Renderable Horizontal

Methods

render :: Horizontal -> UI Element

getLayout :: Horizontal -> Layout

data Columns

A layout monoid that lays elements in columns

Constructors

Next Layout

Continue in the same column

Break Layout

Continue in the next column

Instances

Show Columns

Methods

showsPrec :: Int -> Columns -> ShowS

show :: Columns -> String

showList :: [Columns] -> ShowS

Monoid Columns

Methods

mempty :: Columns

mappend :: Columns -> Columns -> Columns

mconcat :: [Columns] -> Columns

Renderable Columns

Methods

render :: Columns -> UI Element

getLayout :: Columns -> Layout

Type level layouts

data a |*| b

Type level Horizontal layouts

Constructors

a :|*| b

Instances

Bifunctor (|*|)

Methods

bimap :: (a -> b) -> (c -> d) -> (a |*| c) -> b |*| d

first :: (a -> b) -> (a |*| c) -> b |*| c

second :: (b -> c) -> (a |*| b) -> a |*| c

Biapplicative (|*|)

Methods

bipure :: a -> b -> a |*| b

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

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

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

Bifoldable (|*|)

Methods

bifold :: Monoid m => (m |*| m) -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> (a |*| b) -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> (a |*| b) -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> (a |*| b) -> c

(Renderable a, Renderable b) => Renderable ((|*|) a b)

Methods

render :: (a |*| b) -> UI Element

getLayout :: (a |*| b) -> Layout

data a -*- b

Type level Vertical layouts

Constructors

a :-*- b

Instances

Bifunctor (-*-)

Methods

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

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

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

Biapplicative (-*-)

Methods

bipure :: a -> b -> a -*- b

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

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

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

Bifoldable (-*-)

Methods

bifold :: Monoid m => (m -*- m) -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> (a -*- b) -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> (a -*- b) -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> (a -*- b) -> c

(Renderable a, Renderable b) => Renderable ((-*-) a b)

Methods

render :: (a -*- b) -> UI Element

getLayout :: (a -*- b) -> Layout

Layout manipulation

class Renderable w where

Closely related to Widget, this class represents types that can be rendered to an Element

Methods

render :: w -> UI Element

getLayout :: w -> Layout

Instances

Renderable String

Methods

render :: String -> UI Element

getLayout :: String -> Layout

Renderable TextEntry

Methods

render :: TextEntry -> UI Element

getLayout :: TextEntry -> Layout

Renderable Element

Methods

render :: Element -> UI Element

getLayout :: Element -> Layout

Renderable Columns

Methods

render :: Columns -> UI Element

getLayout :: Columns -> Layout

Renderable Horizontal

Methods

render :: Horizontal -> UI Element

getLayout :: Horizontal -> Layout

Renderable Vertical

Methods

render :: Vertical -> UI Element

getLayout :: Vertical -> Layout

Renderable Layout

Methods

render :: Layout -> UI Element

getLayout :: Layout -> Layout

Renderable (ListBox a)

Methods

render :: ListBox a -> UI Element

getLayout :: ListBox a -> Layout

Renderable a => Renderable (UI a)

Methods

render :: UI a -> UI Element

getLayout :: UI a -> Layout

(Renderable a, Renderable b) => Renderable ((-*-) a b)

Methods

render :: (a -*- b) -> UI Element

getLayout :: (a -*- b) -> Layout

(Renderable a, Renderable b) => Renderable ((|*|) a b)

Methods

render :: (a |*| b) -> UI Element

getLayout :: (a |*| b) -> Layout

Orphan instances

(Applicative f, All * Default xs) => Default (NP * f xs)

Methods

def :: NP * f xs