¤ Fudget Library Reference Manual ¤

Created from the Fudget Library sources on Sat Jun 24 16:22:22 CEST 2000

Beginner's Index

Sections

GuiElems

Audio:
bellF :: F a a
Buttons:
data Click = ...
buttonF :: (Graphic a) => a -> F Click Click
radioGroupF :: (Graphic b, Eq a) => [(a, b)] -> a -> F a a
toggleButtonF :: (Graphic a) => a -> F Bool Bool
Data entry fields:
intInputF :: F Int Int
passwdInputF :: F String String
stringInputF :: F String String
Decoration:
labAboveF :: (Graphic a) => a -> F b c -> F b c
labBelowF :: (Graphic a) => a -> F b c -> F b c
labLeftOfF :: (Graphic a) => a -> F b c -> F b c
labRightOfF :: (Graphic a) => a -> F b c -> F b c
labelF :: (Graphic a) => a -> F b c
Displaying and interacting with lists:
type PickListRequest a = ListRequest a
pickListF :: (a -> String) -> F (PickListRequest a) (InputMsg (Int, a))
Displaying text:
moreF :: F [String] (InputMsg (Int, String))
moreFileF :: F String (InputMsg (Int, String))
moreFileShellF :: F String (InputMsg (Int, String))
moreShellF :: String -> F [String] (InputMsg (Int, String))
Displays:
displayF :: (Graphic a) => F a b
intDispF :: F Int a
Menus:
menuF :: (Graphic a, Graphic c) => a -> [(b, c)] -> F b b
popupMenuF :: (Graphic b, Eq b) => [(a, b)] -> F c d -> F (Either [(a, b)] c) (Either a d)
Pop-up windows:
data ConfirmMsg = ...
confirmPopupF :: (Graphic a) => F a (a, ConfirmMsg)
messagePopupF :: (Graphic a) => F a (a, Click)
passwdPopupF :: String -> F (Maybe String, Maybe String) ((Maybe String, Maybe String), String)
stringPopupF :: String -> F (Maybe String, Maybe String) ((Maybe String, Maybe String), String)
Terminating the program:
quitF :: F a b

Combinators

Abstract fudgets: from stream processors:
absF :: SP a b -> F a b
Abstract fudgets: stateful:
mapstateF :: (a -> b -> (a, [c])) -> a -> F b c
Abstract fudgets: stateless:
concatMapF :: (a -> [b]) -> F a b
mapF :: (a -> b) -> F a b
Plumbing: circular connections:
loopF :: F a a -> F a a
loopLeftF :: F (Either a b) (Either a c) -> F b c
loopOnlyF :: F a a -> F a b
loopRightF :: F (Either a b) (Either c b) -> F a c
loopThroughRightF :: F (Either a b) (Either c d) -> F c a -> F b d
Plumbing: serial composition:
serCompF :: F a b -> F c a -> F c b
Plumbing: tagged parallel composition:
compF :: F a b -> F c d -> F (Either a c) (Either b d)
listF :: (Eq a) => [(a, F b c)] -> F (a, b) (a, c)
Plumbing: untagged parallel composition:
untaggedListF :: [F a b] -> F a b
The Fudget type:
data F a b
The identity fudget:
idF :: F a a

InfixOps

Plumbing: serial composition:
infixr 4 >==<
>==< :: F a b -> F c a -> F c b
Plumbing: tagged parallel composition:
infixl 5 >+<
>+< :: F a b -> F c d -> F (Either a c) (Either b d)
Plumbing: untagged parallel composition:
infixl 5 >*<
>*< :: F a b -> F a b -> F a b

Layout

A spacer that centers a box in the available space:
centerS :: Spacer
GUI fudget placement:
data Placer = ...
placerF :: Placer -> F a b -> F a b
GUI fudget spacing:
data Spacer = ...
spacerF :: Spacer -> F a b -> F a b
Placer modifying combinators:
flipP :: Placer -> Placer
revP :: Placer -> Placer
Placers for creating matrixes:
matrixP :: Int -> Placer
Placers for creating tables:
tableP :: Int -> Placer
Placers for vertical and horizontal placement:
horizontalP :: Placer
verticalP :: Placer
Spacers that add margins to boxes:
type Distance = Int
marginS :: Distance -> Spacer

Containers

Scroll bars:
hScrollF :: F a b -> F a b
scrollF :: F a b -> F a b
vScrollF :: F a b -> F a b
Shell (top level) windows:
shellF :: String -> F a b -> F a b

StreamProc

Stream processor equivalents of some common list processing functions:
chopSP :: ((a -> SP b a) -> SP b a) -> SP b a
concatMapAccumlSP :: (a -> b -> (a, [c])) -> a -> SP b c
concatMapSP :: (a -> [b]) -> SP a b
concatSP :: SP [a] a
filterSP :: (a -> Bool) -> SP a a
idSP :: SP a a
mapAccumlSP :: (a -> b -> (a, c)) -> a -> SP b c
mapSP :: (a -> b) -> SP a b
splitAtElemSP :: (a -> Bool) -> Cont (SP a b) [a]
zipSP :: [a] -> SP b (a, b)
The type of plain stream processors:
data SP a b

InOut

A fudget that outputs ticks after specific delays and/or at specific intervals:
data Tick = ...
timerF :: F (Maybe (Int, Int)) Tick
File system access:
readDirF :: F String (String, Either D_IOError [String])
readFileF :: F String (String, Either D_IOError String)
writeFileF :: F (String, String) (String, Either D_IOError ())

LowLevel

The combinator that connects the main fudget to the Haskell I/O system:
fudlogue :: F a b -> IO ()

Types

The Fudget type:
type TEvent = (Path, FResponse)
type TCommand = (Path, FRequest)
type FEvent a = Message TEvent a
type FCommand a = Message TCommand a
type Fudget a b = F a b
type FSP a b = SP (FEvent a) (FCommand b)
data F a b = ...
The type of plain stream processors:
data SP a b

Utilities

Various utility functions for pairs and lists:
aboth :: (a -> b) -> (a, a) -> (b, b)
anth :: Int -> (a -> a) -> [a] -> [a]
gmap :: (a -> [b] -> [b]) -> (c -> a) -> [c] -> [b]
issubset :: (Eq a) => [a] -> [a] -> Bool
lhead :: [a] -> [b] -> [b]
loop :: (a -> a) -> a
lsplit :: [a] -> [b] -> ([b], [b])
ltail :: [a] -> [b] -> [b]
mapPair :: (a -> b, c -> d) -> (a, c) -> (b, d)
number :: Int -> [a] -> [(Int, a)]
oo :: (a -> b) -> (c -> d -> a) -> c -> d -> b
pair :: a -> b -> (a, b)
pairwith :: (a -> b) -> a -> (a, b)
part :: (a -> Bool) -> [a] -> ([a], [a])
remove :: (Eq a) => a -> [a] -> [a]
replace :: (Eq a) => (a, b) -> [(a, b)] -> [(a, b)]
swap :: (a, b) -> (b, a)
unionmap :: (Eq b) => (a -> [b]) -> [a] -> [b]

Debug

A fudget that shows the high level input and output of a fudget on the standard error output:
spyF :: (Show b, Show a) => F a b -> F a b
An identity fudget that copies messages to the standard error output:
teeF :: (a -> [Char]) -> [Char] -> F a a

ContribFudgets

Menus:
menuF :: (Eq a) => Menu a -> F a a