¤ Fudget Library 0.18.1 Reference Manual ¤

Created from the Fudget Library sources on 2019-08-01 19:13

Programmer's Index

Sections


GuiElems

Audio:
bellF :: F ho ho
Button implementation:
data BMevents = ...
pushButtonF :: [(ModState, KeySym)] -> F b1 b2 -> F b1 (b2  Click)
Buttons:
data ButtonF lbl = ...
data Click = ...
class HasLabelInside xxx where ...
buttonF :: (Graphic lbl) => lbl -> F Click Click
buttonF' :: (Graphic lbl) => Customiser (ButtonF lbl) -> lbl -> F Click Click
buttonF'' :: (Graphic lbl) =>
             Customiser (ButtonF lbl) -> lbl -> PF (ButtonF lbl) Click Click
quitButtonF :: F Click b
radioGroupF :: (Eq alt, Graphic lbl) => [(alt, lbl)] -> alt -> F alt alt
radioGroupF' :: (Graphic lbl, Eq alt) =>
                Customiser RadioGroupF -> [(alt, lbl)] -> alt -> F alt alt
setLabel :: lbl -> Customiser (ButtonF lbl)
setPlacer :: Placer -> Customiser RadioGroupF
toggleButtonF :: (Graphic lbl) => lbl -> F Bool Bool
Data entry fields:
data StringF = ...
intF :: F Int (InputMsg Int)
intF' :: Customiser StringF -> F Int (InputMsg Int)
intF'' :: Customiser StringF -> PF StringF Int (InputMsg Int)
intInputF :: F Int Int
intInputF' :: Customiser StringF -> F Int Int
passwdF :: F String (InputMsg String)
passwdF' :: (StringF -> StringF) -> F String (InputMsg String)
passwdF'' :: (StringF -> StringF) -> PF StringF String (InputMsg String)
passwdInputF :: F String String
passwdInputF' :: (StringF -> StringF) -> F String String
setAllowedChar :: (Char -> Bool) -> Customiser StringF
setCursorPos :: Int -> Customiser StringF
setInitString :: String -> Customiser StringF
setInitStringSize :: String -> Customiser StringF
setShowString :: (String -> String) -> Customiser StringF
stringF :: F String (InputMsg String)
stringF' :: Customiser StringF -> F String (InputMsg String)
stringF'' :: Customiser StringF -> PF StringF String (InputMsg String)
stringInputF :: F String String
stringInputF' :: Customiser StringF -> F String String
Decoration:
border3dF :: Bool -> Int -> F a b -> F (Bool  a) b
buttonBorderF :: Int -> F a b -> F (Bool  a) b
labAboveF :: (Graphic p) => p -> F c d -> F c d
labBelowF :: (Graphic p) => p -> F c d -> F c d
labLeftOfF :: (Graphic p) => p -> F c d -> F c d
labRightOfF :: (Graphic p) => p -> F c d -> F c d
labelF :: (Graphic g) => g -> F a b
labelF' :: (Graphic g) => Customiser (DisplayF g) -> g -> F a b
tieLabelF :: (Graphic p) => Orientation -> Alignment -> p -> F c d -> F c d
Displaying and interacting with composite graphical objects:
data GraphicsF gfx = ...
hyperGraphicsF :: (Eq d, Graphic leaf) =>
                  Drawing d leaf -> F ((Drawing d leaf)  (d, Drawing d leaf)) d
hyperGraphicsF' :: (Graphic leaf, Eq d) =>
                   (GraphicsF (Drawing d leaf) -> GraphicsF (Drawing d leaf)) ->
                   Drawing d leaf -> F ((Drawing d leaf)  (d, Drawing d leaf)) d
setAdjustSize :: Bool -> Customiser (GraphicsF gfx)
Displaying and interacting with lists:
type PickListRequest a = ListRequest a
pickListF :: (a -> String) -> F (PickListRequest a) (InputMsg (Int, a))
pickListF' :: Customiser TextF ->
              (a -> String) -> F (PickListRequest a) (InputMsg (Int, a))
Displaying text:
data TextF = ...
type TextRequest = ListRequest String
moreF :: F [String] (InputMsg (Int, String))
moreF' :: Customiser TextF -> F [String] (InputMsg (Int, String))
moreFileF :: F String (InputMsg (Int, String))
moreFileShellF :: F String (InputMsg (Int, String))
moreShellF :: String -> F [String] (InputMsg (Int, String))
moreShellF' :: Customiser TextF -> String -> F [String] (InputMsg (Int, String))
textF :: F TextRequest (InputMsg (Int, String))
textF' :: Customiser TextF -> F TextRequest (InputMsg (Int, String))
Displays:
data DisplayF a = ...
displayF :: (Graphic g) => F g void
displayF' :: (Graphic a) => Customiser (DisplayF a) -> F a b
intDispF :: F Int b
intDispF' :: Customiser (DisplayF Int) -> F Int b
setSpacer :: Spacer -> Customiser (DisplayF a)
Menus:
menuF :: (Graphic mlbl, Graphic albl) => mlbl -> [(alt, albl)] -> F alt alt
popupMenuF :: (Graphic b1, Eq b1) => [(a, b1)] -> F c b2 -> F ([(a, b1)]  c) (a  b2)
Pop-up windows:
data ConfirmMsg = ...
confirmPopupF :: (Graphic msg) => F msg (msg, ConfirmMsg)
inputPopupF :: String ->
               InF a c -> Maybe c -> F (Maybe String, Maybe a) ((Maybe String, Maybe a), c)
inputPopupOptF :: String ->
                  InF a b ->
                  Maybe b -> F (Maybe String, Maybe a) ((Maybe String, Maybe a), Maybe b)
messagePopupF :: (Graphic msg) => F msg (msg, 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 ans ho
quitIdF :: (ho -> Bool) -> F ho ho
Text editors:
data EDirection = ...
data EditCmd = ...
data EditEvt = ...
data EditStop = ...
data EditStopChoice = ...
type EditStopFn = String -> String -> EditStopChoice
data EditorF = ...
editorF :: F EditCmd EditEvt
editorF' :: Customiser EditorF -> F EditCmd EditEvt
loadEditor :: String -> [EditCmd]
selectall :: [EditCmd]
setEditorCursorPos :: (Int, Int) -> [EditCmd]
Miscellaneous (the rest):
type IsSelect = Bool
data PopupMenu = ...
data TerminalCmd = ...
cmdTerminalF :: FontName -> Int -> Int -> F TerminalCmd a
editF :: FontSpec -> F EditCmd EditEvt
gcWarningF :: F a b
inputEditorF :: F String (InputMsg String)
inputEditorF' :: Customiser EditorF -> F String (InputMsg String)
menuPopupF :: F b d -> F (PopupMenu  b) d
newline :: Char
oldConfirmPopupF :: F String (String, ConfirmMsg)
oldMessagePopupF :: F String (String, Click)
passwdPopupOptF :: String ->
                   F (Maybe String, Maybe String) ((Maybe String, Maybe String), Maybe String)
smallPickListF :: (d -> String) -> F [d] d
stringPopupOptF :: String ->
                   F (Maybe String, Maybe String) ((Maybe String, Maybe String), Maybe String)
terminalF :: FontName -> Int -> Int -> F String a

Combinators

Abstract fudgets: from stream processors:
absF :: SP a b -> F a b
Abstract fudgets: stateful:
mapstateF :: (t -> a -> (t, [b])) -> t -> F a b
Abstract fudgets: stateless:
concatMapF :: (a -> [b]) -> F a b
mapF :: (a -> b) -> F a b
Combining data entry fields:
inputListF :: (Eq a) => [(a, InF b c)] -> InF [(a, b)] [(a, c)]
inputPairF :: InF a1 b1 -> InF a2 b2 -> InF (a1, a2) (b1, b2)
inputThroughF :: InF a a -> InF a a
Data entry fields:
type InF a b = F a (InputMsg b)
Delay the activation of a stream processor or fudget:
delayF :: F hi ho -> F hi ho
Dynamic fudget creation/destruction:
type DynFMsg a b = DynMsg a (F a b)
dynF :: F a b -> F ((F a b)  a) b
dynListF :: F (Int, DynFMsg a b) (Int, b)
Plumbing: circular connections:
loopCompF :: F ((r2l  inl)  (l2r  inr)) ((l2r  outl)  (r2l  outr)) ->
             F (inl  inr) (outl  outr)
loopF :: F a a -> F a a
loopLeftF :: F (a  b) (a  c) -> F b c
loopOnlyF :: F a a -> F a b
loopRightF :: F (a  b) (c  b) -> F a c
loopThroughBothF :: F (r2l  inl) (l2r  outl) ->
                    F (l2r  inr) (r2l  outr) -> F (inl  inr) (outl  outr)
loopThroughRightF :: F (a  b) (c  d) -> F c a -> F b d
Plumbing: common patterns of serial and parallel compositions:
bypassF :: F a a -> F a a
idLeftF :: F c d -> F (b  c) (b  d)
idRightF :: F a b -> F (a  c) (b  c)
stubF :: F a b -> F c d
throughF :: F c b -> F c (b  c)
toBothF :: F b (b  b)
Plumbing: tagged parallel composition:
listF :: (Eq a) => [(a, F b c)] -> F (a, b) (a, c)
Plumbing: turn parallel compositions into loops:
loopCompThroughLeftF :: F (a  (b  c)) (b  (a  d)) -> F c d
loopCompThroughRightF :: F ((a  b)  c) ((c  d)  a) -> F b d
Plumbing: turning parallel compositions into serial compositions:
serCompLeftToRightF :: F (a  b) (b  c) -> F a c
serCompRightToLeftF :: F (a  b) (c  a) -> F b c
Plumbing: untagged parallel composition:
untaggedListF :: [F a b] -> F a b
Stream processor combinators that create circular connections:
loopCompSP :: SP ((a1  b1)  (a2  b2)) ((a2  a3)  (a1  b3)) -> SP (b1  b2) (a3  b3)
loopThroughBothSP :: SP (a1  b1) (a2  a3) ->
                     SP (a2  b2) (a1  b3) -> SP (b1  b2) (a3  b3)
The Fudget type:
data F hi ho = ...
The identity fudget:
idF :: F b b
Miscellaneous (the rest):
type Cont c a = (a -> c) -> c
class FudgetIO f where ...
class StreamProcIO sp where ...
appendStartF :: [ho] -> F hi ho -> F hi ho
contDynF :: F a b -> Cont (F a d) b
getF :: Cont (F a ho) a
nullF :: F hi ho
parF :: F c ho -> F c ho -> F c ho
prepostMapHigh :: (hi -> b) -> (c -> ho) -> F b c -> F hi ho
prodF :: F a b -> F c d -> F (a, c) (b  d)
putF :: ho -> F hi ho -> F hi ho
putsF :: [b] -> F a b -> F a b
startupF :: [hi] -> F hi ho -> F hi ho

InfixOps

Plumbing: serial composition:
>==< :: F a1 b -> F a2 a1 -> F a2 b
Plumbing: tagged parallel composition:
>+< :: F a b -> F c d -> F (a  c) (b  d)
Plumbing: untagged parallel composition:
>*< :: F c ho -> F c ho -> F c ho
Stream processor combinators:
-+- :: SP a1 a2 -> SP a3 b -> SP (a1  a3) (a2  b)
-==- :: SP a1 b -> SP a2 a1 -> SP a2 b
Miscellaneous (the rest):
-*- :: SP a b -> SP a b -> SP a b
>=^< :: F c d -> (e -> c) -> F e d
>=^^< :: F c d -> SP e c -> F e d
>^=< :: (a -> b) -> F e a -> F e b
>^^=< :: SP a b -> F e a -> F e b

Layout

A spacer that centers a box in the available space:
centerS :: Spacer
GUI fudget placement:
data Placer = ...
alignF :: Size -> Size -> Alignment -> Alignment -> F a b -> F a b
hBoxF :: F a b -> F a b
marginHVAlignF :: Distance -> Alignment -> Alignment -> F a b -> F a b
matrixF :: Int -> F a b -> F a b
noStretchF :: Bool -> Bool -> F a b -> F a b
placerF :: Placer -> F a b -> F a b
revHBoxF :: F a b -> F a b
revVBoxF :: F a b -> F a b
tableF :: Int -> F a b -> F a b
vBoxF :: F a b -> F a b
GUI fudget spacing:
data Spacer = ...
spacerF :: Spacer -> F a b -> F a b
Name layout:
data NameLayout = ...
hBoxNL :: [NameLayout] -> NameLayout
hBoxNL' :: Distance -> [NameLayout] -> NameLayout
hvAlignNL :: Alignment -> Alignment -> NameLayout -> NameLayout
leafNL :: LName -> NameLayout
marginHVAlignNL :: Distance -> Alignment -> Alignment -> NameLayout -> NameLayout
marginNL :: Distance -> NameLayout -> NameLayout
modNL :: (Placer -> Placer) -> NameLayout -> NameLayout
nameLayoutF :: NameLayout -> F a b -> F a b
nullNL :: NameLayout
placeNL :: Placer -> [NameLayout] -> NameLayout
sepNL :: Size -> NameLayout -> NameLayout
spaceNL :: Spacer -> NameLayout -> NameLayout
vBoxNL :: [NameLayout] -> NameLayout
vBoxNL' :: Distance -> [NameLayout] -> NameLayout
Placer modifying combinators:
flipP :: Placer -> Placer
revP :: Placer -> Placer
Placers for creating matrixes:
data LayoutDir = ...
matrixP :: Int -> Placer
matrixP' :: Int -> LayoutDir -> Distance -> Placer
Placers for creating tables:
tableP :: Int -> Placer
tableP' :: Int -> LayoutDir -> Distance -> Placer
Placers for vertical and horizontal placement:
horizontalP :: Placer
verticalP :: Placer
Spacer combinators:
compS :: Spacer -> Spacer -> Spacer
flipS :: Spacer -> Spacer
idS :: Spacer
Spacers that add margins to boxes:
type Distance = Int
hMarginS :: Distance -> Distance -> Spacer
hvMarginS :: Size -> Size -> Spacer
marginS :: Distance -> Spacer
vMarginS :: Distance -> Distance -> Spacer
Spacers that add space instead of stretching a box when there is extra space:
hAlignS :: Alignment -> Spacer
hvAlignS :: Alignment -> Alignment -> Spacer
vAlignS :: Alignment -> Spacer
Spacers that align boxes with edges:
bottomS :: Spacer
hCenterS :: Spacer
leftS :: Spacer
rightS :: Spacer
topS :: Spacer
vCenterS :: Spacer
Miscellaneous (the rest):
type Alignment = Double
type LName = String
data LayoutRequest = ...
data Sizing = ...
aBottom :: Alignment
aCenter :: Alignment
aLeft :: Alignment
aRight :: Alignment
aTop :: Alignment
autoP :: Placer
center :: Point -> Rect -> Rect
center' :: Point -> Size -> Rect -> Rect
dynListLF :: Placer -> F (Int, DynFMsg a b) (Int, b)
dynPlacerF :: F c ho -> F (Placer  c) ho
dynSpacerF :: F c ho -> F (Spacer  c) ho
flipPoint :: Point -> Point
flipRect :: Rect -> Rect
flipReq :: LayoutRequest -> LayoutRequest
holeF :: F hi ho
horizontalP' :: Distance -> Placer
idP :: Placer
layoutModifierF :: (LayoutRequest -> LayoutRequest) -> F a b -> F a b
listNF :: (Eq a, Show a) => [(a, F b c)] -> F (a, b) (a, c)
marginF :: Distance -> F a b -> F a b
marginHVAlignS :: Distance -> Alignment -> Alignment -> Spacer
maxSizeS :: Size -> Spacer
minSizeS :: Size -> Spacer
nameF :: LName -> F a b -> F a b
noStretchS :: Bool -> Bool -> Spacer
nullLF :: F hi ho
paragraphP :: Placer
paragraphP' :: Size -> Placer
paragraphP'' :: (Int -> Placer) -> Size -> Placer
permuteP :: [Int] -> Placer -> Placer
sepF :: Size -> F a b -> F a b
sepS :: Size -> Spacer
sizeS :: Size -> Spacer
spacer1F :: Spacer -> F a b -> F a b
spacerP :: Spacer -> Placer -> Placer
verticalP' :: Distance -> Placer

Containers

Scroll bars:
hScrollF :: F b d -> F b d
scrollF :: F b d -> F b d
vScrollF :: F b d -> F b d
Shell (top level windows):
unmappedSimpleShellF :: String -> F i o -> F i o
Shell (top level) windows:
data DeleteWindowAction = ...
class HasClickToType xxx where ...
class HasVisible xxx where ...
data ShellF = ...
setDeleteQuit :: Bool -> Customiser ShellF
setDeleteWindowAction :: Maybe DeleteWindowAction -> Customiser ShellF
setInitPos :: Maybe Point -> Customiser ShellF
shellF :: String -> F c d -> F c d
shellF' :: Customiser ShellF -> String -> F c d -> F c d
Miscellaneous (the rest):
data ESelCmd a = ...
data ESelEvt a = ...
data PotRequest = ...
type PotState = (Int, Int, Int)
data SelCmd a = ...
data SelEvt a = ...
bubbleF :: F a b -> F a b
bubblePopupF :: F b2 d2 -> F (PopupMsg b2) d2
bubbleRootPopupF :: F b2 d2 -> F (PopupMsg b2) d2
containerGroupF :: Rect ->
                   Rect ->
                   Int -> Button -> ModState -> F c b -> F ((Rect, Rect)  c) (Rect  b)
eselectionF :: F (ESelCmd String) (ESelEvt String)
hPotF :: F PotRequest PotState
popupShellF :: String -> Maybe Point -> F a b -> F a (a, b)
popupShellF' :: Customiser ShellF -> String -> Maybe Point -> F a b -> F a (a, b)
posPopupShellF :: String -> [WindowAttributes] -> F c a -> F (c, Maybe Point) (c, a)
selectionF :: F (SelCmd String) (SelEvt String)
unmappedSimpleShellF' :: Customiser ShellF -> String -> F i o -> F i o
vPotF :: F PotRequest PotState

Filters

Miscellaneous (the rest):
allcacheF :: F i o -> F i o
doubleClickF :: Time -> F a b -> F a b

DrawingModules

Bitmaps:
data BitmapFile = ...
Drawing:
data Drawing lbl leaf = ...
atomicD :: leaf -> Drawing lbl leaf
attribD :: GCSpec -> Drawing lbl leaf -> Drawing lbl leaf
fgD :: (Show a, ColorGen a) => a -> Drawing lbl leaf -> Drawing lbl leaf
fontD :: (Show a, FontGen a) => a -> Drawing lbl leaf -> Drawing lbl leaf
hardAttribD :: GCtx -> Drawing lbl leaf -> Drawing lbl leaf
hboxD :: [Drawing lbl leaf] -> Drawing lbl leaf
hboxD' :: Distance -> [Drawing lbl leaf] -> Drawing lbl leaf
labelD :: lbl -> Drawing lbl leaf -> Drawing lbl leaf
matrixD :: Int -> [Drawing lbl leaf] -> Drawing lbl leaf
matrixD' :: Distance -> Int -> [Drawing lbl leaf] -> Drawing lbl leaf
softAttribD :: [GCAttributes ColorSpec FontSpec] -> Drawing lbl leaf -> Drawing lbl leaf
tableD :: Int -> [Drawing lbl leaf] -> Drawing lbl leaf
tableD' :: Distance -> Int -> [Drawing lbl leaf] -> Drawing lbl leaf
vboxD :: [Drawing lbl leaf] -> Drawing lbl leaf
vboxD' :: Distance -> [Drawing lbl leaf] -> Drawing lbl leaf
Drawing attributes:
class ColorGen a where ...
data ColorSpec = ...
class FontGen a where ...
data FontSpec = ...
data GCtx = ...
colorSpec :: (ColorGen a, Show a) => a -> ColorSpec
createGCtx :: (FontGen a1, Show a1, Show a2, ColorGen a2, FudgetIO f) =>
              Drawable -> GCtx -> [GCAttributes a2 a1] -> (GCtx -> f i o) -> f i o
fontSpec :: (FontGen a, Show a) => a -> FontSpec
gcBgA :: c -> [GCAttributes c FontSpec]
gcFgA :: c -> [GCAttributes c FontSpec]
gcFontA :: f -> [GCAttributes ColorSpec f]
gctx2gc :: GCtx -> GCId
rootGCtx :: GCtx
wCreateGCtx :: (FudgetIO f, ColorGen a2, Show a2, Show a1, FontGen a1) =>
               GCtx -> [GCAttributes a2 a1] -> (GCtx -> f i o) -> f i o
Drawing manipulation:
type DPath = [Int]
up :: DPath -> DPath
Fixed size drawings:
data FixedColorDrawing = ...
data FixedDrawing = ...
Flexible line drawings:
data FlexibleDrawing = ...
arc :: Int -> Int -> FlexibleDrawing
ellipse :: FlexibleDrawing
filledTriangleDown :: FlexibleDrawing
filledTriangleUp :: FlexibleDrawing
filler :: Bool -> Bool -> Int -> FlexibleDrawing
flex :: (Rect -> [DrawCommand]) -> FlexibleDrawing
flex' :: Size -> (Rect -> [DrawCommand]) -> FlexibleDrawing
frame :: FlexibleDrawing
frame' :: Size -> FlexibleDrawing
hFiller :: Int -> FlexibleDrawing
lbrace :: FlexibleDrawing
lbrack :: FlexibleDrawing
lpar :: FlexibleDrawing
rbrace :: FlexibleDrawing
rbrack :: FlexibleDrawing
rpar :: FlexibleDrawing
vFiller :: Int -> FlexibleDrawing
Font metrics:
data FontStruct = ...
Graphics:
data Gfx = ...
class Graphic a where ...
g :: (Graphic a) => a -> Drawing lbl Gfx
Miscellaneous (the rest):
type Cont c a = (a -> c) -> c
arc' :: Size -> Int -> Int -> FlexibleDrawing
blankD :: Size -> Drawing lbl Gfx
boxD :: [Drawing lbl leaf] -> Drawing lbl leaf
ellipse' :: Size -> FlexibleDrawing
filledEllipse :: FlexibleDrawing
filledEllipse' :: Size -> FlexibleDrawing
filledRectD :: Size -> Drawing lbl Gfx
filledarc :: Int -> Int -> FlexibleDrawing
filledarc' :: Size -> Int -> Int -> FlexibleDrawing
hboxcD :: [Drawing lbl leaf] -> Drawing lbl leaf
hboxcD' :: Distance -> [Drawing lbl leaf] -> Drawing lbl leaf
placedD :: Placer -> Drawing lbl leaf -> Drawing lbl leaf
rectD :: Size -> Drawing lbl Gfx
spacedD :: Spacer -> Drawing lbl leaf -> Drawing lbl leaf
stackD :: [Drawing lbl leaf] -> Drawing lbl leaf
triangleDown :: FlexibleDrawing
triangleUp :: FlexibleDrawing
vboxlD :: [Drawing lbl leaf] -> Drawing lbl leaf
vboxlD' :: Distance -> [Drawing lbl leaf] -> Drawing lbl leaf

StreamProc

Data entry field postprocessors:
inputDoneSP :: SP (InputMsg b) b
inputLeaveDoneSP :: SP (InputMsg b) b
stripInputSP :: SP (InputMsg b) b
Delay the activation of a stream processor or fudget:
delaySP :: SP a b -> SP a b
Stream processor combinators:
compEitherSP :: SP a1 a2 -> SP a3 b -> SP (a1  a3) (a2  b)
idLeftSP :: SP a1 b -> SP (a2  a1) (a2  b)
idRightSP :: SP a1 a2 -> SP (a1  b) (a2  b)
postMapSP :: (t -> b) -> SP a t -> SP a b
preMapSP :: SP a b -> (t -> a) -> SP t b
prepostMapSP :: (t1 -> a) -> (t2 -> b) -> SP a t2 -> SP t1 b
serCompSP :: SP a1 b -> SP a2 a1 -> SP a2 b
Stream processor combinators that create circular connections:
loopLeftSP :: SP (a1  a2) (a1  b) -> SP a2 b
loopSP :: SP a a -> SP a a
Stream processor construction:
getSP :: Cont (SP a b) a
nullSP :: SP a b
putSP :: b -> SP a b -> SP a b
Stream processor equivalents of some common list processing functions:
chopSP :: ((b -> SP a b) -> SP a b) -> SP a b
concatMapAccumlSP :: (t -> a -> (t, [b])) -> t -> SP a b
concatMapSP :: (t -> [b]) -> SP t b
concatSP :: SP [b] b
filterSP :: (b -> Bool) -> SP b b
idSP :: SP b b
mapAccumlSP :: (t -> a -> (t, b)) -> t -> SP a b
mapSP :: (t -> b) -> SP t b
splitAtElemSP :: (a -> Bool) -> Cont (SP a b) [a]
zipSP :: [a] -> SP b (a, b)
Stream processor manipulation:
startupSP :: [a] -> SP a b -> SP a b
Stream processor that splits a stream of pairs:
splitSP :: SP (a, b) (a  b)
The function that turns a stream processor into a list processing function:
runSP :: SP a1 a2 -> [a1] -> [a2]
The type of plain stream processors:
data SP a b = ...
Miscellaneous (the rest):
type Cont c a = (a -> c) -> c
data DynMsg a b = ...
class StreamProcIO sp where ...
appendStartSP :: [b] -> SP a b -> SP a b
feedSP :: a -> [a] -> SP a b -> SP a b
filterJustSP :: SP (Maybe b) b
filterLeftSP :: SP (b1  b2) b1
filterRightSP :: SP (a1  b) b
inputListSP :: (Eq p1) => [p1] -> SP (p1, InputMsg p2) (InputMsg [(p1, p2)])
inputPairSP :: SP ((InputMsg a)  (InputMsg b)) (InputMsg (a, b))
loopOnlySP :: SP a a -> SP a b
loopThroughRightSP :: SP (a1  a2) (a3  b) -> SP a3 a1 -> SP a2 b
mapFilterSP :: (t -> Maybe b) -> SP t b
parSP :: SP a b -> SP a b -> SP a b
pullSP :: SP a1 a2 -> ([a2], SP a1 a2)
putsSP :: [b] -> SP a b -> SP a b
seqSP :: SP a b -> SP a b -> SP a b
stepSP :: [b] -> Cont (SP a b) a
toBothSP :: SP b (b  b)
walkSP :: SP a1 a2 -> a1 -> ([a2], SP a1 a2)

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:
appStorageF :: (Read a, Show a) => String -> a -> F a a
readDirF :: F String (String, IOError  [String])
readFileF :: F String (String, IOError  String)
writeFileF :: F (String, String) (String, IOError  ())
Haskell Dialogue IO:
hIOF :: Request -> (Response -> F a b) -> F a b
hIOSuccF :: Request -> F a b -> F a b
hIOerrF :: Request -> (IOError -> F a b) -> (Response -> F a b) -> F a b
haskellIOF :: Request -> (Response -> F a b) -> F a b
Sockets:
asyncTransceiverF :: Socket -> F [Char] String
asyncTransmitterF :: Socket -> F [Char] b
openLSocketF :: (FudgetIO f) => Port -> (LSocket -> f b ho) -> f b ho
openSocketF :: (FudgetIO f) => Host -> Port -> (Socket -> f b ho) -> f b ho
receiverF :: Socket -> F e String
transceiverF :: Socket -> F [Char] String
transmitterF :: Socket -> F [Char] b
Stdio:
inputLinesSP :: SP [Char] [Char]
linesSP :: SP Char [Char]
outputF :: String -> F String a
stderrF :: F String a
stdinF :: F b String
stdioF :: F String String
stdoutF :: F String a
Miscellaneous (the rest):
getLocalTime :: (FudgetIO f) => (CalendarTime -> f b ho) -> f b ho
getTime :: (FudgetIO f) => (ClockTime -> f b ho) -> f b ho
subProcessF :: String -> F [Char] (String  String)

LowLevel

The combinator that connects the main fudget to the Haskell I/O system:
data Fudlogue = ...
fudlogue :: F a b -> IO ()
fudlogue' :: Customiser Fudlogue -> F a b -> IO ()
Miscellaneous (the rest):
type Cont c a = (a -> c) -> c
class FudgetIO f where ...
class HasCache xxx where ...
cmdContSP :: a -> (b -> Maybe c) -> Cont (SP b a) c
contMap :: (StreamProcIO sp) => (i -> (o -> sp i o) -> sp i o) -> sp i o
conts :: (a -> Cont c b) -> [a] -> Cont c [b]
dropSP :: (t1 -> Maybe t2) -> (t2 -> SP t1 b) -> SP t1 b
getLeftSP :: (t -> SP (t  b1) b2) -> SP (t  b1) b2
getRightSP :: (t -> SP (a1  t) b) -> SP (a1  t) b
waitForF :: (a -> Maybe b) -> Cont (F a c) b
waitForSP :: (a -> Maybe t) -> (t -> SP a b) -> SP a b

XTypesModules

Font metrics:
data FontStruct = ...
Miscellaneous (the rest):
data Button = ...
type ColorName = String
data CoordMode = ...
data DrawCommand = ...
type FontName = String
data GCAttributes a b = ...
data GCCapStyle = ...
data GCFillStyle = ...
data GCFunction = ...
data GCLineStyle = ...
type Host = String
type KeySym = String
data LSocket = ...
type ModState = [Modifiers]
data Modifiers = ...
type Peer = Host
type Port = Int
data RGB = ...
data Shape = ...
data Socket = ...
type Time = Int
type Width = Int
data WindowAttributes = ...
data XCommand = ...
data XEvent = ...
drawCircle :: Point -> Int -> DrawCommand
fillCircle :: Point -> Int -> DrawCommand

Types

Buttons:
data Click = ...
Displaying text:
data ListRequest a = ...
appendItems :: [a] -> ListRequest a
applyListRequest :: ListRequest a -> [a] -> [a]
changeItems :: Int -> [a] -> ListRequest a
deleteItems :: Int -> Int -> ListRequest a
highlightItems :: [Int] -> ListRequest a
insertItems :: Int -> [a] -> ListRequest a
pickItem :: Int -> ListRequest a
replaceAll :: [a] -> ListRequest a
replaceAllFrom :: Int -> [a] -> ListRequest a
replaceItems :: Int -> Int -> [a] -> ListRequest a
Pop-up windows:
data ConfirmMsg = ...
The Fudget type:
data F hi ho = ...
type Fudget a b = F a b
The type of plain stream processors:
data SP a b = ...
Types for messages from data entry fields:
data InputMsg a = ...
inputChange :: a -> InputMsg a
inputDone :: InputMsg a -> Maybe a
inputLeaveDone :: InputMsg a -> Maybe a
inputMsg :: a -> InputMsg a
mapInp :: (t -> a) -> InputMsg t -> InputMsg a
stripInputMsg :: InputMsg p -> p
tstInp :: (t -> p) -> InputMsg t -> p
Miscellaneous (the rest):
type Path = [Direction]
data PopupMsg a = ...
inputButtonKey :: KeySym
inputLeaveKey :: KeySym

FudUtilities

Environment:
argFlag :: [Char] -> Bool -> Bool
argKey :: [Char] -> [Char] -> [Char]
argReadKey :: (Show p, Read p) => [Char] -> p -> p
args :: [[Char]]
bgColor :: ColorName
buttonFont :: FontName
defaultFont :: FontName
fgColor :: ColorName
menuFont :: FontName
options :: [([Char], [Char])]
paperColor :: ColorName
shadowColor :: ColorName
shineColor :: ColorName
Geometry, part 1:
data Line = ...
data Point = ...
data Rect = ...
type Size = Point
lL :: Int -> Int -> Int -> Int -> Line
origin :: Point
pP :: Int -> Int -> Point
rR :: Int -> Int -> Int -> Int -> Rect
Geometry, part 2:
=.> :: Point -> Point -> Bool
confine :: Rect -> Rect -> Rect
freedom :: Rect -> Rect -> Point
growrect :: Rect -> Point -> Rect
inRect :: Point -> Rect -> Bool
moveline :: Line -> Point -> Line
moverect :: Rect -> Point -> Rect
pMax :: [Point] -> Point
pMin :: [Point] -> Point
padd :: Point -> Point -> Point
plim :: Point -> Point -> Point -> Point
pmax :: Point -> Point -> Point
pmin :: Point -> Point -> Point
posrect :: Rect -> Point -> Rect
psub :: Point -> Point -> Point
rectMiddle :: Rect -> Point
rsub :: Rect -> Rect -> Point
scale :: (Integral a2, Integral b, RealFrac a1) => a1 -> a2 -> b
scalePoint :: (RealFrac a) => a -> Point -> Point
sizerect :: Rect -> Size -> Rect
Various utility functions for pairs and lists:
aboth :: (t -> b) -> (t, t) -> (b, b)
anth :: Int -> (a -> a) -> [a] -> [a]
gmap :: (Foldable t1) => (t2 -> [a] -> [a]) -> (t3 -> t2) -> t1 t3 -> [a]
issubset :: (Eq a, Foldable t2, Foldable t1) => t1 a -> t2 a -> Bool
lhead :: [a1] -> [a2] -> [a2]
loop :: (t -> t) -> t
lsplit :: [a1] -> [a2] -> ([a2], [a2])
ltail :: [a1] -> [a2] -> [a2]
mapPair :: (t1 -> a, t2 -> b) -> (t1, t2) -> (a, b)
number :: Int -> [a] -> [(Int, a)]
oo :: (t1 -> t2) -> (t3 -> t4 -> t1) -> t3 -> t4 -> t2
pair :: a -> b -> (a, b)
pairwith :: (t -> b) -> t -> (t, b)
part :: (a -> Bool) -> [a] -> ([a], [a])
remove :: (Eq t) => t -> [t] -> [t]
replace :: (Eq a) => (a, b) -> [(a, b)] -> [(a, b)]
swap :: (b, a) -> (a, b)
unionmap :: (Eq a, Foldable t1) => (t2 -> [a]) -> t1 t2 -> [a]
Various utility functions for the \code{Either} type:
filterLeft :: [b1  b2] -> [b1]
filterRight :: [a  b] -> [b]
fromLeft :: a  b -> a
fromRight :: a  b -> b
isLeft :: a  b -> Bool
isRight :: a  b -> Bool
mapEither :: (t1 -> a) -> (t2 -> b) -> t1  t2 -> a  b
splitEitherList :: [a1  a2] -> ([a1], [a2])
stripEither :: p  p -> p
stripLeft :: a  b -> Maybe a
stripRight :: a1  a2 -> Maybe a2
swapEither :: b  a -> a  b
Various utility functions for the \code{Maybe} type.:
plookup :: (Foldable t) => (a -> Bool) -> t (a, b) -> Maybe b
Miscellaneous (the rest):
type Cont c a = (a -> c) -> c
class Move a where ...
argKeyList :: [Char] -> [[Char]] -> [[Char]]
defaultPosition :: Maybe Point
defaultSep :: (Num a) => a
defaultSize :: Maybe Point
diag :: Int -> Point
edgeWidth :: Int
labelFont :: FontName
line2rect :: Line -> Rect
look3d :: Bool
progName :: String
rect2line :: Rect -> Line
rmax :: Rect -> Rect -> Rect
version :: [Char]
version_0_18_1 :: [Char]

Debug

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

DefaultParams

Displaying text:
class HasInitText xxx where ...
Miscellaneous (the rest):
type Alignment = Double
type Customiser a = a -> a
class HasAlign xxx where ...
class HasBgColorSpec xxx where ...
class HasBorderWidth xxx where ...
class HasFgColorSpec xxx where ...
class HasFontSpec xxx where ...
class HasInitDisp xxx where ...
class HasInitSize xxx where ...
class HasKeys xxx where ...
class HasMargin xxx where ...
class HasSizing xxx where ...
class HasStretchable xxx where ...
class HasWinAttr xxx where ...
type PF p a b = F ((Customiser p)  a) b
setBgColor :: (Show a, ColorGen a, HasBgColorSpec xxx) => a -> Customiser xxx
setFgColor :: (Show a, ColorGen a, HasFgColorSpec xxx) => a -> Customiser xxx
setFont :: (Show a, FontGen a, HasFontSpec xxx) => a -> Customiser xxx
standard :: Customiser a

ContribFudgets

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