FRP.UISF.UIMonad

A simple Graphical User Interface with concepts borrowed from Phooey by Conal Elliot.

UI Type Definition

newtype UI a

A UI widget runs under a given context and any focus information from earlier widgets and maps input signals to outputs, which consists of 6 parts:

• its layout,
• whether the widget needs to be redrawn,
• any focus information that needs to be conveyed to future widgets
• the action (to render graphics or/and sounds),
• any new ThreadIds to keep track of (for proper shutdown when finished),
• and the parametrized output type.

Constructors

UI

Fields

unUI :: (CTX, Focus, Time, UIEvent) -> IO (Layout, DirtyBit, Focus, Action, ControlData, a)

Instances

Monad UI

MonadFix UI

MonadIO UI

ArrowCircuit UISF

ArrowTime UISF

ioToUI :: IO a -> UI a

Lifts an 'IO a' to a 'UI a'

Control Data

type ControlData = [ThreadId]

The control data is simply a list of Thread Ids.

nullCD :: ControlData

No new thread ids.

addThreadID :: ThreadId -> UI ()

A thread handler for the UI monad.

mergeCD :: ControlData -> ControlData -> ControlData

A method for merging to control data objects.

Rendering Context

data CTX

A rendering context specifies the following:

Constructors

CTX

Fields

flow :: Flow

A layout direction to flow widgets.

bounds :: Rect

A rectangle bound of current drawing area to render a UI component. It specifies the max size of a widget, not the actual size. It's up to each individual widget to decide where in this bound to put itself.

isConjoined :: Bool

A flag to tell whether we are in a conjoined state or not. A conjoined context will duplicate itself for subcomponents rather than splitting. This can be useful for making compound widgets when one widget takes up space and the other performs some side effect having to do with that space.

data Flow

Flow determines widget ordering.

Constructors

TopDown

BottomUp

LeftRight

RightLeft

Instances

Eq Flow

Show Flow

type Dimension = (Int, Int)

A dimension specifies size.

type Rect = (Point, Dimension)

A rectangle has a corner point and a dimension.

UI Layout

data Layout

The layout of a widget provides data to calculate its actual size in a given context.

1. hFill/vFill specify how much stretching space (in units) in horizontal/vertical direction should be allocated for this widget.
2. hFixedvFixed specify how much non-stretching space (widthheight in pixels) should be allocated for this widget.
3. minWminH specify minimum values (widthheight in pixels) for the widget's dimensions.

Constructors

Layout

Fields

hFill :: Int

vFill :: Int

hFixed :: Int

vFixed :: Int

minW :: Int

minH :: Int

Instances

Eq Layout

Show Layout

data LayoutType

A dimension can either be:

Constructors

Stretchy

Stretchy with a minimum size in pixels

Fields

minSize :: Int

Fixed

Fixed with a size measured in pixels

Fields

fixedSize :: Int

makeLayout :: LayoutType -> LayoutType -> Layout

This function takes layout information for first the horizontal dimension and then the vertical.

nullLayout :: Layout

The null layout is useful for "widgets" that do not appear or take up space on the screen.

Context and Layout Functions

divideCTX :: CTX -> Layout -> Layout -> (CTX, CTX)

Divides the CTX according to the ratio of a widget's layout and the overall layout of the widget that receives this CTX. Therefore, the first layout argument should basically be a sublayout of the second.

mergeLayout :: Flow -> Layout -> Layout -> Layout

Merge two layouts into one.

Action and System State

type Action = (Graphic, Sound)

Actions include both Graphics and Sound output. Even though both are indeed just IO monads, we separate them because Sound output must be immediately delivered, while graphics can wait until the next screen refresh.

type Sound = IO ()

A type synonym for sounds.

nullSound :: Sound

This is used when there is no sound produced.

nullAction :: Action

This is used when no Action happens at all.

justSoundAction :: Sound -> Action

Convert a Sound to an Action with no Graphic.

justGraphicAction :: Graphic -> Action

Convert a Graphic to an Action with no Sound.

mergeAction :: Monad m => (Graphic, m a) -> (Graphic, m b) -> (Graphic, m b)

Merge two actions into one.

scissorAction :: CTX -> Action -> Action

Use a context to bound the graphical effects of an action.

type Focus = (WidgetID, FocusInfo)

The Focus type helps focusable widgets communicate with each other about which widget is in focus. It consists of a WidgetID and a FocusInfo.

type WidgetID = Int

The WidgetID for any given widget is dynamic based on how many focusable widgets are active at the moment. It is designed basically as a counter that focusable widgets will automatically (via the focusable function) increment.

data FocusInfo

The FocusInfo means one of the following:

Constructors

HasFocus

Indicates that this widget is a subwidget of a widget that is in focus. Thus, this widget too is in focus, and this widget should pass HasFocus forward.

NoFocus

Indicates that there is no focus information to communicate between widgets.

SetFocusTo WidgetID

Indicates that the widget whose id is given should take focus. That widget should then pass NoFocus onward.

Instances

Eq FocusInfo

Show FocusInfo

type DirtyBit = Bool

The dirty bit is a bit to indicate if the widget needs to be redrawn.