Safe Haskell	None
Language	Haskell2010

Graphics.UI.Threepenny.Editors.Types

Contents

GenericWidgets
Editors

Synopsis

GenericWidgets

data GenericWidget control a #

Constructors

GenericWidget
Fields widgetTidings :: Tidings a The dynamic contents of the widget. widgetControl :: control The actual widget.

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 #

Editors

newtype Editor outer widget inner #

An editor for values of type inner inside a datatype outer realized by a widget.

All the three type arguments are functorial, but outer is contravariant, so Editor is a Biapplicative functor and a Profunctor (via dimapE).

Biapplicative allows to compose editors on both their widget and inner structure. When widget is monoidal, widget composition is implicit and Applicative suffices.

Profunctor allows to apply an inner editor to an outer datatype.

Once created, an Editor yields a tuple of an widget and a Tidings inner which can be integrated in a threepenny app.

Constructors

Editor
Fields create :: Behavior outer -> UI (GenericWidget widget inner)

Bundled Patterns

pattern Horizontally :: 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 :: 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

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 # liftA2 :: (a -> b -> c) -> Editor a el a -> Editor a el b -> Editor a el c # (>) :: Editor a el a -> Editor a el b -> Editor a el b # (<*) :: Editor a el a -> Editor a el b -> Editor a el a #

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

Lift an HTML element into a vacuous editor.

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

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

Editor 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 and an 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 and an editor horizontally, wrapped in the given monoidal layout builder.

Editor constructors

editorUnit :: Editor b Element b #

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

editorString :: Editor String TextEntry String #

editorText :: Editor Text TextEntry Text #

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

data EditorCollection k w #

Constructors

EditorCollection
Fields selector :: ListBox k add, remove :: Element selected :: w

Instances

Renderable w => Renderable (EditorCollection k w) #
Methods render :: EditorCollection k w -> UI Element # getLayout :: EditorCollection k w -> Layout #

editorCollection :: forall k v w. (Ord k, Renderable w) => (Behavior (Maybe k, Map k v) -> EditorCollectionConfig k v) -> Editor v w v -> Editor (Maybe k, Map k v) (EditorCollection k w) (Maybe k, Map k v) #

A barebones editor for collections of editable items. Displays an index selector, add and delete buttons, and an editor for the selected item. Limitations: - Won't work with recursive data structures, due to the lack of FRP switch.

editorList :: (HasEmpty a, Renderable w) => Editor a w a -> Editor (Maybe Int, [a]) (EditorCollection Int w) (Maybe Int, [a]) #

A barebones editor for collections of editable items. Displays an index selector, add and delete buttons, and an editor for the selected item. Limitations: - Won't work with recursive data structures, due to the lack of FRP switch.

data EditorCollectionConfig k v #

Constructors

EditorCollectionConfig
Fields eccNewKey :: Behavior k Current value to use for creating a new key eccAfterDelKey :: Behavior (Maybe k) Current value to use if the selected key is deleted eccTemplate :: v Value to use for creating new items eccOptions :: Behavior (Set k) Currently user select able keys eccDisplay :: Behavior (k -> UI Element) How to render a key

defaultEditorCollectionConfig :: (Enum k, Ord k, Show k, HasEmpty v) => Behavior (Maybe k, Map k v) -> EditorCollectionConfig k v #

Representation of empty values

class HasEmpty a where #

This class defines how to represent empty values in a UI. A generic derivation is available for every SOP type.

Methods

emptyValue :: a #

emptyValue :: (Generic a, HasEmptyCode (Code a), All HasEmpty (Head (Code a))) => a #

Instances

HasEmpty Bool #
Methods emptyValue :: Bool #
HasEmpty Char #
Methods emptyValue :: Char #
HasEmpty Double #
Methods emptyValue :: Double #
HasEmpty Int #
Methods emptyValue :: Int #
HasEmpty () #
Methods emptyValue :: () #
HasEmpty Text #
Methods emptyValue :: Text #
HasEmpty [a] #
Methods emptyValue :: [a] #
HasEmpty (Maybe a) #
Methods emptyValue :: Maybe a #
HasEmpty a => HasEmpty (Identity a) #
Methods emptyValue :: Identity a #
HasEmpty (Seq k) #
Methods emptyValue :: Seq k #
Ord k => HasEmpty (Set k) #
Methods emptyValue :: Set k #
(HasEmpty a, HasEmpty b) => HasEmpty (a, b) #
Methods emptyValue :: (a, b) #
Ord k => HasEmpty (Map k v) #
Methods emptyValue :: Map k v #
(HasEmpty a, HasEmpty b) => HasEmpty ((-*-) a b) #
Methods emptyValue :: a -*- b #
(HasEmpty a, HasEmpty b) => HasEmpty ((\|*\|) a b) #
Methods emptyValue :: a \|*\| b #