Fudget Library Reference Manual

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

Programmer's Index

Sections


GuiElems

Audio:
bellF :: F a a
Button implementation:
data BMevents = ...
pushButtonF :: [(ModState, KeySym)] -> F a b -> F a (Either b Click)
Buttons:
data Click = ...
data ButtonF a
class HasLabelInside a where ...
buttonF :: (Graphic a) => a -> F Click Click
buttonF' :: (Graphic a) => Customiser (ButtonF a) -> a -> F Click Click
buttonF'' :: (Graphic a) => Customiser (ButtonF a) -> a -> PF (ButtonF a) Click Click
quitButtonF :: F Click a
radioGroupF :: (Graphic b, Eq a) => [(a, b)] -> a -> F a a
radioGroupF' :: (Graphic b, Eq a) => Customiser RadioGroupF -> [(a, b)] -> a -> F a a
setLabel :: a -> Customiser (ButtonF a)
setPlacer :: Placer -> Customiser RadioGroupF
toggleButtonF :: (Graphic a) => a -> 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 (Either Bool a) b
buttonBorderF :: Int -> F a b -> F (Either Bool a) b
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
labelF' :: (Graphic a) => Customiser (DisplayF a) -> a -> F b c
tieLabelF :: (Graphic a) => Orientation -> Alignment -> a -> F b c -> F b c
Displaying and interacting with composite graphical objects:
data GraphicsF a
hyperGraphicsF :: (Eq a, Graphic b) => Drawing a b -> F (Either (Drawing a b) (a, Drawing a b)) a
hyperGraphicsF' :: (Eq a, Graphic b) => (GraphicsF (Drawing a b) -> GraphicsF (Drawing a b)) -> Drawing a b -> F (Either (Drawing a b) (a, Drawing a b)) a
setAdjustSize :: Bool -> Customiser (GraphicsF a)
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 a) => F a b
displayF' :: (Graphic a) => Customiser (DisplayF a) -> F a b
intDispF :: F Int a
intDispF' :: Customiser (DisplayF Int) -> F Int a
setSpacer :: Spacer -> Customiser (DisplayF 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)
inputPopupF :: String -> InF a b -> Maybe b -> F (Maybe String, Maybe a) ((Maybe String, Maybe a), b)
inputPopupOptF :: String -> InF a b -> Maybe b -> F (Maybe String, Maybe a) ((Maybe String, Maybe a), Maybe b)
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
quitIdF :: (a -> Bool) -> F a a
Text editors:
data EditEvt = ...
data EditCmd = ...
editorF :: F EditCmd EditEvt
editorF' :: Customiser EditorF -> F EditCmd EditEvt
loadEditor :: String -> [EditCmd]
selectall :: [EditCmd]
setEditorCursorPos :: (Int, Int) -> [EditCmd]
Miscellaneous (the rest):
data EditStop = ...
data EDirection = ...
type EditStopFn = String -> String -> EditStopChoice
data EditStopChoice = ...
type IsSelect = Bool
data EditorF
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 a b -> F (Either PopupMenu a) b
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 :: (a -> String) -> F [a] a
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 :: (a -> b -> (a, [c])) -> a -> F b c
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 a b -> InF c d -> InF (a, c) (b, d)
inputThroughF :: InF a a -> InF a a
Data entry field postprocessors:
inputDoneSP :: SP (InputMsg a) a
inputLeaveDoneSP :: SP (InputMsg a) a
stripInputSP :: SP (InputMsg a) a
Data entry fields:
type InF a b = F a (InputMsg b)
Delay the activation of a stream processor or fudget:
delayF :: F a b -> F a b
Dynamic fudget creation/destruction:
type DynFMsg a b = DynMsg a (F a b)
dynF :: F a b -> F (Either (F a b) a) b
dynListF :: F (Int, DynFMsg a b) (Int, b)
Plumbing: circular connections:
loopCompF :: F (Either (Either a b) (Either c d)) (Either (Either c e) (Either a f)) -> F (Either b d) (Either e f)
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
loopThroughBothF :: F (Either a b) (Either c d) -> F (Either c e) (Either a f) -> F (Either b e) (Either d f)
loopThroughRightF :: F (Either a b) (Either 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 a b -> F (Either c a) (Either c b)
idRightF :: F a b -> F (Either a c) (Either b c)
stubF :: F a b -> F c d
throughF :: F a b -> F a (Either b a)
toBothF :: F a (Either a a)
Plumbing: tagged parallel composition:
listF :: (Eq a) => [(a, F b c)] -> F (a, b) (a, c)
Plumbing: turn parallel compositions into loops:
loopCompThroughLeftF :: F (Either a (Either b c)) (Either b (Either a d)) -> F c d
loopCompThroughRightF :: F (Either (Either a b) c) (Either (Either c d) a) -> F b d
Plumbing: turning parallel compositions into serial compositions:
serCompLeftToRightF :: F (Either a b) (Either b c) -> F a c
serCompRightToLeftF :: F (Either a b) (Either 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 (Either (Either a b) (Either c d)) (Either (Either c e) (Either a f)) -> SP (Either b d) (Either e f)
loopThroughBothSP :: SP (Either a b) (Either c d) -> SP (Either c e) (Either a f) -> SP (Either b e) (Either d f)
The Fudget type:
data F a b
The identity fudget:
idF :: F a a
Miscellaneous (the rest):
type Cont a b = (b -> a) -> a
appendStartF :: [a] -> F b a -> F b a
contDynF :: F a b -> Cont (F a c) b
getF :: Cont (F a b) a
inputListSP :: (Eq a) => [a] -> SP (a, InputMsg b) (InputMsg [(a, b)])
inputPairSP :: SP (Either (InputMsg a) (InputMsg b)) (InputMsg (a, b))
nullF :: F a b
parF :: F a b -> F a b -> F a b
prepostMapHigh :: (a -> b) -> (c -> d) -> F b c -> F a d
prodF :: F a b -> F c d -> F (a, c) (Either b d)
putF :: a -> F b a -> F b a
putsF :: [a] -> F b a -> F b a
startupF :: [a] -> F a b -> F a b

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
Miscellaneous (the rest):
infixr 8 -*-
-*- :: SP a b -> SP a b -> SP a b
infixr 8 -+-
-+- :: SP a b -> SP c d -> SP (Either a c) (Either b d)
infixr 8 -==-
-==- :: SP a b -> SP c a -> SP c b
infixl 9 >#+<
>#+< :: (F a b, Orientation) -> F c d -> F (Either a c) (Either b d)
infixl 9 >#==<
>#==< :: (F a b, Orientation) -> F c a -> F c b
infixl 6 >=^<
>=^< :: F a b -> (c -> a) -> F c b
infixl 6 >=^^<
>=^^< :: F a b -> SP c a -> F c b
infixr 7 >^=<
>^=< :: (a -> b) -> F c a -> F c b
infixr 7 >^^=<
>^^=< :: SP a b -> F c a -> F c 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
data LayoutRequest = ...
type LName = String
data Sizing = ...
aBottom :: Alignment
aCenter :: Alignment
aLeft :: Alignment
aRight :: Alignment
aTop :: Alignment
autoP :: Placer
center :: Size -> Rect -> Rect
center' :: Point -> Size -> Rect -> Rect
dynListLF :: Placer -> F (Int, DynFMsg a b) (Int, b)
dynPlacerF :: F a b -> F (Either Placer a) b
dynSpacerF :: F a b -> F (Either Spacer a) b
fixedh :: LayoutRequest -> Bool
fixedv :: LayoutRequest -> Bool
flipPoint :: Point -> Point
flipRect :: Rect -> Rect
flipReq :: LayoutRequest -> LayoutRequest
holeF :: F a b
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 a b
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 a b -> F a b
scrollF :: F a b -> F a b
vScrollF :: F a b -> F a b
Shell (top level windows):
unmappedSimpleShellF :: String -> F a b -> F a b
Shell (top level) windows:
data ShellF
data DeleteWindowAction = ...
class HasClickToType a where ...
class HasVisible a where ...
setDeleteQuit :: Bool -> Customiser ShellF
setDeleteWindowAction :: Maybe DeleteWindowAction -> Customiser ShellF
setInitPos :: Maybe Point -> Customiser ShellF
shellF :: String -> F a b -> F a b
shellF' :: Customiser ShellF -> String -> F a b -> F a b
Miscellaneous (the rest):
data PotRequest = ...
type PotState = (Int, Int, Int)
data SelCmd a = ...
data SelEvt a = ...
data ESelCmd a = ...
data ESelEvt a = ...
bubbleF :: F a b -> F a b
bubblePopupF :: F a b -> F (PopupMsg a) b
bubbleRootPopupF :: F a b -> F (PopupMsg a) b
containerGroupF :: Rect -> Rect -> Int -> Button -> ModState -> F a b -> F (Either (Rect, Rect) a) (Either Rect b)
eselectionF :: F (ESelCmd String) (ESelEvt String)
hPotF :: F PotRequest (Int, Int, Int)
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 a b -> F (a, Maybe Point) (a, b)
selectionF :: F (SelCmd String) (SelEvt String)
unmappedSimpleShellF' :: Customiser ShellF -> String -> F a b -> F a b
vPotF :: F PotRequest (Int, Int, Int)

Filters

Miscellaneous (the rest):
allcacheF :: F a b -> F a b
bitmapdatacacheF :: F a b -> F a b
bitmapfilecacheF :: F a b -> F a b
colorcacheF :: F a b -> F a b
doubleClickF :: Time -> F a b -> F a b
fontcacheF :: F a b -> F a b
fontcursorcacheF :: F a b -> F a b
fstructcacheF :: F a b -> F a b
gCcacheF :: F a b -> F a b

DrawingModules

Bitmaps:
data BitmapFile = ...
Drawing:
data Drawing b a = ...
atomicD :: a -> Drawing b a
attribD :: GCSpec -> Drawing a b -> Drawing a b
fgD :: (Show a, ColorGen a) => a -> Drawing b c -> Drawing b c
fontD :: (Show a, FontGen a) => a -> Drawing b c -> Drawing b c
hardAttribD :: GCtx -> Drawing a b -> Drawing a b
hboxD :: [Drawing a b] -> Drawing a b
hboxD' :: Distance -> [Drawing a b] -> Drawing a b
labelD :: a -> Drawing a b -> Drawing a b
matrixD :: Int -> [Drawing a b] -> Drawing a b
matrixD' :: Distance -> Int -> [Drawing a b] -> Drawing a b
softAttribD :: [GCAttributes ColorSpec FontSpec] -> Drawing a b -> Drawing a b
tableD :: Int -> [Drawing a b] -> Drawing a b
tableD' :: Distance -> Int -> [Drawing a b] -> Drawing a b
vboxD :: [Drawing a b] -> Drawing a b
vboxD' :: Distance -> [Drawing a b] -> Drawing a b
Drawing attributes:
data ColorSpec = ...
data FontSpec = ...
class ColorGen a where ...
class FontGen a where ...
data GCtx = ...
colorSpec :: (Show a, ColorGen a) => a -> ColorSpec
createGCtx :: (Show b, FontGen b, FudgetIO e, Show a, ColorGen a) => Drawable -> GCtx -> [GCAttributes a b] -> (GCtx -> e c d) -> e c d
fontSpec :: (Show a, FontGen a) => a -> FontSpec
gcBgA :: a -> [GCAttributes a FontSpec]
gcFgA :: a -> [GCAttributes a FontSpec]
gcFontA :: a -> [GCAttributes ColorSpec a]
gctx2gc :: GCtx -> GCId
rootGCtx :: GCtx
wCreateGCtx :: (Show b, FontGen b, FudgetIO e, Show a, ColorGen a) => GCtx -> [GCAttributes a b] -> (GCtx -> e c d) -> e c d
Drawing manipulation:
type DPath = [Int]
up :: DPath -> DPath
Fixed size drawings:
data FixedDrawing = ...
data FixedColorDrawing = ...
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 b Gfx
Miscellaneous (the rest):
type Cont a b = (b -> a) -> a
arc' :: Size -> Int -> Int -> FlexibleDrawing
blankD :: Size -> Drawing a Gfx
boxD :: [Drawing a b] -> Drawing a b
ellipse' :: Size -> FlexibleDrawing
filledEllipse :: FlexibleDrawing
filledEllipse' :: Size -> FlexibleDrawing
filledRectD :: Size -> Drawing a Gfx
filledarc :: Int -> Int -> FlexibleDrawing
filledarc' :: Size -> Int -> Int -> FlexibleDrawing
hboxcD :: [Drawing a b] -> Drawing a b
hboxcD' :: Distance -> [Drawing a b] -> Drawing a b
placedD :: Placer -> Drawing a b -> Drawing a b
rectD :: Size -> Drawing a Gfx
spacedD :: Spacer -> Drawing a b -> Drawing a b
stackD :: [Drawing a b] -> Drawing a b
triangleDown :: FlexibleDrawing
triangleUp :: FlexibleDrawing
vboxlD :: [Drawing a b] -> Drawing a b
vboxlD' :: Distance -> [Drawing a b] -> Drawing a b

StreamProc

A stream processor that splits a stream of pairs:
splitSP :: SP (a, b) (Either a b)
Delay the activation of a stream processor or fudget:
delaySP :: SP a b -> SP a b
Stream processor combinators that create circular connections:
loopLeftSP :: SP (Either a b) (Either a c) -> SP b c
loopSP :: SP a a -> SP a a
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)
Stream processor input operation:
getSP :: Cont (SP a b) a
Stream processor manipulation:
startupSP :: [a] -> SP a b -> SP a b
Stream processor output operation:
putSP :: a -> SP b a -> SP b a
The function that turns a stream processor into a list processing function:
runSP :: SP a b -> [a] -> [b]
The idle stream processor:
nullSP :: SP a b
The type of plain stream processors:
data SP a b
Miscellaneous (the rest):
data DynMsg b a = ...
type Cont a b = (b -> a) -> a
class StreamProcIO a where ...
appendStartSP :: [a] -> SP b a -> SP b a
compEitherSP :: SP a b -> SP c d -> SP (Either a c) (Either b d)
feedSP :: a -> [a] -> SP a b -> SP a b
filterJustSP :: SP (Maybe a) a
filterLeftSP :: SP (Either a b) a
filterRightSP :: SP (Either a b) b
idLeftSP :: SP a b -> SP (Either c a) (Either c b)
idRightSP :: SP a b -> SP (Either a c) (Either b c)
loopOnlySP :: SP a a -> SP a b
loopThroughRightSP :: SP (Either a b) (Either c d) -> SP c a -> SP b d
mapFilterSP :: (a -> Maybe b) -> SP a b
parSP :: SP a b -> SP a b -> SP a b
postMapSP :: (a -> b) -> SP c a -> SP c b
preMapSP :: SP a b -> (c -> a) -> SP c b
prepostMapSP :: (a -> b) -> (c -> d) -> SP b c -> SP a d
pullSP :: SP a b -> ([b], SP a b)
putsSP :: [a] -> SP b a -> SP b a
seqSP :: SP a b -> SP a b -> SP a b
serCompSP :: SP a b -> SP c a -> SP c b
stepSP :: [a] -> Cont (SP b a) b
toBothSP :: SP a (Either a a)
walkSP :: SP a b -> a -> ([b], 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 ())
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] a
openLSocketF :: (FudgetIO c) => Port -> (LSocket -> c a b) -> c a b
openSocketF :: (FudgetIO c) => Host -> Port -> (Socket -> c a b) -> c a b
receiverF :: Socket -> F a String
transceiverF :: Socket -> F [Char] String
transmitterF :: Socket -> F [Char] a
Stdio:
inputLinesSP :: SP [Char] [Char]
linesSP :: SP Char [Char]
outputF :: String -> F String a
stderrF :: F String a
stdinF :: F a String
stdioF :: F String String
stdoutF :: F String a
Miscellaneous (the rest):
getLocalTime :: (FudgetIO c) => (CalendarTime -> c a b) -> c a b
getTime :: (FudgetIO c) => (ClockTime -> c a b) -> c a b
subProcessF :: String -> F [Char] (Either 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 a b = (b -> a) -> a
class HasCache a where ...
class FudgetIO a where ...
cmdContSP :: a -> (b -> Maybe c) -> Cont (SP b a) c
contMap :: (StreamProcIO c) => (a -> (b -> c a b) -> c a b) -> c a b
conts :: (a -> Cont b c) -> [a] -> Cont b [c]
dropSP :: (a -> Maybe b) -> (b -> SP a c) -> SP a c
getLeftSP :: (a -> SP (Either a b) c) -> SP (Either a b) c
getRightSP :: (a -> SP (Either b a) c) -> SP (Either b a) c
waitForF :: (a -> Maybe b) -> Cont (F a c) b
waitForSP :: (a -> Maybe b) -> (b -> SP a c) -> SP a c

XTypesModules

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

Types

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
The Fudget type:
type Fudget a b = F a b
data 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 :: (a -> b) -> InputMsg a -> InputMsg b
stripInputMsg :: InputMsg a -> a
tstInp :: (a -> b) -> InputMsg a -> b
Miscellaneous (the rest):
data Message a b = ...
type Path = [Direction]
data PopupMsg a = ...
inputButtonKey :: KeySym
inputLeaveKey :: KeySym

Utilities

Environment:
argFlag :: [Char] -> Bool -> Bool
argKey :: [Char] -> [Char] -> [Char]
argReadKey :: (Read a, Show a) => [Char] -> a -> a
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 Point = ...
type Size = Point
data Line = ...
data Rect = ...
lL :: Int -> Int -> Int -> Int -> Line
origin :: Point
pP :: Int -> Int -> Point
rR :: Int -> Int -> Int -> Int -> Rect
rectpos :: Rect -> Point
rectsize :: Rect -> Size
xcoord :: Point -> Int
ycoord :: Point -> Int
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 :: (RealFrac a, Integral c, Integral b) => a -> b -> c
scalePoint :: (RealFrac a) => a -> Point -> Point
sizerect :: Rect -> Size -> Rect
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]
Various utility functions for the Either type:
filterLeft :: [Either a b] -> [a]
filterRight :: [Either a b] -> [b]
fromLeft :: Either a b -> a
fromRight :: Either a b -> b
isLeft :: Either a b -> Bool
isRight :: Either a b -> Bool
mapEither :: (a -> b) -> (c -> d) -> Either a c -> Either b d
splitEitherList :: [Either a b] -> ([a], [b])
stripEither :: Either a a -> a
stripLeft :: Either a b -> Maybe a
stripRight :: Either a b -> Maybe b
swapEither :: Either a b -> Either b a
Various utility functions for the Maybe type.:
isM :: Maybe a -> Bool
mapfilter :: (a -> Maybe b) -> [a] -> [b]
plookup :: (a -> Bool) -> [(a, b)] -> Maybe b
stripMaybe :: Maybe a -> a
stripMaybeDef :: a -> Maybe a -> a
Miscellaneous (the rest):
type Cont a b = (b -> a) -> a
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 :: String
version13u :: String

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
Miscellaneous (the rest):
ctrace :: (Show a) => [Char] -> a -> b -> b
showCommandF :: String -> F a b -> F a b

DefaultParams

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

ContribFudgets

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